activeobject 0.0.3

data/lib/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,52 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Keys
+        # Return a new hash with all keys converted to strings.
+        def stringify_keys
+          inject({}) do |options, (key, value)|
+            options[key.to_s] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to strings.
+        def stringify_keys!
+          keys.each do |key|
+            self[key.to_s] = delete(key)
+          end
+          self
+        end
+
+        # Return a new hash with all keys converted to symbols.
+        def symbolize_keys
+          inject({}) do |options, (key, value)|
+            options[(key.to_sym rescue key) || key] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to symbols.
+        def symbolize_keys!
+          self.replace(self.symbolize_keys)
+        end
+
+        alias_method :to_options,  :symbolize_keys
+        alias_method :to_options!, :symbolize_keys!
+
+        # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+        # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+        # as keys, this will fail.
+        #
+        # ==== Examples:
+        #   { :name => "Rob", :years => "28" }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key(s): years"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys("name", "age") # => raises "ArgumentError: Unknown key(s): name, age"
+        #   { :name => "Rob", :age => "28" }.assert_valid_keys(:name, :age) # => passes, raises nothing
+        def assert_valid_keys(*valid_keys)
+          unknown_keys = keys - [valid_keys].flatten
+          raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/hash.rb

@@ -0,0 +1,8 @@
+%w(keys conversions).each do |ext|
+  require "active_support/core_ext/hash/#{ext}"
+end
+
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::Keys
+  include ActiveSupport::CoreExtensions::Hash::Conversions
+end

data/lib/active_support/core_ext/module/aliasing.rb

@@ -0,0 +1,74 @@
+module ActiveSupport
+  module CoreExtensions
+    module Module
+      # Encapsulates the common pattern of:
+      #
+      #   alias_method :foo_without_feature, :foo
+      #   alias_method :foo, :foo_with_feature
+      #
+      # With this, you simply do:
+      #
+      #   alias_method_chain :foo, :feature
+      #
+      # And both aliases are set up for you.
+      #
+      # Query and bang methods (foo?, foo!) keep the same punctuation:
+      #
+      #   alias_method_chain :foo?, :feature
+      #
+      # is equivalent to
+      #
+      #   alias_method :foo_without_feature?, :foo?
+      #   alias_method :foo?, :foo_with_feature?
+      #
+      # so you can safely chain foo, foo?, and foo! with the same feature.
+      def alias_method_chain(target, feature)
+        # Strip out punctuation on predicates or bang methods since
+        # e.g. target?_without_feature is not a valid method name.
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        yield(aliased_target, punctuation) if block_given?
+
+        with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        alias_method without_method, target
+        alias_method target, with_method
+
+        case
+          when public_method_defined?(without_method)
+            public target
+          when protected_method_defined?(without_method)
+            protected target
+          when private_method_defined?(without_method)
+            private target
+        end
+      end
+
+      # Allows you to make aliases for attributes, which includes
+      # getter, setter, and query methods.
+      #
+      # Example:
+      #
+      #   class Content < AntMapper::Base
+      #     # has a title attribute
+      #   end
+      #
+      #   class Email < Content
+      #     alias_attribute :subject, :title
+      #   end
+      #
+      #   e = Email.find(1)
+      #   e.title    # => "Superstars"
+      #   e.subject  # => "Superstars"
+      #   e.subject? # => true
+      #   e.subject = "Megastars"
+      #   e.title    # => "Megastars"
+      def alias_attribute(new_name, old_name)
+        module_eval <<-STR, __FILE__, __LINE__+1
+          def #{new_name}; self.#{old_name}; end
+          def #{new_name}?; self.#{old_name}?; end
+          def #{new_name}=(v); self.#{old_name} = v; end
+        STR
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/module/attr_accessor_with_default.rb

