haml 3.0.18 → 3.0.21

data/Rakefile

@@ -42,7 +42,7 @@ END
 # Don't use Rake::GemPackageTast because we want prerequisites to run
 # before we load the gemspec.
 desc "Build all the packages."
-task :package => [:revision_file, :submodules] do
+task :package => [:revision_file, :submodules, :permissions] do
   load scope('haml.gemspec')
   Gem::Builder.new(HAML_GEMSPEC).build
   pkg = "#{HAML_GEMSPEC.name}-#{HAML_GEMSPEC.version}"
@@ -54,6 +54,16 @@ task :package => [:revision_file, :submodules] do
   sh %{gzip pkg/#{pkg}.tar}
 end
 
+task :permissions do
+  sh %{chmod -R a+rx bin}
+  sh %{chmod -R a+r .}
+  require 'shellwords'
+  Dir.glob('test/**/*_test.rb') do |file|
+    next if file =~ %r{^test/haml/spec/}
+    sh %{chmod a+rx #{file}}
+  end
+end
+
 task :revision_file do
   require 'lib/haml'
 

data/VERSION

@@ -1 +1 @@
-3.0.18
+3.0.21

data/extra/haml-mode.el

@@ -4,7 +4,7 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 3.0.14
+;; Version: 3.0.19
 ;; Created: 2007-03-08
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, html
@@ -73,7 +73,7 @@ a specific level to which the current line could be indented.")
   `(,(concat haml-tag-beg-re "[><]*[ \t]*$")
     "^[ \t]*[&!]?[-=~].*do[ \t]*\\(|.*|[ \t]*\\)?$"
     ,(concat "^[ \t]*[&!]?[-=~][ \t]*\\("
-             (regexp-opt '("if" "unless" "while" "until" "else"
+             (regexp-opt '("if" "unless" "while" "until" "else" "for"
                            "begin" "elsif" "rescue" "ensure" "when"))
              "\\)")
     "^[ \t]*/\\(\\[.*\\]\\)?[ \t]*$"

data/extra/sass-mode.el

@@ -4,7 +4,7 @@
 
 ;; Author: Nathan Weizenbaum
 ;; URL: http://github.com/nex3/haml/tree/master
-;; Version: 3.0.14
+;; Version: 3.0.19
 ;; Created: 2007-03-15
 ;; By: Nathan Weizenbaum
 ;; Keywords: markup, language, css

data/lib/haml/engine.rb

@@ -190,7 +190,7 @@ module Haml
     ensure
       # Get rid of the current buffer
       scope_object.instance_eval do
-        @haml_buffer = buffer.upper
+        @haml_buffer = buffer.upper if buffer
       end
     end
     alias_method :to_html, :render

data/lib/haml/exec.rb

@@ -79,10 +79,8 @@ module Haml
           @options[:trace] = true
         end
 
-        if ::Haml::Util.windows?
-          opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
-            @options[:unix_newlines] = true
-          end
+        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
+          @options[:unix_newlines] = true if ::Haml::Util.windows?
         end
 
         opts.on_tail("-?", "-h", "--help", "Show this message") do
@@ -357,7 +355,7 @@ END
           input = @options[:input]
           output = @options[:output]
 
-          @options[:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
+          @options[:for_engine][:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
           tree =
             if input.is_a?(File) && !@options[:check_syntax]
               ::Sass::Files.tree_for(input.path, @options[:for_engine])

data/lib/haml/precompiler.rb

@@ -118,8 +118,8 @@ END
 
       names.map do |name|
         # Can't use || because someone might explicitly pass in false with a symbol
-        sym_local = "_haml_locals[#{name.to_sym.inspect}]"
-        str_local = "_haml_locals[#{name.to_s.inspect}]"
+        sym_local = "_haml_locals[#{inspect(name.to_sym)}]"
+        str_local = "_haml_locals[#{inspect(name.to_s)}]"
         "#{name} = #{sym_local}.nil? ? #{str_local} : #{sym_local}"
       end.join(';') + ';'
     end
@@ -320,7 +320,7 @@ END
       @to_merge.each do |type, val, tabs|
         case type
         when :text
-          str << val.inspect[1...-1]
+          str << inspect(val)[1...-1]
           mtabs += tabs
         when :script
           if mtabs != 0 && !@options[:ugly]
@@ -660,7 +660,7 @@ END
         if type == :static
           static_attributes[name] = val
         else
-          dynamic_attributes << name.inspect << " => " << val << ","
+          dynamic_attributes << inspect(name) << " => " << val << ","
         end
       end
       dynamic_attributes << "}"
@@ -695,7 +695,7 @@ END
 
       return name, [:static, content.first[1]] if content.size == 1
       return name, [:dynamic,
-        '"' + content.map {|(t, v)| t == :str ? v.inspect[1...-1] : "\#{#{v}}"}.join + '"']
+        '"' + content.map {|(t, v)| t == :str ? inspect(v)[1...-1] : "\#{#{v}}"}.join + '"']
     end
 
     # Parses a line that will render as an XHTML tag, and adds the code that will
@@ -800,7 +800,7 @@ END
         return if tag_closed
       else
         flush_merged_text
-        content = parse ? 'nil' : value.inspect
+        content = parse ? 'nil' : inspect(value)
         if attributes_hashes.empty?
           attributes_hashes = ''
         elsif attributes_hashes.size == 1
@@ -811,7 +811,7 @@ END
 
         args = [tag_name, self_closing, !block_opened?, preserve_tag, escape_html,
                 attributes, nuke_outer_whitespace, nuke_inner_whitespace
-               ].map { |v| v.inspect }.join(', ')
+               ].map {|v| inspect(v)}.join(', ')
         push_silent "_hamlout.open_tag(#{args}, #{object_ref}, #{content}#{attributes_hashes})"
         @dont_tab_up_next_text = @dont_indent_next_line = dont_indent_next_line
       end
@@ -1017,14 +1017,14 @@ END
 
     def unescape_interpolation(str, opts = {})
       res = ''
-      rest = Haml::Shared.handle_interpolation str.dump do |scan|
+      rest = Haml::Shared.handle_interpolation inspect(str) do |scan|
         escapes = (scan[2].size - 1) / 2
         res << scan.matched[0...-3 - escapes]
         if escapes % 2 == 1
           res << '#{'
         else
           content = eval('"' + balance(scan, ?{, ?}, 1)[0][0...-1] + '"')
-          content = "Haml::Helpers.html_escape(#{content})" if opts[:escape_html]
+          content = "Haml::Helpers.html_escape((#{content}))" if opts[:escape_html]
           res << '#{' + content + "}"# Use eval to get rid of string escapes
         end
       end

data/lib/haml/util.rb

@@ -656,6 +656,19 @@ MSG
       set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})
     end
 
+    # Like `Object#inspect`, but preserves non-ASCII characters rather than escaping them under Ruby 1.9.2.
+    # This is necessary so that the precompiled Haml template can be `#encode`d into `@options[:encoding]`
+    # before being evaluated.
+    #
+    # @param obj {Object}
+    # @return {String}
+    def inspect(obj)
+      return obj.inspect unless version_geq(::RUBY_VERSION, "1.9.2")
+      return ':' + inspect(obj.to_s) if obj.is_a?(Symbol)
+      return obj.inspect unless obj.is_a?(String)
+      '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
+    end
+
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.

data/lib/sass/script/color.rb

@@ -401,7 +401,8 @@ END
     end
 
     def rgba_str
-      "rgba(#{rgb.join(', ')}, #{alpha % 1 == 0.0 ? alpha.to_i : alpha})"
+      split = options[:style] == :compressed ? ',' : ', '
+      "rgba(#{rgb.join(split)}#{split}#{Number.round(alpha)})"
     end
 
     def hex_str

data/lib/sass/script/funcall.rb

@@ -63,12 +63,10 @@ module Sass
         args = self.args.map {|a| a.perform(environment)}
         ruby_name = name.gsub('-', '_')
         unless Haml::Util.has?(:public_instance_method, Functions, ruby_name) && ruby_name !~ /^__/
-          return Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})")
+          opts(Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})"))
+        else
+          opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
         end
