mongoid_query_string_interface 0.1.7 → 0.2.0

data/Gemfile

@@ -0,0 +1,15 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem "rake", "0.8.7"
+gem 'bson'
+gem 'bson_ext'
+
+platforms :mri_18 do
+  gem "ruby-debug"
+end
+
+platforms :mri_19 do
+  gem "ruby-debug19", :require => 'ruby-debug' if RUBY_VERSION < "1.9.3"
+end

data/Gemfile.lock

@@ -0,0 +1,75 @@
+PATH
+  remote: .
+  specs:
+    mongoid_query_string_interface (0.2.0)
+      json (>= 1.4.6)
+      mongoid (~> 2.0.0.rc)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activesupport (3.0.3)
+    archive-tar-minitar (0.5.2)
+    bson (1.2.0)
+    bson_ext (1.2.0)
+    builder (2.1.2)
+    columnize (0.3.2)
+    database_cleaner (0.6.1)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    json (1.4.6)
+    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)
+      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)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.24)
+      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.4)
+      archive-tar-minitar (>= 0.5.2)
+    tzinfo (0.3.24)
+    will_paginate (3.0.pre2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson
+  bson_ext
+  database_cleaner (>= 0.5.0)
+  json (>= 1.4.6)
+  mongoid (~> 2.0.0.rc)
+  mongoid_query_string_interface!
+  rake (= 0.8.7)
+  rspec (>= 2.3.0)
+  ruby-debug
+  ruby-debug19

data/lib/mongoid/parsers/array_parser.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module QueryStringInterface
+    module Parsers
+      class ArrayParser
+        ARRAY_SEPARATOR = '|'
+        ARRAY_CONDITIONAL_OPERATORS = [:$all, :$in, :$nin]
+  
+        def parseable?(value, operator)
+          operator && ARRAY_CONDITIONAL_OPERATORS.include?(operator.to_sym)
+        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
+      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
+        def parseable?(value, operator)
+          not parse(value).nil?
+        end
+        
+        def parse(value)
+          value.to_time and Time.parse(value)
+        rescue Exception
+          nil
+        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

@@ -0,0 +1,212 @@
+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__))
+
+module Mongoid
+  module QueryStringInterface
+    CONDITIONAL_OPERATORS = [:all, :exists, :gte, :gt, :in, :lte, :lt, :ne, :nin, :size, :near, :within]
+    SORTING_OPERATORS = [:asc, :desc]
+    OR_OPERATOR = :or
+    
+    ATTRIBUTE_REGEX = /(.*)\.(#{(CONDITIONAL_OPERATORS + SORTING_OPERATORS + [OR_OPERATOR]).join('|')})/
+    
+    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 filter_by(params={})
+      params = hash_with_indifferent_access(params)
+      filter_only_by(params).order_by(*sorting_options(params)).paginate(pagination_options(params))
+    end
+    
+    def filter_only_by(params={})
+      where(filtering_options(hash_with_indifferent_access(params)))
+    end
+
+    def paginated_collection_with_filter_by(params={})
+      params = hash_with_indifferent_access(params)
+  
+      pagination = pagination_options(params)
+      pager = WillPaginate::Collection.new pagination[:page], pagination[:per_page], where(filtering_options(params)).count
+  
+      [:total_entries, :total_pages, :per_page, :offset, :previous_page, :current_page, :next_page].inject({}) do |result, attr|
+        result[attr] = pager.send(attr)
+        result
+      end
+    end
+
+    def default_filtering_options
+      {}
+    end
+
+    def default_sorting_options
+      []
+    end
+
+    private
+      def pagination_options(options)
+        options.reverse_merge :per_page => 12, :page => 1
+      end
+  
+      def filtering_options(options)
+        default_filtering_options.merge(parse_operators(only_filtering(options)))
+      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
+      end
+  
+      def hash_with_indifferent_access(params)
+        params.is_a?(HashWithIndifferentAccess) ? params : HashWithIndifferentAccess.new(params)
+      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)
+      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
+          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
+        end
+      end
+  end
+end

data/lib/mongoid_query_string_interface.rb

