radiant 0.6.6 → 0.6.7

data/vendor/plugins/haml/lib/sass/constant.rb

@@ -0,0 +1,245 @@
+require 'sass/constant/operation'
+require 'sass/constant/literal'
+
+module Sass
+  module Constant # :nodoc:
+    # The character that begins a constant.
+    CONSTANT_CHAR   = ?!
+
+    # Whitespace characters
+    WHITESPACE = [?\ , ?\t, ?\n, ?\r]
+
+    # The character used to escape values
+    ESCAPE_CHAR = ?\\
+
+    # The character used to open and close strings
+    STRING_CHAR = ?"
+
+    # A mapping of syntactically-significant characters
+    # to parsed symbols
+    SYMBOLS = {
+      ?( => :open,
+      ?) => :close,
+      ?+ => :plus,
+      ?- => :minus,
+      ?* => :times,
+      ?/ => :div,
+      ?% => :mod,
+      CONSTANT_CHAR => :const,
+      STRING_CHAR => :str,
+      ESCAPE_CHAR => :esc
+    }
+
+    # The regular expression used to parse constants
+    MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }.join}]+)\s*((?:\|\|)?=)\s*(.+)/
+
+    # First-order operations
+    FIRST_ORDER = [:times, :div, :mod]
+
+    # Second-order operations
+    SECOND_ORDER = [:plus, :minus]
+
+    class << self
+      def parse(value, constants, line)
+        begin
+          operationalize(parenthesize(tokenize(value)), constants).to_s
+        rescue Sass::SyntaxError => e
+          if e.message == "Constant arithmetic error"
+            e.instance_eval do
+              @message += ": #{value.dump}."
+            end
+          end
+          e.sass_line = line
+          raise e
+        end
+      end
+
+      private
+
+      def tokenize(value)
+        escaped = false
+        is_string = false
+        beginning_of_token = true
+        str = ''
+        to_return = []
+
+        reset_str = Proc.new do
+          to_return << str unless str.empty?
+          ''
+        end
+
+        value.each_byte do |byte|
+          unless escaped
+            if byte == ESCAPE_CHAR
+              escaped = true
+              next
+            end
+
+            last = to_return[-1]
+
+            # Do we need to open or close a string literal?
+            if byte == STRING_CHAR
+              is_string = !is_string
+
+              # Adjacent strings should be concatenated
+              if is_string && last && (!last.is_a?(Symbol) || last == :close)
+                to_return << :concat
+              end
+
+              str = reset_str.call
+              next
+            end
+
+            unless is_string
+
+              # Are we looking at whitespace?
+              if WHITESPACE.include?(byte)
+                str = reset_str.call
+                next
+              end
+
+              symbol = SYMBOLS[byte]
+
+              # Adjacent values without an operator should be concatenated
+              if (symbol.nil? || symbol == :open || symbol == :const) &&
+                  last && (!last.is_a?(Symbol) || last == :close)
+                to_return << :concat
+              end
+
+              # String then open with no whitespace means funcall
+              if symbol == :open && !str.empty?
+                str = reset_str.call
+                to_return << :funcall
+              end
+
+              # Time for a unary minus!
+              if beginning_of_token && symbol == :minus
+                beginning_of_token = true
+                to_return << :neg
+                next
+              end
+
+              # Is this a constant?
+              if beginning_of_token && symbol == :const
+                beginning_of_token = true
+                to_return << :const
+                next
+              end
+
+              # Are we looking at an operator?
+              if symbol && (symbol != :mod || str.empty?)
+                str = reset_str.call
+                beginning_of_token = true
+                to_return << symbol
+                next
+              end
+            end
+          end
+
+          escaped = false
+          beginning_of_token = false
+          str << byte.chr
+        end
+
+        if is_string
+          raise Sass::SyntaxError.new("Unterminated string: #{value.dump}.")
+        end
+        str = reset_str.call
+        to_return
+      end
+
+      def parenthesize(value)
+        parenthesize_helper(0, value, value.length)[0]
+      end
+
+      def parenthesize_helper(i, value, value_len, return_after_expr = false)
+        to_return = []
+        beginning = i
+        token = value[i]
+
+        while i < value_len && token != :close
+          if token == :open
+            to_return.push(*value[beginning...i])
+            sub, i = parenthesize_helper(i + 1, value, value_len)
+            beginning = i
+            to_return << sub
+          elsif token == :neg
+            if value[i + 1].nil?
+              # This is never actually reached, but we'll leave it in just in case.
+              raise Sass::SyntaxError.new("Unterminated unary minus.")
+            elsif value[i + 1] == :open
+              to_return.push(*value[beginning...i])
+              sub, i = parenthesize_helper(i + 2, value, value_len)
+              beginning = i
+              to_return << [:neg, sub]
+            elsif value[i + 1].is_a?(::Symbol)
+              to_return.push(*value[beginning...i])
+              sub, i = parenthesize_helper(i + 1, value, value_len, true)
+              beginning = i
+              to_return << [:neg, sub]
+            else
+              to_return.push(*value[beginning...i])
+              to_return << [:neg, value[i + 1]]
+              beginning = i = i + 2
+            end
+            return to_return[0], i if return_after_expr
+          elsif token == :const
+            raise Sass::SyntaxError.new("Unterminated constant.") if value[i + 1].nil?
+            raise Sass::SyntaxError.new("Invalid constant.") unless value[i + 1].is_a?(::String)
+
+            to_return.push(*value[beginning...i])
+            to_return << [:const, value[i + 1]]
+            beginning = i = i + 2
+            return to_return[0], i if return_after_expr
+          else
+            i += 1
+          end
+
+          token = value[i]
+        end
+        to_return.push(*value[beginning...i])
+        return to_return, i + 1
+      end
+
+      #--
+      # TODO: Don't pass around original value;
+      #       have Constant.parse automatically add it to exception.
+      #++
+      def operationalize(value, constants)
+        value = [value] unless value.is_a?(Array)
+        if value.length == 1
+          value = value[0]
+          if value.is_a? Array
+            operationalize(value, constants)
+          elsif value.is_a? Operation
+            value
+          else
+            Literal.parse(value)
+          end
+        elsif value.length == 2
+          if value[0] == :neg
+            Operation.new(Sass::Constant::Number.new('0'), operationalize(value[1], constants), :minus)
+          elsif value[0] == :const
+            Literal.parse(get_constant(value[1], constants))
+          else
+            raise SyntaxError.new("Constant arithmetic error")
+          end
+        elsif value.length == 3
+          Operation.new(operationalize(value[0], constants), operationalize(value[2], constants), value[1])
+        else
+          if SECOND_ORDER.include?(value[1]) && FIRST_ORDER.include?(value[3])
+            operationalize([value[0], value[1], operationalize(value[2..4], constants), *value[5..-1]], constants)
+          else
+            operationalize([operationalize(value[0..2], constants), *value[3..-1]], constants)
+          end
+        end
+      end
+
+      def get_constant(value, constants)
+        to_return = constants[value]
+        raise SyntaxError.new("Undefined constant: \"!#{value}\".") unless to_return
+        to_return
+      end
+    end
+  end
+end

