backbone-deep-rails 0.0.2 → 0.0.3

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/dependencies/autoload.rb

@@ -1,50 +0,0 @@
-require "active_support/inflector/methods"
-require "active_support/lazy_load_hooks"
-
-module ActiveSupport
-  module Autoload
-    @@autoloads = {}
-    @@under_path = nil
-    @@at_path = nil
-    @@eager_autoload = false
-
-    def autoload(const_name, path = @@at_path)
-      full = [self.name, @@under_path, const_name.to_s, path].compact.join("::")
-      location = path || Inflector.underscore(full)
-
-      if @@eager_autoload
-        @@autoloads[const_name] = location
-      end
-      super const_name, location
-    end
-
-    def autoload_under(path)
-      @@under_path, old_path = path, @@under_path
-      yield
-    ensure
-      @@under_path = old_path
-    end
-
-    def autoload_at(path)
-      @@at_path, old_path = path, @@at_path
-      yield
-    ensure
-      @@at_path = old_path
-    end
-
-    def eager_autoload
-      old_eager, @@eager_autoload = @@eager_autoload, true
-      yield
-    ensure
-      @@eager_autoload = old_eager
-    end
-
-    def self.eager_autoload!
-      @@autoloads.values.each { |file| require file }
-    end
-
-    def autoloads
-      @@autoloads
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/deprecation.rb

@@ -1,18 +0,0 @@
-require 'active_support/deprecation/behaviors'
-require 'active_support/deprecation/reporting'
-require 'active_support/deprecation/method_wrappers'
-require 'active_support/deprecation/proxy_wrappers'
-
-module ActiveSupport
-  module Deprecation
-    class << self
-      # The version the deprecated behavior will be removed, by default.
-      attr_accessor :deprecation_horizon
-    end
-    self.deprecation_horizon = '4.0'
-
-    # By default, warnings are not silenced and debugging is off.
-    self.silenced = false
-    self.debug = false
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/deprecation/behaviors.rb

