mongoid_query_string_interface 0.2.4 → 0.3.0

data/Gemfile

@@ -12,4 +12,5 @@ end
 
 platforms :mri_19 do
   gem "ruby-debug19", :require => 'ruby-debug' if RUBY_VERSION < "1.9.3"
+  gem 'simplecov', :require => false
 end

data/Gemfile.lock

@@ -1,46 +1,46 @@
 PATH
   remote: .
   specs:
-    mongoid_query_string_interface (0.2.4)
+    mongoid_query_string_interface (0.3.0)
       json (>= 1.4.6)
       mongoid (~> 2.0.0.rc)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.0.3)
-      activesupport (= 3.0.3)
+    activemodel (3.0.5)
+      activesupport (= 3.0.5)
       builder (~> 2.1.2)
       i18n (~> 0.4)
-    activesupport (3.0.3)
+    activesupport (3.0.5)
     archive-tar-minitar (0.5.2)
-    bson (1.2.0)
-    bson_ext (1.2.0)
+    bson (1.2.4)
+    bson_ext (1.2.4)
     builder (2.1.2)
     columnize (0.3.2)
-    database_cleaner (0.6.1)
+    database_cleaner (0.6.6)
     diff-lcs (1.1.2)
     i18n (0.5.0)
-    json (1.4.6)
+    json (1.5.1)
     linecache (0.43)
     linecache19 (0.5.11)
       ruby_core_source (>= 0.1.4)
-    mongo (1.2.0)
-      bson (>= 1.2.0)
-    mongoid (2.0.0.rc.7)
+    mongo (1.2.4)
+      bson (>= 1.2.4)
+    mongoid (2.0.0.rc.8)
       activemodel (~> 3.0)
       mongo (~> 1.2)
       tzinfo (~> 0.3.22)
       will_paginate (~> 3.0.pre)
     rake (0.8.7)
-    rspec (2.4.0)
-      rspec-core (~> 2.4.0)
-      rspec-expectations (~> 2.4.0)
-      rspec-mocks (~> 2.4.0)
-    rspec-core (2.4.0)
-    rspec-expectations (2.4.0)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.4.0)
+    rspec-mocks (2.5.0)
     ruby-debug (0.10.4)
       columnize (>= 0.1)
       ruby-debug-base (~> 0.10.4.0)
@@ -56,7 +56,10 @@ GEM
       ruby-debug-base19 (>= 0.11.19)
     ruby_core_source (0.1.4)
       archive-tar-minitar (>= 0.5.2)
-    tzinfo (0.3.24)
+    simplecov (0.4.1)
+      simplecov-html (~> 0.4.3)
+    simplecov-html (0.4.3)
+    tzinfo (0.3.25)
     will_paginate (3.0.pre2)
 
 PLATFORMS
@@ -73,3 +76,4 @@ DEPENDENCIES
   rspec (>= 2.3.0)
   ruby-debug
   ruby-debug19
+  simplecov

data/lib/mongoid/parsers/array_parser.rb

@@ -3,10 +3,9 @@ module Mongoid
     module Parsers
       class ArrayParser
         ARRAY_SEPARATOR = '|'
-        ARRAY_CONDITIONAL_OPERATORS = [:$all, :$in, :$nin]
   
         def parseable?(value, operator)
-          operator && ARRAY_CONDITIONAL_OPERATORS.include?(operator.to_sym)
+          operator && conditional_operators.include?(operator)
         end
   
         def parse(value)
@@ -19,6 +18,10 @@ module Mongoid
           def regex_parser
             @regex_parser ||= RegexParser.new
           end
+
+          def conditional_operators
+            @conditional_operators ||= Mongoid::QueryStringInterface::ARRAY_CONDITIONAL_OPERATORS.map { |o| "$#{o}" }
+          end
       end
     end
   end

data/lib/mongoid/parsers/date_time_parser.rb

@@ -2,14 +2,14 @@ module Mongoid
   module QueryStringInterface
     module Parsers
       class DateTimeParser
