sprokovuln 0.2.0

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

@@ -0,0 +1,258 @@
+require 'sprockets/engines'
+require 'sprockets/file_reader'
+require 'sprockets/legacy_proc_processor'
+require 'sprockets/legacy_tilt_processor'
+require 'sprockets/mime'
+require 'sprockets/processor_utils'
+require 'sprockets/uri_utils'
+require 'sprockets/utils'
+
+module Sprockets
+  # `Processing` is an internal mixin whose public methods are exposed on
+  # the `Environment` and `CachedEnvironment` classes.
+  module Processing
+    include ProcessorUtils, URIUtils, Utils
+
+    def pipelines
+      config[:pipelines]
+    end
+
+    def register_pipeline(name, proc = nil, &block)
+      proc ||= block
+
+      self.config = hash_reassoc(config, :pipelines) do |pipelines|
+        pipelines.merge(name.to_sym => proc)
+      end
+    end
+
+    # Preprocessors are ran before Postprocessors and Engine
+    # processors.
+    def preprocessors
+      config[:preprocessors]
+    end
+    alias_method :processors, :preprocessors
+
+    # Postprocessors are ran after Preprocessors and Engine processors.
+    def postprocessors
+      config[:postprocessors]
+    end
+
+    # Registers a new Preprocessor `klass` for `mime_type`.
+    #
+    #     register_preprocessor 'text/css', Sprockets::DirectiveProcessor
+    #
+    # A block can be passed for to create a shorthand processor.
+    #
+    #     register_preprocessor 'text/css', :my_processor do |context, data|
+    #       data.gsub(...)
+    #     end
+    #
+    def register_preprocessor(*args, &block)
+      register_config_processor(:preprocessors, *args, &block)
+    end
+    alias_method :register_processor, :register_preprocessor
+
+    # Registers a new Postprocessor `klass` for `mime_type`.
+    #
+    #     register_postprocessor 'application/javascript', Sprockets::DirectiveProcessor
+    #
+    # A block can be passed for to create a shorthand processor.
+    #
+    #     register_postprocessor 'application/javascript', :my_processor do |context, data|
+    #       data.gsub(...)
+    #     end
+    #
+    def register_postprocessor(*args, &block)
+      register_config_processor(:postprocessors, *args, &block)
+    end
+
+    # Remove Preprocessor `klass` for `mime_type`.
+    #
+    #     unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
+    #
+    def unregister_preprocessor(*args)
+      unregister_config_processor(:preprocessors, *args)
+    end
+    alias_method :unregister_processor, :unregister_preprocessor
+
+    # Remove Postprocessor `klass` for `mime_type`.
+    #
+    #     unregister_postprocessor 'text/css', Sprockets::DirectiveProcessor
+    #
+    def unregister_postprocessor(*args)
+      unregister_config_processor(:postprocessors, *args)
+    end
+
+    # Bundle Processors are ran on concatenated assets rather than
+    # individual files.
+    def bundle_processors
+      config[:bundle_processors]
+    end
+
+    # Registers a new Bundle Processor `klass` for `mime_type`.
+    #
+    #     register_bundle_processor  'application/javascript', Sprockets::DirectiveProcessor
+    #
+    # A block can be passed for to create a shorthand processor.
+    #
+    #     register_bundle_processor 'application/javascript', :my_processor do |context, data|
+    #       data.gsub(...)
+    #     end
+    #
+    def register_bundle_processor(*args, &block)
+      register_config_processor(:bundle_processors, *args, &block)
+    end
+
+    # Remove Bundle Processor `klass` for `mime_type`.
+    #
+    #     unregister_bundle_processor 'application/javascript', Sprockets::DirectiveProcessor
+    #
+    def unregister_bundle_processor(*args)
+      unregister_config_processor(:bundle_processors, *args)
+    end
+
+    # Public: Register bundle metadata reducer function.
+    #
+    # Examples
+    #
+    #   Sprockets.register_bundle_metadata_reducer 'application/javascript', :jshint_errors, [], :+
+    #
+    #   Sprockets.register_bundle_metadata_reducer 'text/css', :selector_count, 0 { |total, count|
+    #     total + count
+    #   }
+    #
+    # mime_type - String MIME Type. Use '*/*' applies to all types.
+    # key       - Symbol metadata key
+    # initial   - Initial memo to pass to the reduce funciton (default: nil)
+    # block     - Proc accepting the memo accumulator and current value
+    #
+    # Returns nothing.
+    def register_bundle_metadata_reducer(mime_type, key, *args, &block)
+      case args.size
+      when 0
+        reducer = block
+      when 1
+        if block_given?
+          initial = args[0]
+          reducer = block
+        else
+          initial = nil
+          reducer = args[0].to_proc
+        end
+      when 2
+        initial = args[0]
+        reducer = args[1].to_proc
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0..2)"
+      end
+
+      self.config = hash_reassoc(config, :bundle_reducers, mime_type) do |reducers|
+        reducers.merge(key => [initial, reducer])
+      end
+    end
+
+    protected
+      def resolve_processors_cache_key_uri(uri)
+        params = parse_uri_query_params(uri[11..-1])
+        params[:engine_extnames] = params[:engines] ? params[:engines].split(',') : []
+        processors = processors_for(params[:type], params[:file_type], params[:engine_extnames], params[:pipeline])
+        processors_cache_keys(processors)
+      end
+
+      def build_processors_uri(type, file_type, engine_extnames, pipeline)
+        engines = engine_extnames.join(',') if engine_extnames.any?
+        query = encode_uri_query_params(
+          type: type,
+          file_type: file_type,
+          engines: engines,
+          pipeline: pipeline
+        )
+        "processors:#{query}"
+      end
+
+      def processors_for(type, file_type, engine_extnames, pipeline)
+        pipeline ||= :default
+        config[:pipelines][pipeline.to_sym].call(self, type, file_type, engine_extnames)
+      end
+
+      def default_processors_for(type, file_type, engine_extnames)
+        bundled_processors = config[:bundle_processors][type]
+        if bundled_processors.any?
+          bundled_processors
+        else
+          self_processors_for(type, file_type, engine_extnames)
+        end
+      end
+
+      def self_processors_for(type, file_type, engine_extnames)
+        processors = []
+
+        processors.concat config[:postprocessors][type]
+
+        if type != file_type && processor = config[:transformers][file_type][type]
+          processors << processor
+        end
+
+        processors.concat engine_extnames.map { |ext| engines[ext] }
+        processors.concat config[:preprocessors][file_type]
+
+        if processors.any? || mime_type_charset_detecter(type)
+          processors << FileReader
+        end
+
+        processors
+      end
+
+    private
+      def register_config_processor(type, mime_type, klass, proc = nil, &block)
+        proc ||= block
+        processor = wrap_processor(klass, proc)
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.unshift(processor)
+          processors
+        end
+
+        compute_transformers!
+      end
+
+      def unregister_config_processor(type, mime_type, klass)
+        if klass.is_a?(String) || klass.is_a?(Symbol)
+          klass = config[type][mime_type].detect do |cls|
+            cls.respond_to?(:name) && cls.name == "Sprockets::LegacyProcProcessor (#{klass})"
+          end
+        end
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.delete(klass)
+          processors
+        end
+
+        compute_transformers!
+      end
+
+      def deprecate_legacy_processor_interface(interface)
+        msg = "You are using the a deprecated processor interface #{ interface.inspect }.\n" +
+        "Please update your processor interface:\n" +
+        "https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors\n"
+
+        Deprecation.new([caller[3]]).warn msg
+      end
+
+      def wrap_processor(klass, proc)
+        if !proc
+          if klass.respond_to?(:call)
+            klass
+          else
+            deprecate_legacy_processor_interface(klass)
+            LegacyTiltProcessor.new(klass)
+          end
+        elsif proc.respond_to?(:arity) && proc.arity == 2
+          deprecate_legacy_processor_interface(proc)
+          LegacyProcProcessor.new(klass.to_s, proc)
+        else
+          proc
+        end
+      end
+  end
+end

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

