sassc 2.1.0.pre1-x86-linux

data/lib/sassc/script/value/string.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+class SassC::Script::Value::String < SassC::Script::Value
+
+  # The Ruby value of the string.
+  attr_reader :value
+
+  # Whether this is a CSS string or a CSS identifier.
+  # The difference is that strings are written with double-quotes,
+  # while identifiers aren't.
+  #
+  # @return [Symbol] `:string` or `:identifier`
+  attr_reader :type
+
+  # Returns the quoted string representation of `contents`.
+  #
+  # @options opts :quote [String]
+  #   The preferred quote style for quoted strings. If `:none`, strings are
+  #   always emitted unquoted. If `nil`, quoting is determined automatically.
+  # @options opts :sass [String]
+  #   Whether to quote strings for Sass source, as opposed to CSS. Defaults to `false`.
+  def self.quote(contents, opts = {})
+    quote = opts[:quote]
+
+    # Short-circuit if there are no characters that need quoting.
+    unless contents =~ /[\n\\"']|\#\{/
+      quote ||= '"'
+      return "#{quote}#{contents}#{quote}"
+    end
+
+    if quote.nil?
+      if contents.include?('"')
+        if contents.include?("'")
+          quote = '"'
+        else
+          quote = "'"
+        end
+      else
+        quote = '"'
+      end
+    end
+
+    # Replace single backslashes with multiples.
+    contents = contents.gsub("\\", "\\\\\\\\")
+
+    # Escape interpolation.
+    contents = contents.gsub('#{', "\\\#{") if opts[:sass]
+
+    if quote == '"'
+      contents = contents.gsub('"', "\\\"")
+    else
+      contents = contents.gsub("'", "\\'")
+    end
+
+    contents = contents.gsub(/\n(?![a-fA-F0-9\s])/, "\\a").gsub("\n", "\\a ")
+    "#{quote}#{contents}#{quote}"
+  end
+
+  # Creates a new string.
+  #
+  # @param value [String] See \{#value}
+  # @param type [Symbol] See \{#type}
+  # @param deprecated_interp_equivalent [String?]
+  #   If this was created via a potentially-deprecated string interpolation,
+  #   this is the replacement expression that should be suggested to the user.
+  def initialize(value, type = :identifier)
+    super(value)
+    @type = type
+  end
+
+  # @see Value#plus
+  def plus(other)
+    if other.is_a?(SassC::Script::Value::String)
+      other_value = other.value
+    else
+      other_value = other.to_s(:quote => :none)
+    end
+    SassC::Script::Value::String.new(value + other_value, type)
+  end
+
+  # @see Value#to_s
+  def to_s(opts = {})
+    return @value.gsub(/\n\s*/, ' ') if opts[:quote] == :none || @type == :identifier
+    self.class.quote(value, opts)
+  end
+
+  # @see Value#to_sass
+  def to_sass(opts = {})
+    to_s(opts.merge(:sass => true))
+  end
+
+  def inspect
+    String.quote(value)
+  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/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/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