Remove the concept of value in favor of specific types

examples/expressions.rb

@@ -130,7 +130,7 @@ class Org < Struct.new(:id, :flipper_properties)
 refute Flipper.enabled?(:something, other_user)
 
 puts "\n\nBoolean Expression"
-boolean_expression = Flipper.value(true).eq(true)
+boolean_expression = Flipper.boolean(true).eq(true)
 Flipper.enable :something, boolean_expression
 assert Flipper.enabled?(:something)
 assert Flipper.enabled?(:something, user)

lib/flipper/expression.rb

@@ -1,13 +1,5 @@
 module Flipper
   class Expression
-    SUPPORTED_TYPE_CLASSES = [
-      String,
-      Numeric,
-      NilClass,
-      TrueClass,
-      FalseClass,
-    ].freeze
-
     def self.build(object, convert_to_values: false)
       return object if object.is_a?(Flipper::Expression)
 
@@ -18,10 +10,14 @@ def self.build(object, convert_to_values: false)
         type = object.keys.first
         args = object.values.first
         Expressions.const_get(type).new(args)
-      when *SUPPORTED_TYPE_CLASSES
-        convert_to_values ? Expressions::Value.new(object) : object
+      when String
+        convert_to_values ? Expressions::String.new(object.to_s) : object
       when Symbol
-        convert_to_values ? Expressions::Value.new(object.to_s) : object.to_s
+        convert_to_values ? Expressions::String.new(object.to_s) : object.to_s
+      when Numeric
+        convert_to_values ? Expressions::Number.new(object.to_f) : object
+      when TrueClass, FalseClass
+        convert_to_values ? Expressions::Boolean.new(object) : object
       else
         raise ArgumentError, "#{object.inspect} cannot be converted into an expression"
       end

lib/flipper/expressions/percentage.rb

@@ -8,7 +8,7 @@ def initialize(args)
       end
 
       def evaluate(context = {})
-        value = evaluate_arg(0, context)
+        value = super
 
         value = 0 if value < 0
         value = 100 if value > 100

spec/flipper/expression_spec.rb

