backbone-forms-on-rails 0.10.0 → 0.10.0.1

data/vendor/bundle/gems/backbone-forms-on-rails-0.10.0/vendor/bundle/gems/sprockets-2.2.2/lib/sprockets/cache/file_store.rb

@@ -1,32 +0,0 @@
-require 'digest/md5'
-require 'fileutils'
-require 'pathname'
-
-module Sprockets
-  module Cache
-    # A simple file system cache store.
-    #
-    #     environment.cache = Sprockets::Cache::FileStore.new("/tmp")
-    #
-    class FileStore
-      def initialize(root)
-        @root = Pathname.new(root)
-      end
-
-      # Lookup value in cache
-      def [](key)
-        pathname = @root.join(key)
-        pathname.exist? ? pathname.open('rb') { |f| Marshal.load(f) } : nil
-      end
-
-      # Save value to cache
-      def []=(key, value)
-        # Ensure directory exists
-        FileUtils.mkdir_p @root.join(key).dirname
-
-        @root.join(key).open('w') { |f| Marshal.dump(value, f)}
-        value
-      end
-    end
-  end
-end

data/vendor/bundle/gems/backbone-forms-on-rails-0.10.0/vendor/bundle/gems/sprockets-2.2.2/lib/sprockets/caching.rb

@@ -1,96 +0,0 @@
-module Sprockets
-  # `Caching` is an internal mixin whose public methods are exposed on
-  # the `Environment` and `Index` classes.
-  module Caching
-    protected
-      # Cache helper method. Takes a `path` argument which maybe a
-      # logical path or fully expanded path. The `&block` is passed
-      # for finding and building the asset if its not in cache.
-      def cache_asset(path)
-        # If `cache` is not set, return fast
-        if cache.nil?
-          yield
-
-        # Check cache for `path`
-        elsif (asset = Asset.from_hash(self, cache_get_hash(path.to_s))) && asset.fresh?(self)
-          asset
-
-         # Otherwise yield block that slowly finds and builds the asset
-        elsif asset = yield
-          hash = {}
-          asset.encode_with(hash)
-
-          # Save the asset to its path
-          cache_set_hash(path.to_s, hash)
-
-          # Since path maybe a logical or full pathname, save the
-          # asset its its full path too
-          if path.to_s != asset.pathname.to_s
-            cache_set_hash(asset.pathname.to_s, hash)
-          end
-
-          asset
-        end
-      end
-
-    private
-      # Strips `Environment#root` from key to make the key work
-      # consisently across different servers. The key is also hashed
-      # so it does not exceed 250 characters.
-      def expand_cache_key(key)
-        File.join('sprockets', digest_class.hexdigest(key.sub(root, '')))
-      end
-
-      def cache_get_hash(key)
-        hash = cache_get(expand_cache_key(key))
-        if hash.is_a?(Hash) && digest.hexdigest == hash['_version']
-          hash
-        end
-      end
-
-      def cache_set_hash(key, hash)
-        hash['_version'] = digest.hexdigest
-        cache_set(expand_cache_key(key), hash)
-        hash
-      end
-
-      # Low level cache getter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_get(key)
-        # `Cache#get(key)` for Memcache
-        if cache.respond_to?(:get)
-          cache.get(key)
-
-        # `Cache#[key]` so `Hash` can be used
-        elsif cache.respond_to?(:[])
-          cache[key]
-
-        # `Cache#read(key)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:read)
-          cache.read(key)
-
-        else
-          nil
-        end
-      end
-
-      # Low level cache setter for `key`. Checks a number of supported
-      # cache interfaces.
-      def cache_set(key, value)
-        # `Cache#set(key, value)` for Memcache
-        if cache.respond_to?(:set)
-          cache.set(key, value)
-
-        # `Cache#[key]=value` so `Hash` can be used
-        elsif cache.respond_to?(:[]=)
-          cache[key] = value
-
-        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
-        elsif cache.respond_to?(:write)
-          cache.write(key, value)
-        end
-
-        value
-      end
-  end
-end

