CloudSesame 0.6.8 → 0.7.0

data/lib/cloud_sesame/query/ast/abstract/single_expression_operator.rb

@@ -0,0 +1,39 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        class SingleExpressionOperator < Operator
+
+          DETAILED = false
+
+          attr_accessor :child
+
+          def <<(object)
+            self.child = object
+          end
+
+          def applied(included = true)
+            child.applied(included)
+          end
+
+          def compile(_detailed = nil)
+            if child && (compiled = child.compile operator_detailed) && !compiled.empty?
+              "(#{ symbol  }#{ boost } #{ compiled })"
+            end
+          end
+
+          def is_for(field, options = {})
+            child.is_for field, options if child
+          end
+
+          private
+
+          def operator_detailed
+            self.class::DETAILED
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/cloud_sesame/query/ast/abstract/value.rb

@@ -0,0 +1,88 @@
+module CloudSesame
+  module Query
+    module AST
+      module Abstract
+        class Value
+
+          RANGE_FORMAT = Regexp.new(/\A(\[|{)(.*),(.*)(\}|\])\z/).freeze
+          DIGIT_FORMAT = Regexp.new(/\A\d+(.\d+)?\z/).freeze
+
+          attr_reader :value, :changed, :compiled
+
+          def self.range?(value)
+            value.kind_of?(Range)
+          end
+
+          def self.string_range?(value)
+            RANGE_FORMAT =~ strip(value)
+          end
+
+          def self.numeric?(value)
+            value.is_a?(Numeric)
+          end
+
+          def self.string_numeric?(value)
+            DIGIT_FORMAT =~ value.to_s
+          end
+
+          def self.datetime?(value)
+            value.kind_of?(Date) || value.kind_of?(Time)
+          end
+
+          def initialize(value, type = nil)
+            self.value = value
+            @type = type
+          end
+
+          def value=(value)
+            unless @value == value
+              @changed = true
+              @value = value
+            end
+          end
+
+          def compile
+            changed ? recompile(value) : @compiled
+          end
+
+          def to_s
+            value.to_s
+          end
+
+          def ==(value)
+            (value.respond_to?(:compile) && compile == value.compile) ||
+            @value == value ||
+            compile == value
+          end
+
+          private
+
+          def recompile(value)
+            @changed = false
+            @compiled = value
+          end
+
+          # Private Helper Methods
+          # ===============================================
+
+          def self.strip(string)
+            string.to_s.tr(' '.freeze, ''.freeze)
+          end
+
+          def self.strip!(string)
+            string.to_s.tr!(' '.freeze, ''.freeze)
+          end
+
+          def strip(string)
+            string.to_s.tr(' '.freeze, ''.freeze)
+          end
+
+          def strip!(string)
+            string.to_s.tr!(' '.freeze, ''.freeze)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/cloud_sesame/query/ast/and.rb

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module AST
-      class And < MultiExpressionOperator
+      class And < Abstract::MultiExpressionOperator
         SYMBOL = :and
       end
     end

data/lib/cloud_sesame/query/ast/date_value.rb

@@ -1,10 +1,26 @@
 module CloudSesame
   module Query
     module AST
-      class DateValue < Value
+      class DateValue < StringValue
 
-        def compile
-          strip escape data.strftime '%FT%TZ'
+        FORMAT = '%FT%TZ'.freeze
+
+        def self.parse(value)
+          range?(value) || string_range?(value) ? RangeValue.parse(value, self) : new(value)
+        end
+
+        def to_s
+          compile
+        end
+
+        private
+
+        def recompile(value)
+          super strip format value
+        end
+
+        def format(value)
+          value.strftime FORMAT
         end
 
       end

data/lib/cloud_sesame/query/ast/literal.rb

@@ -3,22 +3,15 @@ module CloudSesame
     module AST
       class Literal
 
