haml 2.0.10 → 2.2.0

data/lib/sass/constant.rb

@@ -1,216 +0,0 @@
-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
-      include Haml::Util
-
-      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
-
-        each_char(value) 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
-
-              # Are we looking at an operator?
-              if symbol && (symbol != :mod || str.empty?)
-                str = reset_str.call
-                beginning_of_token = symbol != :close
-                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, return_after_expr = false)
-        to_return = []
-
-        while (token = value.shift) && token != :close
-          case token
-          when :open
-            to_return << parenthesize(value)
-          when :neg
-            # This is never actually reached, but we'll leave it in just in case.
-            raise Sass::SyntaxError.new("Unterminated unary minus.") if value.first.nil?
-            to_return << [:neg, parenthesize(value, true)]
-          when :const
-            raise Sass::SyntaxError.new("Unterminated constant.") if value.first.nil?
-            raise Sass::SyntaxError.new("Invalid constant.") unless value.first.is_a?(::String)
-
-            to_return << [:const, value.first]
-            value.shift
-          else
-            to_return << token
-          end
-
-          return to_return.first if return_after_expr
-        end
-        return to_return
-      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)
-        case value.length
-        when 0
-          Sass::Constant::Nil.new
-        when 1
-          value = value[0]
-          if value.is_a? Array
-            operationalize(value, constants)
-          elsif value.is_a? Operation
-            value
-          else
-            Literal.parse(value)
-          end
-        when 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
-        when 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/lib/sass/constant/color.rb

@@ -1,101 +0,0 @@
-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/lib/sass/constant/literal.rb

@@ -1,54 +0,0 @@
-# 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'
-require 'sass/constant/nil'
-
-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/lib/sass/constant/nil.rb

@@ -1,9 +0,0 @@
-require 'sass/constant/literal'
-
-module Sass::Constant # :nodoc:
-  class Nil < Literal # :nodoc:
-    def to_s
-      ''
-    end
-  end
-end

data/lib/sass/constant/number.rb

@@ -1,87 +0,0 @@
-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.empty? ? nil : unit
-    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