jonbell-plucky 0.3.8

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 John Nunemaker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,19 @@
+= Plucky
+
+Thin layer over the ruby driver that allows you to quickly grab hold of your data (pluck it!).
+
+== Install
+
+  $ gem install plucky
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 John Nunemaker. See LICENSE for details.

data/lib/plucky.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+require 'set'
+require 'mongo'
+require 'plucky/extensions'
+
+module Plucky
+  autoload :CriteriaHash, 'plucky/criteria_hash'
+  autoload :OptionsHash,  'plucky/options_hash'
+  autoload :Query,        'plucky/query'
+  autoload :Version,      'plucky/version'
+
+  module Pagination
+    autoload :Decorator,  'plucky/pagination/decorator'
+    autoload :Paginator,  'plucky/pagination/paginator'
+  end
+
+  def self.to_object_id(value)
+    if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      nil
+    elsif value.is_a?(BSON::ObjectId)
+      value
+    else
+      if BSON::ObjectId.legal?(value.to_s)
+        BSON::ObjectId.from_string(value.to_s)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/plucky/criteria_hash.rb

@@ -0,0 +1,139 @@
+# encoding: UTF-8
+module Plucky
+  class CriteriaHash
+    attr_reader :source, :options
+
+    def initialize(hash={}, options={})
+      @source, @options = {}, options
+      hash.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(source)
+      super
+      @options = @options.dup
+      @source  = @source.dup
+      each do |key, value|
+        self[key] = value.clone if value.duplicable?
+      end
+    end
+
+    def []=(key, value)
+      normalized_key = normalized_key(key)
+      if key.is_a?(SymbolOperator)
+        operator = "$#{key.operator}"
+        normalized_value = normalized_value(normalized_key, operator, value)
+        source[normalized_key] ||= {}
+        source[normalized_key][operator] = normalized_value
+      else
+        if key == :conditions
+          value.each { |k, v| self[k] = v }
+        else
+          normalized_value = normalized_value(normalized_key, normalized_key, value)
+          source[normalized_key] = normalized_value
+        end
+      end
+    end
+
+    def ==(other)
+      source == other.source
+    end
+
+    def to_hash
+      source
+    end
+
+    def merge(other)
+      target = source.dup
+      other.source.each_key do |key|
+        value, other_value = target[key], other[key]
+        target[key] =
+          if target.key?(key)
+            value_is_hash = value.is_a?(Hash)
+            other_is_hash = other_value.is_a?(Hash)
+
+            if value_is_hash && other_is_hash
+              value.update(other_value) do |key, old_value, new_value|
+                Array(old_value).concat(Array(new_value)).uniq
+              end
+            elsif value_is_hash && !other_is_hash
+              if modifier_key = value.keys.detect { |k| k.to_s[0, 1] == '$' }
+                value[modifier_key].concat(Array(other_value)).uniq!
+              else
+                # kaboom! Array(value).concat(Array(other_value)).uniq
+              end
+            elsif other_is_hash && !value_is_hash
+              if modifier_key = other_value.keys.detect { |k| k.to_s[0, 1] == '$' }
+                other_value[modifier_key].concat(Array(value)).uniq!
+              else
+                # kaboom! Array(value).concat(Array(other_value)).uniq
+              end
+            else
+              Array(value).concat(Array(other_value)).uniq
+            end
+          else
+            other_value
+          end
+      end
+      self.class.new(target)
+    end
+
+    def merge!(other)
+      merge(other).to_hash.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def object_ids
+      @options[:object_ids] ||= []
+    end
+
+    def object_ids=(value)
+      raise ArgumentError unless value.is_a?(Array)
+      @options[:object_ids] = value.flatten
+    end
+
+    # The definition of simple is querying by only _id or _id and _type.
+    # If this is the case, you can use IdentityMap in library to not perform
+    # query and instead just return from map.
+    def simple?
+      key_set = keys.to_set
+      key_set == [:_id].to_set || key_set == [:_id, :_type].to_set
+    end
+
+    private
+      def method_missing(method, *args, &block)
+        @source.send(method, *args, &block)
+      end
+
+      def object_id?(key)
+        object_ids.include?(key.to_sym)
+      end
+
+      def normalized_key(key)
+        key = key.to_sym                 if key.respond_to?(:to_sym)
+        return normalized_key(key.field) if key.respond_to?(:field)
+        return :_id                      if key == :id
+        key
+      end
+
+      def normalized_value(parent_key, key, value)
+        case value
+          when Array, Set
+            value.map! { |v| Plucky.to_object_id(v) } if object_id?(parent_key)
+            parent_key == key && key != :$or ? {'$in' => value.to_a} : value.to_a
+          when Time
+            value.utc
+          when String
+            return Plucky.to_object_id(value) if object_id?(key)
+            value
+          when Hash
+            value.each { |k, v| value[k] = normalized_value(key, k, v) }
+            value
+          when Regexp
+            Regexp.new(value)
+          else
+            value
+        end
+      end
+  end
+end

