backbone-deep-rails 0.0.2 → 0.0.3

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

@@ -1,121 +0,0 @@
-require "active_support/core_ext/array/wrap"
-require "active_support/core_ext/array/extract_options"
-
-module ActiveSupport
-  # \FileUpdateChecker specifies the API used by Rails to watch files
-  # and control reloading. The API depends on four methods:
-  #
-  # * +initialize+ which expects two parameters and one block as
-  #   described below;
-  #
-  # * +updated?+ which returns a boolean if there were updates in
-  #   the filesystem or not;
-  #
-  # * +execute+ which executes the given block on initialization
-  #   and updates the counter to the latest timestamp;
-  #
-  # * +execute_if_updated+ which just executes the block if it was updated;
-  #
-  # After initialization, a call to +execute_if_updated+ must execute
-  # the block only if there was really a change in the filesystem.
-  #
-  # == Examples
-  #
-  # This class is used by Rails to reload the I18n framework whenever
-  # they are changed upon a new request.
-  #
-  #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do
-  #     I18n.reload!
-  #   end
-  #
-  #   ActionDispatch::Reloader.to_prepare do
-  #     i18n_reloader.execute_if_updated
-  #   end
-  #
-  class FileUpdateChecker
-    # It accepts two parameters on initialization. The first is an array
-    # of files and the second is an optional hash of directories. The hash must
-    # have directories as keys and the value is an array of extensions to be
-    # watched under that directory.
-    #
-    # This method must also receive a block that will be called once a path changes.
-    #
-    # == Implementation details
-    #
-    # This particular implementation checks for added and updated files,
-    # but not removed files. Directories lookup are compiled to a glob for
-    # performance. Therefore, while someone can add new files to the +files+
-    # array after initialization (and parts of Rails do depend on this feature),
-    # adding new directories after initialization is not allowed.
-    #
-    # Notice that other objects that implements FileUpdateChecker API may
-    # not even allow new files to be added after initialization. If this
-    # is the case, we recommend freezing the +files+ after initialization to
-    # avoid changes that won't make effect.
-    def initialize(files, dirs={}, &block)
-      @files = files
-      @glob  = compile_glob(dirs)
-      @block = block
-      @updated_at = nil
-      @last_update_at = updated_at
-    end
-
-    # Check if any of the entries were updated. If so, the updated_at
-    # value is cached until the block is executed via +execute+ or +execute_if_updated+
-    def updated?
-      current_updated_at = updated_at
-      if @last_update_at < current_updated_at
-        @updated_at = updated_at
-        true
-      else
-        false
-      end
-    end
-
-    # Executes the given block and updates the counter to latest timestamp.
-    def execute
-      @last_update_at = updated_at
-      @block.call
-    ensure
-      @updated_at = nil
-    end
-
-    # Execute the block given if updated.
-    def execute_if_updated
-      if updated?
-        execute
-        true
-      else
-        false
-      end
-    end
-
-    private
-
-    def updated_at #:nodoc:
-      @updated_at || begin
-        all = []
-        all.concat @files.select { |f| File.exists?(f) }
-        all.concat Dir[@glob] if @glob
-        all.map { |path| File.mtime(path) }.max || Time.at(0)
-      end
-    end
-
-    def compile_glob(hash) #:nodoc:
-      hash.freeze # Freeze so changes aren't accidently pushed
-      return if hash.empty?
-
-      globs = []
-      hash.each do |key, value|
-        globs << "#{key}/**/*#{compile_ext(value)}"
-      end
-      "{#{globs.join(",")}}"
-    end
-
-    def compile_ext(array) #:nodoc:
-      array = Array.wrap(array)
-      return if array.empty?
-      ".{#{array.join(",")}}"
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module ActiveSupport
-  class FileWatcher
-    class Backend
-      def initialize(path, watcher)
-        @watcher = watcher
-        @path    = path
-      end
-
-      def trigger(files)
-        @watcher.trigger(files)
-      end
-    end
-
-    def initialize
-      @regex_matchers = {}
-    end
-
-    def watch(pattern, &block)
-      @regex_matchers[pattern] = block
-    end
-
-    def trigger(files)
-      trigger_files = Hash.new { |h,k| h[k] = Hash.new { |h2,k2| h2[k2] = [] } }
-
-      files.each do |file, state|
-        @regex_matchers.each do |pattern, block|
-          trigger_files[block][state] << file if pattern === file
-        end
-      end
-
-      trigger_files.each do |block, payload|
-        block.call payload
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'zlib'
-require 'stringio'
-require 'active_support/core_ext/string/encoding'
-
-module ActiveSupport
-  # A convenient wrapper for the zlib standard library that allows compression/decompression of strings with gzip.
-  module Gzip
-    class Stream < StringIO
-      def initialize(*)
-        super
-        set_encoding "BINARY" if "".encoding_aware?
-      end
-      def close; rewind; end
-    end
-
-    # Decompresses a gzipped string.
-    def self.decompress(source)
-      Zlib::GzipReader.new(StringIO.new(source)).read
-    end
-
-    # Compresses a string using gzip.
-    def self.compress(source)
-      output = Stream.new
-      gz = Zlib::GzipWriter.new(output)
-      gz.write(source)
-      gz.close
-      output.string
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-
-# This class has dubious semantics and we only have it so that
-# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
-# and they get the same value for both keys.
-
-module ActiveSupport
-  class HashWithIndifferentAccess < Hash
-    
-    # Always returns true, so that <tt>Array#extract_options!</tt> finds members of this class.
-    def extractable_options?
-      true
-    end
-
-    def with_indifferent_access
-      dup
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    def initialize(constructor = {})
-      if constructor.is_a?(Hash)
-        super()
-        update(constructor)
-      else
-        super(constructor)
-      end
-    end
-
-    def default(key = nil)
-      if key.is_a?(Symbol) && include?(key = key.to_s)
-        self[key]
-      else
-        super
-      end
-    end
-
-    def self.new_from_hash_copying_default(hash)
-      new(hash).tap do |new_hash|
-        new_hash.default = hash.default
-      end
-    end
-
-    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-    alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-    # Assigns a new value to the hash:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:key] = "value"
-    #
-    def []=(key, value)
-      regular_writer(convert_key(key), convert_value(value))
-    end
-
-    alias_method :store, :[]=
-
-    # Updates the instantized hash with values from the second:
-    #
-    #   hash_1 = HashWithIndifferentAccess.new
-    #   hash_1[:key] = "value"
-    #
-    #   hash_2 = HashWithIndifferentAccess.new
-    #   hash_2[:key] = "New Value!"
-    #
-    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-    #
-    def update(other_hash)
-      if other_hash.is_a? HashWithIndifferentAccess
-        super(other_hash)
-      else
-        other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-        self
-      end
-    end
-
-    alias_method :merge!, :update
-
-    # Checks the hash for a key matching the argument passed in:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash["key"] = "value"
-    #   hash.key? :key  # => true
-    #   hash.key? "key" # => true
-    #
-    def key?(key)
-      super(convert_key(key))
-    end
-
-    alias_method :include?, :key?
-    alias_method :has_key?, :key?
-    alias_method :member?, :key?
-
-    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-    # either a string or a symbol:
-    #
-    #   counters = HashWithIndifferentAccess.new
-    #   counters[:foo] = 1
-    #
-    #   counters.fetch("foo")          # => 1
-    #   counters.fetch(:bar, 0)        # => 0
-    #   counters.fetch(:bar) {|key| 0} # => 0
-    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-    #
-    def fetch(key, *extras)
-      super(convert_key(key), *extras)
-    end
-
-    # Returns an array of the values at the specified indices:
-    #
-    #   hash = HashWithIndifferentAccess.new
-    #   hash[:a] = "x"
-    #   hash[:b] = "y"
-    #   hash.values_at("a", "b") # => ["x", "y"]
-    #
-    def values_at(*indices)
-      indices.collect {|key| self[convert_key(key)]}
-    end
-
-    # Returns an exact copy of the hash.
-    def dup
-      self.class.new(self).tap do |new_hash|
-        new_hash.default = default
-      end
-    end
-
-    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash.
-    # Does not overwrite the existing hash.
-    def merge(hash)
-      self.dup.update(hash)
-    end
-
-    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
-    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
-    def reverse_merge(other_hash)
-      super self.class.new_from_hash_copying_default(other_hash)
-    end
-
-    def reverse_merge!(other_hash)
-      replace(reverse_merge( other_hash ))
-    end
-
-    # Removes a specified key from the hash.
-    def delete(key)
-      super(convert_key(key))
-    end
-
-    def stringify_keys!; self end
-    def stringify_keys; dup end
-    undef :symbolize_keys!
-    def symbolize_keys; to_hash.symbolize_keys end
-    def to_options!; self end
-
-    # Convert to a Hash with String keys.
-    def to_hash
-      Hash.new(default).merge!(self)
-    end
-
-    protected
-      def convert_key(key)
-        key.kind_of?(Symbol) ? key.to_s : key
-      end
-
-      def convert_value(value)
-        if value.is_a? Hash
-          value.nested_under_indifferent_access
-        elsif value.is_a?(Array)
-          value.dup.replace(value.map { |e| convert_value(e) })
-        else
-          value
-        end
-      end
-  end
-end
-
-HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

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