data/vendor/bundle/gems/backbone-forms-on-rails-0.10.0/vendor/bundle/gems/sprockets-2.2.2/lib/sprockets/charset_normalizer.rb

@@ -1,41 +0,0 @@
-require 'tilt'
-
-module Sprockets
-  # Some browsers have issues with stylesheets that contain multiple
-  # `@charset` definitions. The issue surfaces while using Sass since
-  # it inserts a `@charset` at the top of each file. Then Sprockets
-  # concatenates them together.
-  #
-  # The `CharsetNormalizer` processor strips out multiple `@charset`
-  # definitions.
-  #
-  # The current implementation is naive. It picks the first `@charset`
-  # it sees and strips the others. This works for most people because
-  # the other definitions are usually `UTF-8`. A more sophisticated
-  # approach would be to re-encode stylesheets with mixed encodings.
-  #
-  # This behavior can be disabled with:
-  #
-  #     environment.unregister_bundle_processor 'text/css', Sprockets::CharsetNormalizer
-  #
-  class CharsetNormalizer < Tilt::Template
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      charset = nil
-
-      # Find and strip out any `@charset` definitions
-      filtered_data = data.gsub(/^@charset "([^"]+)";$/) {
-        charset ||= $1; ""
-      }
-
-      if charset
-        # If there was a charset, move it to the top
-        "@charset \"#{charset}\";#{filtered_data}"
-      else
-        data
-      end
-    end
-  end
-end

data/vendor/bundle/gems/backbone-forms-on-rails-0.10.0/vendor/bundle/gems/sprockets-2.2.2/lib/sprockets/context.rb

