csd 0.1.5 → 0.1.6

data/lib/active_support/core_ext/module.rb

@@ -1,12 +0,0 @@
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/module/introspection'
-require 'active_support/core_ext/module/anonymous'
-require 'active_support/core_ext/module/reachable'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/attr_accessor_with_default'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/module/synchronization'
-require 'active_support/core_ext/module/deprecation'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/module/method_names'

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

@@ -1,70 +0,0 @@
-class 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 < ActiveRecord::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 subject; self.title; end
-      def #{new_name}?; self.#{old_name}?; end        # def subject?; self.title?; end
-      def #{new_name}=(v); self.#{old_name} = v; end  # def subject=(v); self.title = v; end
-    STR
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'active_support/core_ext/object/blank'
-
-class Module
-  # A module may or may not have a name.
-  #
-  #   module M; end
-  #   M.name # => "M"
-  #
-  #   m = Module.new
-  #   m.name # => ""
-  #
-  # A module gets a name when it is first assigned to a constant. Either
-  # via the +module+ or +class+ keyword or by an explicit assignment:
-  #
-  #   m = Module.new # creates an anonymous module
-  #   M = m          # => m gets a name here as a side-effect
-  #   m.name         # => "M"
-  #
-  def anonymous?
-    # Uses blank? because the name of an anonymous class is an empty
-    # string in 1.8, and nil in 1.9.
-    name.blank? 
-  end
-end

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

@@ -1,31 +0,0 @@
-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__ + 1)
-      def #{sym}=(value)                        # def age=(value)
-        class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
-        @#{sym} = value                         #   @age = value
-      end                                       # end
-    EVAL
-  end
-end

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

@@ -1,32 +0,0 @@
-class Module
-  # Declares an attribute reader backed by an internally-named instance variable.
-  def attr_internal_reader(*attrs)
-    attrs.each do |attr|
-      module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end", __FILE__, __LINE__
-    end
-  end
-
-  # Declares an attribute writer backed by an internally-named instance variable.
-  def attr_internal_writer(*attrs)
-    attrs.each do |attr|
-      module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end", __FILE__, __LINE__
-    end
-  end
-
-  # Declares an attribute reader and writer backed by an internally-named instance
-  # variable.
-  def attr_internal_accessor(*attrs)
-    attr_internal_reader(*attrs)
-    attr_internal_writer(*attrs)
-  end
-
-  alias_method :attr_internal, :attr_internal_accessor
-
-  class << self; attr_accessor :attr_internal_naming_format end
-  self.attr_internal_naming_format = '@_%s'
-
-  private
-    def attr_internal_ivar_name(attr)
-      Module.attr_internal_naming_format % attr
-    end
-end

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

@@ -1,66 +0,0 @@
-require 'active_support/core_ext/array/extract_options'
-
-class Module
-  def mattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
-      EOS
-      
-      unless options[:instance_reader] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-  end
-
-  def mattr_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
-      EOS
-
-      unless options[:instance_writer] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
-    end
-  end
-
-  # 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!"
-  def mattr_accessor(*syms)
-    mattr_reader(*syms)
-    mattr_writer(*syms)
-  end
-end

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

