plucky 0.1

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,21 @@
+= Plucky
+
+Thin layer over the ruby driver that allows you to quickly grab hold of your data (pluck it!).
+
+*Still rough around the edges and changing rapidly.*
+
+== 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/criteria_hash.rb

@@ -0,0 +1,113 @@
+module Plucky
+  class CriteriaHash
+    attr_reader :source
+
+    def initialize(hash={}, options={})
+      @source, @options = {}, options
+      hash.each { |key, value| self[key] = value }
+    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 object_ids
+      @options[:object_ids] ||= []
+    end
+
+    def object_ids=(value)
+      raise ArgumentError unless value.respond_to?(:flatten)
+      @options[:object_ids] = value.flatten
+    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 ? {'$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
+          else
+            value
+        end
+      end
+  end
+end

data/lib/plucky/extensions.rb

@@ -0,0 +1,15 @@
+class SymbolOperator
+  attr_reader :field, :operator
+
+  def initialize(field, operator, options={})
+    @field, @operator = field, operator
+  end unless method_defined?(:initialize)
+end
+
+class Symbol
+  %w(gt lt gte lte ne in nin mod all size exists asc desc).each do |operator|
+    define_method(operator) do
+      SymbolOperator.new(self, operator)
+    end unless method_defined?(operator)
+  end
+end

data/lib/plucky/options_hash.rb

@@ -0,0 +1,97 @@
+module Plucky
+  class OptionsHash
+    attr_reader :source
+
+    def initialize(hash={})
+      @source = {}
+      hash.each { |key, value| self[key] = value }
+    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
+
+    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
+            value.flatten
+          when Symbol
+            [value]
+          when String
+            value.split(',').map { |v| v.strip }
+          else
+            value
+        end
+      end
+
+      def normalized_sort(value)
+        case value
+          when Array
+            value.compact.map { |v| normalized_sort_piece(v).flatten }
+          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/query.rb

@@ -0,0 +1,113 @@
+module Plucky
+  class Query
+    OptionKeys = [
+      :select, :offset, :order,                                              # MM
+      :fields, :skip, :limit, :sort, :hint, :snapshot, :batch_size, :timeout # Ruby Driver
+    ]
+
+    attr_reader :criteria, :options, :collection
+
+    def initialize(collection, opts={})
+      @collection, @options, @criteria = collection, OptionsHash.new, CriteriaHash.new
+      opts.each { |key, value| self[key] = value }
+    end
+
+    def object_ids(*keys)
+      return criteria.object_ids if keys.empty?
+      criteria.object_ids = *keys
+      self
+    end
+
+    def find(opts={})
+      update(opts).collection.find(criteria.to_hash, options.to_hash)
+    end
+
+    def find_one(opts={})
+      update(opts).collection.find_one(criteria.to_hash, options.to_hash)
+    end
+
+    def all(opts={})
+      [].tap do |docs|
+        update(opts).find(to_hash).each { |doc| docs << doc }
+      end
+    end
+
+    def first(opts={})
+      update(opts).find_one(to_hash)
+    end
+
+    def last(opts={})
+      update(opts).reverse.find_one(to_hash)
+    end
+
+    def remove(opts={})
+      update(opts).collection.remove(criteria.to_hash)
+    end
+
+    def count(opts={})
+      update(opts).find(to_hash).count
+    end
+
+    def update(opts={})
+      opts.each { |key, value| self[key] = value }
+      self
+    end
+
+    def fields(*args)
+      self[:fields] = args
+      self
+    end
+
+    def limit(count=nil)
+      self[:limit] = count
+      self
+    end
+
+    def reverse
+      self[:sort].map! { |s| [s[0], -s[1]] }
+      self
+    end
+
+    def skip(count=nil)
+      self[:skip] = count
+      self
+    end
+
+    def sort(*args)
+      self[:sort] = *args
+      self
+    end
+
+    def where(hash={})
+      criteria.merge(CriteriaHash.new(hash)).to_hash.each { |key, value| self[key] = value }
+      self
+    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.merge(other.criteria).to_hash.merge(options.to_hash.merge(other.options.to_hash))
+      clone.update(merged)
+    end
+
+    def to_hash
+      criteria.to_hash.merge(options.to_hash)
+    end
+  end
+end

data/lib/plucky/version.rb

@@ -0,0 +1,3 @@
+module Plucky
+  Version = '0.1'
+end

data/lib/plucky.rb

@@ -0,0 +1,20 @@
+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'
+
+  def self.to_object_id(value)
+    if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      nil
+    elsif value.is_a?(BSON::ObjectID)
+      value
+    else
+      BSON::ObjectID.from_string(value.to_s)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: plucky
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- John Nunemaker
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongo
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        version: "1.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jnunemaker-matchy
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: 
+email: 
+- nunemaker@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/plucky/criteria_hash.rb
+- lib/plucky/extensions.rb
+- lib/plucky/options_hash.rb
+- lib/plucky/query.rb
+- lib/plucky/version.rb
+- lib/plucky.rb
+- LICENSE
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/jnunemaker/plucky
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+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: []
+