merbjedi-haml 2.1.0

data/lib/sass/script/color.rb

@@ -0,0 +1,97 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  class Color < Literal # :nodoc:
+    class << self; include Haml::Util; end
+
+    HTML4_COLORS = map_vals({
+        'black'   => 0x000000,
+        'silver'  => 0xc0c0c0,
+        'gray'    => 0x808080,
+        'white'   => 0xffffff,
+        'maroon'  => 0x800000,
+        'red'     => 0xff0000,
+        'purple'  => 0x800080,
+        'fuchsia' => 0xff00ff,
+        'green'   => 0x008000,
+        'lime'    => 0x00ff00,
+        'olive'   => 0x808000,
+        'yellow'  => 0xffff00,
+        'navy'    => 0x000080,
+        'blue'    => 0x0000ff,
+        'teal'    => 0x008080,
+        'aqua'    => 0x00ffff
+      }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
+    HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
+
+    def initialize(rgb)
+      rgb = rgb.map {|c| c.to_i}
+      raise Sass::SyntaxError.new("Color values must be between 0 and 255") if rgb.any? {|c| c < 0 || c > 255}
+      super(rgb)
+    end
+
+    def plus(other)
+      if other.is_a? Sass::Script::String
+        Sass::Script::String.new(self.to_s + other.to_s)
+      else
+        piecewise(other, :+)
+      end
+    end
+
+    def minus(other)
+      if other.is_a? Sass::Script::String
+        raise NoMethodError.new(nil, :minus)
+      else
+        piecewise(other, :-)
+      end
+    end
+
+    def times(other)
+      if other.is_a? Sass::Script::String
+        raise NoMethodError.new(nil, :times)
+      else
+        piecewise(other, :*)
+      end
+    end
+
+    def div(other)
+      if other.is_a? Sass::Script::String
+        raise NoMethodError.new(nil, :div)
+      else
+        piecewise(other, :/)
+      end
+    end
+
+    def mod(other)
+      if other.is_a? Sass::Script::String
+        raise NoMethodError.new(nil, :mod)
+      else
+        piecewise(other, :%)
+      end
+    end
+
+    def to_s
+      return HTML4_COLORS_REVERSE[@value] if HTML4_COLORS_REVERSE[@value]
+      red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') }
+      "##{red}#{green}#{blue}"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    def piecewise(other, operation)
+      other_num = other.is_a? Number
+      other_val = other.value
+      if other_num && !other.unitless?
+        raise Sass::SyntaxError.new("Cannot add a number with units (#{other}) to a color (#{self}).") 
+      end
+
+      rgb = []
+      for i in (0...3)
+        res = @value[i].send(operation, other_num ? other_val : other_val[i])
+        rgb[i] = [ [res, 255].min, 0 ].max
+      end
+      Color.new(rgb)
+    end
+  end
+end

data/lib/sass/script/funcall.rb

@@ -0,0 +1,28 @@
+module Sass
+  module Script
+    class Funcall # :nodoc:
+      attr_reader :name, :args
+
+      def initialize(name, args)
+        @name = name
+        @args = args
+      end
+
+      def inspect
+        "#{name}(#{args.map {|a| a.inspect}.join(', ')})"
+      end
+
+      def perform(environment)
+        args = self.args.map {|a| a.perform(environment)}
+        unless Haml::Util.has?(:public_instance_method, Functions, name) && name !~ /^__/
+          return Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})")
+        end
+
+        return Functions.send(name, *args)
+      rescue ArgumentError => e
+        raise e unless e.backtrace.first =~ /:in `(#{name}|perform)'$/
+        raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+      end
+    end
+  end
+end

data/lib/sass/script/functions.rb

@@ -0,0 +1,122 @@
+module Sass::Script
+  # Methods in this module are accessible from the Sass script context.
+  # For example, you can write
+  #
+  #   color = hsl(120, 100%, 50%)
+  #
+  # and it will call Sass::Script::Functions#hsl.
+  #
+  # 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 (currently undocumented) Sass::Script::Literal objects,
+  # Literal objects are also the expected return values.
+  #
+  # 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.
+  #
+  # The following functions are provided:
+  # * +hsl+ - converts an <tt>hsl(hue, saturation, lightness)</tt> triplet into a color.
+  #
+  #   The +hue+ value should be between 0 and 360 inclusive,
+  #   saturation and lightness must be between <tt>0%</tt> to <tt>100%</tt> inclusive.
+  #   The percent sign is optional.
+  # * +percentage+ - converts a unitless number to a css percentage.
+  #
+  #   Example: <tt>percentage(14px / 7px) => 200%</tt>
+  # * +round+ - Rounds a number to the nearest whole number.
+  #
+  #   Example: <tt>round(10.4px) => 10px</tt>
+  # * +ceil+ - Rounds a number up to the nearest whole number.
+  #
+  #   Example: <tt>ceil(10.4px) => 11px</tt>
+  # * +floor+ - Rounds a number down to the nearest whole number.
+  #
+  #   Example: <tt>floor(10.6px) => 10px</tt>
+  # * +abs+ - Returns the absolute value of a number.
+  #
+  #   Example: <tt>abs(-10px) => 10px</tt>
+  module Functions
+    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+    extend self
+
+    # Creates a Sass::Script::Color object from hue, saturation, and lightness.
+    # As per the CSS3 spec (http://www.w3.org/TR/css3-color/#hsl-color),
+    # hue is in degrees,
+    # and saturation and lightness are percentages.
+    def hsl(h, s, l)
+      original_s = s
+      original_l = l
+      # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+      h, s, l = [h, s, l].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 unitless number into a percent and multiplies the number by 100.
+    # E.g. percentage(100px / 50px) => 200%
+    # Some may find this more natural than: 100% * 100px / 50px
+    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.
+    def round(value)
+      numeric_transformation(value) {|n| n.round}
+    end
+
+    # Rounds up to the nearest whole number.
+    def ceil(value)
+      numeric_transformation(value) {|n| n.ceil}
+    end
+
+    # Rounds down to the nearest whole number.
+    def floor(value)
+      numeric_transformation(value) {|n| n.floor}
+    end
+
+    # Returns the absolute value of 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,144 @@
+require 'strscan'
+
+module Sass
+  module Script
+    class Lexer # :nodoc:
+      Token = Struct.new(:type, :value, :line, :offset)
+
+      OPERATORS = {
+        '+' => :plus,
+        '-' => :minus,
+        '*' => :times,
+        '/' => :div,
+        '%' => :mod,
+        '(' => :lparen,
+        ')' => :rparen,
+        ',' => :comma,
+        'and' => :and,
+        'or' => :or,
+        'not' => :not,
+        '==' => :eq,
+        '!=' => :neq,
+        '>=' => :gte,
+        '<=' => :lte,
+        '>' => :gt,
+        '<' => :lt,
+        '}' => :right_bracket,
+      }
+
+      # We'll want to match longer names first
+      # so that > and < don't clobber >= and <=
+      OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
+
+      REGULAR_EXPRESSIONS = {
+        :whitespace => /\s*/,
+        :variable => /!(\w+)/,
+        :ident => /(\\.|[^\s\\+\-*\/%(),=!])+/,
+        :string => /["}]((?:\\.|\#[^{]|[^"\\#])*)(?:"|#\{)/,
+        :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|$)' : ''))})})}
+      }
+
+      def initialize(str, line, offset)
+        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+        @line = line
+        @offset = offset
+        @to_emit = []
+      end
+
+      def token
+        if @tok
+          @tok, tok = nil, @tok
+          return tok
+        end
+
+        return if done?
+
+        value = @to_emit.shift || variable || string || number || color || bool || op || ident
+        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 peek
+        @tok ||= token
+      end
+
+      def done?
+        whitespace
+        @scanner.eos? && @tok.nil? && @to_emit.empty?
+      end
+
+      def rest
+        @scanner.rest
+      end
+
+      private
+
+      def emit(*value)
+        @to_emit.push value
+      end
+
+      def whitespace
+        @scanner.scan(REGULAR_EXPRESSIONS[:whitespace])
+      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
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:string])
+        emit(:right_bracket) if @scanner.matched[0] == ?}
+        emit(:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1")))
+        emit(:begin_interpolation) if @scanner.matched[-2..-1] == '#{'
+        @to_emit.shift
+      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
+        return unless op = @scanner.scan(REGULAR_EXPRESSIONS[:op])
+        [OPERATORS[op]]
+      end
+
+      protected
+
+      def current_position
+        @offset + @scanner.pos + 1
+      end
+      def last_match_position
+        current_position - @scanner.matchedsize
+      end
+    end
+  end
+end

data/lib/sass/script/literal.rb

@@ -0,0 +1,60 @@
+class Sass::Script::Literal # :nodoc:
+  require 'sass/script/string'
+  require 'sass/script/number'
+  require 'sass/script/color'
+  require 'sass/script/bool'
+
+  attr_reader :value
+
+  def initialize(value = nil)
+    @value = value
+  end
+
+  def perform(environment)
+    self
+  end
+
+  def and(other)
+    to_bool ? other : self
+  end
+
+  def or(other)
+    to_bool ? self : other
+  end
+
+  def eq(other)
+    Sass::Script::Bool.new(self.class == other.class && self.value == other.value)
+  end
+
+  def neq(other)
+    Sass::Script::Bool.new(!eq(other).to_bool)
+  end
+
+  def unary_not
+    Sass::Script::Bool.new(!to_bool)
+  end
+
+  def concat(other)
+    Sass::Script::String.new("#{self.to_s} #{other.to_s}")
+  end
+
+  def comma(other)
+    Sass::Script::String.new("#{self.to_s}, #{other.to_s}")
+  end
+
+  def inspect
+    value.inspect
+  end
+
+  def to_bool
+    true
+  end
+
+  def ==(other)
+    eq(other).to_bool
+  end
+
+  def to_i
+    raise Sass::SyntaxError.new("#{self.inspect} is not an integer.")
+  end
+end