@@ -5,102 +5,93 @@
     it "can build Equal" do
       expression = Flipper::Expression.build({
         "Equal" => [
-          {"Value" => ["basic"]},
-          {"Value" => ["basic"]},
+          {"String" => ["basic"]},
+          {"String" => ["basic"]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::Equal)
       expect(expression.args).to eq([
-        Flipper.value("basic"),
-        Flipper.value("basic"),
+        Flipper.string("basic"),
+        Flipper.string("basic"),
       ])
     end
 
     it "can build GreaterThanOrEqualTo" do
       expression = Flipper::Expression.build({
         "GreaterThanOrEqualTo" => [
-          {"Value" => [2]},
-          {"Value" => [1]},
+          {"Number" => [2]},
+          {"Number" => [1]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::GreaterThanOrEqualTo)
       expect(expression.args).to eq([
-        Flipper.value(2),
-        Flipper.value(1),
+        Flipper.number(2),
+        Flipper.number(1),
       ])
     end
 
     it "can build GreaterThan" do
       expression = Flipper::Expression.build({
         "GreaterThan" => [
-          {"Value" => [2]},
-          {"Value" => [1]},
+          {"Number" => [2]},
+          {"Number" => [1]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::GreaterThan)
       expect(expression.args).to eq([
-        Flipper.value(2),
-        Flipper.value(1),
+        Flipper.number(2),
+        Flipper.number(1),
       ])
     end
 
     it "can build LessThanOrEqualTo" do
       expression = Flipper::Expression.build({
         "LessThanOrEqualTo" => [
-          {"Value" => [2]},
-          {"Value" => [1]},
+          {"Number" => [2]},
+          {"Number" => [1]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::LessThanOrEqualTo)
       expect(expression.args).to eq([
-        Flipper.value(2),
-        Flipper.value(1),
+        Flipper.number(2),
+        Flipper.number(1),
       ])
     end
 
     it "can build LessThan" do
       expression = Flipper::Expression.build({
         "LessThan" => [
-          {"Value" => [2]},
-          {"Value" => [1]},
+          {"Number" => [2]},
+          {"Number" => [1]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::LessThan)
       expect(expression.args).to eq([
-        Flipper.value(2),
-        Flipper.value(1),
+        Flipper.number(2),
+        Flipper.number(1),
       ])
     end
 
     it "can build NotEqual" do
       expression = Flipper::Expression.build({
         "NotEqual" => [
-          {"Value" => ["basic"]},
-          {"Value" => ["plus"]},
+          {"String" => ["basic"]},
+          {"String" => ["plus"]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::NotEqual)
       expect(expression.args).to eq([
-        Flipper.value("basic"),
-        Flipper.value("plus"),
+        Flipper.string("basic"),
+        Flipper.string("plus"),
       ])
     end
 
-    it "can build Value" do
-      expression = Flipper::Expression.build({
-        "Value" => [1]
-      })
-
-      expect(expression).to be_instance_of(Flipper::Expressions::Value)
-      expect(expression.args).to eq([1])
-    end
-
     it "can build Number" do
       expression = Flipper::Expression.build({
         "Number" => [1]
@@ -122,24 +113,24 @@
     it "can build PercentageOfActors" do
       expression = Flipper::Expression.build({
         "PercentageOfActors" => [
-          {"Value" => ["User;1"]},
-          {"Value" => [40]},
+          {"String" => ["User;1"]},
+          {"Number" => [40]},
         ]
       })
 
       expect(expression).to be_instance_of(Flipper::Expressions::PercentageOfActors)
       expect(expression.args).to eq([
-        Flipper.value("User;1"),
-        Flipper.value(40),
+        Flipper.string("User;1"),
+        Flipper.number(40),
       ])
     end
 
-    it "can build Value" do
+    it "can build String" do
       expression = Flipper::Expression.build({
-        "Value" => ["basic"]
+        "String" => ["basic"]
       })
 
-      expect(expression).to be_instance_of(Flipper::Expressions::Value)
+      expect(expression).to be_instance_of(Flipper::Expressions::String)
       expect(expression.args).to eq(["basic"])
     end
 
@@ -214,8 +205,8 @@
   describe "#add" do
     it "converts to Any and adds new expressions" do
       expression = described_class.new(["something"])
-      first = Flipper.value(true).eq(true)
-      second = Flipper.value(false).eq(false)
+      first = Flipper.boolean(true).eq(true)
+      second = Flipper.boolean(false).eq(false)
       new_expression = expression.add(first, second)
       expect(new_expression).to be_instance_of(Flipper::Expressions::Any)
       expect(new_expression.args).to eq([
@@ -229,8 +220,8 @@
   describe "#remove" do
     it "converts to Any and removes any expressions that match" do
       expression = described_class.new(["something"])
-      first = Flipper.value(true).eq(true)
-      second = Flipper.value(false).eq(false)
+      first = Flipper.boolean(true).eq(true)
+      second = Flipper.boolean(false).eq(false)
       new_expression = expression.remove(described_class.new(["something"]), first, second)
       expect(new_expression).to be_instance_of(Flipper::Expressions::Any)
       expect(new_expression.args).to eq([])
@@ -295,9 +286,9 @@
   end
 
   it "can convert to PercentageOfActors" do
-    expression = Flipper.value("User;1")
+    expression = Flipper.string("User;1")
     converted = expression.percentage_of_actors(40)
     expect(converted).to be_instance_of(Flipper::Expressions::PercentageOfActors)
-    expect(converted.args).to eq([expression, Flipper.value(40)])
+    expect(converted.args).to eq([expression, Flipper.number(40)])
   end
 end

spec/flipper/expressions/all_spec.rb

@@ -2,16 +2,16 @@
   describe "#evaluate" do
     it "returns true if all args evaluate as true" do
       expression = described_class.new([
-        Flipper.value(true),
-        Flipper.value("yep").eq("yep"),
+        Flipper.boolean(true),
+        Flipper.string("yep").eq("yep"),
       ])
       expect(expression.evaluate).to be(true)
     end
 
     it "returns false if any args evaluate as false" do
       expression = described_class.new([
-        Flipper.value(false),
-        Flipper.value("yep").eq("yep"),
+        Flipper.boolean(false),
+        Flipper.string("yep").eq("yep"),
       ])
       expect(expression.evaluate).to be(false)
     end
@@ -20,57 +20,57 @@
   describe "#all" do
     it "returns self" do
       expression = described_class.new([
-        Flipper.value(true),
-        Flipper.value("yep").eq("yep"),
+        Flipper.boolean(true),
+        Flipper.string("yep").eq("yep"),
       ])
       expect(expression.all).to be(expression)
     end
   end
 
   describe "#add" do
     it "returns new instance with expression added" do
-      expression = described_class.new([Flipper.value(true)])
-      other = Flipper.value("yep").eq("yep")
+      expression = described_class.new([Flipper.boolean(true)])
+      other = Flipper.string("yep").eq("yep")
 
       result = expression.add(other)
       expect(result.args).to eq([
-        Flipper.value(true),
-        Flipper.value("yep").eq("yep"),
+        Flipper.boolean(true),
+        Flipper.string("yep").eq("yep"),
       ])
     end
 
     it "returns new instance with many expressions added" do
-      expression = described_class.new([Flipper.value(true)])
-      second = Flipper.value("yep").eq("yep")
-      third = Flipper.value(1).lte(20)
+      expression = described_class.new([Flipper.boolean(true)])
+      second = Flipper.string("yep").eq("yep")
+      third = Flipper.number(1).lte(20)
 
       result = expression.add(second, third)
       expect(result.args).to eq([
-        Flipper.value(true),
-        Flipper.value("yep").eq("yep"),
-        Flipper.value(1).lte(20),
+        Flipper.boolean(true),
+        Flipper.string("yep").eq("yep"),
+        Flipper.number(1).lte(20),
       ])
     end
 
     it "returns new instance with array of expressions added" do
-      expression = described_class.new([Flipper.value(true)])
-      second = Flipper.value("yep").eq("yep")
-      third = Flipper.value(1).lte(20)
+      expression = described_class.new([Flipper.boolean(true)])
+      second = Flipper.string("yep").eq("yep")
+      third = Flipper.number(1).lte(20)
 
       result = expression.add([second, third])
       expect(result.args).to eq([
-        Flipper.value(true),
-        Flipper.value("yep").eq("yep"),
-        Flipper.value(1).lte(20),
+        Flipper.boolean(true),
+        Flipper.string("yep").eq("yep"),
+        Flipper.number(1).lte(20),
       ])
     end
   end
 
   describe "#remove" do
     it "returns new instance with expression removed" do
-      first = Flipper.value(true)
-      second = Flipper.value("yep").eq("yep")
-      third = Flipper.value(1).lte(20)
+      first = Flipper.boolean(true)
+      second = Flipper.string("yep").eq("yep")
+      third = Flipper.number(1).lte(20)
       expression = described_class.new([first, second, third])
 
       result = expression.remove(second)
@@ -79,9 +79,9 @@
     end
 
     it "returns new instance with many expressions removed" do
-      first = Flipper.value(true)
-      second = Flipper.value("yep").eq("yep")
-      third = Flipper.value(1).lte(20)
+      first = Flipper.boolean(true)
+      second = Flipper.string("yep").eq("yep")
+      third = Flipper.number(1).lte(20)
       expression = described_class.new([first, second, third])
 
       result = expression.remove(second, third)
@@ -90,9 +90,9 @@
     end
 
     it "returns new instance with array of expressions removed" do
-      first = Flipper.value(true)
-      second = Flipper.value("yep").eq("yep")
-      third = Flipper.value(1).lte(20)
+      first = Flipper.boolean(true)
+      second = Flipper.string("yep").eq("yep")
+      third = Flipper.number(1).lte(20)
       expression = described_class.new([first, second, third])
 
       result = expression.remove([second, third])