CloudSesame 0.7.5 → 0.7.7

data/lib/cloud_sesame/domain/base.rb

@@ -88,7 +88,7 @@ module CloudSesame
       end
 
       def create_accessor(name)
-        @builder.field_accessor.__define_accessor__(name)
+        @builder.literal_methods.__define_accessor__(name)
       end
 
       def create_default_literal(name, options)

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

@@ -9,14 +9,14 @@ module CloudSesame
           end
 
           def applied(included = true)
-            children.map { |child| child.applied(included) }
+            children.map { |child| child.applied included }
           end
 
           def children
             @children ||= build_children
           end
 
-          def compile
+          def compile(_ = nil)
             if !children.empty? && (compiled = children.compile) && !compiled.empty?
               "(#{ symbol  }#{ boost } #{ compiled })"
             end
@@ -25,8 +25,7 @@ module CloudSesame
           private
 
           def build_children
-            (children = FieldArray.new)._scope = self
-            children
+            MultiExpressionOperatorChildren.build(self)
           end
 
         end

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

@@ -6,6 +6,8 @@ module CloudSesame
       module Abstract
         class Value
 
+          # CONSTANTS
+          # =====================================
           RANGE_FORMAT = Regexp.new(/\A(\[|{)(.*),(.*)(\}|\])\z/).freeze
           DIGIT_FORMAT = Regexp.new(/\A\d+(.\d+)?\z/).freeze
           DATETIME_FORMAT = Regexp.new(/\d+{4}-\d+{2}-\d+{2}T\d+{2}:\d+{2}:\d+{2}/).freeze
@@ -13,12 +15,15 @@ module CloudSesame
 
           attr_reader :value, :changed, :compiled
 
+          # CLASS METHODS
+          # =====================================
+
           def self.range?(value)
             value.kind_of?(Range)
           end
 
           def self.string_range?(value)
-            RANGE_FORMAT =~ strip(value)
+            value.is_a?(String) && !!(RANGE_FORMAT =~ strip(value))
           end
 
           def self.numeric?(value)
@@ -26,7 +31,7 @@ module CloudSesame
           end
 
           def self.string_numeric?(value)
-            DIGIT_FORMAT =~ value.to_s
+            value.is_a?(String) && !!(DIGIT_FORMAT =~ value)
           end
 
           def self.datetime?(value)
@@ -41,6 +46,9 @@ module CloudSesame
             value.is_a?(String) && DATE_FORMAT =~ value
           end
 
+          # INSTANCE METHODS
+          # =====================================
+
           def initialize(value, type = nil)
             self.value = value
             @type = type

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

@@ -8,10 +8,7 @@ module CloudSesame
         DATE_FORMAT = '%F'.freeze
 
         def self.parse(value)
-          if value.kind_of?(RangeValue)
-            value.type = self
-            return value
-          end
+          return value.parse self if value.kind_of?(RangeValue)
 
           range?(value) || string_range?(value) ? RangeValue.new(value, self) :
           string_datetime?(value) ? new(parse_datetime(value)) :

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