@@ -1,235 +0,0 @@
-require 'base64'
-require 'rack/utils'
-require 'sprockets/errors'
-require 'sprockets/utils'
-require 'pathname'
-require 'set'
-
-module Sprockets
-  # `Context` provides helper methods to all `Tilt` processors. They
-  # are typically accessed by ERB templates. You can mix in custom
-  # helpers by injecting them into `Environment#context_class`. Do not
-  # mix them into `Context` directly.
-  #
-  #     environment.context_class.class_eval do
-  #       include MyHelper
-  #       def asset_url; end
-  #     end
-  #
-  #     <%= asset_url "foo.png" %>
-  #
-  # The `Context` also collects dependencies declared by
-  # assets. See `DirectiveProcessor` for an example of this.
-  class Context
-    attr_reader :environment, :pathname
-    attr_reader :_required_paths, :_stubbed_assets
-    attr_reader :_dependency_paths, :_dependency_assets
-    attr_writer :__LINE__
-
-    def initialize(environment, logical_path, pathname)
-      @environment  = environment
-      @logical_path = logical_path
-      @pathname     = pathname
-      @__LINE__     = nil
-
-      @_required_paths    = []
-      @_stubbed_assets    = Set.new
-      @_dependency_paths  = Set.new
-      @_dependency_assets = Set.new([pathname.to_s])
-    end
-
-    # Returns the environment path that contains the file.
-    #
-    # If `app/javascripts` and `app/stylesheets` are in your path, and
-    # current file is `app/javascripts/foo/bar.js`, `root_path` would
-    # return `app/javascripts`.
-    def root_path
-      environment.paths.detect { |path| pathname.to_s[path] }
-    end
-
-    # Returns logical path without any file extensions.
-    #
-    #     'app/javascripts/application.js'
-    #     # => 'application'
-    #
-    def logical_path
-      @logical_path[/^([^.]+)/, 0]
-    end
-
-    # Returns content type of file
-    #
-    #     'application/javascript'
-    #     'text/css'
-    #
-    def content_type
-      environment.content_type_of(pathname)
-    end
-
-    # Given a logical path, `resolve` will find and return the fully
-    # expanded path. Relative paths will also be resolved. An optional
-    # `:content_type` restriction can be supplied to restrict the
-    # search.
-    #
-    #     resolve("foo.js")
-    #     # => "/path/to/app/javascripts/foo.js"
-    #
-    #     resolve("./bar.js")
-    #     # => "/path/to/app/javascripts/bar.js"
-    #
-    def resolve(path, options = {}, &block)
-      pathname   = Pathname.new(path)
-      attributes = environment.attributes_for(pathname)
-
-      if pathname.absolute?
-        pathname
-
-      elsif content_type = options[:content_type]
-        content_type = self.content_type if content_type == :self
-
-        if attributes.format_extension
-          if content_type != attributes.content_type
-            raise ContentTypeMismatch, "#{path} is " +
-              "'#{attributes.content_type}', not '#{content_type}'"
-          end
-        end
-
-        resolve(path) do |candidate|
-          if self.content_type == environment.content_type_of(candidate)
-            return candidate
-          end
-        end
-
-        raise FileNotFound, "couldn't find file '#{path}'"
-      else
-        environment.resolve(path, :base_path => self.pathname.dirname, &block)
-      end
-    end
-
-    # `depend_on` allows you to state a dependency on a file without
-    # including it.
-    #
-    # This is used for caching purposes. Any changes made to
-    # the dependency file with invalidate the cache of the
-    # source file.
-    def depend_on(path)
-      @_dependency_paths << resolve(path).to_s
-      nil
-    end
-
-    # `depend_on_asset` allows you to state an asset dependency
-    # without including it.
-    #
-    # This is used for caching purposes. Any changes that would
-    # invalidate the dependency asset will invalidate the source
-    # file. Unlike `depend_on`, this will include recursively include
-    # the target asset's dependencies.
-    def depend_on_asset(path)
-      filename = resolve(path).to_s
-      @_dependency_assets << filename
-      nil
-    end
-
-    # `require_asset` declares `path` as a dependency of the file. The
-    # dependency will be inserted before the file and will only be
-    # included once.
-    #
-    # If ERB processing is enabled, you can use it to dynamically
-    # require assets.
-    #
-    #     <%= require_asset "#{framework}.js" %>
-    #
-    def require_asset(path)
-      pathname = resolve(path, :content_type => :self)
-      depend_on_asset(pathname)
-      @_required_paths << pathname.to_s
-      nil
-    end
-
-    # `stub_asset` blacklists `path` from being included in the bundle.
-    # `path` must be an asset which may or may not already be included
-    # in the bundle.
-    def stub_asset(path)
-      @_stubbed_assets << resolve(path, :content_type => :self).to_s
-      nil
-    end
-
-    # Tests if target path is able to be safely required into the
-    # current concatenation.
-    def asset_requirable?(path)
-      pathname = resolve(path)
-      content_type = environment.content_type_of(pathname)
-      stat = environment.stat(path)
-      return false unless stat && stat.file?
-      self.content_type.nil? || self.content_type == content_type
-    end
-
-    # Reads `path` and runs processors on the file.
-    #
-    # This allows you to capture the result of an asset and include it
-    # directly in another.
-    #
-    #     <%= evaluate "bar.js" %>
-    #
-    def evaluate(path, options = {})
-      pathname   = resolve(path)
-      attributes = environment.attributes_for(pathname)
-      processors = options[:processors] || attributes.processors
-
-      if options[:data]
-        result = options[:data]
-      else
-        if environment.respond_to?(:default_external_encoding)
-          mime_type = environment.mime_types(pathname.extname)
-          encoding  = environment.encoding_for_mime_type(mime_type)
-          result    = Sprockets::Utils.read_unicode(pathname, encoding)
-        else
-          result = Sprockets::Utils.read_unicode(pathname)
-        end
-      end
-
-      processors.each do |processor|
-        begin
-          template = processor.new(pathname.to_s) { result }
-          result = template.render(self, {})
-        rescue Exception => e
-          annotate_exception! e
-          raise
-        end
-      end
-
-      result
-    end
-
-    # Returns a Base64-encoded `data:` URI with the contents of the
-    # asset at the specified path, and marks that path as a dependency
-    # of the current file.
-    #
-    # Use `asset_data_uri` from ERB with CSS or JavaScript assets:
-    #
-    #     #logo { background: url(<%= asset_data_uri 'logo.png' %>) }
-    #
-    #     $('<img>').attr('src', '<%= asset_data_uri 'avatar.jpg' %>')
-    #
-    def asset_data_uri(path)
-      depend_on_asset(path)
-      asset  = environment.find_asset(path)
-      base64 = Base64.encode64(asset.to_s).gsub(/\s+/, "")
-      "data:#{asset.content_type};base64,#{Rack::Utils.escape(base64)}"
-    end
-
-    private
-      # Annotates exception backtrace with the original template that
-      # the exception was raised in.
-      def annotate_exception!(exception)
-        location = pathname.to_s
-        location << ":#{@__LINE__}" if @__LINE__
-
-        exception.extend(Sprockets::EngineError)
-        exception.sprockets_annotation = "  (in #{location})"
-      end
-
-      def logger
-        environment.logger
-      end
-  end
-end

