activesupport-refinements 0.0.1

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

@@ -0,0 +1,40 @@
+module ModuleExt; end; module ModuleExt::AttrInternal
+refine Module do
+  # Declares an attribute reader backed by an internally-named instance variable.
+  def attr_internal_reader(*attrs)
+    attrs.each {|attr_name| attr_internal_define(attr_name, :reader)}
+  end
+
+  # Declares an attribute writer backed by an internally-named instance variable.
+  def attr_internal_writer(*attrs)
+    attrs.each {|attr_name| attr_internal_define(attr_name, :writer)}
+  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
+
+    def attr_internal_define(attr_name, type)
+      internal_name = attr_internal_ivar_name(attr_name).sub(/\A@/, '')
+      class_eval do # class_eval is necessary on 1.9 or else the methods a made private
+        # use native attr_* methods as they are faster on some Ruby implementations
+        send("attr_#{type}", internal_name)
+      end
+      attr_name, internal_name = "#{attr_name}=", "#{internal_name}=" if type == :writer
+#      alias_method attr_name, internal_name
+      remove_method internal_name
+    end
+end
+end

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

@@ -0,0 +1,68 @@
+module ModuleExt; end; module ModuleExt::AttributeAccessors
+require 'active_support/refinements/core_ext/array/extract_options'
+
+refine Module do
+  def mattr_reader(*syms)
+    options = syms.extract_options!
+    syms.each do |sym|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{sym} = nil unless defined? @@#{sym}
+
+        def self.#{sym}
+          @@#{sym}
+        end
+      EOS
+
+      unless options[:instance_reader] == false || options[:instance_accessor] == 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|
+      raise NameError.new('invalid attribute name') unless sym =~ /^[_A-Za-z]\w*$/
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+
+      unless options[:instance_writer] == false || options[:instance_accessor] == 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"
+  #   end
+  #
+  #   AppConfiguration.google_api_key # => "123456789"
+  #   AppConfiguration.google_api_key = "overriding the api key!"
+  #   AppConfiguration.google_api_key # => "overriding the api key!"
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end
+end

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

