drnic-haml 2.3.0

data/lib/sass/script/functions.rb

@@ -0,0 +1,199 @@
+module Sass::Script
+  # Methods in this module are accessible from the SassScript context.
+  # For example, you can write
+  #
+  #     !color = hsl(120, 100%, 50%)
+  #
+  # and it will call {Sass::Script::Functions#hsl}.
+  #
+  # The following functions are provided:
+  #
+  # \{#hsl}
+  # : Converts an `hsl(hue, saturation, lightness)` triplet into a color.
+  #
+  # \{#percentage}
+  # : Converts a unitless number to a percentage.
+  #
+  # \{#round}
+  # : Rounds a number to the nearest whole number.
+  #
+  # \{#ceil}
+  # : Rounds a number up to the nearest whole number.
+  #
+  # \{#floor}
+  # : Rounds a number down to the nearest whole number.
+  #
+  # \{#abs}
+  # : Returns the absolute value of a number.
+  #
+  # You can add your own functions to this module,
+  # but there are a few things to keep in mind.
+  # First of all, the arguments passed are {Sass::Script::Literal} objects.
+  # Literal objects are also expected to be returned.
+  #
+  # Second, making Ruby functions accessible from Sass introduces the temptation
+  # to do things like database access within stylesheets.
+  # This temptation must be resisted.
+  # Keep in mind that Sass stylesheets are only compiled once
+  # at a somewhat indeterminate time
+  # and then left as static CSS files.
+  # Any dynamic CSS should be left in `<style>` tags in the HTML.
+  #
+  # Within one of the functions in this module,
+  # methods of {EvaluationContext} can be used.
+  module Functions
+    # The context in which methods in {Script::Functions} are evaluated.
+    # That means that all instance methods of {EvaluationContext}
+    # are available to use in functions.
+    class EvaluationContext
+      include Sass::Script::Functions
+
+      # The options hash for the {Sass::Engine} that is processing the function call
+      #
+      # @return [Hash<Symbol, Object>]
+      attr_reader :options
+
+      # @param options [Hash<Symbol, Object>] See \{#options}
+      def initialize(options)
+        @options = options
+      end
+    end
+
+    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+
+    # Creates a {Color} object from red, green, and blue values.
+    # @param red
+    #   A number between 0 and 255 inclusive
+    # @param green
+    #   A number between 0 and 255 inclusive
+    # @param blue
+    #   A number between 0 and 255 inclusive
+    def rgb(red, green, blue)
+      [red.value, green.value, blue.value].each do |v|
+        next unless v < 0 || v > 255
+        raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
+      end
+      Color.new([red.value, green.value, blue.value])
+    end
+
+    # Creates a {Color} object from hue, saturation, and lightness
+    # as per the CSS3 spec (http://www.w3.org/TR/css3-color/#hsl-color).
+    #
+    # @param hue [Number] The hue of the color.
+    #   Should be between 0 and 360 degrees, inclusive
+    # @param saturation [Number] The saturation of the color.
+    #   Must be between `0%` and `100%`, inclusive
+    # @param lightness [Number] The lightness of the color.
+    #   Must be between `0%` and `100%`, inclusive
+    # @return [Color] The resulting color
+    # @raise [ArgumentError] if `saturation` or `lightness` are out of bounds
+    def hsl(hue, saturation, lightness)
+      original_s = saturation
+      original_l = lightness
+      # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+      h, s, l = [hue, saturation, lightness].map { |a| a.value }
+      raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") if s < 0 || s > 100
+      raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") if l < 0 || l > 100
+
+      h = (h % 360) / 360.0
+      s /= 100.0
+      l /= 100.0
+
+      m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s
+      m1 = l * 2 - m2
+      Color.new([hue_to_rgb(m1, m2, h + 1.0/3),
+                 hue_to_rgb(m1, m2, h),
+                 hue_to_rgb(m1, m2, h - 1.0/3)].map { |c| (c * 0xff).round })
+    end
+
+    # Converts a decimal number to a percentage.
+    # For example:
+    #
+    #     percentage(100px / 50px) => 200%
+    #
+    # @param value [Number] The decimal number to convert to a percentage
+    # @return [Number] The percentage
+    # @raise [ArgumentError] If `value` isn't a unitless number
+    def percentage(value)
+      unless value.is_a?(Sass::Script::Number) && value.unitless?
+        raise ArgumentError.new("#{value} is not a unitless number")
+      end
+      Sass::Script::Number.new(value.value * 100, ['%'])
+    end
+
+    # Rounds a number to the nearest whole number.
+    # For example:
+    #
+    #     round(10.4px) => 10px
+    #     round(10.6px) => 11px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def round(value)
+      numeric_transformation(value) {|n| n.round}
+    end
+
+    # Rounds a number up to the nearest whole number.
+    # For example:
+    #
+    #     ciel(10.4px) => 11px
+    #     ciel(10.6px) => 11px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def ceil(value)
+      numeric_transformation(value) {|n| n.ceil}
+    end
+
+    # Rounds down to the nearest whole number.
+    # For example:
+    #
+    #     floor(10.4px) => 10px
+    #     floor(10.6px) => 10px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def floor(value)
+      numeric_transformation(value) {|n| n.floor}
+    end
+
+    # Finds the absolute value of a number.
+    # For example:
+    #
+    #     abs(10px) => 10px
+    #     abs(-10px) => 10px
+    #
+    # @param value [Number] The number
+    # @return [Number] The absolute value
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def abs(value)
+      numeric_transformation(value) {|n| n.abs}
+    end
+
+    private
+
+    # This method implements the pattern of transforming a numeric value into
+    # another numeric value with the same units.
+    # It yields a number to a block to perform the operation and return a number
+    def numeric_transformation(value)
+      unless value.is_a?(Sass::Script::Number)
+        calling_function = caller.first.scan(/`([^']+)'/).first.first
+        raise Sass::SyntaxError.new("#{value} is not a number for `#{calling_function}'")
+      end
+      Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
+    end
+
+    def hue_to_rgb(m1, m2, h)
+      h += 1 if h < 0
+      h -= 1 if h > 1
+      return m1 + (m2 - m1) * h * 6 if h * 6 < 1
+      return m2 if h * 2 < 1
+      return m1 + (m2 - m1) * (2.0/3 - h) * 6 if h * 3 < 2
+      return m1
+    end
+  end
+end

data/lib/sass/script/lexer.rb

@@ -0,0 +1,191 @@
+require 'strscan'
+
+module Sass
+  module Script
+    # The lexical analyzer for SassScript.
+    # It takes a raw string and converts it to individual tokens
+    # that are easier to parse.
+    class Lexer
+      # A struct containing information about an individual token.
+      #
+      # `type`: [{Symbol}]
+      # : The type of token.
+      #
+      # `value`: [{Object}]
+      # : The Ruby object corresponding to the value of the token.
+      #
+      # `line`: [{Fixnum}]
+      # : The line of the source file on which the token appears.
+      #
+      # `offset`: [{Fixnum}]
+      # : The number of bytes into the line the SassScript token appeared.
+      Token = Struct.new(:type, :value, :line, :offset)
+
+      # A hash from operator strings to the corresponding token types.
+      OPERATORS = {
+        '+' => :plus,
+        '-' => :minus,
+        '*' => :times,
+        '/' => :div,
+        '%' => :mod,
+        '=' => :single_eq,
+        '(' => :lparen,
+        ')' => :rparen,
+        ',' => :comma,
+        'and' => :and,
+        'or' => :or,
+        'not' => :not,
+        '==' => :eq,
+        '!=' => :neq,
+        '>=' => :gte,
+        '<=' => :lte,
+        '>' => :gt,
+        '<' => :lt,
+        '#{' => :begin_interpolation,
+        '}' => :end_interpolation,
+      }
+
+      # A list of operator strings ordered with longer names first
+      # so that `>` and `<` don't clobber `>=` and `<=`.
+      OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
+
+      # A hash of regular expressions that are used for tokenizing.
+      REGULAR_EXPRESSIONS = {
+        :whitespace => /\s*/,
+        :variable => /!(\w+)/,
+        :ident => /(\\.|\#\{|[^\s\\+\-*\/%(),=!])+/,
+        :string_end => /((?:\\.|\#[^{]|[^"\\#])*)(?:"|(?=#\{))/,
+        :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
+        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})/,
+        :bool => /(true|false)\b/,
+        :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
+      }
+
+      # @param str [String, StringScanner] The source text to lex
+      # @param line [Fixnum] The line on which the SassScript appears.
+      #   Used for error reporting
+      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
+      #   Used for error reporting
+      def initialize(str, line, offset, filename)
+        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+        @line = line
+        @offset = offset
+        @filename = filename
+        @prev = nil
+      end
+
+      # Moves the lexer forward one token.
+      #
+      # @return [Token] The token that was moved past
+      def next
+        @tok ||= read_token
+        @tok, tok = nil, @tok
+        @prev = tok
+        return tok
+      end
+
+      # Returns the next token without moving the lexer forward.
+      #
+      # @return [Token] The next token
+      def peek
+        @tok ||= read_token
+      end
+
+      # @return [Boolean] Whether or not there's more source text to lex.
+      def done?
+        whitespace unless after_interpolation?
+        @scanner.eos? && @tok.nil?
+      end
+
+      private
+
+      def read_token
+        return if done?
+
+        value = token
+        unless value
+          raise SyntaxError.new("Syntax error in '#{@scanner.string}' at character #{current_position}.")
+        end
+        Token.new(value.first, value.last, @line, last_match_position)
+      end
+
+      def whitespace
+        @scanner.scan(REGULAR_EXPRESSIONS[:whitespace])
+      end
+
+      def token
+        return string('') if after_interpolation?
+        variable || string || number || color || bool || op || ident
+      end
+
+      def variable
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:variable])
+        [:const, @scanner[1]]
+      end
+
+      def ident
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:ident])
+        [:ident, s.gsub(/\\(.)/, '\1')]
+      end
+
+      def string(start_char = '"')
+        return unless @scanner.scan(/#{start_char}#{REGULAR_EXPRESSIONS[:string_end]}/)
+        [:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1"))]
+      end
+
+      def begin_interpolation
+        @scanner.scan
+      end
+
+      def number
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:number])
+        value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+        value = -value if @scanner[1]
+        [:number, Script::Number.new(value, Array(@scanner[4]))]
+      end
+
+      def color
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:color])
+        value = if @scanner[4]
+                  color = Color::HTML4_COLORS[@scanner[4].downcase]
+                else
+                  (1..3).map {|i| @scanner[i]}.map {|num| num.ljust(2, num).to_i(16)}
+                end
+        [:color, Script::Color.new(value)]
+      end
+
+      def bool
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:bool])
+        [:bool, Script::Bool.new(s == 'true')]
+      end
+
+      def op
+        prev_chr = @scanner.string[@scanner.pos - 1].chr
+        return unless op = @scanner.scan(REGULAR_EXPRESSIONS[:op])
+        if @prev && op == '-' && prev_chr !~ /\s/ &&
+            [:bool, :ident, :const].include?(@prev.type)
+          warn(<<END)
+DEPRECATION WARNING:
+On line #{@line}, character #{last_match_position}#{" of '#{@filename}'" if @filename}
+- will be allowed as part of variable names in version 2.4.
+Please add whitespace to separate it from the previous token.
+END
+        end
+
+        [OPERATORS[op]]
+      end
+
+      def current_position
+        @offset + @scanner.pos + 1
+      end
+
+      def last_match_position
+        current_position - @scanner.matched_size
+      end
+
+      def after_interpolation?
+        @prev && @prev.type == :end_interpolation
+      end
+    end
+  end
+end