@@ -6,45 +6,53 @@ module CloudSesame
         SINGLE_QUATE = Regexp.new(/\'/).freeze
         ESCAPE_QUATE = "\\'".freeze
 
-        attr_reader :value
+        attr_reader :field, :value, :options
 
         def initialize(field, value, options = {})
           @field = field
-          @options = options
-          @value = LazyObject.new { (options[:type] || Value).parse(value) } if value
+          @options = options || default_options
+          @value = parse_value(value) if value
         end
 
-        def is_for(field, options = {})
-          @field = field
-          @options.merge! options
+        def actual_field_name
+          @options[:as] || @field
         end
 
         def applied(included)
           { field: @field, value: @value, included: included } if @value
         end
 
-        def as_field
-          @options[:as] || @field
-        end
-
         def compile(detailed = false)
           (detailed ? detailed_format : standard_format) if @value
         end
 
+        def is_for(field, options)
+          @field = field
+          @options.merge! options if options
+        end
+
         private
 
         def standard_format
-          "#{ as_field }:#{ @value.compile }"
+          "#{ actual_field_name }:#{ @value.compile }"
         end
 
         def detailed_format
-          "field=#{ escape as_field.to_s } #{ @value.compile }"
+          "field=#{ escape actual_field_name.to_s } #{ @value.compile }"
         end
 
         def escape(data)
           "'#{ data.gsub(SINGLE_QUATE) { ESCAPE_QUATE } }'"
         end
 
+        def parse_value(value)
+          LazyObject.new { (@options[:type] || Value).parse(value) }
+        end
+
+        def default_options
+          { type: Value }
+        end
+
       end
     end
   end

data/lib/cloud_sesame/query/ast/{field_array.rb → multi_expression_operator_children.rb}

@@ -1,12 +1,18 @@
 module CloudSesame
   module Query
     module AST
-      class FieldArray < Array
-        include DSL::FieldArrayMethods
+      class MultiExpressionOperatorChildren < Array
+        include DSL::LiteralChainingMethods
 
         attr_accessor :_scope, :_return
         attr_reader :field
 
+        def self.build(scope, children = nil)
+          array = new(children || [])
+          array._scope = scope
+          array
+        end
+
         def field=(field)
           parents.clear
           @field = field

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

@@ -4,14 +4,8 @@ module CloudSesame
       class Not < Abstract::SingleExpressionOperator
         SYMBOL = :not
 
-        def compile
-          if child && (compiled = child.compile) && !compiled.empty?
-            "(#{ symbol  }#{ boost } #{ compiled })"
-          end
-        end
-
         def applied(included = true)
-          child.applied(!included)
+          child.applied !included
         end
 
       end

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

@@ -4,35 +4,54 @@ module CloudSesame
       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.value =  RangeValue.range?(value) ? build_from_range(value) :
+                        RangeValue.string_range?(value) ? build_from_string(value) :
+                        initialize_value
+          self.parse type
+        end
+
+        def parse(type)
+          if type && type.respond_to?(:parse)
+            @changed = true
+            value[1] = type.parse(self.begin) unless self.begin.to_s.empty?
+            value[2] = type.parse(self.end) unless self.end.to_s.empty?
+          end
+          return self
+        end
+
+        def begin
+          value[1]
+        end
+
+        def end
+          value[2]
+        end
 
-          self.type = type if type
+        def lower_bound
+          value[0]
         end
 
-        def type=(type)
-          value_type_handler(type) if (@type = type)
-          type
+        def upper_bound
+          value[3]
         end
 
         def gt(value)
-          update_lower_value(value) if value
+          set_begin(value) if value
           return self
         end
 
         def gte(value)
-          update_lower_value(value, '[') if value
+          set_begin(value, '[') if value
           return self
         end
 
         def lt(value)
-          update_uppoer_value(value) if value
+          set_end(value) if value
           return self
         end
 
         def lte(value)
-          update_uppoer_value(value, ']') if value
+          set_end(value, ']') if value
           return self
         end
 
@@ -41,7 +60,7 @@ module CloudSesame
         end
 
         def ==(object)
-          value == RangeValue.new(object, Value).value
+          value == (object.is_a?(RangeValue) ? object : RangeValue.new(object, Value)).value
         end
 
         private
@@ -50,30 +69,26 @@ module CloudSesame
           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 = '}')
-          self.value[2] = value
-          self.value[3] = included
+        def set_begin(value, included = '{')
+          @changed = true
+          self.value[0, 2] = [included, value]
         end
 
-        def range_handler(value)
-          ['[', value.begin, value.end, value.exclude_end? ? '}' : ']']
+        def set_end(value, included = '}')
+          @changed = true
+          self.value[2, 2] = [value, included]
         end
 
-        def string_handler(value)
-          RANGE_FORMAT.match(strip(value)).captures
+        def build_from_range(range)
+          initialize_value('[', range.begin, range.end, range.exclude_end? ? '}' : ']')
         end
 
-        def value_type_handler(type)
-          self.value[1, 2] = value[1, 2].map { |v| type.parse(v) unless v.to_s.empty? }
+        def build_from_string(string)
+          initialize_value(*RANGE_FORMAT.match(strip(string)).captures)
         end
 
-        def empty_value
-          ['{', nil, nil, '}']
+        def initialize_value(lb = '[', bv = nil, ev = nil, up = ']')
+          [lb, bv, ev, up]
         end
 
       end

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

@@ -10,10 +10,8 @@ module CloudSesame
 
         private
 
-        def create_children
-          array = FieldArray.new(context[:defaults] || [])
-          array._scope = self
-          array
+        def build_children
+          MultiExpressionOperatorChildren.build(self, context[:defaults])
         end
 
       end

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