@@ -0,0 +1,172 @@
+module ModuleExt; end; module ModuleExt::Delegation
+refine Module do
+  # Provides a delegate class method to easily expose contained objects' public 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
+  #
+  # It's also possible to delegate a method to the class by using +:class+:
+  #
+  #   class Foo
+  #     def self.hello
+  #       "world"
+  #     end
+  #
+  #     delegate :hello, to: :class
+  #   end
+  #
+  #   Foo.new.hello # => "world"
+  #
+  # 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
+
+    prefix, allow_nil = options.values_at(:prefix, :allow_nil)
+
+    if prefix == true && to =~ /^[^a-z_]/
+      raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+    end
+
+    method_prefix = \
+      if prefix
+        "#{prefix == true ? to : prefix}_"
+      else
+        ''
+      end
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    to = to.to_s
+    to = 'self.class' if to == 'class'
+
+    methods.each do |method|
+      # Attribute writer methods only accept one argument. Makes sure []=
+      # methods still accept two arguments.
+      definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+
+      if allow_nil
+        module_eval(<<-EOS, file, line - 2)
+          def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
+            if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
+              #{to}.#{method}(#{definition})                  #     client.name(*args, &block)
+            end                                               #   end
+          end                                                 # end
+        EOS
+      else
+        exception = %(raise "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+
+        module_eval(<<-EOS, file, line - 1)
+          def #{method_prefix}#{method}(#{definition})        # def customer_name(*args, &block)
+            #{to}.#{method}(#{definition})                    #   client.name(*args, &block)
+          rescue NoMethodError                                # rescue NoMethodError
+            if #{to}.nil?                                     #   if client.nil?
+              #{exception}                                    #     # add helpful message to the exception
+            else                                              #   else
+              raise                                           #     raise
+            end                                               #   end
+          end                                                 # end
+        EOS
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,27 @@
+module ModuleExt; end; module ModuleExt::Deprecation
+require 'active_support/deprecation/method_wrappers'
+
+refine Module do
+  #   deprecate :foo
+  #   deprecate bar: 'message'
+  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #
+  # You can also use custom deprecator instance:
+  #
+  #   deprecate :foo, deprecator: MyLib::Deprecator.new
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
+  #
+  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
+  # method where you can implement your custom warning behavior.
+  #
+  #   class MyLib::Deprecator
+  #     def deprecation_warning(deprecated_method_name, message, caller_backtrace)
+  #        message = "#{method_name} is deprecated and will be removed from MyLibrary | #{message}"
+  #        Kernel.warn message
+  #     end
+  #   end
+  def deprecate(*method_names)
+    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
+  end
+end
+end

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

@@ -0,0 +1,80 @@
+module ModuleExt; end; module ModuleExt::Introspection
+require 'active_support/inflector'
+
+refine Module do
+  # Returns the name of the module containing this one.
+  #
+  #   M::N.parent_name # => "M"
+  def parent_name
+    if defined? @parent_name
+      @parent_name
+    else
+      @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+    end
+  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
+
+  def local_constants #:nodoc:
+    constants(false)
+  end
+
+  # *DEPRECATED*: Use +local_constants+ instead.
+  #
+  # Returns the names of the constants defined locally as strings.
+  #
+  #   module M
+  #     X = 1
+  #   end
+  #   M.local_constant_names # => ["X"]
+  #
+  # This method is useful for forward compatibility, since Ruby 1.8 returns
+  # constant names as strings, whereas 1.9 returns them as symbols.
+  def local_constant_names
+    ActiveSupport::Deprecation.warn 'Module#local_constant_names is deprecated, use Module#local_constants instead', caller
+    local_constants.map { |c| c.to_s }
+  end
+end
+end

data/lib/active_support/refinements/core_ext/module/qualified_const.rb

@@ -0,0 +1,54 @@
+module ModuleExt; end; module ModuleExt::QualifiedConst
+require 'active_support/refinements/core_ext/string/inflections'
+
+#--
+# Allows code reuse in the methods below without polluting Module.
+#++
+module QualifiedConstUtils
+  def self.raise_if_absolute(path)
+    raise NameError.new("wrong constant name #$&") if path =~ /\A::[^:]+/
+  end
+
+  def self.names(path)
+    path.split('::')
+  end
+end
+
+##
+# Extends the API for constants to be able to deal with qualified names. Arguments
+# are assumed to be relative to the receiver.
+#
+#--
+# Qualified names are required to be relative because we are extending existing
+# methods that expect constant names, ie, relative paths of length 1. For example,
+# Object.const_get('::String') raises NameError and so does qualified_const_get.
+#++
+refine Module do
+  def qualified_const_defined?(path, search_parents=true)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      return unless mod.const_defined?(name, search_parents)
+      mod.const_get(name)
+    end
+    return true
+  end
+
+  def qualified_const_get(path)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    QualifiedConstUtils.names(path).inject(self) do |mod, name|
+      mod.const_get(name)
+    end
+  end
+
+  def qualified_const_set(path, value)
+    QualifiedConstUtils.raise_if_absolute(path)
+
+    const_name = path.demodulize
+    mod_name = path.deconstantize
+    mod = mod_name.empty? ? self : qualified_const_get(mod_name)
+    mod.const_set(const_name, value)
+  end
+end
+end

data/lib/active_support/refinements/core_ext/module/reachable.rb

@@ -0,0 +1,10 @@
+module ModuleExt; end; module ModuleExt::Reachable
+require 'active_support/refinements/core_ext/module/anonymous'
+require 'active_support/refinements/core_ext/string/inflections'
+
+refine Module do
+  def reachable? #:nodoc:
+    !anonymous? && name.safe_constantize.equal?(self)
+  end
+end
+end