giga-lite-hub 0.0.1

data/sprockets-4.2.2/lib/sprockets/processing.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+require 'sprockets/file_reader'
+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
+
+    # Registers a pipeline that will be called by `call_processor` method.
+    def register_pipeline(name, proc = nil, &block)
+      proc ||= block
+
+      self.config = hash_reassoc(config, :pipeline_exts) do |pipeline_exts|
+        pipeline_exts.merge(".#{name}".freeze => name.to_sym)
+      end
+
+      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' do |input|
+    #       input[:data].gsub(...)
+    #     end
+    #
+    def register_preprocessor(*args, &block)
+      register_config_processor(:preprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
+    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' do |input|
+    #       input[:data].gsub(...)
+    #     end
+    #
+    def register_postprocessor(*args, &block)
+      register_config_processor(:postprocessors, *args, &block)
+      compute_transformers!(self.config[:registered_transformers])
+    end
+
+    # Remove Preprocessor `klass` for `mime_type`.
+    #
+    #     unregister_preprocessor 'text/css', Sprockets::DirectiveProcessor
+    #
+    def unregister_preprocessor(*args)
+      unregister_config_processor(:preprocessors, *args)
+      compute_transformers!(self.config[:registered_transformers])
+    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)
+      compute_transformers!(self.config[:registered_transformers])
+    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' do |input|
+    #       input[: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 function (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])
+        processors = processors_for(params[:type], params[:file_type], params[:pipeline])
+        processors_cache_keys(processors)
+      end
+
+      def build_processors_uri(type, file_type, pipeline)
+        query = encode_uri_query_params(
+          type: type,
+          file_type: file_type,
+          pipeline: pipeline
+        )
+        "processors:#{query}"
+      end
+
+      def processors_for(type, file_type, pipeline)
+        pipeline ||= :default
+        if fn = config[:pipelines][pipeline.to_sym]
+          fn.call(self, type, file_type)
+        else
+          raise Error, "no pipeline: #{pipeline}"
+        end
+      end
+
+      def default_processors_for(type, file_type)
+        bundled_processors = config[:bundle_processors][type]
+        if bundled_processors.any?
+          bundled_processors
+        else
+          self_processors_for(type, file_type)
+        end
+      end
+
+      def self_processors_for(type, file_type)
+        processors = []
+
+        processors.concat config[:postprocessors][type]
+        if type != file_type && processor = config[:transformers][file_type][type]
+          processors << processor
+        end
+        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, processor = nil, &block)
+        processor ||= block
+
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.unshift(processor)
+          processors
+        end
+      end
+
+      def unregister_config_processor(type, mime_type, processor)
+        self.config = hash_reassoc(config, type, mime_type) do |processors|
+          processors.delete_if { |p| p == processor || p.class == processor }
+          processors
+        end
+      end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/processor_utils.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+require 'set'
+
+module Sprockets
+  # Functional utilities for dealing with Processor functions.
+  #
+  # A Processor is a general function that may modify or transform an asset as
+  # part of the pipeline. CoffeeScript to JavaScript conversion, Minification
+  # or Concatenation are all implemented as separate 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
+
+    class CompositeProcessor < Struct.new(:processor_strategy, :param, :processors) # :nodoc:
+      SINGULAR = lambda { |param, input| ProcessorUtils.call_processor param, input }
+      PLURAL   = lambda { |param, input| ProcessorUtils.call_processors param, input }
+
+      def self.create(processors)
+        if processors.length == 1
+          new SINGULAR, processors.first, processors
+        else
+          new PLURAL, processors, processors
+        end
+      end
+
+      def call(input)
+        processor_strategy.call param, input
+      end
+
+      def cache_key
+        ProcessorUtils.processors_cache_keys(processors)
+      end
+    end
+
+    # Public: Compose processors in right to left order.
+    #
+    # processors - Array of processors callables
+    #
+    # Returns a composed Proc.
+    def compose_processors(*processors)
+      CompositeProcessor.create processors
+    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,
+      Integer
+    ]).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
+      end
+
+      result
+    end
+  end
+end

