haml 1.0.5 → 1.5.0

data/lib/sass/error.rb

@@ -0,0 +1,35 @@
+module Sass
+  # Sass::SyntaxError encapsulates information about the exception,
+  # such as the line of the Sass template it was raised on
+  # and the Sass file that was being parsed (if applicable).
+  # It also provides a handy way to rescue only exceptions raised
+  # because of a faulty template.
+  class SyntaxError < StandardError
+    # The line of the Sass template on which the exception was thrown.
+    attr_accessor :sass_line
+
+    # The name of the file that was being parsed when the exception was raised.
+    # This will be nil unless Sass is being used as an ActionView plugin.
+    attr_reader :sass_filename
+
+    # Creates a new SyntaxError.
+    # +lineno+ should be the line of the Sass template on which the error occurred.
+    def initialize(msg, lineno = nil)
+      @message = msg
+      @sass_line = lineno
+    end
+
+    # Adds a properly formatted entry to the exception's backtrace.
+    # +filename+ should be the file in which the error occurred,
+    # if applicable (defaults to "(sass)").
+    def add_backtrace_entry(filename) # :nodoc:
+      @sass_filename = filename
+      self.backtrace ||= []
+      self.backtrace.unshift "#{filename || '(sass)'}:#{@sass_line}"
+    end
+
+    def to_s # :nodoc:
+      @message
+    end
+  end
+end

data/lib/sass/plugin.rb

@@ -0,0 +1,119 @@
+require 'sass/engine'
+require 'rubygems'
+require 'action_controller'
+
+RAILS_ROOT = '. 'unless self.class.const_defined?('RAILS_ROOT')
+RAILS_ENV  = 'production' unless self.class.const_defined?('RAILS_ENV')
+
+module Sass
+  # This module contains methods that ActionController calls
+  # to automatically update Sass templates that need updating.
+  # It wasn't designed to be used outside of the context of ActionController.
+  module Plugin
+    class << self
+      @@options = {
+        :template_location  => RAILS_ROOT + '/public/stylesheets/sass',
+        :css_location       => RAILS_ROOT + '/public/stylesheets',
+        :always_update      => false,
+        :always_check       => RAILS_ENV != "production"
+      }
+
+      # Gets various options for Sass. See README for details.
+      #--
+      # TODO: *DOCUMENT OPTIONS*
+      #++
+      def options
+        @@options
+      end
+
+      # Sets various options for Sass.
+      def options=(value)
+        @@options.merge!(value)
+      end
+      
+      # Checks each stylesheet in <tt>options[:css_location]</tt>
+      # to see if it needs updating,
+      # and updates it using the corresponding template
+      # from <tt>options[:templates]</tt>
+      # if it does.
+      def update_stylesheets
+        Dir[options[:template_location] + '/*.sass'].each do |file|
+          name = File.basename(file)[0...-5]
+          
+          if options[:always_update] || stylesheet_needs_update?(name)
+            css = css_filename(name)
+            File.delete(css) if File.exists?(css)
+            
+            filename = template_filename(name)
+            l_options = @@options.dup
+            l_options[:filename] = filename
+            engine = Engine.new(File.read(filename), l_options)
+            begin
+              result = engine.render
+            rescue Exception => e
+              if RAILS_ENV != "production"
+                e_string = "#{e.class}: #{e.message}"
+
+                if e.is_a? Sass::SyntaxError
+                  e_string << "\non line #{e.sass_line}"
+
+                  if e.sass_filename
+                    e_string << " of #{e.sass_filename}"
+
+                    if File.exists?(e.sass_filename)
+                      e_string << "\n\n"
+
+                      min = [e.sass_line - 5, 0].max
+                      File.read(e.sass_filename).rstrip.split("\n")[
+                          min .. e.sass_line + 5
+                      ].each_with_index do |line, i|
+                        e_string << "#{min + i + 1}: #{line}\n"
+                      end
+                    end
+                  end
+                end
+                result = "/*\n#{e_string}\n\nBacktrace:\n#{e.backtrace.join("\n")}\n*/"
+              else
+                result = "/* Internal stylesheet error */"
+              end
+            end
+            
+            Dir.mkdir(l_options[:css_location]) unless File.exist?(l_options[:css_location])
+            File.open(css, 'w') do |file|
+              file.print(result)
+            end
+          end
+        end
+      end
+      
+      private
+      
+      def template_filename(name)
+        "#{@@options[:template_location]}/#{name}.sass"
+      end
+      
+      def css_filename(name)
+        "#{@@options[:css_location]}/#{name}.css"
+      end
+      
+      def stylesheet_needs_update?(name)
+        !File.exists?(css_filename(name)) || (File.mtime(template_filename(name)) - 2) > File.mtime(css_filename(name))
+      end
+    end
+  end
+end
+
+# This module refers to the ActionController module that's part of Ruby on Rails.
+# Sass can be used as an alternate templating engine for Rails,
+# and includes some modifications to make this more doable.
+# The documentation can be found
+# here[http://rubyonrails.org/api/classes/ActionController/Base.html].
+module ActionController
+  class Base # :nodoc:
+    alias_method :sass_old_process, :process
+    def process(*args)
+      Sass::Plugin.update_stylesheets if Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+      sass_old_process(*args)
+    end
+  end
+end