@@ -1,220 +1 @@
-module Mongoid
-  module QueryStringInterface
-    CONDITIONAL_OPERATORS = [:all, :exists, :gte, :gt, :in, :lte, :lt, :ne, :nin, :size, :near, :within]
-    ARRAY_CONDITIONAL_OPERATORS = [:all, :in, :nin]
-    SORTING_OPERATORS = [:asc, :desc]
-
-    def filter_by(params={})
-      params = hash_with_indifferent_access(params)
-      filter_only_by(params).order_by(*sorting_options(params)).paginate(pagination_options(params))
-    end
-    
-    def filter_only_by(params={})
-      where(filtering_options(hash_with_indifferent_access(params)))
-    end
-
-    def paginated_collection_with_filter_by(params={})
-      params = hash_with_indifferent_access(params)
-  
-      pagination = pagination_options(params)
-      pager = WillPaginate::Collection.new pagination[:page], pagination[:per_page], where(filtering_options(params)).count
-  
-      [:total_entries, :total_pages, :per_page, :offset, :previous_page, :current_page, :next_page].inject({}) do |result, attr|
-        result[attr] = pager.send(attr)
-        result
-      end
-    end
-
-    def default_filtering_options
-      {}
-    end
-
-    def default_sorting_options
-      []
-    end
-
-    private
-      def pagination_options(options)
-        options.reverse_merge :per_page => 12, :page => 1
-      end
-  
-      def filtering_options(options)
-        default_filtering_options.merge(parse_operators(only_filtering(options)))
-      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)
-          operator = operator_from(key)
-          value = parse_value(unescape(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
-      end
-  
-      def attribute_from(key)
-        if match = key.match(/(.*)\.(#{(CONDITIONAL_OPERATORS + SORTING_OPERATORS).join('|')})/)
-          match[1].to_sym
-        else
-          key.to_sym
-        end
-      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)
-        parse_date(value) or
-          parse_integer(value) or
-          parse_float(value) or
-          parse_array(value, operator) or
-          parse_regex(value) or
-          parse_boolean_and_nil(value)
-      end
-  
-      def parse_date(date)
-        date.to_time and Time.parse(date)
-      rescue Exception
-        nil
-      end
-      
-      def parse_integer(integer)
-        if match = integer.match(/^\d+$/)
-          match[0].to_i
-        end
-      end
-  
-      def parse_float(float)
-        if match = float.match(/^(\d+)(\.?\d*)$/)
-          match[0].to_f
-        end
-      end
-  
-      def parse_array(value, operator)
-        if array_operator?(operator)
-          split_and_strip(value).map { |item| parse_regex(item) or item }
-        end
-      end
-      
-      def parse_regex(regex)
-        if match = regex.match(/^\/(.*)\/(i|m|x)?$/)
-          eval(match[0])
-        end
-      end
-  
-      def parse_boolean_and_nil(value)
-        unless value.nil? || value.empty?
-          if ['true', 'false'].include?(value.strip)
-            value.strip == 'true'
-          elsif value.strip == 'nil'
-            nil
-          else
-            value
-          end
-        end
-      end
-  
-      def array_operator?(operator)
-        ARRAY_CONDITIONAL_OPERATORS.map { |op| "$#{op}" }.include?(operator.to_s)
-      end
-  
-      def split_and_strip(values)
-        values.split('|').map(&:strip)
-      end
-  
-      def hash_with_indifferent_access(params)
-        params.is_a?(HashWithIndifferentAccess) ? params : HashWithIndifferentAccess.new(params)
-      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)
-      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
-          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
-        end
-      end
-  end
-end
+require File.expand_path(File.join('mongoid', 'query_string_interface'), File.dirname(__FILE__))

data/lib/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mongoid_query_string_interface
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 7
-  version: 0.1.7
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Vicente Mundim
@@ -15,43 +15,74 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-10 00:00:00 -03:00
+date: 2011-02-01 00:00:00 -02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: mongoid
+  name: json
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 4
+        - 6
+        version: 1.4.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 31098209
+        hash: 7712058
         segments: 
         - 2
         - 0
         - 0
-        - beta
-        version: 2.0.0.beta
+        - rc
+        version: 2.0.0.rc
   type: :runtime
-  version_requirements: *id001
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version 
-        hash: 31098209
+        hash: 3
         segments: 
         - 2
+        - 3
+        - 0
+        version: 2.3.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
         - 0
+        - 5
         - 0
-        - beta
-        version: 2.0.0.beta
+        version: 0.5.0
   type: :development
-  version_requirements: *id002
+  version_requirements: *id004
 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.
 email: 
 - vicente.mundim@gmail.com
@@ -62,10 +93,18 @@ extensions: []
 extra_rdoc_files: []
 
 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/number_parser.rb
+- lib/mongoid/parsers/regex_parser.rb
+- lib/mongoid/query_string_interface.rb
 - lib/mongoid_query_string_interface.rb
 - lib/version.rb
 - MIT_LICENSE
 - README.rdoc
+- Gemfile
+- Gemfile.lock
 has_rdoc: true
 homepage: http://github.com/vicentemundim/mongoid_query_string_interface
 licenses: []