mongoid_query_string_interface 0.7.1 → 0.7.2

data/Gemfile

@@ -11,6 +11,6 @@ platforms :mri_18 do
 end
 
 platforms :mri_19 do
-  gem "ruby-debug19", :require => 'ruby-debug' if RUBY_VERSION < "1.9.3"
+  gem "debugger"
   gem 'simplecov', :require => false
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mongoid_query_string_interface (0.7.1)
+    mongoid_query_string_interface (0.7.2)
       mongoid (>= 2.0.2)
       query_string_interface (>= 0.5.0)
       will_paginate (~> 3.0.pre2)
@@ -9,31 +9,35 @@ PATH
 GEM
   remote: http://rubygems.org/
   specs:
-    activemodel (3.2.6)
-      activesupport (= 3.2.6)
+    activemodel (3.2.12)
+      activesupport (= 3.2.12)
       builder (~> 3.0.0)
-    activesupport (3.2.6)
+    activesupport (3.2.12)
       i18n (~> 0.6)
       multi_json (~> 1.0)
-    archive-tar-minitar (0.5.2)
     bson (1.3.1)
     bson_ext (1.3.1)
-    builder (3.0.0)
+    builder (3.0.4)
     columnize (0.3.4)
     database_cleaner (0.6.7)
+    debugger (1.5.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.0)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.0)
     diff-lcs (1.1.2)
-    i18n (0.6.0)
+    i18n (0.6.4)
     linecache (0.46)
       rbx-require-relative (> 0.0.4)
-    linecache19 (0.5.12)
-      ruby_core_source (>= 0.1.4)
-    mongo (1.3.1)
-      bson (>= 1.3.1)
-    mongoid (2.4.11)
-      activemodel (~> 3.1)
-      mongo (<= 1.6.2)
+    mongoid (3.1.2)
+      activemodel (~> 3.2)
+      moped (~> 1.4.2)
+      origin (~> 1.0)
       tzinfo (~> 0.3.22)
-    multi_json (1.3.6)
+    moped (1.4.3)
+    multi_json (1.7.0)
+    origin (1.0.11)
     query_string_interface (0.5.0)
       activesupport (>= 3.0.0)
     rake (0.8.7)
@@ -51,21 +55,11 @@ GEM
       ruby-debug-base (~> 0.10.4.0)
     ruby-debug-base (0.10.4)
       linecache (>= 0.3)
-    ruby-debug-base19 (0.11.25)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby_core_source (>= 0.1.4)
-    ruby-debug19 (0.11.6)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby-debug-base19 (>= 0.11.19)
-    ruby_core_source (0.1.5)
-      archive-tar-minitar (>= 0.5.2)
     simplecov (0.4.2)
       simplecov-html (~> 0.4.4)
     simplecov-html (0.4.5)
-    tzinfo (0.3.33)
-    will_paginate (3.0.3)
+    tzinfo (0.3.37)
+    will_paginate (3.0.4)
 
 PLATFORMS
   ruby
@@ -74,9 +68,9 @@ DEPENDENCIES
   bson
   bson_ext
   database_cleaner (>= 0.5.0)
+  debugger
   mongoid_query_string_interface!
   rake (= 0.8.7)
   rspec (>= 2.3.0)
   ruby-debug
-  ruby-debug19
   simplecov

data/lib/mongoid/helpers.rb

@@ -0,0 +1,24 @@
+module Mongoid
+  module QueryStringInterface
+    module Helpers
+      def hash_with_indifferent_access(params)
+        params.is_a?(HashWithIndifferentAccess) ? params : params.with_indifferent_access
+      end
+
+      def replace_attribute(attribute, hash_with_attributes_to_replace)
+        hash = hash_with_indifferent_access(hash_with_attributes_to_replace)
+        hash.has_key?(attribute) ? hash[attribute] : attribute
+      end
+
+      def replaced_attribute_name(attribute, hash_with_attributes_to_replace)
+        attribute = replace_attribute(attribute, hash_with_attributes_to_replace)
+        attribute.is_a?(Hash) ? attribute[:to] : attribute
+      end
+
+      def replaced_attribute_value(attribute, value, hash_with_attributes_to_replace, raw_params)
+        attribute = replace_attribute(attribute, hash_with_attributes_to_replace)
+        attribute.is_a?(Hash) ? attribute[:convert_value_to].call(value, raw_params) : value
+      end
+    end
+  end
+end

data/lib/mongoid/parsers/array_parser.rb

@@ -0,0 +1,28 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class ArrayParser
+        ARRAY_SEPARATOR = '|'
+  
+        def parseable?(value, operator)
+          operator && conditional_operators.include?(operator)
+        end
+  
+        def parse(value)
+          value.split(ARRAY_SEPARATOR).map(&:strip).map do |item|
+            regex_parser.parse(item) or item
+          end
+        end
+        
+        private
+          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
+end

data/lib/mongoid/parsers/boolean_and_nil_parser.rb

@@ -0,0 +1,30 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class BooleanAndNilParser
+        def parseable?(value, operator)
+          !value.nil? && !value.empty?
+        end
+        
+        def parse(value)
+          if boolean?(value)
+            value.strip == 'true'
+          elsif value.nil? or value.empty? or nil_value?(value)
+            nil
+          else
+            value
+          end
+        end
+        
+        private
+          def boolean?(value)
+            value && ['true', 'false'].include?(value.strip)
+          end
+          
+          def nil_value?(value)
+            value && ['nil', 'null'].include?(value.strip)
+          end
+      end
+    end
+  end
+end

data/lib/mongoid/parsers/date_time_parser.rb

