expressions 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ee105d363cf474e3cea5ed06d5f388998fcd25f82cbf9dadf660871965dab47
-  data.tar.gz: d09b013d9eea9552b5407f4f34bdcb8efb7c35153ccd3f7b92c262595d82dce1
+  metadata.gz: e55a96130ccaa3a7339eb41b9f847ba7ed6bbf661e296b2c299e91fb972ebfbb
+  data.tar.gz: 9703237cc621039067556d95bbadef67dd39be197acff6f2a70dad3fdb3b0d55
 SHA512:
-  metadata.gz: 218dab1a235b9e4884fbf12c6d714748f8d1702a195b29cf669b48774b507484cb6f45bcde2811b4bf88a25bafcb40e98dff6bd04857e0bc8acca98ab7d6cfaf
-  data.tar.gz: a171f17a41bee800df1f828818aa4e8443c759156f179910720f26a748a0282a9fb09c93b8f3ac7055062b915f4239fc95bb29911e00a25d8f1ea567bb7c2e5d
+  metadata.gz: 602cf515cd17fee068a85fcc326b7a6a683e5b5d713df92b770293ee0bdf7c77199a6535b07ed42cfc1e5a05502e80cb386ecbe0a2344436f05c65ec75286b36
+  data.tar.gz: 1e91f795dbefeb8b5bb59d0d6455dc37362fdfba241339daa840ef9a73f476b7859deba291819020b40d09946c6bef7fed1ed0e1810d90f21ed74f2aeb1cb9de

data/lib/expression.rb

@@ -6,114 +6,38 @@ module Expressions
       @expressions = []
     end
 
-    def |(expression)
-      if expression.is_a?(::Expressions::Expression)
-        union_expression(expression)
-      else
-        value?(expression) ? union_value(expression) : union_type(expression)
+    def initialize_copy(source)
+      super
+      @expressions = @expressions.dup
+    end
+
+    OPERATORS = {
+      :| => :union,
+      :& => :intersect,
+      :+ => :add,
+      :> => :gt,
+      :< => :lt,
+      :>= => :gt_or_eq,
+      :<= => :lt_or_eq,
+      :<=> => :compare,
+      :^ => :xor,
+      :* => :multiply,
+      :/ => :divide
+    }.freeze
+
+    # Each operator calls its hook on a copy and returns the copy, so expressions can be in a variable and not mutate.
+    #   string = MyExpression.new
+    #   optional = string | nil # string is unchanged
+    # A subclass with mutable state copies it in `initialize_copy`.
+    OPERATORS.each do |operator, prefix|
+      define_method(operator) do |expression|
+        dup.tap { |copy| copy.send(:call_hook, prefix, expression) }
       end
-
-      self
-    end
-
-    def &(expression)
-      if expression.is_a?(::Expressions::Expression)
-        intersect_expression(expression)
-      else
-        value?(expression) ? intersect_value(expression) : intersect_type(expression)
-      end
-
-      self
-    end
-
-    def +(expression)
-      if expression.is_a?(::Expressions::Expression)
-        add_expression(expression)
-      else
-        value?(expression) ? add_value(expression) : add_type(expression)
-      end
-
-      self
     end
 
-    def >(expression)
-      if expression.is_a?(::Expressions::Expression)
-        gt_expression(expression)
-      else
-        value?(expression) ? gt_value(expression) : gt_type(expression)
-      end
-
-      self
-    end
-
-    def <(expression)
-      if expression.is_a?(::Expressions::Expression)
-        lt_expression(expression)
-      else
-        value?(expression) ? lt_value(expression) : lt_type(expression)
-      end
-
-      self
-    end
-
-    def >=(expression)
-      if expression.is_a?(::Expressions::Expression)
-        gt_or_eq_expression(expression)
-      else
-        value?(expression) ? gt_or_eq_value(expression) : gt_or_eq_type(expression)
-      end
-
-      self
-    end
-
-    def <=(expression)
-      if expression.is_a?(::Expressions::Expression)
-        lt_or_eq_expression(expression)
-      else
-        value?(expression) ? lt_or_eq_value(expression) : lt_or_eq_type(expression)
-      end
-
-      self
-    end
-
-    def <=>(expression)
-      if expression.is_a?(::Expressions::Expression)
-        compare_expression(expression)
-      else
-        value?(expression) ? compare_value(expression) : compare_type(expression)
-      end
-
-      self
-    end
-
-    def ^(expression)
-      if expression.is_a?(::Expressions::Expression)
-        xor_expression(expression)
-      else
-        value?(expression) ? xor_value(expression) : xor_type(expression)
-      end
-
-      self
-    end
-
-    def *(expression)
-      if expression.is_a?(::Expressions::Expression)
-        multiply_expression(expression)
-      else
-        value?(expression) ? multiply_value(expression) : multiply_type(expression)
-      end
-
-      self
-    end
-
-    def /(expression)
-      if expression.is_a?(::Expressions::Expression)
-        divide_expression(expression)
-      else
-        value?(expression) ? divide_value(expression) : divide_type(expression)
-      end
-
-      self
+    # `<<` is an action like Ruby's Array#<<. It calls its hook on the expression itself and returns what was inserted.
+    def <<(expression)
+      call_hook(:append, expression)
     end
 
     def types