-
-        result = Functions::EvaluationContext.new(environment.options).send(ruby_name, *args)
-        result.options = environment.options
-        return result
       rescue ArgumentError => e
         raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")

data/lib/sass/script/interpolation.rb

@@ -64,7 +64,7 @@ module Sass::Script
       res << (val.is_a?(Sass::Script::String) ? val.value : val.to_s)
       res << " " if @after && @whitespace_after
       res << @after.perform(environment).to_s if @after
-      Sass::Script::String.new(res)
+      opts(Sass::Script::String.new(res))
     end
   end
 end

data/lib/sass/script/literal.rb

@@ -117,7 +117,7 @@ MSG
     # @return [Script::String] A string containing both literals
     #   separated by `", "`
     def comma(other)
-      Sass::Script::String.new("#{self.to_s}, #{other.to_s}")
+      Sass::Script::String.new("#{self.to_s},#{' ' unless options[:style] == :compressed}#{other.to_s}")
     end
 
     # The SassScript `=` operation

data/lib/sass/script/node.rb

@@ -90,6 +90,8 @@ module Sass::Script
     end
 
     # Evaluates this node.
+    # Note that all {Literal} objects created within this method
+    # should have their \{#options} attribute set, probably via \{#opts}.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
     # @return [Literal] The SassScript object that is the value of the SassScript
