sassc 2.1.0.pre1-x86-mingw32

data/lib/sassc/script/value.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+# The abstract superclass for SassScript objects.
+# Many of these methods, especially the ones that correspond to SassScript operations,
+# are designed to be overridden by subclasses which may change the semantics somewhat.
+# The operations listed here are just the defaults.
+
+class SassC::Script::Value
+
+  # Returns the pure Ruby value of the value.
+  # The type of this value varies based on the subclass.
+  attr_reader :value
+
+  # The source range in the document on which this node appeared.
+  attr_accessor :source_range
+
+  # Creates a new value.
+  def initialize(value = nil)
+    value.freeze unless value.nil? || value == true || value == false
+    @value = value
+    @options = nil
+  end
+
+  # Sets the options hash for this node,
+  # as well as for all child nodes.
+  # See the official Sass reference for options.
+  attr_writer :options
+
+  # Returns the options hash for this node.
+  # Raises SassC::SyntaxError if the value was created
+  # outside of the parser and \{#to\_s} was called on it
+  def options
+    return @options if @options
+    raise SassC::SyntaxError.new("The #options attribute is not set on this #{self.class}. This error is probably occurring because #to_s was called on this value within a custom Sass function without first setting the #options attribute.")
+  end
+
+  # Returns the hash code of this value. Two objects' hash codes should be
+  # equal if the objects are equal.
+  def hash
+    value.hash
+  end
+
+  # True if this Value is the same as `other`
+  def eql?(other)
+    self == other
+  end
+
+  # Returns a system inspect value for this object
+  def inspect
+    value.inspect
+  end
+
+  # Returns `true` (all Values are truthy)
+  def to_bool
+    true
+  end
+
+  # Compares this object to `other`
+  def ==(other)
+    self.class == other.class && value == other.value
+  end
+
+  # Returns the integer value of this value.
+  # Raises SassC::SyntaxError if this value doesn’t implment integer conversion.
+  def to_i
+    raise SassC::SyntaxError.new("#{inspect} is not an integer.")
+  end
+
+  # @raise [SassC::SyntaxError] if this value isn't an integer
+  def assert_int!; to_i; end
+
+  # Returns the separator for this value. For non-list-like values or the
+  # empty list, this will be `nil`. For lists or maps, it will be `:space` or `:comma`.
+  def separator
+    nil
+  end
+
+  # Whether the value is surrounded by square brackets. For non-list values,
+  # this will be `false`.
+  def bracketed
+    false
+  end
+
+  # Returns the value of this Value as an array.
+  # Single Values are considered the same as single-element arrays.
+  def to_a
+    [self]
+  end
+
+  # Returns the value of this value as a hash. Most values don't have hash
+  # representations, but [Map]s and empty [List]s do.
+  #
+  # @return [Hash<Value, Value>] This value as a hash
+  # @raise [SassC::SyntaxError] if this value doesn't have a hash representation
+  def to_h
+    raise SassC::SyntaxError.new("#{inspect} is not a map.")
+  end
+
+  # Returns the string representation of this value
+  # as it would be output to the CSS document.
+  #
+  # @options opts :quote [String]
+  #   The preferred quote style for quoted strings. If `:none`, strings are
+  #   always emitted unquoted.
+  # @return [String]
+  def to_s(opts = {})
+    SassC::Util.abstract(self)
+  end
+  alias_method :to_sass, :to_s
+
+  # Returns `false` (all Values are truthy)
+  def null?
+    false
+  end
+
+  # Creates a new list containing `contents` but with the same brackets and
+  # separators as this object, when interpreted as a list.
+  #
+  # @param contents [Array<Value>] The contents of the new list.
+  # @param separator [Symbol] The separator of the new list. Defaults to \{#separator}.
+  # @param bracketed [Boolean] Whether the new list is bracketed. Defaults to \{#bracketed}.
+  # @return [Sass::Script::Value::List]
+  def with_contents(contents, separator: self.separator, bracketed: self.bracketed)
+    SassC::Script::Value::List.new(contents, separator: separator, bracketed: bracketed)
+  end
+
+  protected
+
+  # Evaluates the value.
+  #
+  # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+  # @return [Value] This value
+  def _perform(environment)
+    self
+  end
+
+end

data/lib/sassc/script/value_conversion/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module ValueConversion
+      class Base
+        def initialize(value)
+          @value = value
+        end
+      end
+    end
+  end
+end

data/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/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/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/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/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/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/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/lib/sassc/script.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+
+    def self.custom_functions
+      Functions.instance_methods.select do |function|
+        Functions.public_method_defined?(function)
+      end
+    end
+
+    def self.formatted_function_name(function_name)
+      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/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/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