@@ -13,21 +13,13 @@ module CloudSesame
           (klass =TYPES[symbol]) ? klass : self
         end
 
-        # 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
-
+          return value.parse self if value.kind_of?(RangeValue)
           (
             range_value?(value) ? RangeValue :
             numeric_value?(value) ? NumericValue :
             datetime?(value) ? DateValue : StringValue
           ).new(value, self)
-
         end
 
         def self.range_value?(value)

data/lib/cloud_sesame/query/builder.rb

@@ -15,16 +15,16 @@ module CloudSesame
       # ClassSpecific construct class callback
       #
       # after construct searchable specific builder,
-      # construct searchable specific DSL::FieldAccessors,
+      # construct searchable specific DSL::LiteralMethods,
       # and Domain::Block and include the new field accessors
       # in both builder and domain block
       # ===================================================
       after_construct do |searchable|
-        @field_accessor = DSL::FieldAccessors.construct_module(searchable)
-        @block_domain = Domain::Block.construct_class(searchable, callback_args: [field_accessor])
+        @literal_methods = DSL::LiteralMethods.construct_module(searchable)
+        @block_domain = Domain::Block.construct_class(searchable, callback_args: [literal_methods])
         @request = Node::Request.construct_class(searchable)
 
-        include field_accessor
+        include literal_methods
       end
 
       # Domain::Block getter
@@ -37,9 +37,9 @@ module CloudSesame
         @request ||= Node::Request
       end
 
-      # DSL::FieldAccessors getter
-      def self.field_accessor
-        @field_accessor ||= DSL::FieldAccessors
+      # DSL::LiteralMethods getter
+      def self.literal_methods
+        @literal_methods ||= DSL::LiteralMethods
       end
 
       # ===================================================
@@ -62,10 +62,8 @@ module CloudSesame
       private
 
       def _block_domain(block)
-        if block
-          caller = block.binding.eval("self")
-          self.class.block_domain.new caller, _context
-        end
+        caller = block ? block.binding.eval("self") : nil
+        self.class.block_domain.new caller, _context
       end
 
       def _scope

data/lib/cloud_sesame/query/domain/block.rb

@@ -15,11 +15,9 @@ module CloudSesame
 				attr_reader :_caller, :_context, :_scopes
 
 				def initialize(_caller, _context)
-					@_caller = _caller
+					self._caller = _caller
 					@_context = _context
 					@_scopes = []
-
-					_bind_caller_instance_variables
 				end
 
 				def _eval(node, _scope, _return = _scope, &block)

data/lib/cloud_sesame/query/domain/chaining_block.rb

@@ -28,10 +28,9 @@ module CloudSesame
 				private
 
 				def _block_domain(block)
-					@_block_domain ||= (
-						caller = block.binding.eval("self")
-						Domain::Block.new caller, _scope.context
-					)
+					caller = block.binding.eval("self")
+					@_block_domain._caller = caller
+					@_block_domain
 				end
 
 				def missing_block

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

@@ -10,9 +10,7 @@ module CloudSesame
 				def initialize(_name, _options, _caller)
 					@_name = _name
 					@_options = _options
-					@_caller = _caller
-
-					_bind_caller_instance_variables
+					self._caller = _caller
 				end
 
 				def _eval(&block)

data/lib/cloud_sesame/query/dsl/bind_caller.rb

@@ -3,11 +3,16 @@ module CloudSesame
 		module DSL
 			module BindCaller
 
+				def _caller=(caller)
+					__bind_caller_instance_variables__(caller) if caller
+					@_caller = caller
+				end
+
 				private
 
-				def _bind_caller_instance_variables
-					_caller.instance_variables.each do |name|
-						value = _caller.instance_variable_get name
+				def __bind_caller_instance_variables__(caller)
+					caller.instance_variables.each do |name|
+						value = caller.instance_variable_get name
 						instance_variable_set name, value
 					end
 				end
@@ -15,9 +20,11 @@ module CloudSesame
 				# ACCESS CALLER'S METHODS
 				# =========================================
 				def method_missing(name, *args, &block)
-					_caller.send(name, *args, &block)
-				rescue NoMethodError
-					super
+					if _caller && _caller.respond_to?(name, *args, &block)
+						_caller.send(name, *args, &block)
+					else
+						super
+					end
 				end
 
 			end

