social_url_stats 0.0.1 → 0.0.2

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/array/random_access.rb

@@ -1,27 +0,0 @@
-class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's http://github.com/marcandre/backports/
-  # Returns a random element or +n+ random elements from the array.
-  # If the array is empty and +n+ is nil, returns <tt>nil</tt>. if +n+ is passed, returns <tt>[]</tt>.
-  #
-  #   [1,2,3,4,5,6].sample    # => 4
-  #   [1,2,3,4,5,6].sample(3) # => [2, 4, 5]
-  #              [].sample    # => nil
-  #              [].sample(3) # => []
-  def sample(n=nil)
-    return self[Kernel.rand(size)] if n.nil?
-    n = n.to_int
-  rescue Exception => e
-    raise TypeError, "Coercion error: #{n.inspect}.to_int => Integer failed:\n(#{e.message})"
-  else
-    raise TypeError, "Coercion error: obj.to_int did NOT return an Integer (was #{n.class})" unless n.kind_of? Integer
-    raise ArgumentError, "negative array size" if n < 0
-    n = size if n > size
-    result = Array.new(self)
-    n.times do |i|
-      r = i + Kernel.rand(size - i)
-      result[i], result[r] = result[r], result[i]
-    end
-    result[n..size] = []
-    result
-  end unless method_defined? :sample
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/array/uniq_by.rb

@@ -1,17 +0,0 @@
-class Array
-  # Return an unique array based on the criteria given as a proc.
-  #
-  #   [1, 2, 3, 4].uniq_by { |i| i.odd? }
-  #   # => [1, 2]
-  #
-  def uniq_by
-    hash, array = {}, []
-    each { |i| hash[yield(i)] ||= (array << i) }
-    array
-  end
-
-  # Same as uniq_by, but modifies self.
-  def uniq_by!
-    replace(uniq_by{ |i| yield(i) })
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/array/wrap.rb

@@ -1,48 +0,0 @@
-class Array
-  # Wraps its argument in an array unless it is already an array (or array-like).
-  #
-  # Specifically:
-  #
-  # * If the argument is +nil+ an empty list is returned.
-  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
-  # * Otherwise, returns an array with the argument as its single element.
-  #
-  #   Array.wrap(nil)       # => []
-  #   Array.wrap([1, 2, 3]) # => [1, 2, 3]
-  #   Array.wrap(0)         # => [0]
-  #
-  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
-  #
-  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Arraw.wrap</tt> returns
-  # such a +nil+ right away.
-  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
-  # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
-  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
-  #
-  # The last point is particularly worth comparing for some enumerables:
-  #
-  #   Array(:foo => :bar)      # => [[:foo, :bar]]
-  #   Array.wrap(:foo => :bar) # => [{:foo => :bar}]
-  #
-  #   Array("foo\nbar")        # => ["foo\n", "bar"], in Ruby 1.8
-  #   Array.wrap("foo\nbar")   # => ["foo\nbar"]
-  #
-  # There's also a related idiom that uses the splat operator:
-  #
-  #   [*object]
-  #
-  # which returns <tt>[nil]</tt> for +nil+, and calls to <tt>Array(object)</tt> otherwise.
-  #
-  # Thus, in this case the behavior is different for +nil+, and the differences with
-  # <tt>Kernel#Array</tt> explained above apply to the rest of +object+s.
-  def self.wrap(object)
-    if object.nil?
-      []
-    elsif object.respond_to?(:to_ary)
-      object.to_ary
-    else
-      [object]
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/benchmark.rb

@@ -1,7 +0,0 @@
-require 'benchmark'
-
-class << Benchmark
-  def ms
-    1000 * realtime { yield }
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/big_decimal.rb

@@ -1 +0,0 @@
-require 'active_support/core_ext/big_decimal/conversions'

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/big_decimal/conversions.rb