@@ -0,0 +1,180 @@
+require 'set'
+
+module Sprockets
+  # Functional utilities for dealing with Processor functions.
+  #
+  # A Processor is a general function that my modify or transform an asset as
+  # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
+  # or Concatenation are all implemented as seperate Processor steps.
+  #
+  # Processors maybe any object that responds to call. So procs or a class that
+  # defines a self.call method.
+  #
+  # For ergonomics, processors may return a number of shorthand values.
+  # Unfortunately, this means that processors can not compose via ordinary
+  # function composition. The composition helpers here can help.
+  module ProcessorUtils
+    extend self
+
+    # Public: Compose processors in right to left order.
+    #
+    # processors - Array of processors callables
+    #
+    # Returns a composed Proc.
+    def compose_processors(*processors)
+      context = self
+
+      if processors.length == 1
+        obj = method(:call_processor).to_proc.curry[processors.first]
+      else
+        obj = method(:call_processors).to_proc.curry[processors]
+      end
+
+      metaclass = (class << obj; self; end)
+      metaclass.send(:define_method, :cache_key) do
+        context.processors_cache_keys(processors)
+      end
+
+      obj
+    end
+
+    # Public: Invoke list of processors in right to left order.
+    #
+    # The right to left order processing mirrors standard function composition.
+    # Think about:
+    #
+    #   bundle.call(uglify.call(coffee.call(input)))
+    #
+    # processors - Array of processor callables
+    # input - Hash of input data to pass to each processor
+    #
+    # Returns a Hash with :data and other processor metadata key/values.
+    def call_processors(processors, input)
+      data = input[:data] || ""
+      metadata = (input[:metadata] || {}).dup
+
+      processors.reverse_each do |processor|
+        result = call_processor(processor, input.merge(data: data, metadata: metadata))
+        data = result.delete(:data)
+        metadata.merge!(result)
+      end
+
+      metadata.merge(data: data)
+    end
+
+    # Public: Invoke processor.
+    #
+    # processor - Processor callables
+    # input - Hash of input data to pass to processor
+    #
+    # Returns a Hash with :data and other processor metadata key/values.
+    def call_processor(processor, input)
+      metadata = (input[:metadata] || {}).dup
+      metadata[:data] = input[:data]
+
+      case result = processor.call({data: "", metadata: {}}.merge(input))
+      when NilClass
+        metadata
+      when Hash
+        metadata.merge(result)
+      when String
+        metadata.merge(data: result)
+      else
+        raise TypeError, "invalid processor return type: #{result.class}"
+      end
+    end
+
+    # Internal: Get processor defined cached key.
+    #
+    # processor - Processor function
+    #
+    # Returns JSON serializable key or nil.
+    def processor_cache_key(processor)
+      processor.cache_key if processor.respond_to?(:cache_key)
+    end
+
+    # Internal: Get combined cache keys for set of processors.
+    #
+    # processors - Array of processor functions
+    #
+    # Returns Array of JSON serializable keys.
+    def processors_cache_keys(processors)
+      processors.map { |processor| processor_cache_key(processor) }
+    end
+
+    # Internal: Set of all "simple" value types allowed to be returned in
+    # processor metadata.
+    VALID_METADATA_VALUE_TYPES = Set.new([
+      String,
+      Symbol,
+      TrueClass,
+      FalseClass,
+      NilClass
+    ] + (0.class == Integer ? [Integer] : [Bignum, Fixnum])).freeze
+
+    # Internal: Set of all nested compound metadata types that can nest values.
+    VALID_METADATA_COMPOUND_TYPES = Set.new([
+      Array,
+      Hash,
+      Set
+    ]).freeze
+
+    # Internal: Hash of all "simple" value types allowed to be returned in
+    # processor metadata.
+    VALID_METADATA_VALUE_TYPES_HASH = VALID_METADATA_VALUE_TYPES.each_with_object({}) do |type, hash|
+      hash[type] = true
+    end.freeze
+
+    # Internal: Hash of all nested compound metadata types that can nest values.
+    VALID_METADATA_COMPOUND_TYPES_HASH = VALID_METADATA_COMPOUND_TYPES.each_with_object({}) do |type, hash|
+      hash[type] = true
+    end.freeze
+
+    # Internal: Set of all allowed metadata types.
+    VALID_METADATA_TYPES = (VALID_METADATA_VALUE_TYPES + VALID_METADATA_COMPOUND_TYPES).freeze
+
+    # Internal: Validate returned result of calling a processor pipeline and
+    # raise a friendly user error message.
+    #
+    # result - Metadata Hash returned from call_processors
+    #
+    # Returns result or raises a TypeError.
+    def validate_processor_result!(result)
+      if !result.instance_of?(Hash)
+        raise TypeError, "processor metadata result was expected to be a Hash, but was #{result.class}"
+      end
+
+      if !result[:data].instance_of?(String)
+        raise TypeError, "processor :data was expected to be a String, but as #{result[:data].class}"
+      end
+
+      result.each do |key, value|
+        if !key.instance_of?(Symbol)
+          raise TypeError, "processor metadata[#{key.inspect}] expected to be a Symbol"
+        end
+
+        if !valid_processor_metadata_value?(value)
+          raise TypeError, "processor metadata[:#{key}] returned a complex type: #{value.inspect}\n" +
+            "Only #{VALID_METADATA_TYPES.to_a.join(", ")} maybe used."
+        end
+      end
+
+      result
+    end
+
+    # Internal: Validate object is in validate metadata whitelist.
+    #
+    # value - Any Object
+    #
+    # Returns true if class is in whitelist otherwise false.
+    def valid_processor_metadata_value?(value)
+      if VALID_METADATA_VALUE_TYPES_HASH[value.class]
+        true
+      elsif VALID_METADATA_COMPOUND_TYPES_HASH[value.class]
+        value.all? { |v| valid_processor_metadata_value?(v) }
+      else
+        false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+require 'set'
+require 'sprockets/http_utils'
+require 'sprockets/path_dependency_utils'
+require 'sprockets/uri_utils'
+
+module Sprockets
+  module Resolve
+    include HTTPUtils, PathDependencyUtils, URIUtils
+
+    # Public: Find Asset URI for given a logical path by searching the
+    # environment's load paths.
+    #
+    #     resolve("application.js")
+    #     # => "file:///path/to/app/javascripts/application.js?type=application/javascript"
+    #
+    # An accept content type can be given if the logical path doesn't have a
+    # format extension.
+    #
+    #     resolve("application", accept: "application/javascript")
+    #     # => "file:///path/to/app/javascripts/application.coffee?type=application/javascript"
+    #
+    # The String Asset URI is returned or nil if no results are found.
+    def resolve(path, options = {})
+      path = path.to_s
+      paths = options[:load_paths] || config[:paths]
+      accept = options[:accept]
+
+      if valid_asset_uri?(path)
+        uri, deps = resolve_asset_uri(path)
+      elsif absolute_path?(path)
+        filename, type, deps = resolve_absolute_path(paths, path, accept)
+      elsif relative_path?(path)
+        filename, type, pipeline, deps = resolve_relative_path(paths, path, options[:base_path], accept)
+      else
+        filename, type, pipeline, deps = resolve_logical_path(paths, path, accept)
+      end
+
+      if filename
+        params = {}
+        params[:type] = type if type
+        params[:pipeline] = pipeline if pipeline
+        params[:pipeline] = options[:pipeline] if options[:pipeline]
+        uri = build_asset_uri(filename, params)
+      end
+
+      return uri, deps
+    end
+
+    # Public: Same as resolve() but raises a FileNotFound exception instead of
+    # nil if no assets are found.
+    def resolve!(path, options = {})
+      uri, deps = resolve(path, options.merge(compat: false))
+
+      unless uri
+        message = "couldn't find file '#{path}'"
+
+        if relative_path?(path) && options[:base_path]
+          load_path, _ = paths_split(config[:paths], options[:base_path])
+          message << " under '#{load_path}'"
+        end
+
+        message << " with type '#{options[:accept]}'" if options[:accept]
+        message << "\nChecked in these paths: \n  #{ config[:paths].join("\n  ") }"
+
+        raise FileNotFound, message
+      end
+
+      return uri, deps
+    end
+
+    protected
+      def resolve_asset_uri(uri)
+        filename, _ = parse_asset_uri(uri)
+        return uri, Set.new([build_file_digest_uri(filename)])
+      end
+
+      def resolve_absolute_path(paths, filename, accept)
+        deps = Set.new
+        filename = File.expand_path(filename)
+
+        # Ensure path is under load paths
+        return nil, nil, deps unless paths_split(paths, filename)
+
+        _, mime_type, _, _ = parse_path_extnames(filename)
+        type = resolve_transform_type(mime_type, accept)
+        return nil, nil, deps if accept && !type
+
+        return nil, nil, deps unless file?(filename)
+
+        deps << build_file_digest_uri(filename)
+        return filename, type, deps
+      end
+
+      def resolve_relative_path(paths, path, dirname, accept)
+        filename = File.expand_path(path, dirname)
+        load_path, _ = paths_split(paths, dirname)
+        if load_path && logical_path = split_subpath(load_path, filename)
+          resolve_logical_path([load_path], logical_path, accept)
+        else
+          return nil, nil, Set.new
+        end
+      end
+
+      def resolve_logical_path(paths, logical_path, accept)
+        logical_name, mime_type, _, pipeline = parse_path_extnames(logical_path)
+        parsed_accept = parse_accept_options(mime_type, accept)
+        transformed_accepts = expand_transform_accepts(parsed_accept)
+        filename, mime_type, deps = resolve_under_paths(paths, logical_name, transformed_accepts)
+
+        if filename
+          deps << build_file_digest_uri(filename)
+          type = resolve_transform_type(mime_type, parsed_accept)
+          return filename, type, pipeline, deps
+        else
+          return nil, nil, nil, deps
+        end
+      end
+
+      def resolve_under_paths(paths, logical_name, accepts)
+        all_deps = Set.new
+        return nil, nil, all_deps if accepts.empty?
+
+        logical_basename = File.basename(logical_name)
+        paths.each do |load_path|
+          candidates, deps = path_matches(load_path, logical_name, logical_basename)
+          all_deps.merge(deps)
+          candidate = find_best_q_match(accepts, candidates) do |c, matcher|
+            match_mime_type?(c[1] || "application/octet-stream", matcher)
+          end
+          return candidate + [all_deps] if candidate
+        end
+
+        return nil, nil, all_deps
+      end
+
+      def parse_accept_options(mime_type, types)
+        accepts = []
+        accepts += parse_q_values(types) if types
+
+        if mime_type
+          if accepts.empty? || accepts.any? { |accept, _| match_mime_type?(mime_type, accept) }
+            accepts = [[mime_type, 1.0]]
+          else
+            return []
+          end
+        end
+
+        if accepts.empty?
+          accepts << ['*/*', 1.0]
+        end
+
+        accepts
+      end
+
+      def path_matches(load_path, logical_name, logical_basename)
+        dirname    = File.dirname(File.join(load_path, logical_name))
+        candidates = dirname_matches(dirname, logical_basename)
+        deps       = file_digest_dependency_set(dirname)
+
+        result = resolve_alternates(load_path, logical_name)
+        result[0].each do |fn|
+          candidates << [fn, parse_path_extnames(fn)[1]]
+        end
+        deps.merge(result[1])
+
+        dirname = File.join(load_path, logical_name)
+        if directory? dirname
+          result = dirname_matches(dirname, "index")
+          candidates.concat(result)
+        end
+
+        deps.merge(file_digest_dependency_set(dirname))
+
+        return candidates.select { |fn, _| file?(fn) }, deps
+      end
+
+      def dirname_matches(dirname, basename)
+        candidates = []
+        entries = self.entries(dirname)
+        entries.each do |entry|
+          next unless File.basename(entry).start_with?(basename)
+          name, type, _, _ = parse_path_extnames(entry)
+          if basename == name
+            candidates << [File.join(dirname, entry), type]
+          end
+        end
+        candidates
+      end
+
+      def resolve_alternates(load_path, logical_name)
+        return [], Set.new
+      end
+
+      # Internal: Returns the name, mime type and `Array` of engine extensions.
+      #
+      #     "foo.js.coffee.erb"
+      #     # => ["foo", "application/javascript", [".coffee", ".erb"]]
+      #
+      def parse_path_extnames(path)
+        engines = []
+        extname, value = match_path_extname(path, extname_map)
+
+        if extname
+          path = path.chomp(extname)
+          type, engines, pipeline = value.values_at(:type, :engines, :pipeline)
+        end
+
+        return path, type, engines, pipeline
+      end
+  end
+end

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

@@ -0,0 +1,34 @@
+require 'sass'
+
+module Sprockets
+  class SassProcessor
+    # Internal: Cache wrapper for Sprockets cache adapter.
+    class CacheStore < ::Sass::CacheStores::Base
+      VERSION = '1'
+
+      def initialize(cache, version)
+        @cache, @version = cache, "#{VERSION}/#{version}"
+      end
+
+      def _store(key, version, sha, contents)
+        @cache.set("#{@version}/#{version}/#{key}/#{sha}", contents, true)
+      end
+
+      def _retrieve(key, version, sha)
+        @cache.get("#{@version}/#{version}/#{key}/#{sha}", true)
+      end
+
+      def path_to(key)
+        key
+      end
+    end
+  end
+
+  # Deprecated: Use Sprockets::SassProcessor::CacheStore instead.
+  class SassCacheStore < SassProcessor::CacheStore
+    def initialize(*args)
+      Deprecation.new.warn "SassCacheStore is deprecated please use SassProcessor::CacheStore instead"
+      super
+    end
+  end
+end