backbone-deep-rails 0.0.2 → 0.0.3

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

@@ -1,61 +0,0 @@
-require 'active_support/ordered_hash'
-
-# Usually key value pairs are handled something like this:
-#
-#   h = {}
-#   h[:boy] = 'John'
-#   h[:girl] = 'Mary'
-#   h[:boy]  # => 'John'
-#   h[:girl] # => 'Mary'
-#
-# Using <tt>OrderedOptions</tt>, the above code could be reduced to:
-#
-#   h = ActiveSupport::OrderedOptions.new
-#   h.boy = 'John'
-#   h.girl = 'Mary'
-#   h.boy  # => 'John'
-#   h.girl # => 'Mary'
-#
-module ActiveSupport #:nodoc:
-  class OrderedOptions < OrderedHash
-    alias_method :_get, :[] # preserve the original #[] method
-    protected :_get # make it protected
-
-    def []=(key, value)
-      super(key.to_sym, value)
-    end
-
-    def [](key)
-      super(key.to_sym)
-    end
-
-    def method_missing(name, *args)
-      if name.to_s =~ /(.*)=$/
-        self[$1] = args.first
-      else
-        self[name]
-      end
-    end
-
-    def respond_to?(name)
-      true
-    end
-  end
-
-  class InheritableOptions < OrderedOptions
-    def initialize(parent = nil)
-      if parent.kind_of?(OrderedOptions)
-        # use the faster _get when dealing with OrderedOptions
-        super() { |h,k| parent._get(k) }
-      elsif parent
-        super() { |h,k| parent[k] }
-      else
-        super()
-      end
-    end
-
-    def inheritable_copy
-      self.class.new(self)
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-require "active_support"
-require "active_support/i18n_railtie"
-
-module ActiveSupport
-  class Railtie < Rails::Railtie
-    config.active_support = ActiveSupport::OrderedOptions.new
-
-    # Loads support for "whiny nil" (noisy warnings when methods are invoked
-    # on +nil+ values) if Configuration#whiny_nils is true.
-    initializer "active_support.initialize_whiny_nils" do |app|
-      require 'active_support/whiny_nil' if app.config.whiny_nils
-    end
-
-    initializer "active_support.deprecation_behavior" do |app|
-      if deprecation = app.config.active_support.deprecation
-        ActiveSupport::Deprecation.behavior = deprecation
-      else
-        defaults = {"development" => :log,
-                    "production"  => :notify,
-                    "test"        => :stderr}
-
-        env = Rails.env
-
-        if defaults.key?(env)
-          msg = "You did not specify how you would like Rails to report " \
-                "deprecation notices for your #{env} environment, please " \
-                "set config.active_support.deprecation to :#{defaults[env]} " \
-                "at config/environments/#{env}.rb"
-
-          warn msg
-          ActiveSupport::Deprecation.behavior = defaults[env]
-        else
-          msg = "You did not specify how you would like Rails to report " \
-                "deprecation notices for your #{env} environment, please " \
-                "set config.active_support.deprecation to :log, :notify or " \
-                ":stderr at config/environments/#{env}.rb"
-
-          warn msg
-          ActiveSupport::Deprecation.behavior = :stderr
-        end
-      end
-    end
-
-    # Sets the default value for Time.zone
-    # If assigned value cannot be matched to a TimeZone, an exception will be raised.
-    initializer "active_support.initialize_time_zone" do |app|
-      require 'active_support/core_ext/time/zones'
-      zone_default = Time.find_zone!(app.config.time_zone)
-
-      unless zone_default
-        raise \
-          'Value assigned to config.time_zone not recognized.' +
-          'Run "rake -D time" for a list of tasks for finding appropriate time zone names.'
-      end
-
-      Time.zone_default = zone_default
-    end
-  end
-end

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