data/lib/sass/tree/attr_node.rb

@@ -0,0 +1,44 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class AttrNode < ValueNode
+    attr_accessor :name
+    
+    def initialize(name, value, style)
+      @name = name
+      super(value, style)
+    end
+    
+    def to_s(parent_name = nil)
+      if name[-1] == ?: || value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!)", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+      if children.size > 0
+        to_return = String.new
+        children.each do |kid|
+          if @style == :compact
+            to_return << "#{kid.to_s(real_name)} "
+          else
+            to_return << "#{kid.to_s(real_name)}\n"
+          end
+        end
+        to_return << "\n" unless @style == :compact
+        to_return[0...-1]
+      else
+        if value.length < 1
+          raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}", @line)
+        end
+
+        "#{real_name}: #{value};"
+      end
+    end
+
+    private
+
+    def declaration
+      ":#{name} #{value}"
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -0,0 +1,29 @@
+module Sass
+  module Tree
+    class Node
+      attr_accessor :children
+      attr_accessor :line
+
+      def initialize(style)
+        @style = style
+        @children = []
+      end
+
+      def <<(child)
+        @children << child
+      end
+      
+      def to_s
+        result = String.new
+        children.each do |child|
+          if child.is_a? AttrNode
+            raise SyntaxError.new('Attributes aren\'t allowed at the root of a document.', child.line)
+          end
+
+          result += "#{child.to_s(1)}\n"
+        end
+        result[0...-1]
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -0,0 +1,47 @@
+require 'sass/tree/node'
+require 'sass/tree/attr_node'
+
+module Sass::Tree
+  class RuleNode < ValueNode
+    alias_method :rule, :value
+    alias_method :rule=, :value=
+    
+    def to_s(tabs, super_rules = nil)
+      attributes = []
+      sub_rules = []
+      total_rule = if super_rules
+        super_rules.split(/,\s*/).collect! do |s|
+          self.rule.split(/,\s*/).collect! {|r| "#{s} #{r}"}.join(", ")
+        end.join(", ")
+      else
+        self.rule
+      end
+      
+      children.each do |child|
+        if child.is_a? AttrNode
+          attributes << child
+        else
+          sub_rules << child
+        end
+      end
+      
+      to_return = ''
+      unless attributes.empty?
+        if @style == :compact
+          to_return << "#{total_rule} { #{attributes.join(' ')} }\n"
+        else
+          spaces = (@style == :expanded ? 2 : tabs * 2)
+          old_spaces = ' ' * (spaces - 2)
+          spaces = ' ' * spaces
+
+          attributes = attributes.join("\n").gsub("\n", "\n#{spaces}").rstrip
+          end_attrs = (@style == :expanded ? "\n" : ' ')
+          to_return << "#{old_spaces}#{total_rule} {\n#{spaces}#{attributes}#{end_attrs}}\n"
+        end
+      end
+      
+      sub_rules.each { |sub| to_return << sub.to_s(tabs + 1, total_rule) }
+      to_return
+    end
+  end
+end

data/lib/sass/tree/value_node.rb

@@ -0,0 +1,12 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class ValueNode < Node
+    attr_accessor :value
+  
+    def initialize(value, style)
+      @value = value
+      super(style)
+    end
+  end
+end

data/test/benchmark.rb

@@ -1,4 +1,6 @@
-require File.dirname(__FILE__) + '/../lib/haml/template'
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/template'
+require 'sass/engine'
 require 'rubygems'
 require 'active_support'
 require 'action_view'
@@ -19,26 +21,15 @@ module Haml
       end
     end
     
-    # Benchmarks HAML against ERb. If <tt>template_name</tt> is specified,
-    # looks for a haml template in ./templates and an rhtml template in
-    # ./rhtml with the name <tt>template_name</tt>. Otherwise, uses
-    # <tt>haml_template</tt> and <tt>rhtml_template</tt> as the location of
-    # the templates.
+    # Benchmarks haml against ERb, and Sass on its own.
     # 
     # Returns the results of the benchmarking as a string.
     # 