@@ -0,0 +1,17 @@
+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)
+          DATE_REGEX.match(value)
+        end
+        
+        def parse(value)
+          Time.parse(value)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/parsers/filter_parser.rb

@@ -0,0 +1,158 @@
+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
+        include Mongoid::QueryStringInterface::Helpers
+
+        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, attributes_to_replace={}, raw_params={})
+          @raw_attribute = raw_attribute
+          @raw_value = raw_value
+          @attributes_to_replace = attributes_to_replace
+          @raw_params = raw_params
+        end
+
+        def attribute
+          @attribute ||= replaced_attribute_name(parsed_attribute, @attributes_to_replace).to_s
+        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 raw_attribute.is_a?(Mongoid::Criterion::Complex)
+              raw_attribute.key.to_s
+            elsif 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 => replaced_attribute_value(parsed_attribute, parsed_value, @attributes_to_replace, @raw_params) }
+              end
+            else
+              replaced_attribute_value(parsed_attribute, parsed_value, @attributes_to_replace, @raw_params)
+            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, {}, @attributes_to_replace, @raw_params)
+            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 attribute.is_a?(Mongoid::Criterion::Complex)
+              "$#{attribute.operator}"
+            elsif 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,77 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class FiltersParser
+        include Mongoid::QueryStringInterface::Helpers
+
+        attr_reader :filters, :default_filters
+
+        def initialize(filters, default_filters={}, attributes_to_replace={}, raw_filters=nil)
+          @filters = filters.with_indifferent_access
+          @default_filters = default_filters.with_indifferent_access
+          @attributes_to_replace = attributes_to_replace.with_indifferent_access
+          @raw_filters = raw_filters.nil? ? @filters : raw_filters.with_indifferent_access
+        end
+
+        def parse
+          result = default_filters.inject({}) do |result, item|
+            raw_attribute, raw_value = item
+            result[replaced_attribute_name(raw_attribute, @attributes_to_replace).to_s] = replaced_attribute_value(raw_attribute, raw_value, @attributes_to_replace, @raw_filters)
+            result
+          end
+          result.merge(parsed_filters)
+        end
+
+        def filter_parsers
+          @filter_parsers ||= filters.map do |raw_attribute, raw_value|
+            FilterParser.new(raw_attribute, raw_value, @attributes_to_replace, @raw_filters)
+          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/parsers/number_parser.rb

@@ -0,0 +1,28 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class NumberParser
+        def parseable?(value, operator)
+          integer?(value) or float?(value)
+        end
+        
+        def parse(value)
+          if integer?(value)
+            value.to_i
+          elsif float?(value)
+            value.to_f
+          end
+        end
+        
+        private
+          def integer?(value)
+            value =~ /^\d+$/
+          end
+          
+          def float?(value)
+            value =~ /^(\d+)(\.?\d*)$/
+          end
+      end
+    end
+  end
+end

data/lib/mongoid/parsers/regex_parser.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class RegexParser
+        def parseable?(value, operator)
+          value =~ /^\/(.*)\/(i|m|x)?$/
+        end
+        
+        def parse(value)
+          if value =~ /^\/(.*)\/(i|m|x)?$/
+            eval($&)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/query_string_interface.rb

@@ -91,7 +91,7 @@ module Mongoid
       end
 
       def collection_name_in_pagination_result
-        model_name.human.underscore.pluralize.to_sym
+        model_name.human.underscore.pluralize.gsub(/\s/, "_").to_sym
       end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_query_string_interface
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-20 00:00:00.000000000Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: query_string_interface
-  requirement: &2164829240 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: 0.5.0
   type: :runtime
   prerelease: false
-  version_requirements: *2164829240
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: will_paginate
-  requirement: &2164828760 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +37,15 @@ dependencies:
         version: 3.0.pre2
   type: :runtime
   prerelease: false
-  version_requirements: *2164828760
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.pre2
 - !ruby/object:Gem::Dependency
   name: mongoid
-  requirement: &2164828280 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +53,15 @@ dependencies:
         version: 2.0.2
   type: :runtime
   prerelease: false
-  version_requirements: *2164828280
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.2
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2164827800 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +69,15 @@ dependencies:
         version: 2.3.0
   type: :development
   prerelease: false
-  version_requirements: *2164827800
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
   name: database_cleaner
-  requirement: &2164827320 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +85,12 @@ dependencies:
         version: 0.5.0
   type: :development
   prerelease: false
-  version_requirements: *2164827320
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 description: Gives a method that can parse query string parameters into a set of criterias
   that Mongoid can use to perform actual queries in MongoDB databases for a given
   model.
@@ -77,8 +102,16 @@ extra_rdoc_files: []
 files:
 - lib/mongoid/paginate.rb
 - lib/mongoid/query_string_interface.rb
-- lib/mongoid_query_string_interface.rb
+- lib/mongoid/helpers.rb
+- lib/mongoid/parsers/date_time_parser.rb
+- lib/mongoid/parsers/filters_parser.rb
+- lib/mongoid/parsers/regex_parser.rb
+- lib/mongoid/parsers/boolean_and_nil_parser.rb
+- lib/mongoid/parsers/array_parser.rb
+- lib/mongoid/parsers/filter_parser.rb
+- lib/mongoid/parsers/number_parser.rb
 - lib/version.rb
+- lib/mongoid_query_string_interface.rb
 - MIT_LICENSE
 - README.md
 - Gemfile
@@ -103,7 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: mongoid_query_string_interface
-rubygems_version: 1.8.15
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: An interface for performing queries in MongoDB using query string parameters.