sassc-embedded 1.64.2 → 1.68.1

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/bool.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class Bool < Base
+        def to_native
+          Native::make_boolean(@value.value)
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/color.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class Color < Base
+        def to_native
+          Native::make_color(
+            @value.red,
+            @value.green,
+            @value.blue,
+            @value.alpha
+          )
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/list.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      SEPARATORS = {
+        space: :sass_space,
+        comma: :sass_comma
+      }
+
+      class List < Base
+        def to_native
+          list = @value.to_a
+          sep = SEPARATORS.fetch(@value.separator)
+          native_list = Native::make_list(list.size, sep)
+          list.each_with_index do |item, index|
+            native_item = ValueConversion.to_native(item)
+            Native::list_set_value(native_list, index, native_item)
+          end
+          native_list
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/map.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class Map < Base
+        def to_native
+          hash = @value.to_h
+          native_map = Native::make_map( hash.size )
+          hash.each_with_index do |(key, value), index|
+            key   = ValueConversion.to_native key
+            value = ValueConversion.to_native value
+            Native::map_set_key(   native_map, index, key )
+            Native::map_set_value( native_map, index, value )
+          end
+          return native_map
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/number.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class Number < Base
+        def to_native
+          Native::make_number(@value.value, @value.numerator_units.first)
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion/string.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class String < Base
+        def to_native(opts = {})
+          if opts[:quote] == :none || @value.type == :identifier
+            Native::make_string(@value.to_s)
+          else
+            Native::make_qstring(@value.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script/value_conversion.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module SassC::Script::ValueConversion
+
+  def self.from_native(native_value, options)
+    case value_tag = SassC::Native.value_get_tag(native_value)
+    when :sass_null
+      # no-op
+    when :sass_string
+      value = SassC::Native.string_get_value(native_value)
+      type = SassC::Native.string_get_type(native_value)
+      argument = SassC::Script::Value::String.new(value, type)
+      argument
+    when :sass_boolean
+      value = SassC::Native.boolean_get_value(native_value)
+      argument = SassC::Script::Value::Bool.new(value)
+      argument
+    when :sass_number
+      value = SassC::Native.number_get_value(native_value)
+      unit = SassC::Native.number_get_unit(native_value)
+      argument = SassC::Script::Value::Number.new(value, unit)
+      argument
+    when :sass_color
+      red, green, blue, alpha = SassC::Native.color_get_r(native_value), SassC::Native.color_get_g(native_value), SassC::Native.color_get_b(native_value), SassC::Native.color_get_a(native_value)
+      argument = SassC::Script::Value::Color.new(red:red, green:green, blue:blue, alpha:alpha)
+      argument.options = options
+      argument
+    when :sass_map
+      values = {}
+      length = SassC::Native::map_get_length native_value
+      (0..length-1).each do |index|
+        key = SassC::Native::map_get_key(native_value, index)
+        value = SassC::Native::map_get_value(native_value, index)
+        values[from_native(key, options)] = from_native(value, options)
+      end
+      argument = SassC::Script::Value::Map.new values
+      argument
+    when :sass_list
+      length = SassC::Native::list_get_length(native_value)
+      items = (0...length).map do |index|
+        native_item = SassC::Native::list_get_value(native_value, index)
+        from_native(native_item, options)
+      end
+      SassC::Script::Value::List.new(items, separator: :space)
+    else
+      raise UnsupportedValue.new("Sass argument of type #{value_tag} unsupported")
+    end
+  end
+
+  def self.to_native(value)
+    case value_name = value.class.name.split("::").last
+    when "String"
+      SassC::Script::ValueConversion::String.new(value).to_native
+    when "Color"
+      SassC::Script::ValueConversion::Color.new(value).to_native
+    when "Number"
+      SassC::Script::ValueConversion::Number.new(value).to_native
+    when "Map"
+      SassC::Script::ValueConversion::Map.new(value).to_native
+    when "List"
+      SassC::Script::ValueConversion::List.new(value).to_native
+    when "Bool"
+      SassC::Script::ValueConversion::Bool.new(value).to_native
+    else
+      raise SassC::UnsupportedValue.new("Sass return type #{value_name} unsupported")
+    end
+  end
+
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/script.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+
+    def self.custom_functions(functions: Functions)
+      functions.public_instance_methods
+    end
+
+    def self.formatted_function_name(function_name, functions: Functions)
+      params = functions.instance_method(function_name).parameters
+      params = params.map { |param_type, name| "$#{name}#{': null' if param_type == :opt}" }.join(", ")
+      return "#{function_name}(#{params})"
+    end
+
+  end
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/util/normalized_map.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+# A hash that normalizes its string keys while still allowing you to get back
+# to the original keys that were stored. If several different values normalize
+# to the same value, whichever is stored last wins.
+
+class SassC::Util::NormalizedMap
+
+  # Create a normalized map
+  def initialize(map = nil)
+    @key_strings = {}
+    @map = {}
+    map.each {|key, value| self[key] = value} if map
+  end
+
+  # Specifies how to transform the key.
+  # This can be overridden to create other normalization behaviors.
+  def normalize(key)
+    key.tr("-", "_")
+  end
+
+  # Returns the version of `key` as it was stored before
+  # normalization. If `key` isn't in the map, returns it as it was
+  # passed in.
+  # @return [String]
+  def denormalize(key)
+    @key_strings[normalize(key)] || key
+  end
+
+  # @private
+  def []=(k, v)
+    normalized = normalize(k)
+    @map[normalized] = v
+    @key_strings[normalized] = k
+    v
+  end
+
+  # @private
+  def [](k)
+    @map[normalize(k)]
+  end
+
+  # @private
+  def has_key?(k)
+    @map.has_key?(normalize(k))
+  end
+
+  # @private
+  def delete(k)
+    normalized = normalize(k)
+    @key_strings.delete(normalized)
+    @map.delete(normalized)
+  end
+
+  # @return [Hash] Hash with the keys as they were stored (before normalization).
+  def as_stored
+    SassC::Util.map_keys(@map) {|k| @key_strings[k]}
+  end
+
+  def empty?
+    @map.empty?
+  end
+
+  def values
+    @map.values
+  end
+
+  def keys
+    @map.keys
+  end
+
+  def each
+    @map.each {|k, v| yield(k, v)}
+  end
+
+  def size
+    @map.size
+  end
+
+  def to_hash
+    @map.dup
+  end
+
+  def to_a
+    @map.to_a
+  end
+
+  def map
+    @map.map {|k, v| yield(k, v)}
+  end
+
+  def dup
+    d = super
+    d.send(:instance_variable_set, "@map", @map.dup)
+    d
+  end
+
+  def sort_by
+    @map.sort_by {|k, v| yield k, v}
+  end
+
+  def update(map)
+    map = map.as_stored if map.is_a?(NormalizedMap)
+    map.each {|k, v| self[k] = v}
+  end
+
+  def method_missing(method, *args, &block)
+    @map.send(method, *args, &block)
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    @map.respond_to?(method, include_private)
+  end
+
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/util.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "erb"
+require "set"
+require "enumerator"
+require "stringio"
+require "rbconfig"
+require "uri"
+require "thread"
+require "pathname"
+
+# A module containing various useful functions.
+
+module SassC::Util
+
+  extend self
+
+  # An array of ints representing the Ruby version number.
+  # @api public
+  RUBY_VERSION_COMPONENTS = RUBY_VERSION.split(".").map {|s| s.to_i}
+
+  # The Ruby engine we're running under. Defaults to `"ruby"`
+  # if the top-level constant is undefined.
+  # @api public
+  RUBY_ENGINE = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "ruby"
+
+  # Maps the keys in a hash according to a block.
+  # @example
+  #   map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
+  #     #=> {"foo" => "bar", "baz" => "bang"}
+  # @param hash [Hash] The hash to map
+  # @yield [key] A block in which the keys are transformed
+  # @yieldparam key [Object] The key that should be mapped
+  # @yieldreturn [Object] The new value for the key
+  # @return [Hash] The mapped hash
+  # @see #map_vals
+  # @see #map_hash
+  def map_keys(hash)
+    map_hash(hash) {|k, v| [yield(k), v]}
+  end
+
+  # Restricts the numeric `value` to be within `min` and `max`, inclusive.
+  # If the value is lower than `min`
+  def clamp(value, min, max)
+    return min if value < min
+    return max if value > max
+    return value
+  end
+
+  # Like [Fixnum.round], but leaves rooms for slight floating-point
+  # differences.
+  #
+  # @param value [Numeric]
+  # @return [Numeric]
+  def round(value)
+    # If the number is within epsilon of X.5, round up (or down for negative
+    # numbers).
+    mod = value % 1
+    mod_is_half = (mod - 0.5).abs < SassC::Script::Value::Number.epsilon
+    if value > 0
+      !mod_is_half && mod < 0.5 ? value.floor : value.ceil
+    else
+      mod_is_half || mod < 0.5 ? value.floor : value.ceil
+    end
+  end
+
+  # Return an array of all possible paths through the given arrays.
+  #
+  # @param arrs [Array<Array>]
+  # @return [Array<Arrays>]
+  #
+  # @example
+  #   paths([[1, 2], [3, 4], [5]]) #=>
+  #     # [[1, 3, 5],
+  #     #  [2, 3, 5],
+  #     #  [1, 4, 5],
+  #     #  [2, 4, 5]]
+  def paths(arrs)
+    arrs.inject([[]]) do |paths, arr|
+      arr.map {|e| paths.map {|path| path + [e]}}.flatten(1)
+    end
+  end
+
+  # Returns information about the caller of the previous method.
+  #
+  # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
+  # @return [[String, Integer, (String, nil)]]
+  #   An array containing the filename, line, and method name of the caller.
+  #   The method name may be nil
+  def caller_info(entry = nil)
+    # JRuby evaluates `caller` incorrectly when it's in an actual default argument.
+    entry ||= caller[1]
+    info = entry.scan(/^((?:[A-Za-z]:)?.*?):(-?.*?)(?::.*`(.+)')?$/).first
+    info[1] = info[1].to_i
+    # This is added by Rubinius to designate a block, but we don't care about it.
+    info[2].sub!(/ \{\}\Z/, '') if info[2]
+    info
+  end
+
+  # Throws a NotImplementedError for an abstract method.
+  #
+  # @param obj [Object] `self`
+  # @raise [NotImplementedError]
+  def abstract(obj)
+    raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
+  end
+
+  # Prints a deprecation warning for the caller method.
+  #
+  # @param obj [Object] `self`
+  # @param message [String] A message describing what to do instead.
+  def deprecated(obj, message = nil)
+    obj_class = obj.is_a?(Class) ? "#{obj}." : "#{obj.class}#"
+    full_message = "DEPRECATION WARNING: #{obj_class}#{caller_info[2]} " +
+      "will be removed in a future version of Sass.#{("\n" + message) if message}"
+    SassC::Util.sass_warn full_message
+  end
+
+  # Silences all Sass warnings within a block.
+  #
+  # @yield A block in which no Sass warnings will be printed
+  def silence_sass_warnings
+    old_level, Sass.logger.log_level = Sass.logger.log_level, :error
+    yield
+  ensure
+    SassC.logger.log_level = old_level
+  end
+
+  # The same as `Kernel#warn`, but is silenced by \{#silence\_sass\_warnings}.
+  #
+  # @param msg [String]
+  def sass_warn(msg)
+    Sass.logger.warn("#{msg}\n")
+  end
+
+  ## Cross Rails Version Compatibility
+
+  # Returns the root of the Rails application,
+  # if this is running in a Rails context.
+  # Returns `nil` if no such root is defined.
+  #
+  # @return [String, nil]
+  def rails_root
+    if defined?(::Rails.root)
+      return ::Rails.root.to_s if ::Rails.root
+      raise "ERROR: Rails.root is nil!"
+    end
+    return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
+    nil
+  end
+
+  # Returns the environment of the Rails application,
+  # if this is running in a Rails context.
+  # Returns `nil` if no such environment is defined.
+  #
+  # @return [String, nil]
+  def rails_env
+    return ::Rails.env.to_s if defined?(::Rails.env)
+    return RAILS_ENV.to_s if defined?(RAILS_ENV)
+    nil
+  end
+
+  ## Cross-OS Compatibility
+  #
+  # These methods are cached because some of them are called quite frequently
+  # and even basic checks like String#== are too costly to be called repeatedly.
+
+  # Whether or not this is running on Windows.
+  #
+  # @return [Boolean]
+  def windows?
+    return @windows if defined?(@windows)
+    @windows = (RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i)
+  end
+
+  # Whether or not this is running on IronRuby.
+  #
+  # @return [Boolean]
+  def ironruby?
+    return @ironruby if defined?(@ironruby)
+    @ironruby = RUBY_ENGINE == "ironruby"
+  end
+
+  # Whether or not this is running on Rubinius.
+  #
+  # @return [Boolean]
+  def rbx?
+    return @rbx if defined?(@rbx)
+    @rbx = RUBY_ENGINE == "rbx"
+  end
+
+  # Whether or not this is running on JRuby.
+  #
+  # @return [Boolean]
+  def jruby?
+    return @jruby if defined?(@jruby)
+    @jruby = RUBY_PLATFORM =~ /java/
+  end
+
+  # Returns an array of ints representing the JRuby version number.
+  #
+  # @return [Array<Integer>]
+  def jruby_version
+    @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
+  end
+
+  # Returns `path` relative to `from`.
+  #
+  # This is like `Pathname#relative_path_from` except it accepts both strings
+  # and pathnames, it handles Windows path separators correctly, and it throws
+  # an error rather than crashing if the paths use different encodings
+  # (https://github.com/ruby/ruby/pull/713).
+  #
+  # @param path [String, Pathname]
+  # @param from [String, Pathname]
+  # @return [Pathname?]
+  def relative_path_from(path, from)
+    pathname(path.to_s).relative_path_from(pathname(from.to_s))
+  rescue NoMethodError => e
+    raise e unless e.name == :zero?
+
+    # Work around https://github.com/ruby/ruby/pull/713.
+    path = path.to_s
+    from = from.to_s
+    raise ArgumentError("Incompatible path encodings: #{path.inspect} is #{path.encoding}, " +
+      "#{from.inspect} is #{from.encoding}")
+  end
+
+  singleton_methods.each {|method| module_function method}
+
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SassC
+  VERSION = "2.4.0"
+end

data/vendor/github.com/sass/sassc-ruby/lib/sassc.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SassC
+  # The global load paths for Sass files. This is meant for plugins and
+  # libraries to register the paths to their Sass stylesheets to that they may
+  # be `@imported`. This load path is used by every instance of {Sass::Engine}.
+  # They are lower-precedence than any load paths passed in via the
+  # {file:SASS_REFERENCE.md#load_paths-option `:load_paths` option}.
+  #
+  # If the `SASS_PATH` environment variable is set,
+  # the initial value of `load_paths` will be initialized based on that.
+  # The variable should be a colon-separated list of path names
+  # (semicolon-separated on Windows).
+  #
+  # Note that files on the global load path are never compiled to CSS
+  # themselves, even if they aren't partials. They exist only to be imported.
+  #
+  # @example
+  #   SassC.load_paths << File.dirname(__FILE__ + '/sass')
+  # @return [Array<String, Pathname, Sass::Importers::Base>]
+  def self.load_paths
+    @load_paths ||= if ENV['SASS_PATH']
+                      ENV['SASS_PATH'].split(SassC::Util.windows? ? ';' : ':')
+                    else
+                      []
+                    end
+  end
+end
+
+require_relative "sassc/version"
+# require_relative "sassc/native"
+require_relative "sassc/import_handler"
+require_relative "sassc/importer"
+require_relative "sassc/util"
+require_relative "sassc/util/normalized_map"
+require_relative "sassc/script"
+require_relative "sassc/script/value"
+require_relative "sassc/script/value/bool"
+require_relative "sassc/script/value/number"
+require_relative "sassc/script/value/color"
+require_relative "sassc/script/value/string"
+require_relative "sassc/script/value/list"
+require_relative "sassc/script/value/map"
+require_relative "sassc/script/functions"
+# require_relative "sassc/script/value_conversion"
+# require_relative "sassc/script/value_conversion/base"
+# require_relative "sassc/script/value_conversion/string"
+# require_relative "sassc/script/value_conversion/number"
+# require_relative "sassc/script/value_conversion/color"
+# require_relative "sassc/script/value_conversion/map"
+# require_relative "sassc/script/value_conversion/list"
+# require_relative "sassc/script/value_conversion/bool"
+require_relative "sassc/functions_handler"
+require_relative "sassc/dependency"
+require_relative "sassc/error"
+require_relative "sassc/engine"
+# require_relative "sassc/sass_2_scss"
+
+begin
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  require 'sassc-embedded'
+ensure
+  $VERBOSE = old_verbose
+end