mongoid_query_string_interface 0.5.1 → 0.6.0

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    mongoid_query_string_interface (0.5.1)
-      json (>= 1.4.6)
+    mongoid_query_string_interface (0.6.0)
       mongoid (~> 2.0.2)
+      query_string_interface (>= 0.1.0)
       will_paginate (~> 3.0.pre2)
 
 GEM
@@ -22,7 +22,6 @@ GEM
     database_cleaner (0.6.7)
     diff-lcs (1.1.2)
     i18n (0.5.0)
-    json (1.5.3)
     linecache (0.46)
       rbx-require-relative (> 0.0.4)
     linecache19 (0.5.12)
@@ -33,6 +32,8 @@ GEM
       activemodel (~> 3.0)
       mongo (~> 1.3)
       tzinfo (~> 0.3.22)
+    query_string_interface (0.1.0)
+      activesupport (>= 3.0.0)
     rake (0.8.7)
     rbx-require-relative (0.0.5)
     rspec (2.6.0)

data/README.rdoc

@@ -2,7 +2,7 @@
 
 == About Mongoid::QueryStringInterace
 
-Gives a method that can parse query string parameters into a set of criterias
+Gives some methods 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.
 
@@ -27,10 +27,10 @@ To use it, just extend Mongoid::QueryStringInterface in your document model:
   class Document
     include Mongoid::Document
     extend Mongoid::QueryInterfaceString
-    
+
     # ... add fields here
   end
-	
+
 Then, in your controllers put:
 
   def index
@@ -41,7 +41,7 @@ Then, in your controllers put:
 That's it! Now you can do something like this:
 
   http://myhost.com/documents?tags.all=ruby|rails|mongodb&tags.nin=sql|java&updated_at.gt=2010-01-01&created_at.desc&per_page=10&page=3
-	
+
 This would get all documents which have the tags 'ruby', 'rails' and 'mongo',
 and that don't have both 'sql' and 'java' tags, and that were updated after
 2010-01-01, ordered by descending created_at. It will return 10 elements per
@@ -51,12 +51,12 @@ You could even query for embedded documents, and use any of the Mongodb
 conditional operators:
 
   http://myhost.com/documents?comments.author=Shrek
-	
+
 Which would get all documents that have been commented by 'Shrek'. Basically,
 any valid path that you can use in a Mongoid::Criteria can be used here, and
 you can also append any of the Mongodb conditional operators.
 
-You can sort results like this:
+You can sort results by passing a order_by parameter this:
 
   http://myhost.com/documents?order_by=created_at.desc
 
@@ -70,11 +70,7 @@ Which is the same as:
 
 To order by more than one field:
 
-  http://myhost.com/documents?created_at.desc&updated_at.desc
-
-Or even:
-
-  http://myhost.com/documents?created_at=desc&updated_at=desc
+  http://myhost.com/documents?order_by=created_at.desc|updated_at.desc
 
 Check the specs for more use cases.
 

data/lib/mongoid/query_string_interface.rb

@@ -1,30 +1,17 @@
-require File.expand_path(File.join('helpers'), File.dirname(__FILE__))
-require File.expand_path(File.join('paginate'), 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__))
+require "query_string_interface"
+require "mongoid/paginate"
 
 module Mongoid
   module QueryStringInterface
-    include Mongoid::QueryStringInterface::Helpers
-    include Mongoid::Paginate unless instance_methods(:false).include?(:paginate)
+    include ::QueryStringInterface
+    include ::QueryStringInterface::Helpers
 
