backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/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/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/module/attr_internal.rb

@@ -1,39 +0,0 @@
-class Module
-  # 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

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -1,64 +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)
-        @@#{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|
-      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"
-  #
-  #    mattr_accessor :paypal_url
-  #    self.paypal_url = "www.sandbox.paypal.com"
-  #  end
-  #
-  #  AppConfiguration.google_api_key = "overriding the api key!"
-  #
-  # To opt out of the instance writer method, pass :instance_writer => false.
-  # To opt out of the instance reader method, pass :instance_reader => false.
-  # To opt out of both instance methods, pass :instance_accessor => false.
-  def mattr_accessor(*syms)
-    mattr_reader(*syms)
-    mattr_writer(*syms)
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/module/delegation.rb

@@ -1,153 +0,0 @@
-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
-    prefix, to, allow_nil = options[:prefix], options[:to], options[:allow_nil]
-
-    if prefix == true && to.to_s =~ /^[^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
-
-    methods.each do |method|
-      method = method.to_s
-
-      if allow_nil
-        module_eval(<<-EOS, file, line - 2)
-          def #{method_prefix}#{method}(*args, &block)        # def customer_name(*args, &block)
-            if #{to} || #{to}.respond_to?(:#{method})         #   if client || client.respond_to?(:name)
-              #{to}.__send__(:#{method}, *args, &block)       #     client.__send__(: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}(*args, &block)        # def customer_name(*args, &block)
-            #{to}.__send__(:#{method}, *args, &block)         #   client.__send__(: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

data/vendor/bundle/gems/activesupport-3.2.11/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/vendor/bundle/gems/activesupport-3.2.11/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

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/module/method_names.rb

@@ -1,14 +0,0 @@
-class Module
-  if instance_methods[0].is_a?(Symbol)
-    def instance_method_names(*args)
-      instance_methods(*args).map(&:to_s)
-    end
-
-    def method_names(*args)
-      methods(*args).map(&:to_s)
-    end
-  else
-    alias_method :instance_method_names, :instance_methods
-    alias_method :method_names, :methods
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/core_ext/module/qualified_const.rb

@@ -1,64 +0,0 @@
-require 'active_support/core_ext/string/inflections'
-
-#--
-# Allows code reuse in the methods below without polluting Module.
-#++
-module QualifiedConstUtils
-  def self.raise_if_absolute(path)
-    raise NameError, "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.
-#++
-class Module
-  if method(:const_defined?).arity == 1
-    def qualified_const_defined?(path)
-      QualifiedConstUtils.raise_if_absolute(path)
-
-      QualifiedConstUtils.names(path).inject(self) do |mod, name|
-        return unless mod.const_defined?(name)
-        mod.const_get(name)
-      end
-      return true
-    end
-  else
-    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
-  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