sprokovuln 0.2.0

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

@@ -0,0 +1,261 @@
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+module Sprockets
+  # Internal: HTTP transport encoding and charset detecting related functions.
+  # Mixed into Environment.
+  module EncodingUtils
+    extend self
+
+    ## Binary encodings ##
+
+    # Public: Use deflate to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def deflate(str)
+      deflater = Zlib::Deflate.new(
+        Zlib::BEST_COMPRESSION,
+        -Zlib::MAX_WBITS,
+        Zlib::MAX_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      )
+      deflater << str
+      deflater.finish
+    end
+
+    # Internal: Unmarshal optionally deflated data.
+    #
+    # Checks leading marshal header to see if the bytes are uncompressed
+    # otherwise inflate the data an unmarshal.
+    #
+    # str - Marshaled String
+    # window_bits - Integer deflate window size. See ZLib::Inflate.new()
+    #
+    # Returns unmarshaled Object or raises an Exception.
+    def unmarshaled_deflated(str, window_bits = -Zlib::MAX_WBITS)
+      major, minor = str[0], str[1]
+      if major && major.ord == Marshal::MAJOR_VERSION &&
+          minor && minor.ord <= Marshal::MINOR_VERSION
+        marshaled = str
+      else
+        begin
+          marshaled = Zlib::Inflate.new(window_bits).inflate(str)
+        rescue Zlib::DataError
+          marshaled = str
+        end
+      end
+      Marshal.load(marshaled)
+    end
+
+    # Public: Use gzip to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def gzip(str)
+      io = StringIO.new
+      gz = Zlib::GzipWriter.new(io, Zlib::BEST_COMPRESSION)
+      gz.mtime = 1
+      gz << str
+      gz.finish
+      io.string
+    end
+
+    # Public: Use base64 to encode data.
+    #
+    # str - String data
+    #
+    # Returns a encoded String
+    def base64(str)
+      Base64.strict_encode64(str)
+    end
+
+
+    ## Charset encodings ##
+
+    # Internal: Shorthand aliases for detecter functions.
+    CHARSET_DETECT = {}
+
+    # Internal: Mapping unicode encodings to byte order markers.
+    BOM = {
+      Encoding::UTF_32LE => [0xFF, 0xFE, 0x00, 0x00],
+      Encoding::UTF_32BE => [0x00, 0x00, 0xFE, 0xFF],
+      Encoding::UTF_8    => [0xEF, 0xBB, 0xBF],
+      Encoding::UTF_16LE => [0xFF, 0xFE],
+      Encoding::UTF_16BE => [0xFE, 0xFF]
+    }
+
+    # Public: Basic string detecter.
+    #
+    # Attempts to parse any Unicode BOM otherwise falls back to the
+    # environment's external encoding.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:default] = method(:detect)
+
+    # Internal: Use Charlock Holmes to detect encoding.
+    #
+    # To enable this code path, require 'charlock_holmes'
+    #
+    # Returns encoded String.
+    def charlock_detect(str)
+      if defined? CharlockHolmes::EncodingDetector
+        if detected = CharlockHolmes::EncodingDetector.detect(str)
+          str.force_encoding(detected[:encoding]) if detected[:encoding]
+        end
+      end
+
+      str
+    end
+
+    # Public: Detect Unicode string.
+    #
+    # Attempts to parse Unicode BOM and falls back to UTF-8.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect_unicode(str)
+      str = detect_unicode_bom(str)
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:unicode] = method(:detect_unicode)
+
+    # Public: Detect and strip BOM from possible unicode string.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns UTF 8/16/32 encoded String without BOM or the original String if
+    # no BOM was present.
+    def detect_unicode_bom(str)
+      bom_bytes = str.byteslice(0, 4).bytes.to_a
+
+      BOM.each do |encoding, bytes|
+        if bom_bytes[0, bytes.size] == bytes
+          str = str.dup
+          str.force_encoding(Encoding::BINARY)
+          str.slice!(0, bytes.size)
+          str.force_encoding(encoding)
+          return str
+        end
+      end
+
+      return str
+    end
+
+    # Public: Detect and strip @charset from CSS style sheet.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_css(str)
+      str = detect_unicode_bom(str)
+
+      if name = scan_css_charset(str)
+        encoding = Encoding.find(name)
+        str = str.dup
+        str.force_encoding(encoding)
+        len = "@charset \"#{name}\";".encode(encoding).size
+        str.slice!(0, len)
+        str
+      end
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:css] = method(:detect_css)
+
+    # Internal: @charset bytes
+    CHARSET_START = [0x40, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x20, 0x22]
+    CHARSET_SIZE  = CHARSET_START.size
+
+    # Internal: Scan binary CSS string for @charset encoding name.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoding String name or nil.
+    def scan_css_charset(str)
+      buf = []
+      i = 0
+
+      str.each_byte.each do |byte|
+        # Halt on line breaks
+        break if byte == 0x0A || byte == 0x0D
+
+        # Only ascii bytes
+        next unless 0x0 < byte && byte <= 0xFF
+
+        if i < CHARSET_SIZE
+        elsif i == CHARSET_SIZE
+          if buf == CHARSET_START
+            buf = []
+          else
+            break
+          end
+        elsif byte == 0x22
+          return buf.pack('C*')
+        end
+
+        buf << byte
+        i += 1
+      end
+
+      nil
+    end
+
+    # Public: Detect charset from HTML document.
+    #
+    # Attempts to parse any Unicode BOM otherwise attempt Charlock detection
+    # and finally falls back to the environment's external encoding.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_html(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:html] = method(:detect_html)
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'sprockets/legacy_tilt_processor'
+require 'sprockets/utils'
+
+module Sprockets
+  # `Engines` provides a global and `Environment` instance registry.
+  #
+  # An engine is a type of processor that is bound to a filename
+  # extension. `application.js.coffee` indicates that the
+  # `CoffeeScriptProcessor` engine will be ran on the file.
+  #
+  # Extensions can be stacked and will be evaulated from right to
+  # left. `application.js.coffee.erb` will first run `ERBProcessor`
+  # then `CoffeeScriptProcessor`.
+  #
+  # All `Engine`s must follow the `Template` interface. It is
+  # recommended to subclass `Template`.
+  #
+  # Its recommended that you register engine changes on your local
+  # `Environment` instance.
+  #
+  #     environment.register_engine '.foo', FooProcessor
+  #
+  # The global registry is exposed for plugins to register themselves.
+  #
+  #     Sprockets.register_engine '.sass', SassProcessor
+  #
+  module Engines
+    include Utils
+
+    # Returns a `Hash` of `Engine`s registered on the `Environment`.
+    # If an `ext` argument is supplied, the `Engine` associated with
+    # that extension will be returned.
+    #
+    #     environment.engines
+    #     # => {".coffee" => CoffeeScriptProcessor, ".sass" => SassProcessor, ...}
+    #
+    def engines
+      config[:engines]
+    end
+
+    # Internal: Returns a `Hash` of engine extensions to mime types.
+    #
+    # # => { '.coffee' => 'application/javascript' }
+    def engine_mime_types
+      config[:engine_mime_types]
+    end
+
+    # Registers a new Engine `klass` for `ext`. If the `ext` already
+    # has an engine registered, it will be overridden.
+    #
+    #     environment.register_engine '.coffee', CoffeeScriptProcessor
+    #
+    def register_engine(ext, klass, options = {})
+      unless options[:silence_deprecation]
+        msg = <<-MSG
+Sprockets method `register_engine` is deprecated.
+Please register a mime type using `register_mime_type` then
+use `register_compressor` or `register_transformer`.
+https://github.com/rails/sprockets/blob/master/guides/extending_sprockets.md#supporting-all-versions-of-sprockets-in-processors
+        MSG
+
+        Deprecation.new([caller.first]).warn(msg)
+      end
+
+      ext = Sprockets::Utils.normalize_extension(ext)
+
+      self.computed_config = {}
+
+      if klass.respond_to?(:call)
+        processor = klass
+        self.config = hash_reassoc(config, :engines) do |engines|
+          engines.merge(ext => klass)
+        end
+        if options[:mime_type]
+          self.config = hash_reassoc(config, :engine_mime_types) do |mime_types|
+            mime_types.merge(ext.to_s => options[:mime_type])
+          end
+        end
+      else
+        processor = LegacyTiltProcessor.new(klass)
+        self.config = hash_reassoc(config, :engines) do |engines|
+          engines.merge(ext => processor)
+        end
+        if klass.respond_to?(:default_mime_type) && klass.default_mime_type
+          self.config = hash_reassoc(config, :engine_mime_types) do |mime_types|
+            mime_types.merge(ext.to_s => klass.default_mime_type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'sprockets/base'
+require 'sprockets/cache/memory_store'
+require 'sprockets/cached_environment'
+
+module Sprockets
+  class Environment < Base
+    # `Environment` should initialized with your application's root
+    # directory. This should be the same as your Rails or Rack root.
+    #
+    #     env = Environment.new(Rails.root)
+    #
+    def initialize(root = ".")
+      initialize_configuration(Sprockets)
+      self.root = root
+      self.cache = Cache::MemoryStore.new
+      yield self if block_given?
+    end
+
+    # Returns a cached version of the environment.
+    #
+    # All its file system calls are cached which makes `cached` much
+    # faster. This behavior is ideal in production since the file
+    # system only changes between deploys.
+    def cached
+      CachedEnvironment.new(self)
+    end
+    alias_method :index, :cached
+
+    def find_asset(*args)
+      cached.find_asset(*args)
+    end
+
+    def find_all_linked_assets(*args, &block)
+      cached.find_all_linked_assets(*args, &block)
+    end
+
+    def load(*args)
+      cached.load(*args)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'erb'
+
+module Sprockets
+  class ERBProcessor
+    # Public: Return singleton instance with default options.
+    #
+    # Returns ERBProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def initialize(&block)
+      @block = block
+    end
+
+    def call(input)
+      engine = ::ERB.new(input[:data], nil, '<>')
+      context = input[:environment].context_class.new(input)
+      klass = (class << context; self; end)
+      klass.class_eval(&@block) if @block
+      engine.def_method(klass, :_evaluate_template, input[:filename])
+      data = context._evaluate_template
+      context.metadata.merge(data: data)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'sprockets/erb_processor'
+
+module Sprockets
+  # Deprecated
+  class ERBTemplate < ERBProcessor
+    def call(*args)
+      Deprecation.new.warn "ERBTemplate is deprecated please use ERBProcessor instead"
+      super
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# Define some basic Sprockets error classes
+module Sprockets
+  class Error           < StandardError; end
+  class ArgumentError           < Error; end
+  class ContentTypeMismatch     < Error; end
+  class NotImplementedError     < Error; end
+  class NotFound                < Error; end
+  class ConversionError         < NotFound; end
+  class FileNotFound            < NotFound; end
+  class FileOutsidePaths        < NotFound; end
+end

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

@@ -0,0 +1,15 @@
+require 'set'
+
+module Sprockets
+  # Internal: The first processor in the pipeline that reads the file into
+  # memory and passes it along as `input[:data]`.  
+  class FileReader
+    def self.call(input)
+      env = input[:environment]
+      data = env.read_file(input[:filename], input[:content_type])
+      dependencies = Set.new(input[:metadata][:dependencies])
+      dependencies += [env.build_file_digest_uri(input[:filename])]
+      { data: data, dependencies: dependencies }
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+module Sprockets
+  # Internal: HTTP URI utilities. Many adapted from Rack::Utils. Mixed into
+  # Environment.
+  module HTTPUtils
+    extend self
+
+    # Public: Test mime type against mime range.
+    #
+    #    match_mime_type?('text/html', 'text/*') => true
+    #    match_mime_type?('text/plain', '*') => true
+    #    match_mime_type?('text/html', 'application/json') => false
+    #
+    # Returns true if the given value is a mime match for the given mime match
+    # specification, false otherwise.
+    def match_mime_type?(value, matcher)
+      v1, v2 = value.split('/', 2)
+      m1, m2 = matcher.split('/', 2)
+      (m1 == '*' || v1 == m1) && (m2.nil? || m2 == '*' || m2 == v2)
+    end
+
+    # Public: Return values from Hash where the key matches the mime type.
+    #
+    # hash      - Hash of String matcher keys to Object values
+    # mime_type - String mime type
+    #
+    # Returns Array of Object values.
+    def match_mime_type_keys(hash, mime_type)
+      type, subtype = mime_type.split('/', 2)
+      [
+        hash["*"],
+        hash["*/*"],
+        hash["#{type}/*"],
+        hash["#{type}/#{subtype}"]
+      ].compact
+    end
+
+    # Internal: Parse Accept header quality values.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns an Array of [String, Float].
+    def parse_q_values(values)
+      values.to_s.split(/\s*,\s*/).map do |part|
+        value, parameters = part.split(/\s*;\s*/, 2)
+        quality = 1.0
+        if md = /\Aq=([\d.]+)/.match(parameters)
+          quality = md[1].to_f
+        end
+        [value, quality]
+      end
+    end
+
+    # Internal: Find all qvalue matches from an Array of available options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns Array of matched Strings from available Array or [].
+    def find_q_matches(q_values, available, &matcher)
+      matcher ||= lambda { |a, b| a == b }
+
+      matches = []
+
+      case q_values
+      when Array
+      when String
+        q_values = parse_q_values(q_values)
+      when NilClass
+        q_values = []
+      else
+        raise TypeError, "unknown q_values type: #{q_values.class}"
+      end
+
+      q_values.each do |accepted, quality|
+        if match = available.find { |option| matcher.call(option, accepted) }
+          matches << [match, quality]
+        end
+      end
+
+      matches.sort_by! { |match, quality| -quality }
+      matches.map! { |match, quality| match }
+      matches
+    end
+
+    # Internal: Find the best qvalue match from an Array of available options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns the matched String from available Array or nil.
+    def find_best_q_match(q_values, available, &matcher)
+      find_q_matches(q_values, available, &matcher).first
+    end
+
+    # Internal: Find the all qvalue match from an Array of available mime type
+    # options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns Array of matched mime type Strings from available Array or [].
+    def find_mime_type_matches(q_value_header, available)
+      find_q_matches(q_value_header, available) do |a, b|
+        match_mime_type?(a, b)
+      end
+    end
+
+    # Internal: Find the best qvalue match from an Array of available mime type
+    # options.
+    #
+    # Adapted from Rack::Utils#q_values.
+    #
+    # Returns the matched mime type String from available Array or nil.
+    def find_best_mime_type_match(q_value_header, available)
+      find_best_q_match(q_value_header, available) do |a, b|
+        match_mime_type?(a, b)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Sprockets
+  # Public: .jst engine.
+  #
+  # Exports server side compiled templates to an object.
+  #
+  # Name your template "users/show.jst.ejs", "users/new.jst.eco", etc.
+  #
+  # To accept the default options
+  #
+  #     environment.register_engine '.jst',
+  #       JstProcessor,
+  #       mime_type: 'application/javascript'
+  #
+  # Change the default namespace.
+  #
+  #     environment.register_engine '.jst',
+  #       JstProcessor.new(namespace: 'App.templates'),
+  #       mime_type: 'application/javascript'
+  #
+  class JstProcessor
+    def self.default_namespace
+      'this.JST'
+    end
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns JstProcessor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def initialize(options = {})
+      @namespace = options[:namespace] || self.class.default_namespace
+    end
+
+    def call(input)
+      data = input[:data].gsub(/$(.)/m, "\\1  ").strip
+      key  = input[:name]
+      <<-JST
+(function() { #{@namespace} || (#{@namespace} = {}); #{@namespace}[#{key.inspect}] = #{data};
+}).call(this);
+      JST
+    end
+  end
+end