humanoid 1.2.7

data/lib/humanoid/extensions/hash/criteria_helpers.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Hash #:nodoc:
+      module CriteriaHelpers #:nodoc:
+        def expand_complex_criteria
+          hsh = {}
+          self.each_pair do |k,v|
+            if k.class == Humanoid::Criterion::Complex
+              hsh[k.key] = {"$#{k.operator}" => v}
+            else
+              hsh[k] = v
+            end
+          end
+          hsh
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/hash/scoping.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Hash #:nodoc:
+      module Scoping #:nodoc:
+        def scoped(*args)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/integer/conversions.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Integer #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          return nil if value.blank?
+          value =~ /\d/ ? value.to_i : value
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/nil/assimilation.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Nil #:nodoc:
+      module Assimilation #:nodoc:
+        # Will remove the child object from the parent.
+        def assimilate(parent, options, type = nil)
+          parent.remove_attribute(options.name); self
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/object/conversions.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Object #:nodoc:
+      # This module converts objects into humanoid related objects.
+      module Conversions #:nodoc:
+        def self.included(base)
+          base.class_eval do
+            include InstanceMethods
+            extend ClassMethods
+          end
+        end
+
+        module InstanceMethods
+          # Converts this object to a hash of attributes
+          def humanoidize
+            self.attributes
+          end
+        end
+
+        module ClassMethods
+          def set(value)
+            value.respond_to?(:attributes) ? value.attributes : value
+          end
+
+          def get(value)
+            self.new(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/proc/scoping.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Proc #:nodoc:
+      module Scoping #:nodoc:
+        def scoped(*args)
+          call(*args).scoped
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/string/conversions.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          value.to_s
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/string/inflections.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Inflections #:nodoc:
+
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular("address", "address")
+          inflect.singular("addresses", "address")
+          inflect.irregular("canvas", "canvases")
+        end
+
+        # Represents how special characters will get converted when creating a
+        # composite key that should be unique and part of a url.
+        CHAR_CONV = {
+          " " => "-",
+          "!" => "-excl-",
+          "\"" => "-bckslsh-",
+          "#" => "-hash-",
+          "$" => "-dol-",
+          "%" => "-perc-",
+          "&" => "-and-",
+          "'" => "-quo-",
+          "(" => "-oparen-",
+          ")" => "-cparen-",
+          "*" => "-astx-",
+          "+" => "-plus-",
+          "," => "-comma-",
+          "-" => "-dash-",
+          "." => "-period-",
+          "/" => "-fwdslsh-",
+          ":" => "-colon-",
+          ";" => "-semicol-",
+          "<" => "-lt-",
+          "=" => "-eq-",
+          ">" => "-gt-",
+          "?" => "-ques-",
+          "@" => "-at-",
+          "[" => "-obrck-",
+          "\\" => "-bckslsh-",
+          "]" => "-clbrck-",
+          "^" => "-carat-",
+          "_" => "-undscr-",
+          "`" => "-bcktick-",
+          "{" => "-ocurly-",
+          "|" => "-pipe-",
+          "}" => "-clcurly-",
+          "~" => "-tilda-"
+        }
+
+        REVERSALS = {
+          "asc" => "desc",
+          "ascending" => "descending",
+          "desc" => "asc",
+          "descending" => "ascending"
+        }
+
+        def collectionize
+          tableize.gsub("/", "_")
+        end
+
+        def identify
+          if Humanoid.parameterize_keys
+            key = ""
+            each_char { |c| key += (CHAR_CONV[c] || c.downcase) }; key
+          else
+            self
+          end
+        end
+
+        def labelize
+          underscore.humanize
+        end
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          singularize == self
+        end
+
+        def plural?
+          pluralize == self
+        end
+
+        def reader
+          writer? ? gsub("=", "") : self
+        end
+
+        def writer?
+          include?("=")
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/symbol/inflections.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+      module Inflections #:nodoc:
+
+        REVERSALS = {
+          :asc => :desc,
+          :ascending => :descending,
+          :desc => :asc,
+          :descending => :ascending
+        }
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          to_s.singular?
+        end
+
+        def plural?
+          to_s.plural?
+        end
+
+        ["gt", "lt", "gte", "lte", "ne", "in", "nin", "mod", "all", "size", "exists"].each do |oper|
+          class_eval <<-OPERATORS
+            def #{oper}
+              Criterion::Complex.new(:key => self, :operator => "#{oper}")
+            end
+          OPERATORS
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/extensions/time/conversions.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Extensions #:nodoc:
+    module Time #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          return nil if value.blank?
+          time = ::Time.parse(value.is_a?(::Time) ? value.strftime("%Y-%m-%d %H:%M:%S %Z") : value.to_s)
+          time.utc? ? time : time.utc
+        end
+        def get(value)
+          return nil if value.blank?
+          ::Time.zone ? value.getlocal : value
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/factory.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  class Factory #:nodoc:
+    # Builds a new +Document+ from the supplied attributes.
+    #
+    # Example:
+    #
+    # <tt>Humanoid::Factory.build(Person, {})</tt>
+    #
+    # Options:
+    #
+    # klass: The class to instantiate from if _type is not present.
+    # attributes: The +Document+ attributes.
+    def self.build(klass, attrs)
+      type = attrs["_type"]
+      type ? type.constantize.instantiate(attrs) : klass.instantiate(attrs)
+    end
+  end
+end

data/lib/humanoid/field.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  class Field
+
+    attr_reader \
+      :default,
+      :name,
+      :type
+
+    # Create the new field with a name and optional additional options. Valid
+    # options are :default
+    #
+    # Options:
+    #
+    # name: The name of the field as a +Symbol+.
+    # options: A +Hash+ of options for the field.
+    #
+    # Example:
+    #
+    # <tt>Field.new(:score, :default => 0)</tt>
+    def initialize(name, options = {})
+      @name = name
+      @default = options[:default]
+      @type = options[:type] || String
+    end
+
+    # Used for setting an object in the attributes hash. If nil is provided the
+    # default will get returned if it exists.
+    def set(object)
+      object.nil? ? default : type.set(object)
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    def get(object)
+      type.get(object)
+    end
+
+  end
+end

data/lib/humanoid/fields.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  module Fields #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        # Set up the class attributes that must be available to all subclasses.
+        # These include defaults, fields
+        class_inheritable_accessor :defaults, :fields
+
+        self.defaults = {}
+        self.fields = {}
+
+        delegate :defaults, :fields, :to => "self.class"
+      end
+    end
+
+    module ClassMethods #:nodoc
+      # Defines all the fields that are accessable on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # Options:
+      #
+      # name: The name of the field, as a +Symbol+.
+      # options: A +Hash+ of options to supply to the +Field+.
+      #
+      # Example:
+      #
+      # <tt>field :score, :default => 0</tt>
+      def field(name, options = {})
+        access = name.to_s
+        set_field(access, options)
+        set_default(access, options)
+      end
+
+      protected
+      # Define a field attribute for the +Document+.
+      def set_field(name, options = {})
+        meth = options.delete(:as) || name
+        fields[name] = Field.new(name, options)
+        create_accessors(name, meth, options)
+      end
+
+      # Create the field accessors.
+      def create_accessors(name, meth, options = {})
+        define_method(meth) { read_attribute(name) }
+        define_method("#{meth}=") { |value| write_attribute(name, value) }
+        define_method("#{meth}?") do
+          attr = read_attribute(name)
+          (options[:type] == Boolean) ? attr == true : attr.present?
+        end
+      end
+
+      # Set up a default value for a field.
+      def set_default(name, options = {})
+        value = options[:default]
+        defaults[name] = value unless value.nil?
+      end
+    end
+  end
+end

data/lib/humanoid/finders.rb

@@ -0,0 +1,224 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Finders #:nodoc:
+    # Find +Documents+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.all(:conditions => { :attribute => "value" })</tt>
+    def all(*args)
+      find(:all, *args)
+    end
+
+    # Returns a count of matching records in the database based on the
+    # provided arguments.
+    #
+    # <tt>Person.count(:first, :conditions => { :attribute => "value" })</tt>
+    def count(*args)
+      Criteria.translate(self, *args).count
+    end
+
+    # Helper to initialize a new +Criteria+ object for this class.
+    #
+    # Example:
+    #
+    # <tt>Person.criteria</tt>
+    def criteria
+      Criteria.new(self)
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectID and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(Mongo::ObjectID.new.to_s)</tt>
+    def find(*args)
+      raise Errors::InvalidOptions.new("Calling Document#find with nil is invalid") if args[0].nil?
+      type = args.delete_at(0) if args[0].is_a?(Symbol)
+      criteria = Criteria.translate(self, *args)
+      case type
+      when :first then return criteria.one
+      when :last then return criteria.last
+      else
+        return criteria
+      end
+    end
+
+    # Find the first +Document+ given the conditions, or creates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_create_by(:attribute => "value")</tt>
+    def find_or_create_by(attrs = {})
+      find_or(:create, attrs)
+    end
+
+    # Find the first +Document+ given the conditions, or instantiates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_initialize_by(:attribute => "value")</tt>
+    def find_or_initialize_by(attrs = {})
+      find_or(:new, attrs)
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.first(:conditions => { :attribute => "value" })</tt>
+    def first(*args)
+      find(:first, *args)
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.last(:conditions => { :attribute => "value" })</tt>
+    def last(*args)
+      find(:last, *args)
+    end
+
+    # Convenience method for returning the max value of a field.
+    #
+    # Options:
+    #
+    # field: The field to use when calculating the max.
+    #
+    # Example:
+    #
+    # <tt>Person.max(:age)</tt>
+    #
+    # Returns: <tt>Float</tt> max value.
+    def max(field)
+      Criteria.new(self).max(field)
+    end
+
+    # Will execute a +Criteria+ based on the +DynamicFinder+ that gets
+    # generated.
+    #
+    # Options:
+    #
+    # name: The finder method name
+    # args: The arguments to pass to the method.
+    #
+    # Example:
+    #
+    # <tt>Person.find_all_by_title_and_age("Sir", 30)</tt>
+    # def method_missing(name, *args)
+      # dyna = DynamicFinder.new(name, *args)
+      # finder, conditions = dyna.finder, dyna.conditions
+      # results = find(finder, :conditions => conditions)
+      # results ? results : dyna.create(self)
+    # end
+
+    # Convenience method for returning the min value of a field.
+    #
+    # Options:
+    #
+    # field: The field to use when calculating the min.
+    #
+    # Example:
+    #
+    # <tt>Person.min(:age)</tt>
+    #
+    # Returns: <tt>Float</tt> min value.
+    def min(field)
+      Criteria.new(self).min(field)
+    end
+
+    # Find all documents in paginated fashion given the supplied arguments.
+    # If no parameters are passed just default to offset 0 and limit 20.
+    #
+    # Options:
+    #
+    # params: A +Hash+ of params to pass to the Criteria API.
+    #
+    # Example:
+    #
+    # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
+    # :per_page => 20)</tt>
+    #
+    # Returns paginated array of docs.
+    def paginate(params = {})
+      Criteria.translate(self, params).paginate
+    end
+
+    # Entry point for creating a new criteria from a Document. This will
+    # instantiate a new +Criteria+ object with the supplied select criterion
+    # already added to it.
+    #
+    # Options:
+    #
+    # args: A list of field names to retrict the returned fields to.
+    #
+    # Example:
+    #
+    # <tt>Person.only(:field1, :field2, :field3)</tt>
+    #
+    # Returns: <tt>Criteria</tt>
+    def only(*args)
+      Criteria.new(self).only(*args)
+    end
+
+    # Convenience method for returning the sum of a specified field for all
+    # documents in the database.
+    #
+    # Options:
+    #
+    # field: The field to use when calculating the sum.
+    #
+    # Example:
+    #
+    # <tt>Person.sum(:age)</tt>
+    #
+    # Returns: <tt>Float</tt> of the sum.
+    def sum(field)
+      Criteria.new(self).sum(field)
+    end
+
+    # Entry point for creating a new criteria from a Document. This will
+    # instantiate a new +Criteria+ object with the supplied select criterion
+    # already added to it.
+    #
+    # Options:
+    #
+    # selector: A where criteria to initialize.
+    #
+    # Example:
+    #
+    # <tt>Person.where(:field1 => "Value")</tt>
+    #
+    # Returns: <tt>Criteria</tt>
+    def where(selector = nil)
+      Criteria.new(self).where(selector)
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {})
+      first(:conditions => attrs) || send(method, attrs)
+    end
+  end
+end