+        DATE_REGEX = /^(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?([ \t]*)(Z?|[-+]\d{2}?(:?\d{2})?))$/
+
         def parseable?(value, operator)
-          not parse(value).nil?
+          DATE_REGEX.match(value)
         end
         
         def parse(value)
-          value.to_time and Time.parse(value)
-        rescue Exception
-          nil
+          Time.parse(value)
         end
       end
     end

data/lib/mongoid/parsers/filter_parser.rb

@@ -0,0 +1,149 @@
+require 'cgi'
+
+require File.expand_path(File.join('date_time_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('number_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('array_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('regex_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('boolean_and_nil_parser'), File.dirname(__FILE__))
+
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class FilterParser
+        attr_reader :raw_attribute, :raw_value
+
+        PARSERS = [
+          Mongoid::QueryStringInterface::Parsers::DateTimeParser.new,
+          Mongoid::QueryStringInterface::Parsers::NumberParser.new,
+          Mongoid::QueryStringInterface::Parsers::ArrayParser.new,
+          Mongoid::QueryStringInterface::Parsers::RegexParser.new,
+          Mongoid::QueryStringInterface::Parsers::BooleanAndNilParser.new
+        ]
+
+        def initialize(raw_attribute, raw_value)
+          @raw_attribute = raw_attribute
+          @raw_value = raw_value
+        end
+
+        def attribute
+          @attribute ||= parsed_attribute
+        end
+
+        def value
+          @value ||= expanded_value
+        end
+
+        def operator
+          @operator ||= operator_from(raw_attribute)
+        end
+
+        def or_attribute?
+          raw_attribute == 'or'
+        end
+
+        def include?(other_filter)
+          if or_attribute?
+            json_value.any? do |filters|
+              filters.filter_parsers.any? do |filter_parser|
+                filter_parser.attribute == other_filter.attribute &&
+                  conditional_array_operators.include?(filter_parser.operator) &&
+                  filter_parser.operator == other_filter.operator
+              end
+            end
+          end
+        end
+
+        def merge(other_filter)
+          if or_attribute?
+            @value = json_value.map do |filters|
+              filters.filter_parsers << other_filter
+              filters.parse
+            end
+          elsif conditional_array_operators.include?(other_filter.operator) && operator == other_filter.operator
+            @value = value.inject({}) do |result, filter|
+              filter_operation, filter_value = filter
+              filter_value = filter_value.concat(other_filter.value[filter_operation]) if other_filter.value[filter_operation]
+              result[filter_operation] = filter_value
+              result
+            end
+          else
+            @value = value.merge(other_filter.value)
+          end
+        end
+
+        private
+          def parsed_attribute
+            if or_attribute?
+              '$or'
+            elsif raw_attribute =~ Mongoid::QueryStringInterface::ATTRIBUTE_REGEX
+              $1
+            else
+              raw_attribute
+            end
+          end
+
+          def expanded_value
+            if operator
+              if or_attribute?
+                parsed_json_value
+              else
+                { operator => parsed_value }
+              end
+            else
+              parsed_value
+            end
+          end
+
+          def parsed_value
+            if raw_value.is_a?(String)
+              PARSERS.each do |parser|
+                return parser.parse(unescaped_raw_value) if parser.parseable?(unescaped_raw_value, operator)
+              end
+
+              return nil
+            else
+              raw_value
+            end
+          end
+
+          def parsed_json_value
+            if unescaped_raw_value.is_a?(String)
+              json_value.map(&:parse)
+            else
+              unescaped_raw_value
+            end
+          end
+
+          def json_value
+            raw_or_data = ::JSON.parse(unescaped_raw_value)
+
+            raise "$or query filters must be given as an array of hashes" unless valid_or_filters?(raw_or_data)
+
+            raw_or_data.map do |filters|
+              FiltersParser.new(filters)
+            end
+          end
+
+          def valid_or_filters?(raw_or_data)
+            raw_or_data.is_a?(Array) and raw_or_data.all? { |item| item.is_a?(Hash) }
+          end
+
+          def unescaped_raw_value
+            @unescaped_raw_value ||= raw_value.is_a?(String) ? CGI.unescape(raw_value) : raw_value
+          end
+
+          def conditional_array_operators
+            Mongoid::QueryStringInterface::ARRAY_CONDITIONAL_OPERATORS.map { |o| "$#{o}" }
+          end
+
+          def operator_from(attribute)
+            if or_attribute?
+              '$or'
+            elsif attribute =~ Mongoid::QueryStringInterface::OPERATOR_REGEX
+              "$#{$1}"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/mongoid/parsers/filters_parser.rb

@@ -0,0 +1,68 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class FiltersParser
+        attr_reader :filters, :default_filters
+
+        def initialize(filters, default_filters={})
+          @filters = filters.with_indifferent_access
+          @default_filters = default_filters.with_indifferent_access
+        end
+
+        def parse
+          default_filters.merge(parsed_filters)
+        end
+
+        def filter_parsers
+          @filter_parsers ||= filters.map do |raw_attribute, raw_value|
+            FilterParser.new(raw_attribute, raw_value)
+          end
+        end
+
+        private
+
+          def parsed_filters
+            filter_parsers_hash.inject({}) do |result, item|
+              attribute, filter_parser = item
+
+              result[attribute] = filter_parser.value
+
+              result
+            end
+          end
+
+          def filter_parsers_hash
+            optimized_filter_parsers.inject({}) do |result, filter_parser|
+              if result.has_key?(filter_parser.attribute)
+                result[filter_parser.attribute].merge(filter_parser)
+              else
+                result[filter_parser.attribute] = filter_parser
+              end
+
+              result
+            end
+          end
+
+          def optimized_filter_parsers
+            if or_filter_parser
+              filter_parsers.inject([]) do |result, filter_parser|
+                if filter_parser != or_filter_parser && or_filter_parser.include?(filter_parser)
+                  or_filter_parser.merge(filter_parser)
+                else
+                  result << filter_parser
+                end
+
+                result
+              end
+            else
+              filter_parsers
+            end
+          end
+
+          def or_filter_parser
+            @or_filter_parser ||= filter_parsers.select { |filter_parser| filter_parser.or_attribute? }.first
+          end
+      end
+    end
+  end
+end

data/lib/mongoid/query_string_interface.rb

@@ -1,25 +1,23 @@
-require File.expand_path(File.join('parsers', 'date_time_parser'), File.dirname(__FILE__))
-require File.expand_path(File.join('parsers', 'number_parser'), File.dirname(__FILE__))
-require File.expand_path(File.join('parsers', 'array_parser'), File.dirname(__FILE__))
-require File.expand_path(File.join('parsers', 'regex_parser'), File.dirname(__FILE__))
-require File.expand_path(File.join('parsers', 'boolean_and_nil_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('parsers', 'filter_parser'), File.dirname(__FILE__))
+require File.expand_path(File.join('parsers', 'filters_parser'), File.dirname(__FILE__))
 
 module Mongoid
   module QueryStringInterface
-    CONDITIONAL_OPERATORS = [:all, :exists, :gte, :gt, :in, :lte, :lt, :ne, :nin, :size, :near, :within]
+    NORMAL_CONDITIONAL_OPERATORS = [:exists, :gte, :gt, :lte, :lt, :ne, :size, :near, :within]
+    ARRAY_CONDITIONAL_OPERATORS = [:all, :in, :nin]
+    CONDITIONAL_OPERATORS = ARRAY_CONDITIONAL_OPERATORS + NORMAL_CONDITIONAL_OPERATORS
     SORTING_OPERATORS = [:asc, :desc]
     OR_OPERATOR = :or
-    
-    ATTRIBUTE_REGEX = /(.*)\.(#{(CONDITIONAL_OPERATORS + SORTING_OPERATORS + [OR_OPERATOR]).join('|')})/
+
+    ATTRIBUTE_REGEX = /^(.*)\.(#{(CONDITIONAL_OPERATORS + SORTING_OPERATORS + [OR_OPERATOR]).join('|')})$/
+    OPERATOR_REGEX = /^.*\.(#{Mongoid::QueryStringInterface::CONDITIONAL_OPERATORS.join('|')})$/
+
     PAGER_ATTRIBUTES = [:total_entries, :total_pages, :per_page, :offset, :previous_page, :current_page, :next_page]
 
-    PARSERS = [
-      Mongoid::QueryStringInterface::Parsers::DateTimeParser.new,
-      Mongoid::QueryStringInterface::Parsers::NumberParser.new,
-      Mongoid::QueryStringInterface::Parsers::ArrayParser.new,
-      Mongoid::QueryStringInterface::Parsers::RegexParser.new,
-      Mongoid::QueryStringInterface::Parsers::BooleanAndNilParser.new
-    ]
+    ORDER_BY_PARAMETER = :order_by
+    PAGINATION_PARAMTERS = [:per_page, :page]
+    FRAMEWORK_PARAMETERS = [:controller, :action, :format]
+    RESERVED_PARAMETERS = FRAMEWORK_PARAMETERS + PAGINATION_PARAMTERS + [ORDER_BY_PARAMETER]
     
     def filter_by(params={})
       params = hash_with_indifferent_access(params)
@@ -67,175 +65,47 @@ module Mongoid
       end
     end
 
-    def default_filtering_options
-      {}
-    end
-
-    def default_sorting_options
-      []
-    end
-
-    def default_pagination_options
-      { :per_page => 12, :page => 1 }
-    end
+    def default_filtering_options; {}; end
+    def default_sorting_options; []; end
+    def default_pagination_options; { :per_page => 12, :page => 1 }; end
 
     protected
       def pagination_options(options)
-        options.reverse_merge default_pagination_options
+        hash_with_indifferent_access(default_pagination_options).merge(options)
       end
   
       def filtering_options(options)
-        default_filtering_options.merge(parse_operators(only_filtering(options)))
+        Mongoid::QueryStringInterface::Parsers::FiltersParser.new(
+          only_filtering(options),
+          default_filtering_options
+        ).parse
       end
   
       def sorting_options(options)
-        options = only_sorting(options)
-
-        sorting_options = []
-        sorting_options.concat(parse_order_by(options))
-        sorting_options.concat(parse_sorting(options))      
-    
-        sorting_options.empty? ? default_sorting_options : sorting_options
-      end
-  
-      def parse_operators(options)
-        options.inject({}) do |result, item|
-          key, value = item
-      
-          attribute = attribute_from(key)
-          
-          if or_attribute?(attribute)
-            parse_or_attribute(attribute, key, value, result)
-          else
-            parse_normal_attribute(attribute, key, value, result)
-          end
-        end
-      end
-      
-      def parse_or_attribute(attribute, key, value, result)
-        result["$or"] = ::JSON.parse(unescape(value)).map do |filters|
-          parse_operators(filters)
-        end
-        
-        result
-      end
-      
-      def parse_normal_attribute(attribute, key, value, result)
-        operator = operator_from(key)
-        value = parse_value(value, operator)
-
-        if operator
-          filter = { operator => value }
-
-          if result.has_key?(attribute)
-            result[attribute].merge!(filter)
-          else
-            result[attribute] = filter
-          end
-        else
-          result[attribute] = value
-        end
-    
-        result
-      end
-  
-      def attribute_from(key)
-        if key =~ ATTRIBUTE_REGEX
-          $1.to_sym
-        else
-          key.to_sym
-        end
-      end
-      
-      def or_attribute?(attribute)
-        OR_OPERATOR == attribute
-      end
-  
-      def operator_from(key)
-        if match = key.match(/.*\.(#{CONDITIONAL_OPERATORS.join('|')})/)
-          "$#{match[1]}".to_sym
-        end
-      end
-      
-      def unescape(value)
-        URI.unescape(value)
-      end
-  
-      def parse_value(value, operator)
-        if value.is_a?(String)
-          value = unescape(value)
-          
-          PARSERS.each do |parser|
-            return parser.parse(value) if parser.parseable?(value, operator)
-          end
-        
-          return nil
-        else
-          value
-        end
+        parse_order_by(options) || default_sorting_options
       end
   
       def hash_with_indifferent_access(params)
-        params.is_a?(HashWithIndifferentAccess) ? params : HashWithIndifferentAccess.new(params)
+        params.is_a?(HashWithIndifferentAccess) ? params : params.with_indifferent_access
       end
   
       def only_filtering(options)
-        options.except(*only_sorting(options).keys).except(:per_page, :page, :action, :controller, :format, :order_by)
-      end
-  
-      def only_sorting(options)
-        options.inject({}) do |result, item|
-          key, value = item
-          result[key] = value if sorting_parameter?(key, value)
-          result
-        end
-      end
-  
-      def sorting_parameter?(key, value)
-        order_by_parameter?(key) or sorting_key_parameter?(key) or sorting_value_parameter?(value)
-      end
-      
-      def order_by_parameter?(key)
-        key.to_s == 'order_by'
-      end
-      
-      def sorting_key_parameter?(key)
-        key.match(/(.*)\.(#{SORTING_OPERATORS.join('|')})/)
-      end
-      
-      def sorting_value_parameter?(value)
-        value.present? && SORTING_OPERATORS.include?(value.to_sym)
+        options.except(*RESERVED_PARAMETERS)
       end
   
       def parse_order_by(options)
-        sorting_options = []
-    
-        if order_by = options.delete('order_by')
-          if match = order_by.match(/(.*)\.(#{SORTING_OPERATORS.join('|')})/)
-            sorting_options << match[1].to_sym.send(match[2])
-          else
-            sorting_options << order_by.to_sym.asc
+        if options.has_key?('order_by')
+          options['order_by'].split('|').map do |field|
+            sorting_operator_for(field)
           end
         end
-    
-        sorting_options
       end
-  
-      def parse_sorting(options)
-        options.inject([]) do |result, item|
-          key, value = item
-      
-          attribute = attribute_from(key)
-          sorting_operator = sorting_operator_from(key)
 
-          result << attribute.send(sorting_operator || value)        
-          result
-        end
-      end
-  
-      def sorting_operator_from(key)
-        if match = key.match(/.*\.(#{SORTING_OPERATORS.join('|')})/)
-          match[1].to_sym
+      def sorting_operator_for(field)
+        if match = field.match(/(.*)\.(#{SORTING_OPERATORS.join('|')})/)
+          match[1].to_sym.send(match[2])
+        else
+          field.to_sym.asc
         end
       end
   end

data/lib/version.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 module Mongoid #:nodoc
   module QueryStringInterface #:nodoc
-    VERSION = "0.2.4"
+    VERSION = "0.3.0"
   end
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: mongoid_query_string_interface
 version: !ruby/object:Gem::Version 
-  hash: 31
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 4
-  version: 0.2.4
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Vicente Mundim
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-21 00:00:00 -03:00
+date: 2011-03-29 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,7 +25,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 11
         segments: 
         - 1
         - 4
@@ -42,7 +40,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7712058
         segments: 
         - 2
         - 0
@@ -59,7 +56,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
         segments: 
         - 2
         - 3
@@ -75,7 +71,6 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 11
         segments: 
         - 0
         - 5
@@ -96,6 +91,8 @@ files:
 - lib/mongoid/parsers/array_parser.rb
 - lib/mongoid/parsers/boolean_and_nil_parser.rb
 - lib/mongoid/parsers/date_time_parser.rb
+- lib/mongoid/parsers/filter_parser.rb
+- lib/mongoid/parsers/filters_parser.rb
 - lib/mongoid/parsers/number_parser.rb
 - lib/mongoid/parsers/regex_parser.rb
 - lib/mongoid/query_string_interface.rb
@@ -119,7 +116,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
@@ -128,7 +124,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 23
       segments: 
       - 1
       - 3