sassc 2.1.0.pre1-x64-mingw32

data/lib/sassc/native/sass2scss_api.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    # ADDAPI char* ADDCALL sass2scss (const char* sass, const int options);
+    attach_function :sass2scss, [:string, :int], :string
+
+    # ADDAPI const char* ADDCALL sass2scss_version(void);
+  end
+end

data/lib/sassc/native/sass_input_style.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    SassInputStyle = enum(
+      :sass_context_null,
+      :sass_context_file,
+      :sass_context_data,
+      :sass_context_folder
+    )
+  end
+end
+

data/lib/sassc/native/sass_output_style.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    SassOutputStyle = enum(
+      :sass_style_nested,
+      :sass_style_expanded,
+      :sass_style_compact,
+      :sass_style_compressed
+    )
+  end
+end

data/lib/sassc/native/sass_value.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    class SassValue < FFI::Union; end
+
+    SassTag = enum(
+      :sass_boolean,
+      :sass_number,
+      :sass_color,
+      :sass_string,
+      :sass_list,
+      :sass_map,
+      :sass_null,
+      :sass_error,
+      :sass_warning
+    )
+
+    SassSeparator = enum(
+      :sass_comma,
+      :sass_space
+    )
+
+    class SassUnknown < FFI::Struct
+      layout :tag, SassTag
+    end
+
+    class SassBoolean < FFI::Struct
+      layout :tag, SassTag,
+             :value, :bool
+    end
+
+    class SassNumber < FFI::Struct
+      layout :tag, SassTag,
+             :value, :double,
+             :unit, :string
+    end
+
+    class SassColor < FFI::Struct
+      layout :tag, SassTag,
+             :r, :double,
+             :g, :double,
+             :b, :double,
+             :a, :double
+    end
+
+    class SassString < FFI::Struct
+      layout :tag, SassTag,
+             :value, :string
+    end
+
+    class SassList < FFI::Struct
+      layout :tag, SassTag,
+             :separator, SassSeparator,
+             :length, :size_t,
+             :values, :pointer
+    end
+
+    class SassMapPair < FFI::Struct
+      layout :key, SassValue.ptr,
+             :value, SassValue.ptr
+    end
+
+    class SassMap < FFI::Struct
+      layout :tag, SassTag,
+             :length, :size_t,
+             :pairs, SassMapPair.ptr
+    end
+
+    class SassNull < FFI::Struct
+      layout :tag, SassTag
+    end
+
+    class SassError < FFI::Struct
+      layout :tag, SassTag,
+             :message, :string
+    end
+
+    class SassWarning < FFI::Struct
+      layout :tag, SassTag,
+             :message, :string
+    end
+
+    class SassValue # < FFI::Union
+      layout :unknown, SassUnknown,
+             :boolean, SassBoolean,
+             :number, SassNumber,
+             :color, SassColor,
+             :string, SassString,
+             :list, SassList,
+             :map, SassMap,
+             :null, SassNull,
+             :error, SassError,
+             :warning, SassWarning
+    end
+  end
+end

data/lib/sassc/native/string_list.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module SassC
+  module Native
+    class StringList < FFI::Struct
+      layout :string_list, StringList.ptr,
+             :string, :string
+    end
+  end
+end