@@ -1,27 +0,0 @@
-require 'bigdecimal'
-require 'yaml'
-
-class BigDecimal
-  YAML_TAG = 'tag:yaml.org,2002:float'
-  YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
-
-  yaml_as YAML_TAG
-
-  # This emits the number without any scientific notation.
-  # This is better than self.to_f.to_s since it doesn't lose precision.
-  #
-  # Note that reconstituting YAML floats to native floats may lose precision.
-  def to_yaml(opts = {})
-    YAML.quick_emit(nil, opts) do |out|
-      string = to_s
-      out.scalar(YAML_TAG, YAML_MAPPING[string] || string, :plain)
-    end
-  end
-
-  DEFAULT_STRING_FORMAT = 'F'
-  def to_formatted_s(format = DEFAULT_STRING_FORMAT)
-    _original_to_s(format)
-  end
-  alias_method :_original_to_s, :to_s
-  alias_method :to_s, :to_formatted_s
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/cgi.rb

@@ -1 +0,0 @@
-require 'active_support/core_ext/cgi/escape_skipping_slashes'

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/cgi/escape_skipping_slashes.rb

@@ -1,19 +0,0 @@
-require 'cgi'
-
-class CGI #:nodoc:
-  if RUBY_VERSION >= '1.9'
-    def self.escape_skipping_slashes(str)
-      str = str.join('/') if str.respond_to? :join
-      str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
-        "%#{$1.unpack('H2' * $1.bytesize).join('%').upcase}"
-      end.tr(' ', '+')
-    end
-  else
-    def self.escape_skipping_slashes(str)
-      str = str.join('/') if str.respond_to? :join
-      str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
-        "%#{$1.unpack('H2').first.upcase}"
-      end.tr(' ', '+')
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/class.rb

@@ -1,5 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/class/inheritable_attributes'
-require 'active_support/core_ext/class/delegating_attributes'
-require 'active_support/core_ext/class/subclasses'

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/class/attribute.rb