data/lib/cloud_sesame/query/dsl/{field_array_methods.rb → literal_chaining_methods.rb}

@@ -1,12 +1,7 @@
-# =========================================================
-# field array methods enables field array to chain
-# operators after calling the field expression
-# accessor
-# =========================================================
 module CloudSesame
 	module Query
 		module DSL
-			module FieldArrayMethods
+			module LiteralChainingMethods
 
 				# NOT
 				# =======================================

data/lib/cloud_sesame/query/dsl/{field_accessors.rb → literal_methods.rb}

@@ -1,7 +1,7 @@
 module CloudSesame
   module Query
     module DSL
-      module FieldAccessors
+      module LiteralMethods
         extend ClassSpecific
 
         def self.__define_accessor__(name)

data/lib/cloud_sesame/query/node/fuzziness.rb

@@ -3,7 +3,7 @@ module CloudSesame
     module Node
       class Fuzziness
 
-        EXCLUDING_TERMS = /^\-/.freeze
+        EXCLUDING_TERMS = /(^\-|\*$)/.freeze
 
         def initialize(&block)
 

data/lib/cloud_sesame.rb

@@ -25,10 +25,11 @@ require 'cloud_sesame/config/credential'
 require 'cloud_sesame/query/dsl/applied_filter_query'
 require 'cloud_sesame/query/dsl/bind_caller'
 require 'cloud_sesame/query/dsl/block_styled_operators'
-require 'cloud_sesame/query/dsl/field_accessors'
+require 'cloud_sesame/query/dsl/literal_methods'
+require 'cloud_sesame/query/dsl/literal_chaining_methods'
 require 'cloud_sesame/query/dsl/scope_accessors'
 require 'cloud_sesame/query/dsl/operators'
-require 'cloud_sesame/query/dsl/field_array_methods'
+
 require 'cloud_sesame/query/dsl/inspect_method'
 require 'cloud_sesame/query/dsl/page_methods'
 require 'cloud_sesame/query/dsl/query_methods'
@@ -49,7 +50,7 @@ require 'cloud_sesame/query/ast/abstract/operator'
 require 'cloud_sesame/query/ast/abstract/multi_expression_operator'
 require 'cloud_sesame/query/ast/abstract/single_expression_operator'
 require 'cloud_sesame/query/ast/abstract/value'
-require 'cloud_sesame/query/ast/field_array'
+require 'cloud_sesame/query/ast/multi_expression_operator_children'
 require 'cloud_sesame/query/ast/and'
 require 'cloud_sesame/query/ast/or'
 require 'cloud_sesame/query/ast/not'

data/spec/cloud_sesame/query/ast/abstract/multi_expression_operator_spec.rb

@@ -19,11 +19,15 @@ module CloudSesame
               expect(subject.children).to be_empty
             end
             it 'should be an Field Array' do
-              expect(subject.children).to be_a AST::FieldArray
+              expect(subject.children).to be_a AST::MultiExpressionOperatorChildren
             end
           end
 
           describe '#compile' do
+            it 'should accept one optional param' do
+              expect{ subject.compile(true) }.to_not raise_error
+            end
+
             context 'when theres children' do
               let(:child) { OpenStruct.new(compile: "compiled") }
               before { subject.children << child }

data/spec/cloud_sesame/query/ast/field_array_spec.rb

@@ -0,0 +1,57 @@
+module CloudSesame
+  module Query
+    module AST
+      describe MultiExpressionOperatorChildren do
+
+        describe '.build' do
+
+
+
+          context 'when children is given' do
+
+          end
+        end
+
+        describe '#field=' do
+
+        end
+
+        describe '#parents' do
+
+        end
+
+        describe '#_context' do
+
+        end
+
+        describe '#compile' do
+
+        end
+      end
+      # class FieldArray < Array
+      #   include DSL::FieldArrayMethods
+
+      #   attr_accessor :_scope, :_return
+      #   attr_reader :field
+
+      #   def field=(field)
+      #     parents.clear
+      #     @field = field
+      #   end
+
+      #   def parents
+      #     @parents ||= []
+      #   end
+
+      #   def _context
+      #     _scope && _scope.context
+      #   end
+
+      #   def compile
+      #     map(&:compile).join(' ')
+      #   end
+
+      # end
+    end
+  end
+end