@@ -1,49 +0,0 @@
-require "active_support/notifications"
-require "active_support/core_ext/array/wrap"
-
-module ActiveSupport
-  module Deprecation
-    class << self
-      # Whether to print a backtrace along with the warning.
-      attr_accessor :debug
-
-      # Returns the set behavior or if one isn't set, defaults to +:stderr+
-      def behavior
-        @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
-      end
-
-      # Sets the behavior to the specified value. Can be a single value or an array.
-      #
-      # Examples
-      #
-      #   ActiveSupport::Deprecation.behavior = :stderr
-      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
-      def behavior=(behavior)
-        @behavior = Array.wrap(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
-      end
-    end
-
-    # Default warning behaviors per Rails.env.
-    DEFAULT_BEHAVIORS = {
-      :stderr => Proc.new { |message, callstack|
-         $stderr.puts(message)
-         $stderr.puts callstack.join("\n  ") if debug
-       },
-      :log => Proc.new { |message, callstack|
-         logger =
-           if defined?(Rails) && Rails.logger
-             Rails.logger
-           else
-             require 'logger'
-             Logger.new($stderr)
-           end
-         logger.warn message
-         logger.debug callstack.join("\n  ") if debug
-       },
-       :notify => Proc.new { |message, callstack|
-          ActiveSupport::Notifications.instrument("deprecation.rails",
-            :message => message, :callstack => callstack)
-       }
-    }
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/deprecation/method_wrappers.rb

@@ -1,29 +0,0 @@
-require 'active_support/core_ext/module/deprecation'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/array/extract_options'
-
-module ActiveSupport
-  class << Deprecation
-    # Declare that a method has been deprecated.
-    def deprecate_methods(target_module, *method_names)
-      options = method_names.extract_options!
-      method_names += options.keys
-
-      method_names.each do |method_name|
-        target_module.alias_method_chain(method_name, :deprecation) do |target, punctuation|
-          target_module.module_eval(<<-end_eval, __FILE__, __LINE__ + 1)
-            def #{target}_with_deprecation#{punctuation}(*args, &block)
-              ::ActiveSupport::Deprecation.warn(
-                ::ActiveSupport::Deprecation.deprecated_method_warning(
-                  :#{method_name},
-                  #{options[method_name].inspect}),
-                caller
-              )
-              send(:#{target}_without_deprecation#{punctuation}, *args, &block)
-            end
-          end_eval
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/deprecation/proxy_wrappers.rb

@@ -1,81 +0,0 @@
-require 'active_support/inflector/methods'
-
-module ActiveSupport
-  module Deprecation
-    class DeprecationProxy #:nodoc:
-      def self.new(*args, &block)
-        object = args.first
-
-        return object unless object
-        super
-      end
-
-      instance_methods.each { |m| undef_method m unless m =~ /^__|^object_id$/ }
-
-      # Don't give a deprecation warning on inspect since test/unit and error
-      # logs rely on it for diagnostics.
-      def inspect
-        target.inspect
-      end
-
-      private
-        def method_missing(called, *args, &block)
-          warn caller, called, args
-          target.__send__(called, *args, &block)
-        end
-    end
-
-    class DeprecatedObjectProxy < DeprecationProxy #:nodoc:
-      def initialize(object, message)
-        @object = object
-        @message = message
-      end
-
-      private
-        def target
-          @object
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn(@message, callstack)
-        end
-    end
-
-    # Stand-in for <tt>@request</tt>, <tt>@attributes</tt>, <tt>@params</tt>, etc.
-    # which emits deprecation warnings on any method call (except +inspect+).
-    class DeprecatedInstanceVariableProxy < DeprecationProxy #:nodoc:
-      def initialize(instance, method, var = "@#{method}")
-        @instance, @method, @var = instance, method, var
-      end
-
-      private
-        def target
-          @instance.__send__(@method)
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
-        end
-    end
-
-    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:all
-      def initialize(old_const, new_const)
-        @old_const = old_const
-        @new_const = new_const
-      end
-
-      def class
-        target.class
-      end
-
-      private
-        def target
-          ActiveSupport::Inflector.constantize(@new_const.to_s)
-        end
-
-        def warn(callstack, called, args)
-          ActiveSupport::Deprecation.warn("#{@old_const} is deprecated! Use #{@new_const} instead.", callstack)
-        end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/deprecation/reporting.rb

@@ -1,65 +0,0 @@
-module ActiveSupport
-  module Deprecation
-    class << self
-      attr_accessor :silenced
-
-      # Outputs a deprecation warning to the output configured by <tt>ActiveSupport::Deprecation.behavior</tt>
-      #
-      #   ActiveSupport::Deprecation.warn("something broke!")
-      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
-      def warn(message = nil, callstack = caller)
-        return if silenced
-        deprecation_message(callstack, message).tap do |m|
-          behavior.each { |b| b.call(m, callstack) }
-        end
-      end
-
-      # Silence deprecation warnings within the block.
-      def silence
-        old_silenced, @silenced = @silenced, true
-        yield
-      ensure
-        @silenced = old_silenced
-      end
-
-      def deprecated_method_warning(method_name, message = nil)
-        warning = "#{method_name} is deprecated and will be removed from Rails #{deprecation_horizon}"
-        case message
-          when Symbol then "#{warning} (use #{message} instead)"
-          when String then "#{warning} (#{message})"
-          else warning
-        end
-      end
-
-      private
-        def deprecation_message(callstack, message = nil)
-          message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
-          message += '.' unless message =~ /\.$/
-          "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
-        end
-
-        def deprecation_caller_message(callstack)
-          file, line, method = extract_callstack(callstack)
-          if file
-            if line && method
-              "(called from #{method} at #{file}:#{line})"
-            else
-              "(called from #{file}:#{line})"
-            end
-          end
-        end
-
-        def extract_callstack(callstack)
-          rails_gem_root = File.expand_path("../../../../..", __FILE__) + "/"
-          offending_line = callstack.find { |line| !line.start_with?(rails_gem_root) } || callstack.first
-          if offending_line
-            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-              md.captures
-            else
-              offending_line
-            end
-          end
-        end
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/descendants_tracker.rb

@@ -1,45 +0,0 @@
-module ActiveSupport
-  # This module provides an internal implementation to track descendants
-  # which is faster than iterating through ObjectSpace.
-  module DescendantsTracker
-    @@direct_descendants = Hash.new { |h, k| h[k] = [] }
-
-    def self.direct_descendants(klass)
-      @@direct_descendants[klass]
-    end
-
-    def self.descendants(klass)
-      @@direct_descendants[klass].inject([]) do |descendants, _klass|
-        descendants << _klass
-        descendants.concat _klass.descendants
-      end
-    end
-
-    def self.clear
-      if defined? ActiveSupport::Dependencies
-        @@direct_descendants.each do |klass, descendants|
-          if ActiveSupport::Dependencies.autoloaded?(klass)
-            @@direct_descendants.delete(klass)
-          else
-            descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
-          end
-        end
-      else
-        @@direct_descendants.clear
-      end
-    end
-
-    def inherited(base)
-      self.direct_descendants << base
-      super
-    end
-
-    def direct_descendants
-      DescendantsTracker.direct_descendants(self)
-    end
-
-    def descendants
-      DescendantsTracker.descendants(self)
-    end
-  end
-end

data/vendor/bundle/gems/activesupport-3.2.11/lib/active_support/duration.rb

@@ -1,110 +0,0 @@
-require 'active_support/basic_object'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/object/acts_like'
-
-module ActiveSupport
-  # Provides accurate date and time measurements using Date#advance and
-  # Time#advance, respectively. It mainly supports the methods on Numeric.
-  # Example:
-  #
-  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
-  class Duration < BasicObject
-    attr_accessor :value, :parts
-    delegate :duplicable?, :to => :value # required when using ActiveSupport's BasicObject on 1.8
-
-    def initialize(value, parts) #:nodoc:
-      @value, @parts = value, parts
-    end
-
-    # Adds another Duration or a Numeric to this Duration. Numeric values
-    # are treated as seconds.
-    def +(other)
-      if Duration === other
-        Duration.new(value + other.value, @parts + other.parts)
-      else
-        Duration.new(value + other, @parts + [[:seconds, other]])
-      end
-    end
-
-    # Subtracts another Duration or a Numeric from this Duration. Numeric
-    # values are treated as seconds.
-    def -(other)
-      self + (-other)
-    end
-
-    def -@ #:nodoc:
-      Duration.new(-value, parts.map { |type,number| [type, -number] })
-    end
-
-    def is_a?(klass) #:nodoc:
-      Duration == klass || value.is_a?(klass)
-    end
-    alias :kind_of? :is_a?
-
-    # Returns true if <tt>other</tt> is also a Duration instance with the
-    # same <tt>value</tt>, or if <tt>other == value</tt>.
-    def ==(other)
-      if Duration === other
-        other.value == value
-      else
-        other == value
-      end
-    end
-
-    def self.===(other) #:nodoc:
-      other.is_a?(Duration)
-    rescue ::NoMethodError
-      false
-    end
-
-    # Calculates a new Time or Date that is as far in the future
-    # as this Duration represents.
-    def since(time = ::Time.current)
-      sum(1, time)
-    end
-    alias :from_now :since
-
-    # Calculates a new Time or Date that is as far in the past
-    # as this Duration represents.
-    def ago(time = ::Time.current)
-      sum(-1, time)
-    end
-    alias :until :ago
-
-    def inspect #:nodoc:
-      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-      parts = [:years, :months, :days, :minutes, :seconds].map do |length|
-        n = consolidated[length]
-        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-      end.compact
-      parts = ["0 seconds"] if parts.empty?
-      parts.to_sentence(:locale => :en)
-    end
-
-    def as_json(options = nil) #:nodoc:
-      to_i
-    end
-
-    protected
-
-      def sum(sign, time = ::Time.current) #:nodoc:
-        parts.inject(time) do |t,(type,number)|
-          if t.acts_like?(:time) || t.acts_like?(:date)
-            if type == :seconds
-              t.since(sign * number)
-            else
-              t.advance(type => sign * number)
-            end
-          else
-            raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
-          end
-        end
-      end
-
-    private
-
-      def method_missing(method, *args, &block) #:nodoc:
-        value.send(method, *args, &block)
-      end
-  end
-end