@@ -1,90 +0,0 @@
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/remove_method'
-
-class Class
-  # Declare a class-level attribute whose value is inheritable by subclasses.
-  # Subclasses can change their own value and it will not impact parent class.
-  #
-  #   class Base
-  #     class_attribute :setting
-  #   end
-  #
-  #   class Subclass < Base
-  #   end
-  #
-  #   Base.setting = true
-  #   Subclass.setting            # => true
-  #   Subclass.setting = false
-  #   Subclass.setting            # => false
-  #   Base.setting                # => true
-  #
-  # In the above case as long as Subclass does not assign a value to setting
-  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
-  # would read value assigned to parent class. Once Subclass assigns a value then
-  # the value assigned by Subclass would be returned.
-  #
-  # This matches normal Ruby method inheritance: think of writing an attribute
-  # on a subclass as overriding the reader method. However, you need to be aware
-  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
-  # In such cases, you don't want to do changes in places but use setters:
-  #
-  #   Base.setting = []
-  #   Base.setting                # => []
-  #   Subclass.setting            # => []
-  #
-  #   # Appending in child changes both parent and child because it is the same object:
-  #   Subclass.setting << :foo
-  #   Base.setting               # => [:foo]
-  #   Subclass.setting           # => [:foo]
-  #
-  #   # Use setters to not propagate changes:
-  #   Base.setting = []
-  #   Subclass.setting += [:foo]
-  #   Base.setting               # => []
-  #   Subclass.setting           # => [:foo]
-  #
-  # For convenience, a query method is defined as well:
-  #
-  #   Subclass.setting?       # => false
-  #
-  # Instances may overwrite the class value in the same way:
-  #
-  #   Base.setting = true
-  #   object = Base.new
-  #   object.setting          # => true
-  #   object.setting = false
-  #   object.setting          # => false
-  #   Base.setting            # => true
-  #
-  # To opt out of the instance writer method, pass :instance_writer => false.
-  #
-  #   object.setting = false  # => NoMethodError
-  def class_attribute(*attrs)
-    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
-
-    attrs.each do |name|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{name}() nil end
-        def self.#{name}?() !!#{name} end
-
-        def self.#{name}=(val)
-          singleton_class.class_eval do
-            remove_possible_method(:#{name})
-            define_method(:#{name}) { val }
-          end
-          val
-        end
-
-        def #{name}
-          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
-        end
-
-        def #{name}?
-          !!#{name}
-        end
-      RUBY
-
-      attr_writer name if instance_writer
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -1,79 +0,0 @@
-require 'active_support/core_ext/array/extract_options'
-
-# Extends the class object with class and instance accessors for class attributes,
-# just like the native attr* accessors for instance attributes.
-#
-# Note that unlike +class_attribute+, if a subclass changes the value then that would
-# also change the value for parent class. Similarly if parent class changes the value
-# then that would change the value of subclasses too.
-#
-#  class Person
-#    cattr_accessor :hair_colors
-#  end
-#
-#  Person.hair_colors = [:brown, :black, :blonde, :red]
-#  Person.hair_colors     # => [:brown, :black, :blonde, :red]
-#  Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-#
-# To opt out of the instance writer method, pass :instance_writer => false.
-# To opt out of the instance reader method, pass :instance_reader => false.
-#
-#   class Person
-#     cattr_accessor :hair_colors, :instance_writer => false, :instance_reader => false
-#   end
-#
-#   Person.new.hair_colors = [:brown]  # => NoMethodError
-#   Person.new.hair_colors             # => NoMethodError
-class Class
-  def cattr_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 cattr_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
-      self.send("#{sym}=", yield) if block_given?
-    end
-  end
-
-  def cattr_accessor(*syms, &blk)
-    cattr_reader(*syms)
-    cattr_writer(*syms, &blk)
-  end
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -1,44 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/remove_method'
-
-class Class
-  def superclass_delegating_accessor(name, options = {})
-    # Create private _name and _name= methods that can still be used if the public
-    # methods are overridden. This allows
-    _superclass_delegating_accessor("_#{name}")
-
-    # Generate the public methods name, name=, and name?
-    # These methods dispatch to the private _name, and _name= methods, making them
-    # overridable
-    singleton_class.send(:define_method, name) { send("_#{name}") }
-    singleton_class.send(:define_method, "#{name}?") { !!send("_#{name}") }
-    singleton_class.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
-
-    # If an instance_reader is needed, generate methods for name and name= on the
-    # class itself, so instances will be able to see them
-    define_method(name) { send("_#{name}") } if options[:instance_reader] != false
-    define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
-  end
-
-private
-
-  # Take the object being set and store it in a method. This gives us automatic
-  # inheritance behavior, without having to store the object in an instance
-  # variable and look up the superclass chain manually.
-  def _stash_object_in_method(object, method, instance_reader = true)
-    singleton_class.remove_possible_method(method)
-    singleton_class.send(:define_method, method) { object }
-    remove_possible_method(method)
-    define_method(method) { object } if instance_reader
-  end
-
-  def _superclass_delegating_accessor(name, options = {})
-    singleton_class.send(:define_method, "#{name}=") do |value|
-      _stash_object_in_method(value, name, options[:instance_reader] != false)
-    end
-    send("#{name}=", nil)
-  end
-
-end

data/vendor/ruby/1.9.1/gems/activesupport-3.0.0/lib/active_support/core_ext/class/inheritable_attributes.rb

@@ -1,254 +0,0 @@
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/array/extract_options'
-
-# Retained for backward compatibility.  Methods are now included in Class.
-module ClassInheritableAttributes # :nodoc:
-end
-
-# It is recommended to use <tt>class_attribute</tt> over methods defined in this file. Please
-# refer to documentation for <tt>class_attribute</tt> for more information. Officially it is not
-# deprecated but <tt>class_attribute</tt> is faster.
-#
-# Allows attributes to be shared within an inheritance hierarchy. Each descendant gets a copy of
-# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
-# to, for example, an array without those additions being shared with either their parent, siblings, or
-# children. This is unlike the regular class-level attributes that are shared across the entire hierarchy.
-#
-# The copies of inheritable parent attributes are added to subclasses when they are created, via the
-# +inherited+ hook.
-#
-#  class Person
-#    class_inheritable_accessor :hair_colors
-#  end
-#
-#  Person.hair_colors = [:brown, :black, :blonde, :red]
-#  Person.hair_colors     # => [:brown, :black, :blonde, :red]
-#  Person.new.hair_colors # => [:brown, :black, :blonde, :red]
-#
-# To opt out of the instance writer method, pass :instance_writer => false.
-# To opt out of the instance reader method, pass :instance_reader => false.
-#
-#   class Person
-#     class_inheritable_accessor :hair_colors :instance_writer => false, :instance_reader => false
-#   end
-#
-#   Person.new.hair_colors = [:brown]  # => NoMethodError
-#   Person.new.hair_colors             # => NoMethodError
-class Class # :nodoc:
-  def class_inheritable_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      next if sym.is_a?(Hash)
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}                                # def self.after_add
-          read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}                                     # def after_add
-          self.class.#{sym}                            #   self.class.after_add
-        end                                            # end
-        " unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.color=(obj)
-          write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def color=(obj)
-          self.class.#{sym} = obj                      #   self.class.color = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_array_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.levels=(obj)
-          write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def levels=(obj)
-          self.class.#{sym} = obj                      #   self.class.levels = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_hash_writer(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}=(obj)                          # def self.nicknames=(obj)
-          write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
-        end                                            # end
-                                                       #
-        #{"                                            #
-        def #{sym}=(obj)                               # def nicknames=(obj)
-          self.class.#{sym} = obj                      #   self.class.nicknames = obj
-        end                                            # end
-        " unless options[:instance_writer] == false }  # # the writer above is generated unless options[:instance_writer] == false
-      EOS
-    end
-  end
-
-  def class_inheritable_accessor(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_writer(*syms)
-  end
-
-  def class_inheritable_array(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_array_writer(*syms)
-  end
-
-  def class_inheritable_hash(*syms)
-    class_inheritable_reader(*syms)
-    class_inheritable_hash_writer(*syms)
-  end
-
-  def inheritable_attributes
-    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  def write_inheritable_attribute(key, value)
-    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-      @inheritable_attributes = {}
-    end
-    inheritable_attributes[key] = value
-  end
-
-  def write_inheritable_array(key, elements)
-    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
-  end
-
-  def write_inheritable_hash(key, hash)
-    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
-  def read_inheritable_attribute(key)
-    inheritable_attributes[key]
-  end
-
-  def reset_inheritable_attributes
-    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-  end
-
-  private
-    # Prevent this constant from being created multiple times
-    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze
-
-    def inherited_with_inheritable_attributes(child)
-      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
-
-      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
-        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
-      else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => value.duplicable? ? value.dup : value)
-        end
-      end
-
-      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
-    end
-
-    alias inherited_without_inheritable_attributes inherited
-    alias inherited inherited_with_inheritable_attributes
-end
-
-class Class
-  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
-  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
-  #
-  # @api public
-  #
-  # @todo Do we want to block instance_reader via :instance_reader => false
-  # @todo It would be preferable that we do something with a Hash passed in
-  #   (error out or do the same as other methods above) instead of silently
-  #   moving on). In particular, this makes the return value of this function
-  #   less useful.
-  def extlib_inheritable_reader(*ivars, &block)
-    options = ivars.extract_options!
-
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}
-          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
-          ivar = superclass.#{ivar}
-          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
-          @#{ivar} = ivar.duplicable? ? ivar.dup : ivar
-        end
-      RUBY
-      unless options[:instance_reader] == false
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{ivar}
-            self.class.#{ivar}
-          end
-        RUBY
-      end
-      instance_variable_set(:"@#{ivar}", yield) if block_given?
-    end
-  end
-
-  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
-  #   define inheritable writer for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
-  #
-  # @api public
-  #
-  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
-  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
-  def extlib_inheritable_writer(*ivars)
-    options = ivars.extract_options!
-
-    ivars.each do |ivar|
-      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def self.#{ivar}=(obj)
-          @#{ivar} = obj
-        end
-      RUBY
-      unless options[:instance_writer] == false
-        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{ivar}=(obj) self.class.#{ivar} = obj end
-        RUBY
-      end
-
-      self.send("#{ivar}=", yield) if block_given?
-    end
-  end
-
-  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
-  # each subclass has a copy of parent's attribute.
-  #
-  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
-  #   define inheritable accessor for.
-  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
-  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
-  #
-  # @api public
-  def extlib_inheritable_accessor(*syms, &block)
-    extlib_inheritable_reader(*syms)
-    extlib_inheritable_writer(*syms, &block)
-  end
-end