@@ -97,5 +99,14 @@ module Sass::Script
     def _perform(environment)
       raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #_perform.")
     end
+
+    # Sets the \{#options} field on the given literal and returns it
+    #
+    # @param literal [Literal]
+    # @return [Literal]
+    def opts(literal)
+      literal.options = options
+      literal
+    end
   end
 end

data/lib/sass/script/number.rb

@@ -248,15 +248,7 @@ module Sass::Script
     #
     # @return [String] The representation
     def inspect(opts = {})
-      value =
-        if self.value.is_a?(Float) && (self.value.infinite? || self.value.nan?)
-          self.value
-        elsif int?
-          self.value.to_i
-        else
-          (self.value * PRECISION).round / PRECISION
-        end
-      "#{value}#{unit_str}"
+      "#{self.class.round(self.value)}#{unit_str}"
     end
     alias_method :to_sass, :inspect
 
@@ -334,6 +326,17 @@ module Sass::Script
 
     private
 
+    # @private
+    def self.round(num)
+      if num.is_a?(Float) && (num.infinite? || num.nan?)
+        num
+      elsif num % 1 == 0.0
+        num.to_i
+      else
+        (num * PRECISION).round / PRECISION
+      end
+    end
+
     def operate(other, operation)
       this = self
       if [:+, :-, :<=, :<, :>, :>=].include?(operation)

data/lib/sass/script/operation.rb

@@ -72,9 +72,7 @@ module Sass::Script
       end
 
       begin
-        res = literal1.send(@operator, literal2)
-        res.options = environment.options
-        res
+        opts(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}\".")

data/lib/sass/script/parser.rb

@@ -246,7 +246,7 @@ RUBY
         return if @stop_at && @stop_at.include?(@lexer.peek.value)
 
         name = @lexer.next
-        if color = Color::HTML4_COLORS[name.value]
+        if color = Color::HTML4_COLORS[name.value.downcase]
           return node(Color.new(color))
         end
         node(Script::String.new(name.value, :identifier))

data/lib/sass/script/string_interpolation.rb

@@ -72,7 +72,7 @@ module Sass::Script
       mid = @mid.perform(environment)
       res << (mid.is_a?(Sass::Script::String) ? mid.value : mid.to_s)
       res << @after.perform(environment).value
-      Sass::Script::String.new(res, before.type)
+      opts(Sass::Script::String.new(res, before.type))
     end
 
     private

data/lib/sass/tree/rule_node.rb

@@ -134,7 +134,7 @@ module Sass::Tree
       per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
 
       total_rule = total_indent + resolved_rules.members.
-        map {|seq| seq.to_a.join}.
+        map {|seq| seq.to_a.join.gsub(/([^,])\n/m, style == :compressed ? '\1 ' : "\\1\n")}.
         join(rule_separator).split("\n").map do |line|
         per_rule_indent + line.strip
       end.join(line_separator)

data/test/haml/engine_test.rb

@@ -111,6 +111,17 @@ MESSAGE
     Haml::Engine.new(text, options)
   end
 
+  def setup
+    return if Haml::Util.ruby1_8?
+    @old_default_internal = Encoding.default_internal
+    Encoding.default_internal = nil
+  end
+
+  def teardown
+    return if Haml::Util.ruby1_8?
+    Encoding.default_internal = @old_default_internal
+  end
+
   def test_empty_render
     assert_equal "", render("")
   end
@@ -763,6 +774,14 @@ HTML
 HAML
   end
 
+  def test_escape_html_with_interpolated_if_statement
+    assert_equal(<<HTML, render(<<HAML, :escape_html => true))
+foo,
+HTML
+foo\#{"," if true}
+HAML
+  end
+
   # HTML escaping tests
 
   def test_ampersand_equals_should_escape
@@ -1506,7 +1525,7 @@ HAML
 
   def test_loud_ruby_multiline_with_block
     assert_equal(<<HTML, render(<<HAML))
-farfazfang
+#{%w[far faz fang]}
 <p>foo</p>
 <p>bar</p>
 HTML
@@ -1636,18 +1655,8 @@ HAML
 HAML
     end
 
-    def test_convert_template_render
-      assert_equal(<<HTML, render(<<HAML.encode("iso-8859-1"), :encoding => "utf-8"))
-<p>bâr</p>
-<p>föö</p>
-HTML
-%p bâr
-%p föö
-HAML
-    end
-
     def test_fake_ascii_encoding
