plucky 0.5.2 → 0.6.0

data/lib/plucky/normalizers/fields_value.rb

@@ -0,0 +1,26 @@
+module Plucky
+  module Normalizers
+    class FieldsValue
+
+      # Public: Given a value returns it normalized for Mongo's fields option
+      def call(value)
+        return nil if value.respond_to?(:empty?) && value.empty?
+
+        case value
+          when Array
+            if value.size == 1 && value.first.is_a?(Hash)
+              value.first
+            else
+              value.flatten
+            end
+          when Symbol
+            [value]
+          when String
+            value.split(',').map { |v| v.strip }
+          else
+            value
+        end
+      end
+    end
+  end
+end

data/lib/plucky/normalizers/integer.rb

@@ -0,0 +1,19 @@
+module Plucky
+  module Normalizers
+    class Integer
+
+      # Public: Returns value coerced to integer or nil
+      #
+      # value - The value to normalize to an integer
+      #
+      # Returns an Integer or nil
+      def call(value)
+        if value.nil?
+          nil
+        else
+          value.to_i
+        end
+      end
+    end
+  end
+end

data/lib/plucky/normalizers/options_hash_key.rb

@@ -0,0 +1,23 @@
+module Plucky
+  module Normalizers
+    class OptionsHashKey
+
+      # Internal: Keys with values that they should normalize to
+      NormalizedKeys = {
+        :order  => :sort,
+        :select => :fields,
+        :offset => :skip,
+        :id     => :_id,
+      }
+
+      # Public: Normalizes an options hash key
+      #
+      # key - The key to normalize
+      #
+      # Returns a Symbol.
+      def call(key)
+        NormalizedKeys.fetch key.to_sym, key
+      end
+    end
+  end
+end

data/lib/plucky/normalizers/options_hash_value.rb

@@ -0,0 +1,85 @@
+require 'plucky/normalizers/integer'
+require 'plucky/normalizers/fields_value'
+require 'plucky/normalizers/sort_value'
+
+module Plucky
+  module Normalizers
+    class OptionsHashValue
+
+      # Public: Initialize an OptionsHashValue.
+      #
+      # args - The hash of arguments (default: {})
+      #        :key_normalizer - The key normalizer to use, must respond to call
+      #        :value_normalizers - Hash where key is name of options hash key
+      #                             to normalize and value is what should be used
+      #                             to normalize the value accordingly (must respond
+      #                             to call). Allows adding normalizers for new keys
+      #                             and overriding existing default normalizers.
+      #
+      #
+      # Examples
+      #
+      #   Plucky::Normalizers::OptionsHashValue.new({
+      #     :key_normalizer => lambda { |key| key}, # key normalizer must responds to call
+      #     :value_normalizers => {
+      #       :new_key => lambda { |key| key.to_s.upcase }, # add normalizer for :new_key
+      #       :fields  => lambda { |key| key }, # override normalizer for fields to one that does nothing
+      #     }
+      #   })
+      #
+      # Returns the duplicated String.
+      def initialize(args = {})
+        @key_normalizer = args.fetch(:key_normalizer) {
+          raise ArgumentError, "Missing required key :key_normalizer"
+        }
+
+        @value_normalizers = {
+          :fields => default_fields_value_normalizer,
+          :sort   => default_sort_value_normalizer,
+          :limit  => default_limit_value_normalizer,
+          :skip   => default_skip_value_normalizer,
+        }
+
+        if (value_normalizers = args[:value_normalizers])
+          @value_normalizers.update(value_normalizers)
+        end
+      end
+
+      # Public: Returns value normalized for Mongo
+      #
+      # key - The name of the key whose value is being normalized
+      # value - The value to normalize
+      #
+      # Returns value normalized for Mongo.
+      def call(key, value)
+        if (value_normalizer = @value_normalizers[key])
+          value_normalizer.call(value)
+        else
+          value
+        end
+      end
+
+      # Private
+      def default_fields_value_normalizer
+        Normalizers::FieldsValue.new
+      end
+
+      # Private
+      def default_sort_value_normalizer
+        Normalizers::SortValue.new({
+          :key_normalizer => @key_normalizer,
+        })
+      end
+
+      # Private
+      def default_limit_value_normalizer
+        Normalizers::Integer.new
+      end
+
+      # Private
+      def default_skip_value_normalizer
+        Normalizers::Integer.new
+      end
+    end
+  end
+end