data/sprockets-4.2.2/lib/sprockets/resolve.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+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, load_paths: config[:paths], accept: nil, pipeline: nil, base_path: nil)
+      paths = load_paths
+
+      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, path_pipeline, deps, index_alias = resolve_relative_path(paths, path, base_path, accept)
+      else
+        filename, type, path_pipeline, deps, index_alias = resolve_logical_path(paths, path, accept)
+      end
+
+      if filename
+        uri = build_asset_uri(filename, type: type, pipeline: pipeline || path_pipeline, index_alias: index_alias)
+      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, **kargs)
+      uri, deps = resolve(path, **kargs)
+
+      unless uri
+        message = +"couldn't find file '#{path}'"
+
+        if relative_path?(path) && kargs[:base_path]
+          load_path, _ = paths_split(config[:paths], kargs[:base_path])
+          message << " under '#{load_path}'"
+        end
+
+        message << " with type '#{kargs[:accept]}'" if kargs[:accept]
+
+        load_paths = kargs[:load_paths] || config[:paths]
+        message << "\nChecked in these paths: \n  #{ load_paths.join("\n  ") }"
+
+        raise FileNotFound, message
+      end
+
+      return uri, deps
+    end
+
+    protected
+
+      # Internal: Finds an asset given a URI
+      #
+      # uri - String. Contains file:// scheme, absolute path to
+      #       file.
+      #       e.g. "file:///Users/schneems/sprockets/test/fixtures/default/gallery.js?type=application/javascript"
+      #
+      # Returns Array. Contains a String uri and Set of dependencies
+      def resolve_asset_uri(uri)
+        filename, _ = URIUtils.parse_asset_uri(uri)
+        return uri, Set.new( [URIUtils.build_file_digest_uri(filename)] )
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths    - Array of Strings.
+      # filename - String containing absolute path to a file including extension.
+      #            e.g. "/Users/schneems/sprockets/test/fixtures/asset/application.js"
+      # accept   - String. A Quality value incoded set of
+      #            mime types that we are looking for. Can be nil.
+      #            e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      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 PathUtils.paths_split(paths, filename)
+
+        _, mime_type = PathUtils.match_path_extname(filename, config[:mime_exts])
+        type = resolve_transform_type(mime_type, accept)
+        return nil, nil, deps if accept && !type
+
+        return nil, nil, deps unless file?(filename)
+
+        deps << URIUtils.build_file_digest_uri(filename)
+        return filename, type, deps
+      end
+
+      # Internal: Finds a relative file in a set of given paths
+      #
+      # paths   - Array of Strings.
+      # path    - String. A relative filename with or without extension
+      #           e.g. "./jquery" or "../foo.js"
+      # dirname - String. Base path where we start looking for the given file.
+      # accept  - String. A Quality value incoded set of
+      #           mime types that we are looking for. Can be nil.
+      #           e.g. "application/javascript" or "text/css, */*"
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      def resolve_relative_path(paths, path, dirname, accept)
+        filename = File.expand_path(path, dirname)
+        load_path, _ = PathUtils.paths_split(paths, dirname)
+        if load_path && logical_path = PathUtils.split_subpath(load_path, filename)
+          resolve_logical_path([load_path], logical_path, accept)
+        else
+          return nil, nil, nil, Set.new
+        end
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_path - String. A filename with extension
+      #                e.g. "coffee/foo.js" or "foo.js"
+      # accept       - String. A Quality value incoded set of
+      #                mime types that we are looking for. Can be nil.
+      #                e.g. "application/javascript" or "text/css, */*"
+      #
+      # Finds a file on the given paths.
+      #
+      # Returns Array. Filename, type, path_pipeline, deps, index_alias
+      def resolve_logical_path(paths, logical_path, accept)
+        extname, mime_type = PathUtils.match_path_extname(logical_path, config[:mime_exts])
+        logical_name = logical_path.chomp(extname)
+
+        extname, pipeline = PathUtils.match_path_extname(logical_name, config[:pipeline_exts])
+        logical_name = logical_name.chomp(extname)
+
+        parsed_accept = parse_accept_options(mime_type, accept)
+        transformed_accepts = expand_transform_accepts(parsed_accept)
+
+        filename, mime_type, deps, index_alias = 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, index_alias
+        else
+          return nil, nil, nil, deps
+        end
+      end
+
+      # Internal: Finds a file in a set of given paths
+      #
+      # paths        - Array of Strings.
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # accepts      - Array of array containing mime/version pairs
+      #                e.g. [["application/javascript", 1.0]]
+      #
+      # Finds a file with the same name as `logical_name` or "index" inside
+      # of the `logical_name` directory that matches a valid mime-type/version from
+      # `accepts`.
+      #
+      # Returns Array. Filename, type, dependencies, and index_alias
+      def resolve_under_paths(paths, logical_name, accepts)
+        deps = Set.new
+        return nil, nil, deps if accepts.empty?
+
+        # TODO: Allow new path resolves to be registered
+        @resolvers ||= [
+          method(:resolve_main_under_path),
+          method(:resolve_alts_under_path),
+          method(:resolve_index_under_path)
+        ]
+        mime_exts = config[:mime_exts]
+
+        paths.each do |load_path|
+          candidates = []
+          @resolvers.each do |fn|
+            result = fn.call(load_path, logical_name, mime_exts)
+            candidates.concat(result[0])
+            deps.merge(result[1])
+          end
+
+          candidate = HTTPUtils.find_best_q_match(accepts, candidates) do |c, matcher|
+            match_mime_type?(c[:type] || "application/octet-stream", matcher)
+          end
+          return candidate[:filename], candidate[:type], deps, candidate[:index_alias] if candidate
+        end
+
+        return nil, nil, deps
+      end
+
+      # Internal: Finds candidate files on a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Finds files that match a given `logical_name` with an acceptable
+      # mime type that is included in `mime_exts` on the `load_path`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_main_under_path(load_path, logical_name, mime_exts)
+        dirname    = File.dirname(File.join(load_path, logical_name))
+        candidates = self.find_matching_path_for_extensions(dirname, File.basename(logical_name), mime_exts)
+        candidates.map! do |c|
+          { filename: c[0], type: c[1] }
+        end
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
+      end
+
+
+      # Internal: Finds candidate index files in a given path
+      #
+      # load_path    - String. An absolute path to a directory
+      # logical_name - String. A filename without extension
+      #                e.g. "application" or "coffee/foo"
+      # mime_exts    - Hash of file extensions and their mime types
+      #                e.g. {".xml.builder"=>"application/xml+builder"}
+      #
+      # Looking in the given `load_path` this method will find all files under the `logical_name` directory
+      # that are named `index` and have a matching mime type in `mime_exts`.
+      #
+      # Returns Array. First element is an Array of hashes or empty, second is a String
+      def resolve_index_under_path(load_path, logical_name, mime_exts)
+        dirname = File.join(load_path, logical_name)
+
+        if self.directory?(dirname)
+          candidates = self.find_matching_path_for_extensions(dirname, "index".freeze, mime_exts)
+        else
+          candidates = []
+        end
+
+        candidates.map! do |c|
+          { filename: c[0],
+            type: c[1],
+            index_alias: compress_from_root(c[0].sub(/\/index(\.[^\/]+)$/, '\1')) }
+        end
+
+        return candidates, [ URIUtils.build_file_digest_uri(dirname) ]
+      end
+
+      def resolve_alts_under_path(load_path, logical_name, mime_exts)
+        filenames, deps = self.resolve_alternates(load_path, logical_name)
+        filenames.map! do |fn|
+          _, mime_type = PathUtils.match_path_extname(fn, mime_exts)
+          { filename: fn, type: mime_type }
+        end
+        return filenames, deps
+      end
+
+      # Internal: Converts mimetype into accept Array
+      #
+      # - mime_type     - String, optional. e.g. "text/html"
+      # - explicit_type - String, optional. e.g. "application/javascript"
+      #
+      # When called with an explicit_type and a mime_type, only a mime_type
+      # that matches the given explicit_type will be accepted.
+      #
+      # Returns Array of Array
+      #
+      #     [["application/javascript", 1.0]]
+      #     [["*/*", 1.0]]
+      #     []
+      def parse_accept_options(mime_type, explicit_type)
+        if mime_type
+          return [[mime_type, 1.0]] if explicit_type.nil?
+          return [[mime_type, 1.0]] if HTTPUtils.parse_q_values(explicit_type).any? { |accept, _| HTTPUtils.match_mime_type?(mime_type, accept) }
+          return []
+        end
+
+        accepts = HTTPUtils.parse_q_values(explicit_type)
+        accepts << ['*/*'.freeze, 1.0] if accepts.empty?
+        return accepts
+      end
+
+      def resolve_alternates(load_path, logical_name)
+        return [], Set.new
+      end
+  end
+end