data/lib/sassc/sass_2_scss.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SassC
+  class Sass2Scss
+    def self.convert(sass)
+      Native.sass2scss(sass, 0)
+    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/script/functions.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SassC
+  module Script
+    module Functions
+    end
+  end
+end

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/bool.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a boolean (true or false) value.
+
+class SassC::Script::Value::Bool < SassC::Script::Value
+
+  # The true value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  TRUE = new(true)
+
+  # The false value in SassScript.
+  # This is assigned before new is overridden below so that we use the default implementation.
+  FALSE = new(false)
+
+  # We override object creation so that users of the core API
+  # will not need to know that booleans are specific constants.
+  # Tests `value` for truthiness and returns the TRUE or FALSE constant.
+  def self.new(value)
+    value ? TRUE : FALSE
+  end
+
+  # The pure Ruby value of this Boolean
+  attr_reader :value
+  alias_method :to_bool, :value
+
+  # Returns the string "true" or "false" for this value
+  def to_s(opts = {})
+    @value.to_s
+  end
+  alias_method :to_sass, :to_s
+
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# A SassScript object representing a CSS color.
+# This class provides a very bare-bones system for storing a RGB(A) or HSL(A)
+# color and converting it to a CSS color function.
+#
+# If your Sass method accepts a  color you will need to perform any
+# needed color mathematics or transformations yourself.
+
+class SassC::Script::Value::Color < SassC::Script::Value
+
+  attr_reader :red
+  attr_reader :green
+  attr_reader :blue
+  attr_reader :hue
+  attr_reader :saturation
+  attr_reader :lightness
+  attr_reader :alpha
+
+  # Creates a new color with (`red`, `green`, `blue`) or (`hue`, `saturation`, `lightness`
+  # values, plus an optional `alpha` transparency value.
+  def initialize(red:nil, green:nil, blue:nil, hue:nil, saturation:nil, lightness:nil, alpha:1.0)
+    if red && green && blue && alpha
+      @mode = :rgba
+      @red = SassC::Util.clamp(red.to_i, 0, 255)
+      @green = SassC::Util.clamp(green.to_i, 0, 255)
+      @blue = SassC::Util.clamp(blue.to_i, 0, 255)
+      @alpha = SassC::Util.clamp(alpha.to_f, 0.0, 1.0)
+    elsif hue && saturation && lightness && alpha
+      @mode = :hsla
+      @hue = SassC::Util.clamp(hue.to_i, 0, 360)
+      @saturation = SassC::Util.clamp(saturation.to_i, 0, 100)
+      @lightness = SassC::Util.clamp(lightness.to_i, 0, 100)
+      @alpha = SassC::Util.clamp(alpha.to_f, 0.0, 1.0)
+    else
+      raise SassC::UnsupportedValue, "Unable to determine color configuration for "
+    end
+  end
+
+  # Returns a CSS color declaration in the form
+  # `rgb(…)`, `rgba(…)`, `hsl(…)`, or `hsla(…)`.
+  def to_s
+    if rgba? && @alpha == 1.0
+      return "rgb(#{@red}, #{@green}, #{@blue})"
+    elsif rgba?
+      return "rgba(#{@red}, #{@green}, #{@blue}, #{alpha_string})"
+    elsif hsla? && @alpha == 1.0
+      return "hsl(#{@hue}, #{@saturation}%, #{@lightness}%)"
+    else # hsla?
+      return "hsla(#{@hue}, #{@saturation}%, #{@lightness}%, #{alpha_string})"
+    end
+  end
+
+  # True if this color has RGBA values
+  def rgba?
+    @mode == :rgba
+  end
+
+  # True if this color has HSLA values
+  def hlsa?
+    @mode == :hlsa
+  end
+
+  # Returns the alpha value of this color as a string
+  # and rounded to 8 decimal places.
+  def alpha_string
+    alpha.round(8).to_s
+  end
+
+  # Returns the values of this color in an array.
+  # Provided for compatibility between different SassC::Script::Value classes
+  def value
+    return [
+      red, green, blue,
+      hue, saturation, lightness,
+      alpha,
+    ].compact
+  end
+
+  # True if this Color is equal to `other_color`
+  def eql?(other_color)
+    unless other_color.is_a?(self.class)
+      raise ArgumentError, "No implicit conversion of #{other_color.class} to #{self.class}"
+    end
+    self.value == other_color.value
+  end
+  alias_method :==, :eql?
+
+  # Returns a numeric value for comparing two Color objects
+  # This method is used internally by the Hash class and is not the same as `.to_h`
+  def hash
+    value.hash
+  end
+
+end