data/lib/plucky/extensions.rb

@@ -0,0 +1,3 @@
+# encoding: UTF-8
+require 'plucky/extensions/duplicable'
+require 'plucky/extensions/symbol'

data/lib/plucky/extensions/duplicable.rb

@@ -0,0 +1,86 @@
+# Copyright (c) 2005-2010 David Heinemeier Hansson
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check duplicable? instead of
+# using that rescue idiom.
+class Object
+  # Can you safely .dup this object?
+  # False for nil, false, true, symbols, numbers, class and module objects; true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Symbol #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Numeric #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Class #:nodoc:
+  def duplicable?
+    false
+  end
+end
+
+class Module #:nodoc:
+  def duplicable?
+    false
+  end
+end

data/lib/plucky/extensions/symbol.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+module Plucky
+  module Extensions
+    module Symbol
+      def gt
+        SymbolOperator.new(self, 'gt')
+      end
+
+      def lt
+        SymbolOperator.new(self, 'lt')
+      end
+
+      def gte
+        SymbolOperator.new(self, 'gte')
+      end
+
+      def lte
+        SymbolOperator.new(self, 'lte')
+      end
+
+      def ne
+        SymbolOperator.new(self, 'ne')
+      end
+
+      def in
+        SymbolOperator.new(self, 'in')
+      end
+
+      def nin
+        SymbolOperator.new(self, 'nin')
+      end
+
+      def mod
+        SymbolOperator.new(self, 'mod')
+      end
+
+      def all
+        SymbolOperator.new(self, 'all')
+      end
+
+      def size
+        SymbolOperator.new(self, 'size')
+      end unless Symbol.instance_methods.include?(:size) # Ruby 1.9 defines symbol size
+
+      def exists
+        SymbolOperator.new(self, 'exists')
+      end
+
+      def asc
+        SymbolOperator.new(self, 'asc')
+      end
+
+      def desc
+        SymbolOperator.new(self, 'desc')
+      end
+    end
+  end
+end
+
+class SymbolOperator
+  include Comparable
+
+  attr_reader :field, :operator
+
+  def initialize(field, operator, options={})
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+
+  def <=>(other)
+    if field == other.field
+      operator <=> other.operator
+    else
+      field.to_s <=> other.field.to_s
+    end
+  end
+
+  def ==(other)
+    field == other.field && operator == other.operator
+  end
+end
+
+class Symbol
+  include Plucky::Extensions::Symbol
+end

