sprokovuln 0.2.0

data/vendor/ruby/gems/sprockets-3.7.1/lib/rake/sprocketstask.rb

@@ -0,0 +1,152 @@
+require 'rake'
+require 'rake/tasklib'
+
+require 'sprockets'
+require 'logger'
+
+module Rake
+  # Simple Sprockets compilation Rake task macro.
+  #
+  #   Rake::SprocketsTask.new do |t|
+  #     t.environment = Sprockets::Environment.new
+  #     t.output      = "./public/assets"
+  #     t.assets      = %w( application.js application.css )
+  #   end
+  #
+  class SprocketsTask < Rake::TaskLib
+    # Name of the task. Defaults to "assets".
+    #
+    # The name will also be used to suffix the clean and clobber
+    # tasks, "clean_assets" and "clobber_assets".
+    attr_accessor :name
+
+    # `Environment` instance used for finding assets.
+    #
+    # You'll most likely want to reassign `environment` to your own.
+    #
+    #   Rake::SprocketsTask.new do |t|
+    #     t.environment = Foo::Assets
+    #   end
+    #
+    def environment
+      if !@environment.is_a?(Sprockets::Base) && @environment.respond_to?(:call)
+        @environment = @environment.call
+      else
+        @environment
+      end
+    end
+    attr_writer :environment
+
+    # Returns cached cached environment
+    def cached
+      @cached ||= environment.cached if environment
+    end
+    alias_method :index, :cached
+
+    # `Manifest` instance used for already compiled assets.
+    #
+    # Will be created by default if an environment and output
+    # directory are given
+    def manifest
+      if !@manifest.is_a?(Sprockets::Manifest) && @manifest.respond_to?(:call)
+        @manifest = @manifest.call
+      else
+        @manifest
+      end
+    end
+    attr_writer :manifest
+
+    # Directory to write compiled assets too. As well as the manifest file.
+    #
+    #   t.output = "./public/assets"
+    #
+    attr_accessor :output
+
+    # Array of asset logical paths to compile.
+    #
+    #   t.assets = %w( application.js jquery.js application.css )
+    #
+    attr_accessor :assets
+
+    # Number of old assets to keep.
+    attr_accessor :keep
+
+    # Logger to use during rake tasks. Defaults to using stderr.
+    #
+    #   t.logger = Logger.new($stdout)
+    #
+    attr_accessor :logger
+
+    # Returns logger level Integer.
+    def log_level
+      @logger.level
+    end
+
+    # Set logger level with constant or symbol.
+    #
+    #   t.log_level = Logger::INFO
+    #   t.log_level = :debug
+    #
+    def log_level=(level)
+      if level.is_a?(Integer)
+        @logger.level = level
+      else
+        @logger.level = Logger.const_get(level.to_s.upcase)
+      end
+    end
+
+    def initialize(name = :assets)
+      @name         = name
+      @environment  = lambda { Sprockets::Environment.new(Dir.pwd) }
+      @manifest     = lambda { Sprockets::Manifest.new(cached, output) }
+      @logger       = Logger.new($stderr)
+      @logger.level = Logger::INFO
+      @keep         = 2
+
+      yield self if block_given?
+
+      define
+    end
+
+    # Define tasks
+    def define
+      desc name == :assets ? "Compile assets" : "Compile #{name} assets"
+      task name do
+        with_logger do
+          manifest.compile(assets)
+        end
+      end
+
+      desc name == :assets ? "Remove all assets" : "Remove all #{name} assets"
+      task "clobber_#{name}" do
+        with_logger do
+          manifest.clobber
+        end
+      end
+
+      task :clobber => ["clobber_#{name}"]
+
+      desc name == :assets ? "Clean old assets" : "Clean old #{name} assets"
+      task "clean_#{name}" do
+        with_logger do
+          manifest.clean(keep)
+        end
+      end
+
+      task :clean => ["clean_#{name}"]
+    end
+
+    private
+      # Sub out environment logger with our rake task logger that
+      # writes to stderr.
+      def with_logger
+        if env = manifest.environment
+          old_logger = env.logger
+          env.logger = @logger
+        end
+        yield
+      ensure
+        env.logger = old_logger if env
+      end
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/asset.rb