data/vendor/plugins/haml/lib/sass/constant/color.rb

@@ -0,0 +1,101 @@
+require 'sass/constant/literal'
+
+module Sass::Constant # :nodoc:
+  class Color < Literal # :nodoc:
+
+    HTML4_COLORS = {
+      '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
+    }
+
+    REGEXP = /\##{"([0-9a-fA-F]{1,2})" * 3}/
+
+    def parse(value)
+      if (value =~ REGEXP)
+        @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, num).to_i(16) }
+      else
+        color = HTML4_COLORS[value.downcase]
+        @value = (0..2).map{ |n| color >> (n << 3) & 0xff }.reverse
+      end
+    end
+
+    def plus(other)
+      if other.is_a? Sass::Constant::String
+        Sass::Constant::String.from_value(self.to_s + other.to_s)
+      else
+        piecewise(other, :+)
+      end
+    end
+
+    def minus(other)
+      if other.is_a? Sass::Constant::String
+        raise NoMethodError.new(nil, :minus)
+      else
+        piecewise(other, :-)
+      end
+    end
+
+    def times(other)
+      if other.is_a? Sass::Constant::String
+        raise NoMethodError.new(nil, :times)
+      else
+        piecewise(other, :*)
+      end
+    end
+
+    def div(other)
+      if other.is_a? Sass::Constant::String
+        raise NoMethodError.new(nil, :div)
+      else
+        piecewise(other, :/)
+      end
+    end
+
+    def mod(other)
+      if other.is_a? Sass::Constant::String
+        raise NoMethodError.new(nil, :mod)
+      else
+        piecewise(other, :%)
+      end
+    end
+
+    def to_s
+      red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') }
+      "##{red}#{green}#{blue}"
+    end
+
+    protected
+
+    def self.filter_value(value)
+      value.map { |num| num.to_i }
+    end
+
+    private
+
+    def piecewise(other, operation)
+      other_num = other.is_a? Number
+      other_val = other.value
+
+      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.from_value(rgb)
+    end
+  end
+end