@@ -0,0 +1,31 @@
+class Module
+  # Declare an attribute accessor with an initial default return value.
+  #
+  # To give attribute <tt>:age</tt> the initial value <tt>25</tt>:
+  #  
+  #   class Person
+  #     attr_accessor_with_default :age, 25
+  #   end
+  #
+  #   some_person.age
+  #   => 25
+  #   some_person.age = 26
+  #   some_person.age
+  #   => 26
+  #
+  # To give attribute <tt>:element_name</tt> a dynamic default value, evaluated
+  # in scope of self:
+  #
+  #   attr_accessor_with_default(:element_name) { name.underscore } 
+  #
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__)
+      def #{sym}=(value)
+        class << self; attr_reader :#{sym} end
+        @#{sym} = value
+      end
+    EVAL
+  end
+end

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -0,0 +1,58 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+#
+#  module AppConfiguration
+#    mattr_accessor :google_api_key
+#    self.google_api_key = "123456789"
+#
+#    mattr_accessor :paypal_url
+#    self.paypal_url = "www.sandbox.paypal.com"
+#  end
+#
+#  AppConfiguration.google_api_key = "overriding the api key!"
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+        
+        #{"
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+        " unless options[:instance_writer] == false }
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/active_support/core_ext/module.rb

@@ -0,0 +1,16 @@
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/attr_accessor_with_default'
+require 'active_support/core_ext/module/aliasing'
+
+module ActiveSupport
+  module CoreExtensions
+    # Various extensions for the Ruby core Module class.
+    module Module
+      # Nothing here. Only defined for API documentation purposes.
+    end
+  end
+end
+
+class Module
+  include ActiveSupport::CoreExtensions::Module
+end

data/lib/active_support/core_ext/object/conversions.rb

@@ -0,0 +1,14 @@
+class Object
+  # Alias of <tt>to_s</tt>.
+  def to_param
+    to_s
+  end
+
+  # Converts an object into a string suitable for use as a URL query string, using the given <tt>key</tt> as the
+  # param name.
+  #
+  # Note: This method is defined as a default implementation for all Objects for Hash#to_query to work.
+  def to_query(key)
+    "#{CGI.escape(key.to_s)}=#{CGI.escape(to_param.to_s)}"
+  end
+end

data/lib/active_support/core_ext/object/extending.rb