@@ -121,7 +45,7 @@ module Expressions
     end
 
     class << self
-      def |(expression)
+      def |(expression) # rubocop:disable Naming/BinaryOperatorParameterName
         self.new | expression
       end
     end
@@ -132,136 +56,60 @@ module Expressions
       !expression.instance_of?(Class)
     end
 
-    def union_expression(expression)
-      nil
-    end
-
-    def union_value(value)
-      nil
-    end
-
-    def union_type(type)
-      nil
-    end
-
-    def intersect_expression(expression)
-      nil
-    end
+    def call_hook(prefix, expression)
+      return send(:"#{prefix}_expression", expression) if expression.is_a?(::Expressions::Expression)
 
-    def intersect_value(value)
-      nil
+      value?(expression) ? send(:"#{prefix}_value", expression) : send(:"#{prefix}_type", expression)
     end
 
-    def intersect_type(type)
-      nil
-    end
+    # rubocop:disable Lint/UnusedMethodArgument
+    def union_expression(expression) = nil
+    def union_value(value) = nil
+    def union_type(type) = nil
 
-    def add_expression(expression)
-      nil
-    end
+    def intersect_expression(expression) = nil
+    def intersect_value(value) = nil
+    def intersect_type(type) = nil
 
-    def add_value(value)
-      nil
-    end
+    def add_expression(expression) = nil
+    def add_value(value) = nil
+    def add_type(type) = nil
 
-    def add_type(type)
-      nil
-    end
+    def gt_expression(expression) = nil
+    def gt_value(value) = nil
+    def gt_type(type) = nil
 
-    def gt_expression(expression)
-      nil
-    end
+    def lt_expression(expression) = nil
+    def lt_value(value) = nil
+    def lt_type(type) = nil
 
-    def gt_value(value)
-      nil
-    end
+    def gt_or_eq_expression(expression) = nil
+    def gt_or_eq_value(value) = nil
+    def gt_or_eq_type(type) = nil
 
-    def gt_type(type)
-      nil
-    end
+    def lt_or_eq_expression(expression) = nil
+    def lt_or_eq_value(value) = nil
+    def lt_or_eq_type(type) = nil
 
-    def lt_expression(expression)
-      nil
-    end
+    def compare_expression(expression) = nil
+    def compare_value(value) = nil
+    def compare_type(type) = nil
 
-    def lt_value(value)
-      nil
-    end
+    def xor_expression(expression) = nil
+    def xor_value(value) = nil
+    def xor_type(type) = nil
 
-    def lt_type(type)
-      nil
-    end
+    def multiply_expression(expression) = nil
+    def multiply_value(value) = nil
+    def multiply_type(type) = nil
 
-    def gt_or_eq_expression(expression)
-      nil
-    end
+    def divide_expression(expression) = nil
+    def divide_value(value) = nil
+    def divide_type(type) = nil
 
-    def gt_or_eq_value(value)
-      nil
-    end
-
-    def gt_or_eq_type(type)
-      nil
-    end
-
-    def lt_or_eq_expression(expression)
-      nil
-    end
-
-    def lt_or_eq_value(value)
-      nil
-    end
-
-    def lt_or_eq_type(type)
-      nil
-    end
-
-    def compare_expression(expression)
-      nil
-    end
-
-    def compare_value(value)
-      nil
-    end
-
-    def compare_type(type)
-      nil
-    end
-
-    def xor_expression(expression)
-      nil
-    end
-
-    def xor_value(value)
-      nil
-    end
-
-    def xor_type(type)
-      nil
-    end
-
-    def multiply_expression(expression)
-      nil
-    end
-
-    def multiply_value(value)
-      nil
-    end
-
-    def multiply_type(type)
-      nil
-    end
-
-    def divide_expression(expression)
-      nil
-    end
-
-    def divide_value(value)
-      nil
-    end
-
-    def divide_type(type)
-      nil
-    end
+    def append_expression(expression) = nil
+    def append_value(value) = nil
+    def append_type(type) = nil
+    # rubocop:enable Lint/UnusedMethodArgument
   end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Expressions
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expressions
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - maedi