@@ -1,9 +0,0 @@
-begin
-  require 'i18n'
-  require 'active_support/lazy_load_hooks'
-rescue LoadError => e
-  $stderr.puts "The i18n gem is not available. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-
-I18n.load_path << "#{File.dirname(__FILE__)}/locale/en.yml"

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

@@ -1,102 +0,0 @@
-require "active_support"
-require "active_support/file_update_checker"
-require "active_support/core_ext/array/wrap"
-
-module I18n
-  class Railtie < Rails::Railtie
-    config.i18n = ActiveSupport::OrderedOptions.new
-    config.i18n.railties_load_path = []
-    config.i18n.load_path = []
-    config.i18n.fallbacks = ActiveSupport::OrderedOptions.new
-
-    def self.reloader
-      @reloader ||= ActiveSupport::FileUpdateChecker.new(reloader_paths){ I18n.reload! }
-    end
-
-    def self.reloader_paths
-      @reloader_paths ||= []
-    end
-
-    # Add <tt>I18n::Railtie.reloader</tt> to ActionDispatch callbacks. Since, at this
-    # point, no path was added to the reloader, I18n.reload! is not triggered
-    # on to_prepare callbacks. This will only happen on the config.after_initialize
-    # callback below.
-    initializer "i18n.callbacks" do |app|
-      app.reloaders << I18n::Railtie.reloader
-      ActionDispatch::Reloader.to_prepare do
-        I18n::Railtie.reloader.execute_if_updated
-      end
-    end
-
-    # Set the i18n configuration after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
-      I18n::Railtie.initialize_i18n(app)
-    end
-
-    # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded
-    config.before_eager_load do |app|
-      I18n::Railtie.initialize_i18n(app)
-    end
-
-  protected
-
-    @i18n_inited = false
-
-    # Setup i18n configuration
-    def self.initialize_i18n(app)
-      return if @i18n_inited
-
-      fallbacks = app.config.i18n.delete(:fallbacks)
-
-      app.config.i18n.each do |setting, value|
-        case setting
-        when :railties_load_path
-          app.config.i18n.load_path.unshift(*value)
-        when :load_path
-          I18n.load_path += value
-        else
-          I18n.send("#{setting}=", value)
-        end
-      end
-
-      init_fallbacks(fallbacks) if fallbacks && validate_fallbacks(fallbacks)
-
-      reloader_paths.concat I18n.load_path
-      reloader.execute
-
-      @i18n_inited = true
-    end
-
-    def self.include_fallbacks_module
-      I18n.backend.class.send(:include, I18n::Backend::Fallbacks)
-    end
-
-    def self.init_fallbacks(fallbacks)
-      include_fallbacks_module
-
-      args = case fallbacks
-      when ActiveSupport::OrderedOptions
-        [*(fallbacks[:defaults] || []) << fallbacks[:map]].compact
-      when Hash, Array
-        Array.wrap(fallbacks)
-      else # TrueClass
-        []
-      end
-
-      I18n.fallbacks = I18n::Locale::Fallbacks.new(*args)
-    end
-
-    def self.validate_fallbacks(fallbacks)
-      case fallbacks
-      when ActiveSupport::OrderedOptions
-        !fallbacks.empty?
-      when TrueClass, Array, Hash
-        true
-      else
-        raise "Unexpected fallback type #{fallbacks.inspect}"
-      end
-    end
-  end
-end