@@ -0,0 +1,200 @@
+require 'fileutils'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  class Asset
+    attr_reader :logical_path
+
+    # Private: Intialize Asset wrapper from attributes Hash.
+    #
+    # Asset wrappers should not be initialized directly, only
+    # Environment#find_asset should vend them.
+    #
+    # attributes - Hash of ivars
+    #
+    # Returns Asset.
+    def initialize(environment, attributes = {})
+      @environment  = environment
+      @attributes   = attributes
+      @content_type = attributes[:content_type]
+      @filename     = attributes[:filename]
+      @id           = attributes[:id]
+      @load_path    = attributes[:load_path]
+      @logical_path = attributes[:logical_path]
+      @metadata     = attributes[:metadata]
+      @mtime        = attributes[:mtime]
+      @name         = attributes[:name]
+      @source       = attributes[:source]
+      @uri          = attributes[:uri]
+    end
+
+    # Internal: Return all internal instance variables as a hash.
+    #
+    # Returns a Hash.
+    def to_hash
+      @attributes
+    end
+
+    # Public: Metadata accumulated from pipeline process.
+    #
+    # The API status of the keys is dependent on the pipeline processors
+    # itself. So some values maybe considered public and others internal.
+    # See the pipeline proccessor documentation itself.
+    #
+    # Returns Hash.
+    attr_reader :metadata
+
+    # Public: Returns String path of asset.
+    attr_reader :filename
+
+    # Internal: Unique asset object ID.
+    #
+    # Returns a String.
+    attr_reader :id
+
+    # Public: Internal URI to lookup asset by.
+    #
+    # NOT a publically accessible URL.
+    #
+    # Returns URI.
+    attr_reader :uri
+
+    # Public: Return logical path with digest spliced in.
+    #
+    #   "foo/bar-37b51d194a7513e45b56f6524f2d51f2.js"
+    #
+    # Returns String.
+    def digest_path
+      logical_path.sub(/\.(\w+)$/) { |ext| "-#{etag}#{ext}" }
+    end
+
+    # Public: Returns String MIME type of asset. Returns nil if type is unknown.
+    attr_reader :content_type
+
+    # Public: Get all externally linked asset filenames from asset.
+    #
+    # All linked assets should be compiled anytime this asset is.
+    #
+    # Returns Set of String asset URIs.
+    def links
+      metadata[:links] || Set.new
+    end
+
+    # Public: Get all internally required assets that were concated into this
+    # asset.
+    #
+    # Returns Array of String asset URIs.
+    def included
+      metadata[:included]
+    end
+
+    # Public: Return `String` of concatenated source.
+    #
+    # Returns String.
+    def source
+      if @source
+        @source
+      else
+        # File is read everytime to avoid memory bloat of large binary files
+        File.binread(filename)
+      end
+    end
+
+    # Public: Alias for #source.
+    #
+    # Returns String.
+    def to_s
+      source
+    end
+
+    # Public: Get charset of source.
+    #
+    # Returns a String charset name or nil if binary.
+    def charset
+      metadata[:charset]
+    end
+
+    # Public: Returns Integer length of source.
+    def length
+      metadata[:length]
+    end
+    alias_method :bytesize, :length
+
+    # Public: Returns String hexdigest of source.
+    def hexdigest
+      DigestUtils.pack_hexdigest(metadata[:digest])
+    end
+
+    # Deprecated: Returns String hexdigest of source.
+    #
+    # In 4.x this will be changed to return a raw Digest byte String.
+    alias_method :digest, :hexdigest
+
+    # Pubic: ETag String of Asset.
+    alias_method :etag, :hexdigest
+
+    # Public: Returns String base64 digest of source.
+    def base64digest
+      DigestUtils.pack_base64digest(metadata[:digest])
+    end
+
+    # Public: A "named information" URL for subresource integrity.
+    def integrity
+      DigestUtils.integrity_uri(metadata[:digest])
+    end
+
+    # Public: Add enumerator to allow `Asset` instances to be used as Rack
+    # compatible body objects.
+    #
+    # block
+    #   part - String body chunk
+    #
+    # Returns nothing.
+    def each
+      yield to_s
+    end
+
+    # Deprecated: Save asset to disk.
+    #
+    # filename - String target
+    #
+    # Returns nothing.
+    def write_to(filename)
+      FileUtils.mkdir_p File.dirname(filename)
+
+      PathUtils.atomic_write(filename) do |f|
+        f.write source
+      end
+
+      # Set mtime correctly
+      File.utime(mtime, mtime, filename)
+
+      nil
+    end
+
+    # Public: Pretty inspect
+    #
+    # Returns String.
+    def inspect
+      "#<#{self.class}:#{object_id.to_s(16)} #{uri.inspect}>"
+    end
+
+    # Public: Implements Object#hash so Assets can be used as a Hash key or
+    # in a Set.
+    #
+    # Returns Integer hash of the id.
+    def hash
+      id.hash
+    end
+
+    # Public: Compare assets.
+    #
+    # Assets are equal if they share the same path and digest.
+    #
+    # Returns true or false.
+    def eql?(other)
+      self.class == other.class && self.id == other.id
+    end
+    alias_method :==, :eql?
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/closure.rb