@@ -1,146 +0,0 @@
-require "active_support/core_ext/module/remove_method"
-
-class Module
-  # Provides a delegate class method to easily expose contained objects' methods
-  # as your own. Pass one or more methods (specified as symbols or strings)
-  # and the name of the target object via the <tt>:to</tt> option (also a symbol
-  # or string). At least one method and the <tt>:to</tt> option are required.
-  #
-  # Delegation is particularly useful with Active Record associations:
-  #
-  #   class Greeter < ActiveRecord::Base
-  #     def hello
-  #       "hello"
-  #     end
-  #
-  #     def goodbye
-  #       "goodbye"
-  #     end
-  #   end
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :to => :greeter
-  #   end
-  #
-  #   Foo.new.hello   # => "hello"
-  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
-  #
-  # Multiple delegates to the same target are allowed:
-  #
-  #   class Foo < ActiveRecord::Base
-  #     belongs_to :greeter
-  #     delegate :hello, :goodbye, :to => :greeter
-  #   end
-  #
-  #   Foo.new.goodbye # => "goodbye"
-  #
-  # Methods can be delegated to instance variables, class variables, or constants
-  # by providing them as a symbols:
-  #
-  #   class Foo
-  #     CONSTANT_ARRAY = [0,1,2,3]
-  #     @@class_array  = [4,5,6,7]
-  #
-  #     def initialize
-  #       @instance_array = [8,9,10,11]
-  #     end
-  #     delegate :sum, :to => :CONSTANT_ARRAY
-  #     delegate :min, :to => :@@class_array
-  #     delegate :max, :to => :@instance_array
-  #   end
-  #
-  #   Foo.new.sum # => 6
-  #   Foo.new.min # => 4
-  #   Foo.new.max # => 11
-  #
-  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
-  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
-  # delegated to.
-  #
-  #   Person = Struct.new(:name, :address)
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => true
-  #   end
-  #
-  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.client_name    # => "John Doe"
-  #   invoice.client_address # => "Vimmersvej 13"
-  #
-  # It is also possible to supply a custom prefix.
-  #
-  #   class Invoice < Struct.new(:client)
-  #     delegate :name, :address, :to => :client, :prefix => :customer
-  #   end
-  #
-  #   invoice = Invoice.new(john_doe)
-  #   invoice.customer_name    # => "John Doe"
-  #   invoice.customer_address # => "Vimmersvej 13"
-  #
-  # If the delegate object is +nil+ an exception is raised, and that happens
-  # no matter whether +nil+ responds to the delegated method. You can get a
-  # +nil+ instead with the +:allow_nil+ option.
-  #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar
-  #  end
-  #
-  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
-  #
-  #  class Foo
-  #    attr_accessor :bar
-  #    def initialize(bar = nil)
-  #      @bar = bar
-  #    end
-  #    delegate :zoo, :to => :bar, :allow_nil => true
-  #  end
-  #
-  #  Foo.new.zoo   # returns nil
-  #
-  def delegate(*methods)
-    options = methods.pop
-    unless options.is_a?(Hash) && to = options[:to]
-      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
-    end
-
-    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
-
-    file, line = caller.first.split(':', 2)
-    line = line.to_i
-
-    methods.each do |method|
-      on_nil =
-        if options[:allow_nil]
-          'return'
-        else
-          %(raise "#{self}##{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
-        end
-
-      module_eval(<<-EOS, file, line - 5)
-        if instance_methods(false).map(&:to_s).include?("#{prefix}#{method}")
-          remove_possible_method("#{prefix}#{method}")
-        end
-
-        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
-          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
-        rescue NoMethodError                                # rescue NoMethodError
-          if #{to}.nil?                                     #   if client.nil?
-            #{on_nil}                                       #     return # depends on :allow_nil
-          else                                              #   else
-            raise                                           #     raise
-          end                                               #   end
-        end                                                 # end
-      EOS
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-class Module
-  # Declare that a method has been deprecated.
-  #   deprecate :foo
-  #   deprecate :bar => 'message'
-  #   deprecate :foo, :bar, :baz => 'warning!', :qux => 'gone!'
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
-  end
-end

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

@@ -1,88 +0,0 @@
-require 'active_support/inflector'
-
-class Module
-  # Returns the name of the module containing this one.
-  #
-  #   M::N.parent_name # => "M"
-  def parent_name
-    unless defined? @parent_name
-      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
-    end
-    @parent_name
-  end
-
-  # Returns the module which contains this one according to its name.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M::N.parent # => M
-  #   X.parent    # => M
-  #
-  # The parent of top-level and anonymous modules is Object.
-  #
-  #   M.parent          # => Object
-  #   Module.new.parent # => Object
-  #
-  def parent
-    parent_name ? ActiveSupport::Inflector.constantize(parent_name) : Object
-  end
-
-  # Returns all the parents of this module according to its name, ordered from
-  # nested outwards. The receiver is not contained within the result.
-  #
-  #   module M
-  #     module N
-  #     end
-  #   end
-  #   X = M::N
-  #
-  #   M.parents    # => [Object]
-  #   M::N.parents # => [M, Object]
-  #   X.parents    # => [M, Object]
-  #
-  def parents
-    parents = []
-    if parent_name
-      parts = parent_name.split('::')
-      until parts.empty?
-        parents << ActiveSupport::Inflector.constantize(parts * '::')
-        parts.pop
-      end
-    end
-    parents << Object unless parents.include? Object
-    parents
-  end
-
-  if RUBY_VERSION < '1.9'
-    # Returns the constants that have been defined locally by this object and
-    # not in an ancestor. This method is exact if running under Ruby 1.9. In
-    # previous versions it may miss some constants if their definition in some
-    # ancestor is identical to their definition in the receiver.
-    def local_constants
-      inherited = {}
-
-      ancestors.each do |anc|
-        next if anc == self
-        anc.constants.each { |const| inherited[const] = anc.const_get(const) }
-      end
-
-      constants.select do |const|
-        !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
-      end
-    end
-  else
-    def local_constants #:nodoc:
-      constants(false)
-    end
-  end
-
-  # Returns the names of the constants defined locally rather than the
-  # constants themselves. See <tt>local_constants</tt>.
-  def local_constant_names
-    local_constants.map { |c| c.to_s }
-  end
-end