data/lib/sass/script/literal.rb

@@ -0,0 +1,177 @@
+module Sass::Script
+  # 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 Literal < Node
+    require 'sass/script/string'
+    require 'sass/script/number'
+    require 'sass/script/color'
+    require 'sass/script/bool'
+
+    # Returns the Ruby value of the literal.
+    # The type of this value varies based on the subclass.
+    #
+    # @return [Object]
+    attr_reader :value
+
+    # Creates a new literal.
+    #
+    # @param value [Object] The object for \{#value}
+    def initialize(value = nil)
+      @value = value
+    end
+
+    # Evaluates the literal.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Literal] This literal
+    def perform(environment)
+      self
+    end
+
+    # The SassScript `and` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of a logical and:
+    #   `other` if this literal isn't a false {Bool},
+    #   and this literal otherwise
+    def and(other)
+      to_bool ? other : self
+    end
+
+    # The SassScript `or` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of the logical or:
+    #   this literal if it isn't a false {Bool},
+    #   and `other` otherwise
+    def or(other)
+      to_bool ? self : other
+    end
+
+    # The SassScript `==` operation.
+    # **Note that this returns a {Sass::Script::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Bool] True if this literal is the same as the other,
+    #   false otherwise
+    def eq(other)
+      Sass::Script::Bool.new(self.class == other.class && self.value == other.value)
+    end
+
+    # The SassScript `!=` operation.
+    # **Note that this returns a {Sass::Script::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Bool] False if this literal is the same as the other,
+    #   true otherwise
+    def neq(other)
+      Sass::Script::Bool.new(!eq(other).to_bool)
+    end
+
+    # The SassScript `==` operation.
+    # **Note that this returns a {Sass::Script::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Bool] True if this literal is the same as the other,
+    #   false otherwise
+    def unary_not
+      Sass::Script::Bool.new(!to_bool)
+    end
+
+    # The SassScript default operation (e.g. `!a !b`, `"foo" "bar"`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by a space
+    def concat(other)
+      Sass::Script::String.new("#{self.to_s} #{other.to_s}")
+    end
+
+    # The SassScript `,` operation (e.g. `!a, !b`, `"foo", "bar"`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by `", "`
+    def comma(other)
+      Sass::Script::String.new("#{self.to_s}, #{other.to_s}")
+    end
+
+    # The SassScript `+` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   without any separation
+    def plus(other)
+      Sass::Script::String.new(self.to_s + other.to_s)
+    end
+
+    # The SassScript `-` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by `"-"`
+    def minus(other)
+      Sass::Script::String.new("#{self.to_s}-#{other.to_s}")
+    end
+
+    # The SassScript `/` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by `"/"`
+    def div(other)
+      Sass::Script::String.new("#{self.to_s}/#{other.to_s}")
+    end
+
+    # The SassScript unary `-` operation (e.g. `-!a`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing the literal
+    #   preceded by `"-"`
+    def unary_minus
+      Sass::Script::String.new("-#{self.to_s}")
+    end
+
+    # The SassScript unary `/` operation (e.g. `/!a`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing the literal
+    #   preceded by `"/"`
+    def unary_div
+      Sass::Script::String.new("/#{self.to_s}")
+    end
+
+    # @return [String] A readable representation of the literal
+    def inspect
+      value.inspect
+    end
+
+    # @return [Boolean] `true` (the Ruby boolean value)
+    def to_bool
+      true
+    end
+
+    # Compares this object with another.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this literal is equivalent to `other`
+    def ==(other)
+      eq(other).to_bool
+    end
+
+    # @return [Fixnum] The integer value of this literal
+    # @raise [Sass::SyntaxError] if this literal isn't an integer
+    def to_i
+      raise Sass::SyntaxError.new("#{self.inspect} is not an integer.")
+    end
+
+    # @raise [Sass::SyntaxError] if this literal isn't an integer
+    def assert_int!; to_i; end
+  end
+end