data/lib/plucky/options_hash.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+module Plucky
+  class OptionsHash
+    attr_reader :source
+
+    def initialize(hash={})
+      @source = {}
+      hash.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(source)
+      super
+      @source = @source.dup
+      each do |key, value|
+        self[key] = value.clone if value.duplicable?
+      end
+    end
+
+    def []=(key, value)
+      key = normalized_key(key)
+      source[key] = normalized_value(key, value)
+    end
+
+    def ==(other)
+      source == other.source
+    end
+
+    def to_hash
+      source
+    end
+
+    def fields?
+      !self[:fields].nil?
+    end
+
+    def merge(other)
+      self.class.new(to_hash.merge(other.to_hash))
+    end
+
+    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
+
+      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
+
+      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
+
+      def normalized_direction(field, direction=nil)
+        direction ||= 'ASC'
+        direction = direction.upcase == 'ASC' ? 1 : -1
+        [normalized_key(field).to_s, direction]
+      end
+  end
+end

data/lib/plucky/pagination/decorator.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+module Plucky
+  module Pagination
+    module Decorator
+      extend Forwardable
+
+      def_delegators  :@paginator,
+                      :total_entries, :total_pages,
+                      :current_page,  :per_page,
+                      :previous_page, :next_page,
+                      :skip,          :limit, 
+                      :offset,        :out_of_bounds?
+
+      def paginator(p=nil)
+        return @paginator if p.nil?
+        @paginator = p
+        self
+      end
+    end
+  end
+end

data/lib/plucky/pagination/paginator.rb

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+module Plucky
+  module Pagination
+    class Paginator
+      attr_reader :total_entries, :current_page, :per_page
+
+      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
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+
+      def out_of_bounds?
+        current_page > total_pages
+      end
+
+      def previous_page
+        current_page > 1 ? (current_page - 1) : nil
+      end
+
+      def next_page
+        current_page < total_pages ? (current_page + 1) : nil
+      end
+
+      def skip
+        (current_page - 1) * per_page
+      end
+
+      alias :limit :per_page
+      alias :offset :skip
+    end
+  end
+end

data/lib/plucky/query.rb