data/vendor/bundle/gems/backbone-forms-on-rails-0.10.0/vendor/bundle/gems/sprockets-2.2.2/lib/sprockets/directive_processor.rb

@@ -1,406 +0,0 @@
-require 'pathname'
-require 'shellwords'
-require 'tilt'
-require 'yaml'
-
-module Sprockets
-  # The `DirectiveProcessor` is responsible for parsing and evaluating
-  # directive comments in a source file.
-  #
-  # A directive comment starts with a comment prefix, followed by an "=",
-  # then the directive name, then any arguments.
-  #
-  #     // JavaScript
-  #     //= require "foo"
-  #
-  #     # CoffeeScript
-  #     #= require "bar"
-  #
-  #     /* CSS
-  #      *= require "baz"
-  #      */
-  #
-  # The Processor is implemented as a `Tilt::Template` and is loosely
-  # coupled to Sprockets. This makes it possible to disable or modify
-  # the processor to do whatever you'd like. You could add your own
-  # custom directives or invent your own directive syntax.
-  #
-  # `Environment#processors` includes `DirectiveProcessor` by default.
-  #
-  # To remove the processor entirely:
-  #
-  #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
-  #     env.unregister_processor('application/javascript', Sprockets::DirectiveProcessor)
-  #
-  # Then inject your own preprocessor:
-  #
-  #     env.register_processor('text/css', MyProcessor)
-  #
-  class DirectiveProcessor < Tilt::Template
-    # Directives will only be picked up if they are in the header
-    # of the source file. C style (/* */), JavaScript (//), and
-    # Ruby (#) comments are supported.
-    #
-    # Directives in comments after the first non-whitespace line
-    # of code will not be processed.
-    #
-    HEADER_PATTERN = /
-      \A (
-        (?m:\s*) (
-          (\/\* (?m:.*?) \*\/) |
-          (\#\#\# (?m:.*?) \#\#\#) |
-          (\/\/ .* \n?)+ |
-          (\# .* \n?)+
-        )
-      )+
-    /x
-
-    # Directives are denoted by a `=` followed by the name, then
-    # argument list.
-    #
-    # A few different styles are allowed:
-    #
-    #     // =require foo
-    #     //= require foo
-    #     //= require "foo"
-    #
-    DIRECTIVE_PATTERN = /
-      ^ [\W]* = \s* (\w+.*?) (\*\/)? $
-    /x
-
-    attr_reader :pathname
-    attr_reader :header, :body
-
-    def prepare
-      @pathname = Pathname.new(file)
-
-      @header = data[HEADER_PATTERN, 0] || ""
-      @body   = $' || data
-      # Ensure body ends in a new line
-      @body  += "\n" if @body != "" && @body !~ /\n\Z/m
-
-      @included_pathnames = []
-      @compat             = false
-    end
-
-    # Implemented for Tilt#render.
-    #
-    # `context` is a `Context` instance with methods that allow you to
-    # access the environment and append to the bundle. See `Context`
-    # for the complete API.
-    def evaluate(context, locals, &block)
-      @context = context
-
-      @result = ""
-      @has_written_body = false
-
-      process_directives
-      process_source
-
-      @result
-    end
-
-    # Returns the header String with any directives stripped.
-    def processed_header
-      lineno = 0
-      @processed_header ||= header.lines.map { |line|
-        lineno += 1
-        # Replace directive line with a clean break
-        directives.assoc(lineno) ? "\n" : line
-      }.join.chomp
-    end
-
-    # Returns the source String with any directives stripped.
-    def processed_source
-      @processed_source ||= processed_header + body
-    end
-
-    # Returns an Array of directive structures. Each structure
-    # is an Array with the line number as the first element, the
-    # directive name as the second element, followed by any
-    # arguments.
-    #
-    #     [[1, "require", "foo"], [2, "require", "bar"]]
-    #
-    def directives
-      @directives ||= header.lines.each_with_index.map { |line, index|
-        if directive = line[DIRECTIVE_PATTERN, 1]
-          name, *args = Shellwords.shellwords(directive)
-          if respond_to?("process_#{name}_directive", true)
-            [index + 1, name, *args]
-          end
-        end
-      }.compact
-    end
-
-    protected
-      attr_reader :included_pathnames
-      attr_reader :context
-
-      # Gathers comment directives in the source and processes them.
-      # Any directive method matching `process_*_directive` will
-      # automatically be available. This makes it easy to extend the
-      # processor.
-      #
-      # To implement a custom directive called `require_glob`, subclass
-      # `Sprockets::DirectiveProcessor`, then add a method called
-      # `process_require_glob_directive`.
-      #
-      #     class DirectiveProcessor < Sprockets::DirectiveProcessor
-      #       def process_require_glob_directive
-      #         Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
-      #           require(filename)
-      #         end
-      #       end
-      #     end
-      #
-      # Replace the current processor on the environment with your own:
-      #
-      #     env.unregister_processor('text/css', Sprockets::DirectiveProcessor)
-      #     env.register_processor('text/css', DirectiveProcessor)
-      #
-      def process_directives
-        directives.each do |line_number, name, *args|
-          context.__LINE__ = line_number
-          send("process_#{name}_directive", *args)
-          context.__LINE__ = nil
-        end
-      end
-
-      def process_source
-        unless @has_written_body || processed_header.empty?
-          @result << processed_header << "\n"
-        end
-
-        included_pathnames.each do |pathname|
-          @result << context.evaluate(pathname)
-        end
-
-        unless @has_written_body
-          @result << body
-        end
-
-        if compat? && constants.any?
-          @result.gsub!(/<%=(.*?)%>/) { constants[$1.strip] }
-        end
-      end
-
-      # The `require` directive functions similar to Ruby's own `require`.
-      # It provides a way to declare a dependency on a file in your path
-      # and ensures its only loaded once before the source file.
-      #
-      # `require` works with files in the environment path:
-      #
-      #     //= require "foo.js"
-      #
-      # Extensions are optional. If your source file is ".js", it
-      # assumes you are requiring another ".js".
-      #
-      #     //= require "foo"
-      #
-      # Relative paths work too. Use a leading `./` to denote a relative
-      # path:
-      #
-      #     //= require "./bar"
-      #
-      def process_require_directive(path)
-        if @compat
-          if path =~ /<([^>]+)>/
-            path = $1
-          else
-            path = "./#{path}" unless relative?(path)
-          end
-        end
-
-        context.require_asset(path)
-      end
-
-      # `require_self` causes the body of the current file to be
-      # inserted before any subsequent `require` or `include`
-      # directives. Useful in CSS files, where it's common for the
-      # index file to contain global styles that need to be defined
-      # before other dependencies are loaded.
-      #
-      #     /*= require "reset"
-      #      *= require_self
-      #      *= require_tree .
-      #      */
-      #
-      def process_require_self_directive
-        if @has_written_body
-          raise ArgumentError, "require_self can only be called once per source file"
-        end
-
-        context.require_asset(pathname)
-        process_source
-        included_pathnames.clear
-        @has_written_body = true
-      end
-
-      # The `include` directive works similar to `require` but
-      # inserts the contents of the dependency even if it already
-      # has been required.
-      #
-      #     //= include "header"
-      #
-      def process_include_directive(path)
-        pathname = context.resolve(path)
-        context.depend_on_asset(pathname)
-        included_pathnames << pathname
-      end
-
-      # `require_directory` requires all the files inside a single
-      # directory. It's similar to `path/*` since it does not follow
-      # nested directories.
-      #
-      #     //= require_directory "./javascripts"
-      #
-      def process_require_directory_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
-
-          unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_directory argument must be a directory"
-          end
-
-          context.depend_on(root)
-
-          entries(root).each do |pathname|
-            pathname = root.join(pathname)
-            if pathname.to_s == self.file
-              next
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_directory argument must be a relative path"
-        end
-      end
-
-      # `require_tree` requires all the nested files in a directory.
-      # Its glob equivalent is `path/**/*`.
-      #
-      #     //= require_tree "./public"
-      #
-      def process_require_tree_directive(path = ".")
-        if relative?(path)
-          root = pathname.dirname.join(path).expand_path
-
-          unless (stats = stat(root)) && stats.directory?
-            raise ArgumentError, "require_tree argument must be a directory"
-          end
-
-          context.depend_on(root)
-
-          each_entry(root) do |pathname|
-            if pathname.to_s == self.file
-              next
-            elsif stat(pathname).directory?
-              context.depend_on(pathname)
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
-            end
-          end
-        else
-          # The path must be relative and start with a `./`.
-          raise ArgumentError, "require_tree argument must be a relative path"
-        end
-      end
-
-      # Allows you to state a dependency on a file without
-      # including it.
-      #
-      # This is used for caching purposes. Any changes made to
-      # the dependency file will invalidate the cache of the
-      # source file.
-      #
-      # This is useful if you are using ERB and File.read to pull
-      # in contents from another file.
-      #
-      #     //= depend_on "foo.png"
-      #
-      def process_depend_on_directive(path)
-        context.depend_on(path)
-      end
-
-      # Allows you to state a dependency on an asset without including
-      # it.
-      #
-      # This is used for caching purposes. Any changes that would
-      # invalid the asset dependency will invalidate the cache our the
-      # source file.
-      #
-      # Unlike `depend_on`, the path must be a requirable asset.
-      #
-      #     //= depend_on_asset "bar.js"
-      #
-      def process_depend_on_asset_directive(path)
-        context.depend_on_asset(path)
-      end
-
-      # Allows dependency to be excluded from the asset bundle.
-      #
-      # The `path` must be a valid asset and may or may not already
-      # be part of the bundle. Once stubbed, it is blacklisted and
-      # can't be brought back by any other `require`.
-      #
-      #     //= stub "jquery"
-      #
-      def process_stub_directive(path)
-        context.stub_asset(path)
-      end
-
-      # Enable Sprockets 1.x compat mode.
-      #
-      # Makes it possible to use the same JavaScript source
-      # file in both Sprockets 1 and 2.
-      #
-      #     //= compat
-      #
-      def process_compat_directive
-        @compat = true
-      end
-
-      # Checks if Sprockets 1.x compat mode enabled
-      def compat?
-        @compat
-      end
-
-      # Sprockets 1.x allowed for constant interpolation if a
-      # constants.yml was present. This is only available if
-      # compat mode is on.
-      def constants
-        if compat?
-          pathname = Pathname.new(context.root_path).join("constants.yml")
-          stat(pathname) ? YAML.load_file(pathname) : {}
-        else
-          {}
-        end
-      end
-
-      # `provide` is stubbed out for Sprockets 1.x compat.
-      # Mutating the path when an asset is being built is
-      # not permitted.
-      def process_provide_directive(path)
-      end
-
-    private
-      def relative?(path)
-        path =~ /^\.($|\.?\/)/
-      end
-
-      def stat(path)
-        context.environment.stat(path)
-      end
-
-      def entries(path)
-        context.environment.entries(path)
-      end
-
-      def each_entry(root, &block)
-        context.environment.each_entry(root, &block)
-      end
-  end
-end