create an include expression

lib/flipper/expression/builder.rb

@@ -53,6 +53,10 @@ def less_than_or_equal_to(object)
       alias lte less_than_or_equal_to
       alias less_than_or_equal less_than_or_equal_to
 
+      def include(object)
+        build({ Include: [self, object] })
+      end
+
       def percentage_of_actors(object)
         build({ PercentageOfActors: [self, build(object)] })
       end

lib/flipper/expressions/include.rb

@@ -0,0 +1,9 @@
+module Flipper
+  module Expressions
+    class Include
+      def self.call(left, right)
+        left.respond_to?(:include?) && left.include?(right)
+      end
+    end
+  end
+end

spec/flipper/expression_spec.rb

@@ -79,6 +79,19 @@
       ])
     end
 
+    it "can build Include" do
+      expression = described_class.build({
+        "Inlcude" => [["hello"], "hello"]
+      })
+
+      expect(expression).to be_instance_of(Flipper::Expression)
+      expect(expression.function).to be(Flipper::Expressions::Include)
+      expect(expression.args).to eq([
+        Flipper.constant(["hello"]),
+        Flipper.constant("hello"),
+      ])
+    end
+
     it "can build NotEqual" do
       expression = described_class.build({
         "NotEqual" => [

spec/flipper/expressions/include_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Flipper::Expressions::Include do
+  describe "#call" do
+    it "returns true when left includes right" do
+      expect(described_class.call([2], 2)).to be(true)
+    end
+
+    it "returns false when left does not include right" do
+      expect(described_class.call([2], "2")).to be(false)
+    end
+
+    it "returns false when left does not respond to #include?" do
+      expect(described_class.call(nil, nil)).to be(false)
+    end
+
+    it "raises ArgumentError with no arguments" do
+      expect { described_class.call }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError with one argument" do
+      expect { described_class.call(10) }.to raise_error(ArgumentError)
+    end
+  end
+end