@@ -0,0 +1,7 @@
+require 'closure-compiler'
+
+module Sprockets
+  module Autoload
+    Closure = ::Closure
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/coffee_script.rb

@@ -0,0 +1,7 @@
+require 'coffee_script'
+
+module Sprockets
+  module Autoload
+    CoffeeScript = ::CoffeeScript
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/eco.rb

@@ -0,0 +1,7 @@
+require 'eco'
+
+module Sprockets
+  module Autoload
+    Eco = ::Eco
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/ejs.rb

@@ -0,0 +1,7 @@
+require 'ejs'
+
+module Sprockets
+  module Autoload
+    EJS = ::EJS
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/sass.rb

@@ -0,0 +1,7 @@
+require 'sass'
+
+module Sprockets
+  module Autoload
+    Sass = ::Sass
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/uglifier.rb

@@ -0,0 +1,7 @@
+require 'uglifier'
+
+module Sprockets
+  module Autoload
+    Uglifier = ::Uglifier
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload/yui.rb

@@ -0,0 +1,7 @@
+require 'yui/compressor'
+
+module Sprockets
+  module Autoload
+    YUI = ::YUI
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/autoload.rb

@@ -0,0 +1,11 @@
+module Sprockets
+  module Autoload
+    autoload :Closure, 'sprockets/autoload/closure'
+    autoload :CoffeeScript, 'sprockets/autoload/coffee_script'
+    autoload :Eco, 'sprockets/autoload/eco'
+    autoload :EJS, 'sprockets/autoload/ejs'
+    autoload :Sass, 'sprockets/autoload/sass'
+    autoload :Uglifier, 'sprockets/autoload/uglifier'
+    autoload :YUI, 'sprockets/autoload/yui'
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/base.rb

@@ -0,0 +1,110 @@
+require 'sprockets/asset'
+require 'sprockets/bower'
+require 'sprockets/cache'
+require 'sprockets/configuration'
+require 'sprockets/digest_utils'
+require 'sprockets/errors'
+require 'sprockets/loader'
+require 'sprockets/path_digest_utils'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/path_utils'
+require 'sprockets/resolve'
+require 'sprockets/server'
+require 'sprockets/loader'
+require 'sprockets/uri_tar'
+
+module Sprockets
+  # `Base` class for `Environment` and `Cached`.
+  class Base
+    include PathUtils, PathDependencyUtils, PathDigestUtils, DigestUtils
+    include Configuration
+    include Server
+    include Resolve, Loader
+    include Bower
+
+    # Get persistent cache store
+    attr_reader :cache
+
+    # Set persistent cache store
+    #
+    # The cache store must implement a pair of getters and
+    # setters. Either `get(key)`/`set(key, value)`,
+    # `[key]`/`[key]=value`, `read(key)`/`write(key, value)`.
+    def cache=(cache)
+      @cache = Cache.new(cache, logger)
+    end
+
+    # Return an `Cached`. Must be implemented by the subclass.
+    def cached
+      raise NotImplementedError
+    end
+    alias_method :index, :cached
+
+    # Internal: Compute digest for path.
+    #
+    # path - String filename or directory path.
+    #
+    # Returns a String digest or nil.
+    def file_digest(path)
+      if stat = self.stat(path)
+        # Caveat: Digests are cached by the path's current mtime. Its possible
+        # for a files contents to have changed and its mtime to have been
+        # negligently reset thus appearing as if the file hasn't changed on
+        # disk. Also, the mtime is only read to the nearest second. It's
+        # also possible the file was updated more than once in a given second.
+        key = UnloadedAsset.new(path, self).file_digest_key(stat.mtime.to_i)
+        cache.fetch(key) do
+          self.stat_digest(path, stat)
+        end
+      end
+    end
+
+    # Find asset by logical path or expanded path.
+    def find_asset(path, options = {})
+      uri, _ = resolve(path, options.merge(compat: false))
+      if uri
+        load(uri)
+      end
+    end
+
+    def find_all_linked_assets(path, options = {})
+      return to_enum(__method__, path, options) unless block_given?
+
+      asset = find_asset(path, options)
+      return unless asset
+
+      yield asset
+      stack = asset.links.to_a
+
+      while uri = stack.shift
+        yield asset = load(uri)
+        stack = asset.links.to_a + stack
+      end
+
+      nil
+    end
+
+    # Preferred `find_asset` shorthand.
+    #
+    #     environment['application.js']
+    #
+    def [](*args)
+      find_asset(*args)
+    end
+
+    # Pretty inspect
+    def inspect
+      "#<#{self.class}:0x#{object_id.to_s(16)} " +
+        "root=#{root.to_s.inspect}, " +
+        "paths=#{paths.inspect}>"
+    end
+
+    def compress_from_root(uri)
+      URITar.new(uri, self).compress
+    end
+
+    def expand_from_root(uri)
+      URITar.new(uri, self).expand
+    end
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/bower.rb