-    # :call-seq:
-    # benchmark(runs = 100, template_name = 'standard')
-    # benchmark(runs = 100, haml_template, rhtml_template)
-    # 
-    def benchmark(runs = 100, template_name = 'standard', other_template = nil)
-      if other_template.nil?
-        haml_template = "templates/#{template_name}"
-        rhtml_template = "rhtml/#{template_name}"
-      else
-        haml_template = template_name
-        rhtml_template = other_template
-      end
+    def benchmark(runs = 100)
+      template_name = 'standard'
+      haml_template = "haml/templates/#{template_name}"
+      rhtml_template = "haml/rhtml/#{template_name}"
+      sass_template = File.dirname(__FILE__) + "/sass/templates/complex.sass"
       
       old_stdout = $stdout
       $stdout = StringIO.new
@@ -48,10 +39,16 @@ module Haml
         b.report("erb:") { runs.times { @base.render rhtml_template } }
       end
       
-      #puts times.inspect
+      #puts times[0].inspect, times[1].inspect
       ratio = sprintf("%g", times[0].to_a[5] / times[1].to_a[5])
       puts "Haml/ERB: " + ratio
       
+      puts '', '-' * 50, 'Sass on its own', '-' * 50
+      
+      Benchmark.bmbm do |b|
+        b.report("sass:") { runs.times { Sass::Engine.new(File.read(sass_template)).render } }
+      end
+      
       $stdout.pos = 0
       to_return = $stdout.read
       $stdout = old_stdout

data/test/haml/engine_test.rb