@@ -1,115 +0,0 @@
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/proc'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/array/extract_options'
-
-module ActiveSupport
-  # Rescuable module adds support for easier exception handling.
-  module Rescuable
-    extend Concern
-
-    included do
-      class_attribute :rescue_handlers
-      self.rescue_handlers = []
-    end
-
-    module ClassMethods
-      # Rescue exceptions raised in controller actions.
-      #
-      # <tt>rescue_from</tt> receives a series of exception classes or class
-      # names, and a trailing <tt>:with</tt> option with the name of a method
-      # or a Proc object to be called to handle them. Alternatively a block can
-      # be given.
-      #
-      # Handlers that take one argument will be called with the exception, so
-      # that the exception can be inspected when dealing with it.
-      #
-      # Handlers are inherited. They are searched from right to left, from
-      # bottom to top, and up the hierarchy. The handler of the first class for
-      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if
-      # any.
-      #
-      #   class ApplicationController < ActionController::Base
-      #     rescue_from User::NotAuthorized, :with => :deny_access # self defined exception
-      #     rescue_from ActiveRecord::RecordInvalid, :with => :show_errors
-      #
-      #     rescue_from 'MyAppError::Base' do |exception|
-      #       render :xml => exception, :status => 500
-      #     end
-      #
-      #     protected
-      #       def deny_access
-      #         ...
-      #       end
-      #
-      #       def show_errors(exception)
-      #         exception.record.new_record? ? ...
-      #       end
-      #   end
-      #
-      def rescue_from(*klasses, &block)
-        options = klasses.extract_options!
-
-        unless options.has_key?(:with)
-          if block_given?
-            options[:with] = block
-          else
-            raise ArgumentError, "Need a handler. Supply an options hash that has a :with key as the last argument."
-          end
-        end
-
-        klasses.each do |klass|
-          key = if klass.is_a?(Class) && klass <= Exception
-            klass.name
-          elsif klass.is_a?(String)
-            klass
-          else
-            raise ArgumentError, "#{klass} is neither an Exception nor a String"
-          end
-
-          # put the new handler at the end because the list is read in reverse
-          self.rescue_handlers += [[key, options[:with]]]
-        end
-      end
-    end
-
-    # Tries to rescue the exception by looking up and calling a registered handler.
-    def rescue_with_handler(exception)
-      if handler = handler_for_rescue(exception)
-        handler.arity != 0 ? handler.call(exception) : handler.call
-        true # don't rely on the return value of the handler
-      end
-    end
-
-    def handler_for_rescue(exception)
-      # We go from right to left because pairs are pushed onto rescue_handlers
-      # as rescue_from declarations are found.
-      _, rescuer = self.class.rescue_handlers.reverse.detect do |klass_name, handler|
-        # The purpose of allowing strings in rescue_from is to support the
-        # declaration of handler associations for exception classes whose
-        # definition is yet unknown.
-        #
-        # Since this loop needs the constants it would be inconsistent to
-        # assume they should exist at this point. An early raised exception
-        # could trigger some other handler and the array could include
-        # precisely a string whose corresponding constant has not yet been
-        # seen. This is why we are tolerant to unknown constants.
-        #
-        # Note that this tolerance only matters if the exception was given as
-        # a string, otherwise a NameError will be raised by the interpreter
-        # itself when rescue_from CONSTANT is executed.
-        klass = self.class.const_get(klass_name) rescue nil
-        klass ||= klass_name.constantize rescue nil
-        exception.is_a?(klass) if klass
-      end
-
-      case rescuer
-      when Symbol
-        method(rescuer)
-      when Proc
-        rescuer.bind(self)
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# Backported Ruby builtins so you can code with the latest & greatest
-# but still run on any Ruby 1.8.x.
-#
-# Date        next_year, next_month
-# DateTime    to_date, to_datetime, xmlschema
-# Enumerable  group_by, each_with_object, none?
-# Process     Process.daemon
-# REXML       security fix
-# String      ord
-# Time        to_date, to_time, to_datetime
-require 'active_support'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/process/daemon'
-require 'active_support/core_ext/string/conversions'
-require 'active_support/core_ext/string/interpolation'
-require 'active_support/core_ext/string/encoding'
-require 'active_support/core_ext/rexml'
-require 'active_support/core_ext/time/conversions'
-require 'active_support/core_ext/file/path'
-require 'active_support/core_ext/module/method_names'

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