-        SINGLE_QUATE = /\'/
-        ESCAPE_QUATE = "\\'"
+        SINGLE_QUATE = Regexp.new(/\'/).freeze
+        ESCAPE_QUATE = "\\'".freeze
 
-        attr_accessor :field
-        attr_reader :options, :value
+        attr_reader :value
 
-        def initialize(field, value = nil, options = {})
-          @field, @options = field, options
-          self.value = value
-        end
-
-        def value=(value)
-          if value
-            @value = Value.parse value
-            is_included
-          end
+        def initialize(field, value, options = {})
+          @field = field
+          @options = options
+          @value = LazyObject.new { (options[:type] || Value).parse(value) } if value
         end
 
         def is_for(field, options = {})
@@ -26,34 +19,26 @@ module CloudSesame
           @options.merge! options
         end
 
-        def is_included
-          applied[value] = true
-        end
-
-        def is_excluded
-          applied[value] = applied[value] == false ? true : false
+        def applied(included)
+          { field: @field, value: @value, included: included } if @value
         end
 
         def as_field
-          options[:as] || field
+          @options[:as] || @field
         end
 
         def compile(detailed = false)
-          (detailed ? detailed_format : standard_format) if value
+          (detailed ? detailed_format : standard_format) if @value
         end
 
         private
 
-        def applied
-          options[:applied] ||= {}
-        end
-
         def standard_format
-          "#{ as_field }:#{ value.compile }"
+          "#{ as_field }:#{ @value.compile }"
         end
 
         def detailed_format
-          "field=#{ escape as_field.to_s } #{ value.compile }"
+          "field=#{ escape as_field.to_s } #{ @value.compile }"
         end
 
         def escape(data)

data/lib/cloud_sesame/query/ast/near.rb

@@ -1,15 +1,15 @@
 module CloudSesame
   module Query
     module AST
-      class Near < SingleExpressionOperator
+      class Near < Abstract::SingleExpressionOperator
         DETAILED = true
-				SYMBOL = :near
+        SYMBOL = :near
 
-				def compile(_detailed = nil)
+        def compile(_detailed = nil)
           if child && (compiled = child.compile operator_detailed) && !compiled.empty?
             "(#{ symbol }#{ boost }#{ distance } #{ compiled })"
           end
-				end
+        end
 
         def distance
           " distance=#{ options[:distance] }" if options[:distance]

data/lib/cloud_sesame/query/ast/not.rb

@@ -1,13 +1,8 @@
 module CloudSesame
   module Query
     module AST
-      class Not < SingleExpressionOperator
-				SYMBOL = :not
-
-        def <<(object)
-          object.is_excluded
-          self.child = object
-        end
+      class Not < Abstract::SingleExpressionOperator
+        SYMBOL = :not
 
         def compile
           if child && (compiled = child.compile) && !compiled.empty?
@@ -15,6 +10,10 @@ module CloudSesame
           end
         end
 
+        def applied(included = true)
+          child.applied(!included)
+        end
+
       end
     end
   end

data/lib/cloud_sesame/query/ast/numeric_value.rb

@@ -1,19 +1,27 @@
 module CloudSesame
-	module Query
-		module AST
-			class NumericValue < Value
+  module Query
+    module AST
+      class NumericValue < Abstract::Value
 
-				def compile
-					data.to_s
-				end
+        def self.parse(value)
+          range?(value) || string_range?(value) ? RangeValue.parse(value, self) : new(value)
+        end
+
+        def to_s
+          compile
+        end
 
         def ==(value)
-          value == data.to_f ||
-          value == data ||
-          value == compile
+          value == @value.to_f || value == @value || value == compile
+        end
+
+        private
+
+        def recompile(value)
+          super value.to_s
         end
 
-			end
-		end
-	end
+      end
+    end
+  end
 end

data/lib/cloud_sesame/query/ast/or.rb

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module AST
-      class Or < MultiExpressionOperator
+      class Or < Abstract::MultiExpressionOperator
         SYMBOL = :or
       end
     end

data/lib/cloud_sesame/query/ast/phrase.rb

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module AST
-      class Phrase < SingleExpressionOperator
+      class Phrase < Abstract::SingleExpressionOperator
 				DETAILED = true
         SYMBOL = :phrase
       end

data/lib/cloud_sesame/query/ast/prefix.rb

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module AST
-      class Prefix < SingleExpressionOperator
+      class Prefix < Abstract::SingleExpressionOperator
         DETAILED = true
 				SYMBOL = :prefix
       end

data/lib/cloud_sesame/query/ast/range_value.rb

@@ -1,78 +1,79 @@
 module CloudSesame
   module Query
     module AST
-      class RangeValue < Value
-
-        RANGE_FORMAT = /\A(\[|{)(.*),(.*)(\}|\])\z/
-
-        def initialize(value = nil)
-          @data = (
-            if value.kind_of?(Range)
-              range_to_array(value)
-            elsif value.is_a?(String) && (match = string_format?(value))
-              data = match.captures
-              data[1, 2] = data[1, 2].map { |i| Value.parse(i) unless i.nil? || i.empty? }
-              data
-            else
-              default_range
-            end
-          )
+      class RangeValue < Abstract::Value
+
+        def initialize(value = nil, type = nil)
+
+          self.value = RangeValue.range?(value) ? range_handler(value) :
+                       RangeValue.string_range?(value) ? string_handler(value) :
+                       empty_value
+
+          self.type = type if type
         end
 
-        def gt(value = nil)
+        def type=(type)
+          value_type_handler(type) if (@type = type)
+          type
+        end
+
+        def gt(value)
           update_lower_value(value) if value
           return self
         end
 
-        def gte(value = nil)
-          update_lower_value(value, true) if value
+        def gte(value)
+          update_lower_value(value, '[') if value
           return self
         end
 
-        def lt(value = nil)
+        def lt(value)
           update_uppoer_value(value) if value
           return self
         end
 
-        def lte(value = nil)
-          update_uppoer_value(value, true) if value
+        def lte(value)
+          update_uppoer_value(value, ']') if value
           return self
         end
 
-        def compile
-          "#{ data[0] }#{ data[1] },#{ data[2] }#{ data[3] }"
+        def to_s
+          compile
         end
 
         def ==(object)
-          data == Value.parse(object).data
+          value == RangeValue.new(object, Value).value
         end
 
         private
 
-        def update_lower_value(value, included = false)
-          data[0], data[1] = (included ? '[' : '{'), Value.parse(value)
+        def recompile(value)
+          super "#{ value[0] }#{ value[1] },#{ value[2] }#{ value[3] }"
+        end
+
+        def update_lower_value(value, included = '{')
+          self.value[0] = included
+          self.value[1] = value
         end
 
-        def update_uppoer_value(value, included = false)
-          data[2], data[3] = Value.parse(value), (included ? ']' : '}')
+        def update_uppoer_value(value, included = '}')
+          self.value[2] = value
+          self.value[3] = included
         end
 
-        def string_format?(string)
-           RANGE_FORMAT.match string.tr(' ', '')
+        def range_handler(value)
+          ['[', value.begin, value.end, value.exclude_end? ? '}' : ']']
         end
 
-        def range_to_array(range)
-          ['[',
-            Value.parse(range.begin),
-            Value.parse(range.end),
-            end_symbol(range)]
+        def string_handler(value)
+          RANGE_FORMAT.match(strip(value)).captures
         end
 
-        def end_symbol(value)
-          value.exclude_end? ? '}' : ']'
+        def value_type_handler(type)
+          self.value[1, 2] = value[1, 2].map { |v| type.parse(v) unless v.to_s.empty? }
         end
 
-        def default_range
+        def empty_value
           ['{', nil, nil, '}']
         end
 

data/lib/cloud_sesame/query/ast/root.rb

@@ -1,15 +1,11 @@
 module CloudSesame
   module Query
     module AST
-      class Root < MultiExpressionOperator
+      class Root < Abstract::MultiExpressionOperator
         SYMBOL = :and # default operator for root
 
         def compile
-          more_than_one_child? ? super : children.compile
-        end
-
-        def more_than_one_child?
-          children.size > 1
+          children.size > 1 ? super : children.compile
         end
 
         private

data/lib/cloud_sesame/query/ast/string_value.rb

@@ -0,0 +1,26 @@
+module CloudSesame
+	module Query
+		module AST
+			class StringValue < Abstract::Value
+
+				SINGLE_QUATE = Regexp.new(/\'/).freeze
+        ESCAPE_QUATE = "\\'".freeze
+
+				def self.parse(value)
+					new value.to_s if value
+				end
+
+				private
+
+				def recompile(value)
+					super escape value.to_s
+				end
+
+				def escape(value)
+				  "'#{ value.gsub(SINGLE_QUATE) { ESCAPE_QUATE } }'"
+				end
+
+			end
+		end
+	end
+end

data/lib/cloud_sesame/query/ast/term.rb

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module AST
-      class Term < SingleExpressionOperator
+      class Term < Abstract::SingleExpressionOperator
         DETAILED = true
         SYMBOL = :term
       end

data/lib/cloud_sesame/query/ast/value.rb

@@ -1,70 +1,41 @@
 module CloudSesame
   module Query
     module AST
-      class Value
+      class Value < Abstract::Value
 
-        RANGE_FORMAT = /\A(\[|{)(.*),(.*)(\}|\])\z/
-        DIGIT_FORMAT = /\A\d+(.\d+)?\z/
-        SINGLE_QUATE = /\'/
-        ESCAPE_QUATE = "\\'"
+        TYPES = {
+          string: StringValue,
+          numeric: NumericValue,
+          date: DateValue
+        }
 
-        attr_reader :data
-
-        def self.parse(value)
-          return value if value.kind_of? AST::Value
-          (
-            is_a_numeric?(value) ? AST::NumericValue :
-            is_a_datetime?(value) ? AST::DateValue :
-            is_a_range?(value) ? AST::RangeValue :
-            AST::Value
-          ).new(value)
-        end
-
-        def self.is_a_numeric?(value)
-          value.is_a?(Numeric) || (value.is_a?(String) && DIGIT_FORMAT =~ value)
-        end
-
-        def self.is_a_datetime?(value)
-          value.kind_of?(Date) || value.kind_of?(Time)
-        end
-
-        def self.is_a_range?(value)
-          value.kind_of?(Range) || (value.is_a?(String) && RANGE_FORMAT =~ value)
-        end
-
-        def initialize(data)
-          @data = data
-        end
-
-        def compile
-          updated? ? recompile : @compiled
-        end
-
-        def to_s
-          compile
+        def self.map_type(symbol)
+          (klass =TYPES[symbol]) ? klass : self
         end
 
-        def ==(value)
-          value == data || value == compile
-        end
-
-        private
+        # if the value is already a range value object
+        # set the type to Value and return the value
+        # else determine the type of value and create it
+        def self.parse(value)
+          if value.kind_of?(RangeValue)
+            value.type = self
+            return value
+          end
 
-        def updated?
-          @compiled_data != @data
-        end
+          (
+            range_value?(value) ? RangeValue :
+            numeric_value?(value) ? NumericValue :
+            datetime?(value) ? DateValue : StringValue
+          ).new(value, self)
 
-        def recompile
-          @compiled_data = @data
-          @compiled = escape @compiled_data
         end
 
-        def escape(data)
-          "'#{ data.gsub(SINGLE_QUATE) { ESCAPE_QUATE } }'"
+        def self.range_value?(value)
+          range?(value) || string_range?(value)
         end
 
-        def strip(string)
-          string.tr(" ", "")
+        def self.numeric_value?(value)
+          numeric?(value) || string_numeric?(value)
         end
 
       end