-    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('|')})$/
-    OPERATOR_REGEX = /^.*\.(#{Mongoid::QueryStringInterface::CONDITIONAL_OPERATORS.join('|')})$/
+    def self.extended(base)
+      base.extend Mongoid::Paginate unless base.methods.include?(:paginate)
+    end
 
     PAGER_ATTRIBUTES = [:total_entries, :total_pages, :per_page, :offset, :previous_page, :current_page, :next_page]
 
-    ORDER_BY_PARAMETER = :order_by
-    PAGINATION_PARAMTERS = [:per_page, :page]
-    FRAMEWORK_PARAMETERS = [:controller, :action, :format]
-    CONTROL_PARAMETERS = [:disable_default_filters]
-    RESERVED_PARAMETERS = FRAMEWORK_PARAMETERS + PAGINATION_PARAMTERS + [ORDER_BY_PARAMETER] + CONTROL_PARAMETERS
-
     def filter_by(params={})
       params = hash_with_indifferent_access(params)
       filter_only_and_order_by(params).paginate(pagination_options(params))
@@ -38,7 +25,7 @@ module Mongoid
         pager
       end
 
-      return { :pager => pager, model_name.human.underscore.pluralize.to_sym => result }
+      return { :pager => pager, collection_name_in_pagination_result => result }
     end
 
     def filter_with_optimized_pagination_by(params={})
@@ -71,49 +58,16 @@ 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 sorting_attributes_to_replace; {} end
-    def filtering_attributes_to_replace; {} end
-
     protected
-      def pagination_options(options)
-        hash_with_indifferent_access(default_pagination_options).merge(options)
-      end
-
-      def filtering_options(options)
-        Mongoid::QueryStringInterface::Parsers::FiltersParser.new(
-          only_filtering(options),
-          options.has_key?(:disable_default_filters) ? {} : default_filtering_options,
-          filtering_attributes_to_replace
-        ).parse
-      end
-
       def sorting_options(options)
-        parse_order_by(options) || default_sorting_options.map { |field| sorting_operator_for(field) }
-      end
-
-      def only_filtering(options)
-        options.except(*RESERVED_PARAMETERS)
-      end
-
-      def parse_order_by(options)
-        if options.has_key?('order_by')
-          options['order_by'].split('|').map do |field|
-            sorting_operator_for(field)
-          end
+        super(options).map do |sort_option|
+          attribute = sort_option.keys.first
+          attribute.send(sort_option[attribute])
         end
       end
 
-      def sorting_operator_for(field)
-        if field.is_a?(Mongoid::Criterion::Complex)
-          replace_attribute(field.key, sorting_attributes_to_replace).to_sym.send(field.operator)
-        elsif match = field.match(/(.*)\.(#{SORTING_OPERATORS.join('|')})/)
-          replace_attribute(match[1], sorting_attributes_to_replace).to_sym.send(match[2])
-        else
-          replace_attribute(field, sorting_attributes_to_replace).to_sym.asc
-        end
+      def collection_name_in_pagination_result
+        model_name.human.underscore.pluralize.to_sym
       end
   end
 end

data/lib/version.rb

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

metadata

@@ -2,7 +2,7 @@
 name: mongoid_query_string_interface
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - Vicente Mundim
@@ -10,17 +10,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-21 00:00:00 Z
+date: 2011-09-26 00:00:00 -03:00
+default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: json
+  name: query_string_interface
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.6
+        version: 0.1.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -77,15 +78,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/mongoid/helpers.rb
 - lib/mongoid/paginate.rb
-- 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
 - lib/mongoid_query_string_interface.rb
 - lib/version.rb
@@ -93,6 +86,7 @@ files:
 - README.rdoc
 - Gemfile
 - Gemfile.lock
+has_rdoc: true
 homepage: http://github.com/vicentemundim/mongoid_query_string_interface
 licenses: []
 
@@ -116,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: mongoid_query_string_interface
-rubygems_version: 1.8.5
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: An interface for performing queries in MongoDB using query string parameters.

data/lib/mongoid/helpers.rb

@@ -1,24 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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|
-            parse_item(item)
-          end
-        end
-        
-        private
-          def parse_item(item)
-            other_parsers.each do |parser|
-              return parser.parse(item) if parser.parseable?(item, '')
-            end
-          end
-
-          def other_parsers
-            @other_parsers ||= Mongoid::QueryStringInterface::Parsers::FilterParser::PARSERS.reject do |parser|
-              parser.is_a?(ArrayParser)
-            end
-          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

@@ -1,30 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,158 +0,0 @@
-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::ArrayParser.new,
-          Mongoid::QueryStringInterface::Parsers::DateTimeParser.new,
-          Mongoid::QueryStringInterface::Parsers::NumberParser.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

@@ -1,77 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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