haml 1.0.5 → 1.5.0

data/lib/sass/constant/color.rb

@@ -0,0 +1,77 @@
+require 'sass/constant/literal'
+
+module Sass::Constant # :nodoc:
+  class Color < Literal # :nodoc:
+  
+    REGEXP = /\##{"([0-9a-fA-F]{1,2})" * 3}/
+  
+    def parse(value)
+      @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, 'f').to_i(16) }
+    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

@@ -0,0 +1,51 @@
+# 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  = /^(-?[0-9]*?\.?)([0-9]+)([^0-9\s]*)$/
+
+  # The regular expression matching colors.
+  COLOR = /^\#(#{"[0-9a-fA-F]" * 3}|#{"[0-9a-fA-F]" * 6})/
+  
+  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/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

data/lib/sass/constant/operation.rb

@@ -0,0 +1,30 @@
+require 'sass/constant/string'
+require 'sass/constant/number'
+require 'sass/constant/color'
+
+module Sass::Constant # :nodoc:
+  class Operation # :nodoc:
+    def initialize(operand1, operand2, operator)
+      @operand1 = operand1
+      @operand2 = operand2
+      @operator = operator
+    end
+    
+    def to_s
+      self.perform.to_s
+    end
+    
+    protected
+    
+    def perform
+      literal1 = @operand1.perform
+      literal2 = @operand2.perform
+      begin
+        literal1.send(@operator, literal2)
+      rescue NoMethodError => e
+        raise e unless e.name.to_s == @operator.to_s
+        raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\"")
+      end
+    end
+  end
+end

data/lib/sass/constant/string.rb

@@ -0,0 +1,18 @@
+require 'sass/constant/literal'
+
+module Sass::Constant # :nodoc:
+  class String < Literal # :nodoc:
+    
+    def parse(value)
+      @value = value
+    end
+    
+    def plus(other)
+      Sass::Constant::String.from_value(self.to_s + other.to_s)
+    end
+    
+    def to_s
+      @value
+    end
+  end
+end

data/lib/sass/engine.rb

@@ -0,0 +1,179 @@
+require 'sass/tree/node'
+require 'sass/tree/value_node'
+require 'sass/tree/rule_node'
+require 'sass/constant'
+require 'sass/error'
+
+module Sass
+  # This is the class where all the parsing and processing of the Sass
+  # template is done. It can be directly used by the user by creating a
+  # new instance and calling <tt>render</tt> to render the template. For example:
+  #
+  #   template = File.load('stylesheets/sassy.sass')
+  #   sass_engine = Sass::Engine.new(template)
+  #   output = sass_engine.render
+  #   puts output
+  class Engine
+    # The character that begins a CSS attribute.
+    ATTRIBUTE_CHAR  = ?:
+    
+    # The character that designates that
+    # an attribute should be assigned to the result of constant arithmetic.
+    SCRIPT_CHAR     = ?=
+    
+    # The string that begins one-line comments.
+    COMMENT_STRING  = '//'
+
+    # The regex that matches attributes.
+    ATTRIBUTE = /:([^\s=]+)\s*(=?)\s*(.*)/
+  
+    # Creates a new instace of Sass::Engine that will compile the given
+    # template string when <tt>render</tt> is called.
+    # See README for available options.
+    #
+    #--
+    #
+    # TODO: Add current options to REFRENCE. Remember :filename!
+    #
+    # When adding options, remember to add information about them
+    # to README!
+    #++
+    #
+    def initialize(template, options={})
+      @options = {
+        :style => :nested
+      }.merge! options
+      @template = template.split("\n")
+      @lines = []
+      @constants = {}
+    end
+  
+    # Processes the template and returns the result as a string.
+    def render
+      begin
+        split_lines
+      
+        root = Tree::Node.new(@options[:style])
+        index = 0
+        while @lines[index]
+          child, index = build_tree(index)
+          child.line = index if child
+          root << child if child
+        end
+        @line = nil
+
+        root.to_s
+      rescue SyntaxError => err
+        err.add_backtrace_entry(@options[:filename])
+        raise err
+      end
+    end
+
+    alias_method :to_css, :render
+    
+    private
+    
+    # Readies each line in the template for parsing,
+    # and computes the tabulation of the line.
+    def split_lines
+      old_tabs = 0
+      @template.each_with_index do |line, index|
+        @line = index + 1
+      
+        # TODO: Allow comments appended to the end of lines,
+        # find some way to make url(http://www.google.com/) work
+        unless line[0..1] == COMMENT_STRING # unless line is a comment
+          tabs = count_tabs(line)
+          
+          if tabs # if line isn't blank
+            if tabs - old_tabs > 1
+              raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line) 
+            end
+            @lines << [line.strip, tabs]
+
+            old_tabs = tabs
+          end
+        end
+      end
+      @line = nil
+    end
+    
+    # Counts the tabulation of a line.
+    def count_tabs(line)
+      spaces = line.index(/[^ ]/)
+      if spaces
+        if spaces % 2 == 1 || line[spaces] == ?\t
+          raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line) 
+        end
+        spaces / 2
+      else
+        nil
+      end
+    end
+    
+    def build_tree(index)
+      line, tabs = @lines[index]
+      index += 1
+      @line = index
+      node = parse_line(line)
+
+      # Node is nil if it's non-outputting, like a constant assignment
+      return nil, index unless node
+
+      has_children = has_children?(index, tabs)
+      
+      while has_children
+        child, index = build_tree(index)
+
+        if child.nil?
+          raise SyntaxError.new("Constants may only be declared at the root of a document.", @line)
+        end
+
+        child.line = @line
+        node << child if child
+        has_children = has_children?(index, tabs)
+      end
+      
+      return node, index
+    end
+    
+    def has_children?(index, tabs)
+      next_line = @lines[index]
+      next_line && next_line[1] > tabs
+    end
+    
+    def parse_line(line)
+      case line[0]
+        when ATTRIBUTE_CHAR
+          parse_attribute(line)
+        when Constant::CONSTANT_CHAR
+          parse_constant(line)
+        else
+          Tree::RuleNode.new(line, @options[:style])
+      end
+    end
+    
+    def parse_attribute(line)
+      name, eq, value = line.scan(ATTRIBUTE)[0]
+
+      if name.nil? || value.nil?
+        raise SyntaxError.new("Invalid attribute: \"#{line}\"", @line)
+      end
+      
+      if eq[0] == SCRIPT_CHAR
+        value = Sass::Constant.parse(value, @constants, @line).to_s
+      end
+      
+      Tree::AttrNode.new(name, value, @options[:style])
+    end
+    
+    def parse_constant(line)
+      name, value = line.scan(Sass::Constant::MATCH)[0]
+      unless name && value
+        raise SyntaxError.new("Invalid constant: \"#{line}\"", @line)
+      end
+      @constants[name] = Sass::Constant.parse(value, @constants, @line)
+      nil
+    end
+  end
+end