@@ -0,0 +1,80 @@
+class Object
+  def remove_subclasses_of(*superclasses) #:nodoc:
+    Class.remove_class(*subclasses_of(*superclasses))
+  end
+
+  begin
+    ObjectSpace.each_object(Class.new) {}
+
+    # Exclude this class unless it's a subclass of our supers and is defined.
+    # We check defined? in case we find a removed class that has yet to be
+    # garbage collected. This also fails for anonymous classes -- please
+    # submit a patch if you have a workaround.
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(class << sup; self; end) do |k|
+          if k != sup && (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+      end
+
+      subclasses
+    end
+  rescue RuntimeError
+    # JRuby and any implementations which cannot handle the objectspace traversal
+    # above fall back to this implementation
+    def subclasses_of(*superclasses) #:nodoc:
+      subclasses = []
+
+      superclasses.each do |sup|
+        ObjectSpace.each_object(Class) do |k|
+          if superclasses.any? { |superclass| k < superclass } &&
+            (k.name.blank? || eval("defined?(::#{k}) && ::#{k}.object_id == k.object_id"))
+            subclasses << k
+          end
+        end
+        subclasses.uniq!
+      end
+      subclasses
+    end
+  end
+
+  def extended_by #:nodoc:
+    ancestors = class << self; ancestors end
+    ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+  end
+
+  def extend_with_included_modules_from(object) #:nodoc:
+    object.extended_by.each { |mod| extend mod }
+  end
+
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+
+    # Evaluate the block with the given arguments within the context of
+    # this object, so self is set to the method receiver.
+    #
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -0,0 +1,74 @@
+class Object
+  # Available in 1.8.6 and later.
+  unless respond_to?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+
+  # Returns a hash that maps instance variable names without "@" to their
+  # corresponding values. Keys are strings both in Ruby 1.8 and 1.9.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #   
+  #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
+  def instance_values #:nodoc:
+    instance_variables.inject({}) do |values, name|
+      values[name.to_s[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+
+  # Returns an array of instance variable names including "@". They are strings
+  # both in Ruby 1.8 and 1.9.
+  #
+  #   class C
+  #     def initialize(x, y)
+  #       @x, @y = x, y
+  #     end
+  #   end
+  #   
+  #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
+  if RUBY_VERSION >= '1.9'
+    def instance_variable_names
+      instance_variables.map { |var| var.to_s }
+    end
+  else
+    alias_method :instance_variable_names, :instance_variables
+  end
+
+  # Copies the instance variables of +object+ into +self+.
+  #
+  # Instance variable names in the +exclude+ array are ignored. If +object+
+  # responds to <tt>protected_instance_variables</tt> the ones returned are
+  # also ignored. For example, Rails controllers implement that method.
+  #
+  # In both cases strings and symbols are understood, and they have to include
+  # the at sign.
+  #
+  #   class C
+  #     def initialize(x, y, z)
+  #       @x, @y, @z = x, y, z
+  #     end
+  #   
+  #     def protected_instance_variables
+  #       %w(@z)
+  #     end
+  #   end
+  #   
+  #   a = C.new(0, 1, 2)
+  #   b = C.new(3, 4, 5)
+  #   
+  #   a.copy_instance_variables_from(b, [:@y])
+  #   # a is now: @x = 3, @y = 1, @z = 2
+  def copy_instance_variables_from(object, exclude = []) #:nodoc:
+    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
+
+    vars = object.instance_variables.map(&:to_s) - exclude.map(&:to_s)
+    vars.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
+  end
+end

data/lib/active_support/core_ext/object/metaclass.rb

@@ -0,0 +1,13 @@
+class Object
+  # Get object's meta (ghost, eigenclass, singleton) class
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  # If class_eval is called on an object, add those methods to its metaclass
+  def class_eval(*args, &block)
+    metaclass.class_eval(*args, &block)
+  end
+end

data/lib/active_support/core_ext/object/misc.rb

@@ -0,0 +1,43 @@
+class Object
+  # Returns +value+ after yielding +value+ to the block. This simplifies the
+  # process of constructing an object, performing work on the object, and then
+  # returning the object from a method. It is a Ruby-ized realization of the K
+  # combinator, courtesy of Mikael Brockman.
+  #
+  # ==== Examples
+  #
+  #  # Without returning
+  #  def foo
+  #    values = []
+  #    values << "bar"
+  #    values << "baz"
+  #    return values
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #
+  #  # returning with a local variable
+  #  def foo
+  #    returning values = [] do
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  #
+  #  # returning with a block argument
+  #  def foo
+  #    returning [] do |values|
+  #      values << 'bar'
+  #      values << 'baz'
+  #    end
+  #  end
+  #
+  #  foo # => ['bar', 'baz']
+  def returning(value)
+    yield(value)
+    value
+  end
+
+end

data/lib/active_support/core_ext/object.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/object/conversions'
+require 'active_support/core_ext/object/extending'
+require 'active_support/core_ext/object/instance_variables'
+require 'active_support/core_ext/object/metaclass'
+require 'active_support/core_ext/object/misc'

data/lib/active_support/core_ext/string/inflections.rb

@@ -0,0 +1,167 @@
+require 'active_support/inflector'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # String inflections define new methods on the String class to transform names for different purposes.
+      # For instance, you can figure out the name of a database from the name of a class.
+      #
+      #   "ScaleScore".tableize # => "scale_scores"
+      module Inflections
+        # Returns the plural form of the word in the string.
+        #
+        #   "post".pluralize             # => "posts"
+        #   "octopus".pluralize          # => "octopi"
+        #   "sheep".pluralize            # => "sheep"
+        #   "words".pluralize            # => "words"
+        #   "the blue mailman".pluralize # => "the blue mailmen"
+        #   "CamelOctopus".pluralize     # => "CamelOctopi"
+        def pluralize
+          Inflector.pluralize(self)
+        end
+
+        # The reverse of +pluralize+, returns the singular form of a word in a string.
+        #
+        #   "posts".singularize            # => "post"
+        #   "octopi".singularize           # => "octopus"
+        #   "sheep".singularize            # => "sheep"
+        #   "word".singularize             # => "word"
+        #   "the blue mailmen".singularize # => "the blue mailman"
+        #   "CamelOctopi".singularize      # => "CamelOctopus"
+        def singularize
+          Inflector.singularize(self)
+        end
+
+        # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+        # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+        #
+        # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+        #
+        #   "active_record".camelize                # => "ActiveRecord"
+        #   "active_record".camelize(:lower)        # => "activeRecord"
+        #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+        #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+        def camelize(first_letter = :upper)
+          case first_letter
+            when :upper then Inflector.camelize(self, true)
+            when :lower then Inflector.camelize(self, false)
+          end
+        end
+        alias_method :camelcase, :camelize
+
+        # Capitalizes all the words and replaces some characters in the string to create
+        # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+        # used in the Rails internals.
+        #
+        # +titleize+ is also aliased as +titlecase+.
+        #
+        #   "man from the boondocks".titleize # => "Man From The Boondocks"
+        #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+        def titleize
+          Inflector.titleize(self)
+        end
+        alias_method :titlecase, :titleize
+
+        # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+        # 
+        # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+        #
+        #   "ActiveRecord".underscore         # => "active_record"
+        #   "ActiveRecord::Errors".underscore # => active_record/errors
+        def underscore
+          Inflector.underscore(self)
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        #   "puni_puni" # => "puni-puni"
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        # Removes the module part from the constant expression in the string.
+        #
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+        #   "Inflections".demodulize                                       # => "Inflections"
+        def demodulize
+          Inflector.demodulize(self)
+        end
+
+        # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
+        # 
+        # ==== Examples
+        #
+        #   class Person
+        #     def to_param
+        #       "#{id}-#{name.parameterize}"
+        #     end
+        #   end
+        # 
+        #   @person = Person.find(1)
+        #   # => #<Person id: 1, name: "Donald E. Knuth">
+        # 
+        #   <%= link_to(@person.name, person_path %>
+        #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
+        def parameterize
+          Inflector.parameterize(self)
+        end
+
+        # Creates the name of a table like Rails does for models to table names. This method
+        # uses the +pluralize+ method on the last word in the string.
+        #
+        #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+        #   "egg_and_ham".tableize     # => "egg_and_hams"
+        #   "fancyCategory".tableize   # => "fancy_categories"
+        def tableize
+          Inflector.tableize(self)
+        end
+
+        # Create a class name from a plural table name like Rails does for table names to models.
+        # Note that this returns a string and not a class. (To convert to an actual class
+        # follow +classify+ with +constantize+.)
+        #
+        #   "egg_and_hams".classify # => "EggAndHam"
+        #   "posts".classify        # => "Post"
+        #
+        # Singular names are not handled correctly.
+        #
+        #   "business".classify # => "Busines"
+        def classify
+          Inflector.classify(self)
+        end
+        
+        # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+        # Like +titleize+, this is meant for creating pretty output.
+        #
+        #   "employee_salary" # => "Employee salary" 
+        #   "author_id"       # => "Author"
+        def humanize
+          Inflector.humanize(self)
+        end
+
+        # Creates a foreign key name from a class name.
+        # +separate_class_name_and_id_with_underscore+ sets whether
+        # the method should put '_' between the name and 'id'.
+        #
+        # Examples
+        #   "Message".foreign_key        # => "message_id"
+        #   "Message".foreign_key(false) # => "messageid"
+        #   "Admin::Post".foreign_key    # => "post_id"
+        def foreign_key(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        end
+
+        # +constantize+ tries to find a declared constant with the name specified
+        # in the string. It raises a NameError when the name is not in CamelCase
+        # or is not initialized.
+        #
+        # Examples
+        #   "Module".constantize # => Module
+        #   "Class".constantize  # => Class
+        def constantize
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end

data/lib/active_support/core_ext/string.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+require 'active_support/core_ext/string/inflections'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Inflections
+end

data/lib/active_support/core_ext.rb

@@ -0,0 +1,4 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require "active_support/core_ext/#{filename}"
+end