data/lib/plucky/normalizers/sort_value.rb

@@ -0,0 +1,55 @@
+module Plucky
+  module Normalizers
+    class SortValue
+
+      # Public: Initializes a Plucky::Normalizers::SortValue
+      #
+      # args - The hash of arguments
+      #        :key_normalizer - What to use to normalize keys, must
+      #                          respond to call.
+      #
+      def initialize(args = {})
+        @key_normalizer = args.fetch(:key_normalizer) {
+          raise ArgumentError, "Missing required key :key_normalizer"
+        }
+      end
+
+      # Public: Given a value returns it normalized for Mongo's sort option
+      def call(value)
+        case value
+          when Array
+            if value.size == 1 && value[0].is_a?(String)
+              normalized_sort_piece(value[0])
+            else
+              value.compact.map { |v| normalized_sort_piece(v).flatten }
+            end
+          else
+            normalized_sort_piece(value)
+        end
+      end
+
+      # Private
+      def normalized_sort_piece(value)
+        case value
+          when SymbolOperator
+            [normalized_direction(value.field, value.operator)]
+          when String
+            value.split(',').map do |piece|
+              normalized_direction(*piece.split(' '))
+            end
+          when Symbol
+            [normalized_direction(value)]
+          else
+            value
+        end
+      end
+
+      # Private
+      def normalized_direction(field, direction=nil)
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [@key_normalizer.call(field).to_s, direction]
+      end
+    end
+  end
+end

data/lib/plucky/options_hash.rb

@@ -1,127 +1,98 @@
 # encoding: UTF-8
+
+require 'plucky/normalizers/options_hash_key'
+require 'plucky/normalizers/options_hash_value'
+
 module Plucky
   class OptionsHash
+
+    # Private: The Hash that stores the query options
     attr_reader :source
 
-    def initialize(hash={})
+    # Private: The Hash that stores instance options
+    attr_reader :options
+
+    # Public
+    def initialize(hash={}, options={})
       @source = {}
+      @options = options
       hash.each { |key, value| self[key] = value }
     end
 
-    def initialize_copy(source)
+    def initialize_copy(original)
       super
       @source = @source.dup
-      each do |key, value|
+      @source.each do |key, value|
         self[key] = value.clone if value.duplicable?
       end
     end
 
+    # Public
+    def [](key)
+      @source[key]
+    end
+
+    # Public
     def []=(key, value)
       key = normalized_key(key)
-      source[key] = normalized_value(key, value)
+      @source[key] = normalized_value(key, value)
     end
 
+    # Public
+    def keys
+      @source.keys
+    end
+
+    # Public
     def ==(other)
-      source == other.source
+      @source == other.source
     end
 
+    # Public
     def to_hash
-      source
+      @source
     end
 
+    # Public
     def fields?
       !self[:fields].nil?
     end
 
+    # Public
     def merge(other)
       self.class.new(to_hash.merge(other.to_hash))
     end
 
+    # Public
     def merge!(other)
       other.to_hash.each { |key, value| self[key] = value }
       self
     end
 