@@ -0,0 +1,209 @@
+# encoding: UTF-8
+require 'forwardable'
+module Plucky
+  class Query
+    include Enumerable
+    extend  Forwardable
+
+    OptionKeys = [
+      :select, :offset, :order,                         # MM
+      :fields, :skip, :limit, :sort, :hint, :snapshot,  # Ruby Driver
+      :batch_size, :timeout, :transformer               # Ruby Driver
+    ]
+
+    attr_reader    :criteria, :options, :collection
+    def_delegator  :criteria, :simple?
+    def_delegator  :options,  :fields?
+    def_delegators :to_a, :each, :include?
+
+    def initialize(collection, opts={})
+      @collection, @options, @criteria = collection, OptionsHash.new, CriteriaHash.new
+      opts.each { |key, value| self[key] = value }
+    end
+
+    def initialize_copy(source)
+      super
+      @criteria = @criteria.dup
+      @options  = @options.dup
+    end
+
+    def object_ids(*keys)
+      return criteria.object_ids if keys.empty?
+      criteria.object_ids = *keys
+      self
+    end
+
+    def per_page(limit=nil)
+      return @per_page || 25 if limit.nil?
+      @per_page = limit
+      self
+    end
+
+    def paginate(opts={})
+      page          = opts.delete(:page)
+      limit         = opts.delete(:per_page) || per_page
+      query         = clone.update(opts)
+      total         = query.count
+      paginator     = Pagination::Paginator.new(total, page, limit)
+      query[:limit] = paginator.limit
+      query[:skip]  = paginator.skip
+      query.all.tap do |docs|
+        docs.extend(Pagination::Decorator)
+        docs.paginator(paginator)
+      end
+    end
+
+    def find_each(opts={})
+      query = clone.update(opts)
+      query.collection.find(query.criteria.to_hash, query.options.to_hash)
+    end
+
+    def find_one(opts={})
+      query = clone.update(opts)
+      query.collection.find_one(query.criteria.to_hash, query.options.to_hash)
+    end
+
+    def find(*ids)
+      return nil if ids.empty?
+      if ids.size == 1 && !ids[0].is_a?(Array)
+        first(:_id => ids[0])
+      else
+        all(:_id => ids.flatten)
+      end
+    end
+
+    def all(opts={})
+      find_each(opts).to_a
+    end
+
+    def first(opts={})
+      find_one(opts)
+    end
+
+    def last(opts={})
+      clone.update(opts).reverse.find_one
+    end
+
+    def remove(opts={})
+      query = clone.update(opts)
+      query.collection.remove(query.criteria.to_hash)
+    end
+
+    def count(opts={})
+      find_each(opts).count
+    end
+
+    def size
+      count
+    end
+
+    def distinct(key, opts = {})
+      query = clone.update(opts)
+      query.collection.distinct(key, query.criteria.to_hash)
+    end
+
+    def update(opts={})
+      opts.each { |key, value| self[key] = value }
+      self
+    end
+
+    def fields(*args)
+      clone.tap { |query| query.options[:fields] = *args }
+    end
+
+    def ignore(*args)
+      set_fields(args, 0)
+    end
+
+    def only(*args)
+      set_fields(args, 1)
+    end
+
+    def limit(count=nil)
+      clone.tap { |query| query.options[:limit] = count }
+    end
+
+    def reverse
+      clone.tap do |query|
+        query[:sort] = query[:sort].map do |s|
+          [s[0], -s[1]]
+        end unless query.options[:sort].nil?
+      end
+    end
+
+    def skip(count=nil)
+      clone.tap { |query| query.options[:skip] = count }
+    end
+    alias offset skip
+
+    def sort(*args)
+      clone.tap { |query| query.options[:sort] = *args }
+    end
+    alias order sort
+
+    def where(hash={})
+      clone.tap do |query|
+        query.criteria.merge!(CriteriaHash.new(hash))
+      end
+    end
+
+    def empty?
+      count.zero?
+    end
+
+    def exists?(options={})
+      !count(options).zero?
+    end
+    alias :exist? :exists?
+
+    def to_a
+      all
+    end
+
+    def [](key)
+      key = key.to_sym if key.respond_to?(:to_sym)
+      if OptionKeys.include?(key)
+        @options[key]
+      else
+        @criteria[key]
+      end
+    end
+
+    def []=(key, value)
+      key = key.to_sym if key.respond_to?(:to_sym)
+      if OptionKeys.include?(key)
+        @options[key] = value
+      else
+        @criteria[key] = value
+      end
+    end
+
+    def merge(other)
+      merged_criteria = criteria.merge(other.criteria).to_hash
+      merged_options  = options.merge(other.options).to_hash
+      clone.update(merged_criteria).update(merged_options)
+    end
+
+    def to_hash
+      criteria.to_hash.merge(options.to_hash)
+    end
+
+    def explain
+      collection.find(criteria.to_hash, options.to_hash).explain
+    end
+
+    def inspect
+      as_nice_string = to_hash.collect do |key, value|
+        " #{key}: #{value.inspect}"
+      end.sort.join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
+  private
+    def set_fields(field_list, value)
+      the_fields = {}
+      field_list.each {|field| the_fields[field.to_sym] = value}
+      clone.tap { |query| query.options[:fields] =  the_fields}
+    end
+  end
+end

data/lib/plucky/version.rb

@@ -0,0 +1,5 @@
+# encoding: UTF-8
+module Plucky
+  Version = '0.3.8'
+  MongoVersion = '~> 1.3'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: jonbell-plucky
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 8
+  version: 0.3.8
+platform: ruby
+authors: 
+- John Nunemaker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-29 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jonbell-mongo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- nunemaker@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/plucky/criteria_hash.rb
+- lib/plucky/extensions/duplicable.rb
+- lib/plucky/extensions/symbol.rb
+- lib/plucky/extensions.rb
+- lib/plucky/options_hash.rb
+- lib/plucky/pagination/decorator.rb
+- lib/plucky/pagination/paginator.rb
+- lib/plucky/query.rb
+- lib/plucky/version.rb
+- lib/plucky.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/jonbell/plucky
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Thin layer over the ruby driver that allows you to quickly grab hold of your data (pluck it!).
+test_files: []
+