-      assert_equal(<<HTML.force_encoding("ascii-8bit"), render(<<HAML, :encoding => "ascii-8bit"))
+      assert_encoded_equal(<<HTML.force_encoding("ascii-8bit"), render(<<HAML, :encoding => "ascii-8bit"))
 <p>bâr</p>
 <p>föö</p>
 HTML
@@ -1701,15 +1710,23 @@ HTML
 HAML
     end
 
-    def test_different_coding_comment_than_encoding
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# coding: ibm866
-%p bâr
-%p föö
-HAML
+    def test_coding_comments
+      assert_valid_encoding_comment("-# coding: ibm866")
+      assert_valid_encoding_comment("-# CodINg: IbM866")
+      assert_valid_encoding_comment("-#coding:ibm866")
+      assert_valid_encoding_comment("-# CodINg= ibm866")
+      assert_valid_encoding_comment("-# foo BAR FAOJcoding: ibm866")
+      assert_valid_encoding_comment("-# coding: ibm866 ASFJ (&(&#!$")
+      assert_valid_encoding_comment("-# -*- coding: ibm866")
+      assert_valid_encoding_comment("-# coding: ibm866 -*- coding: blah")
+      assert_valid_encoding_comment("-# -*- coding: ibm866 -*-")
+      assert_valid_encoding_comment("-# -*- encoding: ibm866 -*-")
+      assert_valid_encoding_comment('-# -*- coding: "ibm866" -*-')
+      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
+      assert_valid_encoding_comment("-#-*-coding:ibm866-*-")
+      assert_valid_encoding_comment("-# -*- foo: bar; coding: ibm866; baz: bang -*-")
+      assert_valid_encoding_comment("-# foo bar coding: baz -*- coding: ibm866 -*-")
+      assert_valid_encoding_comment("-# -*- coding: ibm866 -*- foo bar coding: baz")
     end
 
     def test_different_coding_than_system
@@ -1719,182 +1736,27 @@ HTML
 %p тАЬ
 HAML
     end
+  end
 
-    def test_case_insensitive_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# CodINg: IbM866
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_whitespace_insensitive_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--#coding:ibm866
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_equals_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# CodINg= ibm866
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_prefixed_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# foo BAR FAOJcoding: ibm866
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_suffixed_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# coding: ibm866 ASFJ (&(&#!$
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_emacs_prefixed_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# -*- coding: ibm866
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_emacs_suffixed_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# coding: ibm866 -*- coding: blah
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# -*- coding: ibm866 -*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_emacs_encoding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# -*- encoding: ibm866 -*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_quoted_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# -*- coding: "ibm866" -*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_whitespace_insensitive_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--#-*-coding:ibm866-*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_whitespace_insensitive_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--#-*-coding:ibm866-*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_one_of_several_emacs_comments
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# -*- foo: bar; coding: ibm866; baz: bang -*-
-%p bâr
-%p föö
-HAML
-    end
-
-    def test_prefixed_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
-HTML
--# foo bar coding: baz -*- coding: ibm866 -*-
-%p bâr
-%p föö
-HAML
-    end
+  private
 
-    def test_suffixed_emacs_coding_comment
-      assert_renders_encoded(<<HTML.force_encoding("IBM866"), <<HAML)
-<p>bâr</p>
-<p>föö</p>
+  def assert_valid_encoding_comment(comment)
+    assert_renders_encoded(<<HTML.encode("IBM866"), <<HAML.encode("IBM866").force_encoding("UTF-8"))
+<p>ЖЛЫ</p>
+<p>тАЬ</p>
 HTML
--# -*- coding: ibm866 -*- foo bar coding: baz
-%p bâr
-%p föö
+#{comment}
+%p ЖЛЫ
+%p тАЬ
 HAML
-    end
-
   end
 
-  private
-
   def assert_converts_template_properly
-    engine = Haml::Engine.new(<<HAML.encode("iso-8859-1"), :encoding => "utf-8")
+    engine = Haml::Engine.new(<<HAML.encode("iso-8859-1"), :encoding => "macRoman")
 %p bâr
 %p föö
 HAML
-    assert_equal(<<HTML, yield(engine))
+    assert_encoded_equal(<<HTML.encode("macRoman"), yield(engine))
 <p>bâr</p>
 <p>föö</p>
 HTML
@@ -1902,7 +1764,11 @@ HTML
 
   def assert_renders_encoded(html, haml)
     result = render(haml)
-    assert_equal html.encoding, result.encoding
-    assert_equal html, result
+    assert_encoded_equal html, result
+  end
+
+  def assert_encoded_equal(expected, actual)
+    assert_equal expected.encoding, actual.encoding
+    assert_equal expected, actual
   end
 end