humanoid 1.2.7

data/lib/humanoid/identity.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  class Identity #:nodoc:
+    class << self
+      # Create the identity for the +Document+.
+      #
+      # The id will be set in either in the form of a Mongo
+      # +ObjectID+ or a composite key set up by defining a key on the document.
+      #
+      # The _type will be set to the document's class name.
+      def create(doc)
+        identify(doc); type(doc); doc
+      end
+
+      protected
+      # Return the proper id for the document.
+      def generate_id
+        id = Mongo::ObjectID.new
+        Humanoid.use_object_ids ? id : id.to_s
+      end
+
+      # Set the id for the document.
+      def identify(doc)
+        doc.id = compose(doc).join(" ").identify if doc.primary_key
+        doc.id = generate_id unless doc.id
+      end
+
+      # Set the _type field on the document.
+      def type(doc)
+        doc._type = doc.class.name
+      end
+
+      # Generates the composite key for a document.
+      def compose(doc)
+        doc.primary_key.collect { |key| doc.attributes[key] }.reject { |val| val.nil? }
+      end
+    end
+  end
+end

data/lib/humanoid/indexes.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  module Indexes #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        cattr_accessor :indexed
+        self.indexed = false
+      end
+    end
+
+    module ClassMethods #:nodoc
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        unless indexed
+          self._collection.create_index(:_type, false)
+          self.indexed = true
+        end
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        collection.create_index(name, options[:unique])
+      end
+    end
+  end
+end

data/lib/humanoid/matchers.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require "humanoid/matchers/default"
+require "humanoid/matchers/all"
+require "humanoid/matchers/exists"
+require "humanoid/matchers/gt"
+require "humanoid/matchers/gte"
+require "humanoid/matchers/in"
+require "humanoid/matchers/lt"
+require "humanoid/matchers/lte"
+require "humanoid/matchers/ne"
+require "humanoid/matchers/nin"
+require "humanoid/matchers/size"
+
+module Humanoid #:nodoc:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end
+      true
+    end
+
+    protected
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Humanoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(attributes[key])
+      end
+      Default.new(attributes[key])
+    end
+  end
+end

data/lib/humanoid/matchers/all.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class All < Default
+      # Return true if the attribute and first value in the hash are equal.
+      def matches?(value)
+        @attribute == value.values.first
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/default.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Default
+      # Creating a new matcher only requires the value.
+      def initialize(attribute)
+        @attribute = attribute
+      end
+      # Return true if the attribute and value are equal.
+      def matches?(value)
+        @attribute == value
+      end
+
+      protected
+      # Return the first value in the hash.
+      def first(value)
+        value.values.first
+      end
+
+      # If object exists then compare, else return false
+      def determine(value, operator)
+        @attribute ? @attribute.send(operator, first(value)) : false
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/exists.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Exists < Default
+      # Return true if the attribute exists and checking for existence or
+      # return true if the attribute does not exist and checking for
+      # non-existence.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/gt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gt < Default
+      # Return true if the attribute is greater than the value.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/gte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gte < Default
+      # Return true if the attribute is greater than or equal to the value.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/in.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class In < Default
+      # Return true if the attribute is in the values.
+      def matches?(value)
+        value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/lt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lt < Default
+      # Return true if the attribute is less than the value.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/humanoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/humanoid/memoization.rb