data/vendor/plugins/haml/lib/sass/constant/literal.rb

@@ -0,0 +1,53 @@
+# Let the subclasses see the superclass
+module Sass::Constant; class Literal; end; end; # :nodoc:
+
+require 'sass/constant/string'
+require 'sass/constant/number'
+require 'sass/constant/color'
+
+class Sass::Constant::Literal # :nodoc:
+  # The regular expression matching numbers.
+  NUMBER  = /^(-?\d*?\.?)(\d+)([^\d\s]*)$/
+
+  html_color_matcher = Sass::Constant::Color::HTML4_COLORS.keys.map { |c| "^#{c}$" }.join '|'
+
+  # The regular expression matching colors.
+  COLOR = /^\# (?: [\da-f]{3} | [\da-f]{6} ) | #{html_color_matcher}/ix
+
+  def self.parse(value)
+    case value
+    when NUMBER
+      Sass::Constant::Number.new(value)
+    when COLOR
+      Sass::Constant::Color.new(value)
+    else
+      Sass::Constant::String.new(value)
+    end
+  end
+
+  def initialize(value = nil)
+    self.parse(value) if value
+  end
+
+  def perform
+    self
+  end
+
+  def concat(other)
+    Sass::Constant::String.from_value("#{self.to_s} #{other.to_s}")
+  end
+
+  attr_reader :value
+
+  protected
+
+  def self.filter_value(value)
+    value
+  end
+
+  def self.from_value(value)
+    instance = self.new
+    instance.instance_variable_set('@value', self.filter_value(value))
+    instance
+  end
+end

data/vendor/plugins/haml/lib/sass/constant/number.rb

@@ -0,0 +1,87 @@
+require 'sass/constant/literal'
+
+module Sass::Constant  # :nodoc:
+  class Number < Literal # :nodoc:
+
+    attr_reader :unit
+
+    def parse(value)
+      first, second, unit = value.scan(Literal::NUMBER)[0]
+      @value = first.empty? ? second.to_i : "#{first}#{second}".to_f
+      @unit = unit unless unit.empty?
+    end
+
+    def plus(other)
+      if other.is_a? Number
+        operate(other, :+)
+      elsif other.is_a? Color
+        other.plus(self)
+      else
+        Sass::Constant::String.from_value(self.to_s + other.to_s)
+      end
+    end
+
+    def minus(other)
+      if other.is_a? Number
+        operate(other, :-)
+      else
+        raise NoMethodError.new(nil, :minus)
+      end
+    end
+
+    def times(other)
+      if other.is_a? Number
+        operate(other, :*)
+      elsif other.is_a? Color
+        other.times(self)
+      else
+        raise NoMethodError.new(nil, :times)
+      end
+    end
+
+    def div(other)
+      if other.is_a? Number
+        operate(other, :/)
+      else
+        raise NoMethodError.new(nil, :div)
+      end
+    end
+
+    def mod(other)
+      if other.is_a? Number
+        operate(other, :%)
+      else
+        raise NoMethodError.new(nil, :mod)
+      end
+    end
+
+    def to_s
+      value = @value
+      value = value.to_i if value % 1 == 0.0
+      "#{value}#{@unit}"
+    end
+
+    protected
+
+    def self.from_value(value, unit=nil)
+      instance = super(value)
+      instance.instance_variable_set('@unit', unit)
+      instance
+    end
+
+    def operate(other, operation)
+      unit = nil
+      if other.unit.nil?
+        unit = self.unit
+      elsif self.unit.nil?
+        unit = other.unit
+      elsif other.unit == self.unit
+        unit = self.unit
+      else
+        raise Sass::SyntaxError.new("Incompatible units: #{self.unit} and #{other.unit}.")
+      end
+
+      Number.from_value(self.value.send(operation, other.value), unit)
+    end
+  end
+end