@@ -0,0 +1,220 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/../../lib/haml'
+require 'haml/engine'
+
+class EngineTest < Test::Unit::TestCase
+
+  def render(text, options = {})
+    Haml::Engine.new(text, options).to_html
+  end
+
+  def test_empty_render_should_remain_empty
+    assert_equal('', render(''))
+  end
+
+  # This is ugly because Hashes are unordered; we don't always know the order
+  # in which attributes will be returned.
+  # There is probably a better way to do this.
+  def test_attributes_should_render_correctly
+    assert_equal("<div class='atlantis' style='ugly'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp)
+  rescue
+    assert_equal("<div style='ugly' class='atlantis'>\n</div>", render(".atlantis{:style => 'ugly'}").chomp)
+  end
+
+  def test_ruby_code_should_work_inside_attributes
+    author = 'hcatlin'
+    assert_equal("<p class='3'>foo</p>", render("%p{:class => 1+2} foo").chomp)
+  end
+
+  def test_nil_should_render_empty_tag
+    assert_equal("<div class='no_attributes'>\n</div>",
+                 render(".no_attributes{:nil => nil}").chomp)
+  end
+
+  def test_strings_should_get_stripped_inside_tags
+    assert_equal("<div class='stripped'>This should have no spaces in front of it</div>",
+                 render(".stripped    This should have no spaces in front of it").chomp)
+  end
+
+  def test_one_liner_should_be_one_line
+    assert_equal("<p>Hello</p>", render('%p Hello').chomp)
+  end
+
+  def test_long_liner_should_not_print_on_one_line
+    assert_equal("<div>\n  #{'x' * 51}\n</div>", render("%div #{'x' * 51}").chomp)
+  end
+
+  def test_multi_render
+    engine = Haml::Engine.new("%strong Hi there!")
+    assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
+    assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
+    assert_equal("<strong>Hi there!</strong>\n", engine.to_html)
+  end
+
+  # Options tests
+
+  def test_stop_eval
+    assert_equal("", render("= 'Hello'", :suppress_eval => true))
+  end
+
+  def test_attr_wrapper
+    assert_equal("<p strange=*attrs*>\n</p>\n", render("%p{ :strange => 'attrs'}", :attr_wrapper => '*'))
+    assert_equal("<p escaped='quo\"te'>\n</p>\n", render("%p{ :escaped => 'quo\"te'}", :attr_wrapper => '"'))
+    assert_equal("<p escaped=\"q'uo&quot;te\">\n</p>\n", render("%p{ :escaped => 'q\\'uo\"te'}", :attr_wrapper => '"'))
+    assert_equal("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n", render("!!! XML", :attr_wrapper => '"'))
+  end
+
+  def test_locals
+    assert_equal("<p>Paragraph!</p>\n", render("%p= text", :locals => { :text => "Paragraph!" }))
+  end
+
+  def test_precompiled
+    precompiled = <<-END
+      def _haml_render
+        _hamlout = @haml_stack[-1]
+        _erbout = _hamlout.buffer
+
+        _hamlout.open_tag("p", 0, nil, true, "", nil, nil, false)
+        @haml_lineno = 1
+        haml_temp =  "Haml Rocks Socks"
+        haml_temp = _hamlout.push_script(haml_temp, 1, false)
+        _hamlout.close_tag("p", 0)
+      end
+    END
+
+    assert_equal("<p>Haml Rocks Socks</p>\n", render("%h1 I shall not be rendered", :precompiled => precompiled))
+  end
+  
+  def test_comps
+    assert_equal(-1, "foo" <=> nil)
+    assert_equal(1, nil <=> "foo")
+  end
+
+  def test_rec_merge
+    hash1 = {1=>2, 3=>{5=>7, 8=>9}}
+    hash1_2 = hash1.clone
+    hash2 = {4=>5, 3=>{5=>2, 16=>12}}
+    hash3 = {1=>2, 4=>5, 3=>{5=>2, 8=>9, 16=>12}}
+
+    assert_equal(hash3, hash1.rec_merge(hash2))
+    assert_equal(hash1_2, hash1)
+    hash1.rec_merge!(hash2)
+    assert_equal(hash3, hash1)
+  end
+
+  def test_exception_type
+    begin
+      render("%p hi\n= undefined")
+    rescue Exception => e
+      assert(e.is_a?(Haml::Error))
+      assert_equal(2, e.haml_line)
+      assert_equal(nil, e.haml_filename)
+      assert_equal('(haml):2', e.backtrace[0])
+    else
+      # Test failed... should have raised an exception
+      assert(false)
+    end
+  end
+
+  def test_syntax_errors
+    errs = [ "!!!\n  a", "a\n  b", "a\n:foo\nb", "/ a\n  b",
+      "% a", "%p a\n  b", "a\n%p=\nb", "%p=\n  a",
+      "a\n%p~\nb", "a\n~\nb", "%p/\n  a", "%p\n \t%a b",
+      "%a\n b\nc", "%a\n    b\nc",
+      ":notafilter\n  This isn't\n  a filter!",
+    ]
+    errs.each do |err|
+      begin
+        render(err)
+      rescue Exception => e
+        assert(e.is_a?(Haml::Error),
+               "#{err.dump} doesn't produce Haml::SyntaxError!")
+      else
+        assert(false,
+               "#{err.dump} doesn't produce an exception!")
+      end
+    end
+  end
+
+  def test_compile_error
+    begin
+      render("a\nb\n- fee do\nc")
+    rescue Exception => e
+      assert_equal(3, e.haml_line)
+    else
+      assert(false,
+             '"a\nb\n- fee do\nc" doesn\'t produce an exception!')
+    end
+  end
+
+  def test_no_bluecloth
+    old_markdown = false
+    if defined?(Haml::Filters::Markdown)
+      old_markdown = Haml::Filters::Markdown
+    end
+
+    Kernel.module_eval do
+      alias_method :haml_old_require, :gem_original_require
+
+      def gem_original_require(file)
+        raise LoadError if file == 'bluecloth'
+        haml_old_require(file)
+      end
+    end
+    
+    if old_markdown
+      Haml::Filters.instance_eval do
+        remove_const 'Markdown'
+      end
+    end
+
+    # This is purposefully redundant, so it doesn't stop
+    # haml/filters from being required later on.
+    require 'haml/../haml/filters'
+
+    assert_equal("<h1>Foo</h1>\t<p>- a\n- b</p>\n",
+                 Haml::Engine.new(":markdown\n  Foo\n  ===\n  - a\n  - b").to_html)
+
+    Haml::Filters.instance_eval do
+      remove_const 'Markdown'
+    end
+
+    Haml::Filters.const_set('Markdown', old_markdown) if old_markdown
+
+    Kernel.module_eval do
+      alias_method :gem_original_require, :haml_old_require
+    end
+
+    NOT_LOADED.delete 'bluecloth'
+  end
+
+  def test_no_redcloth
+    Kernel.module_eval do
+      alias_method :haml_old_require2, :gem_original_require
+
+      def gem_original_require(file)
+        raise LoadError if file == 'redcloth'
+        haml_old_require2(file)
+      end
+    end
+
+    # This is purposefully redundant, so it doesn't stop
+    # haml/filters from being required later on.
+    require 'haml/../haml/../haml/filters'
+
+    begin
+      Haml::Engine.new(":redcloth\n  _foo_").to_html
+    rescue Haml::HamlError
+    else
+      assert(false, "No exception raised!")
+    end
+
+    Kernel.module_eval do
+      alias_method :gem_original_require2, :haml_old_require
+    end
+
+    NOT_LOADED.delete 'redcloth'
+  end
+end