@@ -1,21 +0,0 @@
-module ActiveSupport
-  # Wrapping a string in this class gives you a prettier way to test
-  # for equality. The value returned by <tt>Rails.env</tt> is wrapped
-  # in a StringInquirer object so instead of calling this:
-  #
-  #   Rails.env == "production"
-  #
-  # you can call this:
-  #
-  #   Rails.env.production?
-  #
-  class StringInquirer < String
-    def method_missing(method_name, *arguments)
-      if method_name.to_s[-1,1] == "?"
-        self == method_name.to_s[0..-2]
-      else
-        super
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/deprecation'
-require 'logger'
-
-module ActiveSupport
-  # Wraps any standard Logger class to provide tagging capabilities. Examples:
-  #
-  #   Logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-  #   Logger.tagged("BCX") { Logger.info "Stuff" }                            # Logs "[BCX] Stuff"
-  #   Logger.tagged("BCX", "Jason") { Logger.info "Stuff" }                   # Logs "[BCX] [Jason] Stuff"
-  #   Logger.tagged("BCX") { Logger.tagged("Jason") { Logger.info "Stuff" } } # Logs "[BCX] [Jason] Stuff"
-  #
-  # This is used by the default Rails.logger as configured by Railties to make it easy to stamp log lines
-  # with subdomains, request ids, and anything else to aid debugging of multi-user production applications.
-  class TaggedLogging
-    def initialize(logger)
-      @logger = logger
-    end
-
-    def tagged(*tags)
-      new_tags = push_tags(*tags)
-      yield self
-    ensure
-      pop_tags(new_tags.size)
-    end
-
-    def push_tags(*tags)
-      tags.flatten.reject(&:blank?).tap do |new_tags|
-        current_tags.concat new_tags
-      end
-    end
-
-    def pop_tags(size = 1)
-      current_tags.pop size
-    end
-
-    def clear_tags!
-      current_tags.clear
-    end
-
-    def silence(temporary_level = Logger::ERROR, &block)
-      @logger.silence(temporary_level, &block)
-    end
-    deprecate :silence
-
-    def add(severity, message = nil, progname = nil, &block)
-      message = (block_given? ? block.call : progname) if message.nil?
-      @logger.add(severity, "#{tags_text}#{message}", progname)
-    end
-
-    %w( fatal error warn info debug unknown ).each do |severity|
-      eval <<-EOM, nil, __FILE__, __LINE__ + 1
-        def #{severity}(progname = nil, &block)
-          add(Logger::#{severity.upcase}, nil, progname, &block)
-        end
-      EOM
-    end
-
-    def flush
-      clear_tags!
-      @logger.flush if @logger.respond_to?(:flush)
-    end
-
-    def method_missing(method, *args)
-      @logger.send(method, *args)
-    end
-
-    private
-      def tags_text
-        tags = current_tags
-        if tags.any?
-          tags.collect { |tag| "[#{tag}] " }.join
-        end
-      end
-
-      def current_tags
-        Thread.current[:activesupport_tagged_logging_tags] ||= []
-      end
-  end
-end

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

@@ -1,34 +0,0 @@
-require 'test/unit/testcase'
-require 'active_support/testing/setup_and_teardown'
-require 'active_support/testing/assertions'
-require 'active_support/testing/deprecation'
-require 'active_support/testing/declarative'
-require 'active_support/testing/pending'
-require 'active_support/testing/isolation'
-require 'active_support/testing/mochaing'
-require 'active_support/core_ext/kernel/reporting'
-
-module ActiveSupport
-  class TestCase < ::Test::Unit::TestCase
-    if defined? MiniTest
-      Assertion = MiniTest::Assertion
-      alias_method :method_name, :name if method_defined? :name
-      alias_method :method_name, :__name__ if method_defined? :__name__
-    else
-      Assertion = Test::Unit::AssertionFailedError
-
-      undef :default_test
-    end
-
-    $tags = {}
-    def self.for_tag(tag)
-      yield if $tags[tag]
-    end
-
-    include ActiveSupport::Testing::SetupAndTeardown
-    include ActiveSupport::Testing::Assertions
-    include ActiveSupport::Testing::Deprecation
-    include ActiveSupport::Testing::Pending
-    extend ActiveSupport::Testing::Declarative
-  end
-end

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

@@ -1,97 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/object/blank'
-
-module ActiveSupport
-  module Testing
-    module Assertions
-      # Test numeric difference between the return value of an expression as a result of what is evaluated
-      # in the yielded block.
-      #
-      #   assert_difference 'Article.count' do
-      #     post :create, :article => {...}
-      #   end
-      #
-      # An arbitrary expression is passed in and evaluated.
-      #
-      #   assert_difference 'assigns(:article).comments(:reload).size' do
-      #     post :create, :comment => {...}
-      #   end
-      #
-      # An arbitrary positive or negative difference can be specified. The default is +1.
-      #
-      #   assert_difference 'Article.count', -1 do
-      #     post :delete, :id => ...
-      #   end
-      #
-      # An array of expressions can also be passed in and evaluated.
-      #
-      #   assert_difference [ 'Article.count', 'Post.count' ], +2 do
-      #     post :create, :article => {...}
-      #   end
-      #
-      # A lambda or a list of lambdas can be passed in and evaluated:
-      #
-      #   assert_difference lambda { Article.count }, 2 do
-      #     post :create, :article => {...}
-      #   end
-      #
-      #   assert_difference [->{ Article.count }, ->{ Post.count }], 2 do
-      #     post :create, :article => {...}
-      #   end
-      #
-      # A error message can be specified.
-      #
-      #   assert_difference 'Article.count', -1, "An Article should be destroyed" do
-      #     post :delete, :id => ...
-      #   end
-      def assert_difference(expression, difference = 1, message = nil, &block)
-        expressions = Array.wrap expression
-
-        exps = expressions.map { |e|
-          e.respond_to?(:call) ? e : lambda { eval(e, block.binding) }
-        }
-        before = exps.map { |e| e.call }
-
-        yield
-
-        expressions.zip(exps).each_with_index do |(code, e), i|
-          error  = "#{code.inspect} didn't change by #{difference}"
-          error  = "#{message}.\n#{error}" if message
-          assert_equal(before[i] + difference, e.call, error)
-        end
-      end
-
-      # Assertion that the numeric result of evaluating an expression is not changed before and after
-      # invoking the passed in block.
-      #
-      #   assert_no_difference 'Article.count' do
-      #     post :create, :article => invalid_attributes
-      #   end
-      #
-      # A error message can be specified.
-      #
-      #   assert_no_difference 'Article.count', "An Article should not be created" do
-      #     post :create, :article => invalid_attributes
-      #   end
-      def assert_no_difference(expression, message = nil, &block)
-        assert_difference expression, 0, message, &block
-      end
-
-      # Test if an expression is blank. Passes if object.blank? is true.
-      #
-      #   assert_blank [] # => true
-      def assert_blank(object, message=nil)
-        message ||= "#{object.inspect} is not blank"
-        assert object.blank?, message
-      end
-
-      # Test if an expression is not blank. Passes if object.present? is true.
-      #
-      #   assert_present {:data => 'x' } # => true
-      def assert_present(object, message=nil)
-        message ||= "#{object.inspect} is blank"
-        assert object.present?, message
-      end
-    end
-  end
-end