@@ -0,0 +1,27 @@
+module Humanoid #:nodoc
+  module Memoization
+
+    # Handles cases when accessing an association that should be memoized in
+    # the Humanoid specific manner.
+    def memoized(name, &block)
+      var = "@#{name}"
+      if instance_variable_defined?(var)
+        return instance_variable_get(var)
+      end
+      value = yield
+      instance_variable_set(var, value)
+    end
+
+    # Humanoid specific behavior is to remove the memoized object when setting
+    # the association, or if it wasn't previously memoized it will get set.
+    def reset(name, &block)
+      var = "@#{name}"
+      value = yield
+      if instance_variable_defined?(var)
+        remove_instance_variable(var)
+      else
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/lib/humanoid/named_scope.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Humanoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, options = {}, &block)
+      name = name.to_sym
+      scopes[name] = lambda do |parent, *args|
+        Scope.new(parent, options.scoped(*args), &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+
+  end
+end
+

data/lib/humanoid/scope.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  class Scope #:nodoc:
+
+    delegate :scopes, :to => :parent
+
+    attr_reader :parent, :conditions
+
+    # If the other is a scope then compare the parent and conditions, otherwise
+    # if its enumerable collect and compare.
+    def ==(other)
+      case other
+      when Scope
+        @parent == other.parent && @conditions == other.conditions
+      when Enumerable
+        @collection ||= entries
+        return (@collection == other)
+      else
+        return false
+      end
+    end
+
+    # Create the new +Scope+. If a block is passed in, this Scope will extend
+    # the block.
+    #
+    # Options:
+    #
+    # parent: The class the scope belongs to, or a parent +Scope+.
+    # conditions: A +Hash+ of conditions.
+    #
+    # Example:
+    #
+    #   Humanoid::Scope.new(Person, { :title => "Sir" }) do
+    #     def knighted?
+    #       title == "Sir"
+    #     end
+    #   end
+    def initialize(parent, conditions, &block)
+      @parent, @conditions = parent, conditions
+      extend Module.new(&block) if block_given?
+    end
+
+    # Return the class for the +Scope+. This will be the parent if the parent
+    # is a class, otherwise will be nil.
+    def klass
+      @klass ||= @parent unless @parent.is_a?(Scope)
+    end
+
+    # Chaining is supported through method_missing. If a scope is already
+    # defined with the method name the call will be passed there, otherwise it
+    # will be passed to the target or parent.
+    def method_missing(name, *args, &block)
+      if scopes.include?(name)
+        scopes[name].call(self, *args)
+      elsif klass
+        target.send(name, *args, &block)
+      else
+        @parent.fuse(@conditions); @parent.send(name, *args, &block)
+      end
+    end
+
+    # The +Scope+ must respond like a +Criteria+ object. If this is a parent
+    # criteria delegate to the target, otherwise bubble up to the parent.
+    def respond_to?(name)
+      super || (klass ? target.respond_to?(name) : @parent.respond_to?(name))
+    end
+
+    # Returns the target criteria if it has already been set or creates a new
+    # criteria from the parent class.
+    def target
+      @target ||= klass.criteria.fuse(@conditions)
+    end
+  end
+end
+

data/lib/humanoid/timestamps.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Humanoid
+  module Timestamps
+
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        field :created_at, :type => Time
+        field :updated_at, :type => Time
+        before_save :set_created_at, :set_updated_at
+      end
+    end
+
+    module InstanceMethods
+
+      # Update the created_at field on the Document to the current time. This is
+      # only called on create.
+      def set_created_at
+        self.created_at = Time.now.utc if !created_at
+      end
+
+      # Update the updated_at field on the Document to the current time.
+      # This is only called on create and on save.
+      def set_updated_at
+        self.updated_at = Time.now.utc
+      end
+    end
+
+  end
+end

data/lib/humanoid/versioning.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  # Include this module to get automatic versioning of root level documents.
+  # This will add a version field to the +Document+ and a has_many association
+  # with all the versions contained in it.
+  module Versioning
+    def self.included(base)
+      base.class_eval do
+        field :version, :type => Integer, :default => 1
+        has_many :versions, :class_name => self.name
+        before_save :revise
+        include InstanceMethods
+      end
+    end
+    module InstanceMethods
+      # Create a new version of the +Document+. This will load the previous
+      # document from the database and set it as the next version before saving
+      # the current document. It then increments the version number.
+      def revise
+        last_version = self.class.first(:conditions => { :_id => id, :version => version })
+        if last_version
+          self.versions << last_version.clone
+          self.version = version + 1
+        end
+      end
+    end
+  end
+end