@@ -0,0 +1,58 @@
+require 'json'
+
+module Sprockets
+  module Bower
+    # Internal: All supported bower.json files.
+    #
+    # https://github.com/bower/json/blob/0.4.0/lib/json.js#L7
+    POSSIBLE_BOWER_JSONS = ['bower.json', 'component.json', '.bower.json']
+
+    # Internal: Override resolve_alternates to install bower.json behavior.
+    #
+    # load_path    - String environment path
+    # logical_path - String path relative to base
+    #
+    # Returns candiate filenames.
+    def resolve_alternates(load_path, logical_path)
+      candidates, deps = super
+
+      # bower.json can only be nested one level deep
+      if !logical_path.index('/')
+        dirname = File.join(load_path, logical_path)
+
+        if directory?(dirname)
+          filenames = POSSIBLE_BOWER_JSONS.map { |basename| File.join(dirname, basename) }
+          filename  = filenames.detect { |fn| self.file?(fn) }
+
+          if filename
+            deps << build_file_digest_uri(filename)
+            read_bower_main(dirname, filename) do |path|
+              candidates << path
+            end
+          end
+        end
+      end
+
+      return candidates, deps
+    end
+
+    # Internal: Read bower.json's main directive.
+    #
+    # dirname  - String path to component directory.
+    # filename - String path to bower.json.
+    #
+    # Returns nothing.
+    def read_bower_main(dirname, filename)
+      bower = JSON.parse(File.read(filename), create_additions: false)
+
+      case bower['main']
+      when String
+        yield File.expand_path(bower['main'], dirname)
+      when Array
+        bower['main'].each do |name|
+          yield File.expand_path(name, dirname)
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/gems/sprockets-3.7.1/lib/sprockets/bundle.rb

@@ -0,0 +1,69 @@
+require 'set'
+require 'sprockets/utils'
+
+module Sprockets
+  # Internal: Bundle processor takes a single file asset and prepends all the
+  # `:required` URIs to the contents.
+  #
+  # Uses pipeline metadata:
+  #
+  #   :required - Ordered Set of asset URIs to prepend
+  #   :stubbed  - Set of asset URIs to substract from the required set.
+  #
+  # Also see DirectiveProcessor.
+  class Bundle
+    def self.call(input)
+      env  = input[:environment]
+      type = input[:content_type]
+      dependencies = Set.new(input[:metadata][:dependencies])
+
+      processed_uri, deps = env.resolve(input[:filename], accept: type, pipeline: :self, compat: false)
+      dependencies.merge(deps)
+
+      find_required = proc { |uri| env.load(uri).metadata[:required] }
+      required = Utils.dfs(processed_uri, &find_required)
+      stubbed  = Utils.dfs(env.load(processed_uri).metadata[:stubbed], &find_required)
+      required.subtract(stubbed)
+      assets = required.map { |uri| env.load(uri) }
+
+      (required + stubbed).each do |uri|
+        dependencies.merge(env.load(uri).metadata[:dependencies])
+      end
+
+      reducers = Hash[env.match_mime_type_keys(env.config[:bundle_reducers], type).flat_map(&:to_a)]
+      process_bundle_reducers(assets, reducers).merge(dependencies: dependencies, included: assets.map(&:uri))
+    end
+
+    # Internal: Run bundle reducers on set of Assets producing a reduced
+    # metadata Hash.
+    #
+    # assets - Array of Assets
+    # reducers - Array of [initial, reducer_proc] pairs
+    #
+    # Returns reduced asset metadata Hash.
+    def self.process_bundle_reducers(assets, reducers)
+      initial = {}
+      reducers.each do |k, (v, _)|
+        if v.respond_to?(:call)
+          initial[k] = v.call
+        elsif !v.nil?
+          initial[k] = v
+        end
+      end
+
+      assets.reduce(initial) do |h, asset|
+        reducers.each do |k, (_, block)|
+          value = k == :data ? asset.source : asset.metadata[k]
+          if h.key?(k)
+            if !value.nil?
+              h[k] = block.call(h[k], value)
+            end
+          else
+            h[k] = value
+          end
+        end
+        h
+      end
+    end
+  end
+end