-    private
-      def method_missing(method, *args, &block)
-        @source.send(method, *args, &block)
-      end
-
-      NormalizedKeys = {
-        :order  => :sort,
-        :select => :fields,
-        :offset => :skip,
-        :id     => :_id,
-      }
-
-      def normalized_key(key)
-        NormalizedKeys.default = key
-        NormalizedKeys[key.to_sym]
-      end
-
-      def normalized_value(key, value)
-        case key
-          when :fields
-            normalized_fields(value)
-          when :sort
-            normalized_sort(value)
-          when :limit, :skip
-            value.nil? ? nil : value.to_i
-          else
-            value
-        end
-      end
-
-      def normalized_fields(value)
-        return nil if value.respond_to?(:empty?) && value.empty?
-        case value
-          when Array
-            if value.size == 1 && value.first.is_a?(Hash)
-              value.first
-            else
-              value.flatten
-            end
-          when Symbol
-            [value]
-          when String
-            value.split(',').map { |v| v.strip }
-          else
-            value
-        end
-      end
+    # Private
+    def normalized_key(key)
+      key_normalizer.call(key)
+    end
 
-      def normalized_sort(value)
-        case value
-          when Array
-            if value.size == 1 && value[0].is_a?(String)
-              normalized_sort_piece(value[0])
-            else
-              value.compact.map { |v| normalized_sort_piece(v).flatten }
-            end
-          else
-            normalized_sort_piece(value)
-        end
-      end
+    # Private
+    def normalized_value(key, value)
+      value_normalizer.call(key, value)
+    end
 
-      def normalized_sort_piece(value)
-        case value
-          when SymbolOperator
-            [normalized_direction(value.field, value.operator)]
-          when String
-            value.split(',').map do |piece|
-              normalized_direction(*piece.split(' '))
-            end
-          when Symbol
-            [normalized_direction(value)]
-          else
-            value
-        end
-      end
+    # Private
+    def key_normalizer
+      @key_normalizer ||= @options.fetch(:key_normalizer) {
+        Normalizers::OptionsHashKey.new
+      }
+    end
 
-      def normalized_direction(field, direction=nil)
-        direction ||= 'ASC'
-        direction = direction.upcase == 'ASC' ? 1 : -1
-        [normalized_key(field).to_s, direction]
-      end
+    # Private
+    def value_normalizer
+      @value_normalizer ||= @options.fetch(:value_normalizer) {
+        Normalizers::OptionsHashValue.new({
+          :key_normalizer => key_normalizer,
+        })
+      }
+    end
   end
-end
+end

data/lib/plucky/pagination/decorator.rb

@@ -8,9 +8,10 @@ module Plucky
                       :total_entries, :total_pages,
                       :current_page,  :per_page,
                       :previous_page, :next_page,
-                      :skip,          :limit, 
+                      :skip,          :limit,
                       :offset,        :out_of_bounds?
 
+      # Public
       def paginator(p=nil)
         return @paginator if p.nil?
         @paginator = p
@@ -18,4 +19,4 @@ module Plucky
       end
     end
   end
-end
+end

data/lib/plucky/pagination/paginator.rb

@@ -4,34 +4,43 @@ module Plucky
     class Paginator
       attr_reader :total_entries, :current_page, :per_page
 
+      # Public
       def initialize(total, page, per_page=nil)
         @total_entries = total.to_i
         @current_page  = [page.to_i, 1].max
         @per_page      = (per_page || 25).to_i
       end
 
+      # Public
       def total_pages
-        (total_entries / per_page.to_f).ceil
+        (@total_entries / @per_page.to_f).ceil
       end
 
+      # Public
       def out_of_bounds?
-        current_page > total_pages
+        @current_page > total_pages
       end
 
+      # Public
       def previous_page
-        current_page > 1 ? (current_page - 1) : nil
+        @current_page > 1 ? (@current_page - 1) : nil
       end
 
+      # Public
       def next_page
-        current_page < total_pages ? (current_page + 1) : nil
+        @current_page < total_pages ? (@current_page + 1) : nil
       end
 
+      # Public
       def skip
-        (current_page - 1) * per_page
+        (@current_page - 1) * @per_page
       end
 
+      # Public
       alias :limit :per_page
+
+      # Public
       alias :offset :skip
     end
   end
-end
+end