haml-edge 2.3.39 → 2.3.40

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.39
+2.3.40

data/VERSION

@@ -1 +1 @@
-2.3.39
+2.3.40

data/lib/haml/engine.rb

@@ -96,6 +96,8 @@ module Haml
         @options[:encoding] = @options[:encoding].name
       end
 
+      check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+
       # :eod is a special end-of-document marker
       @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
       @template_index = 0
@@ -111,7 +113,9 @@ module Haml
 
       precompile
     rescue Haml::Error => e
-      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
+      if @index || e.line
+        e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}"
+      end
       raise
     end
 

data/lib/haml/exec.rb

@@ -414,6 +414,9 @@ END
         @module_opts[:rhtml] &&= @options[:no_rhtml] != false
 
         output.write(::Haml::HTML.new(input, @module_opts).render)
+      rescue ::Haml::Error => e
+        raise "#{e.is_a?(::Haml::SyntaxError) ? "Syntax error" : "Error"} on line " +
+          "#{get_line e}: #{e.message}"
       end
     end
 
@@ -458,6 +461,9 @@ END
         output = @options[:output]
 
         output.write(::Sass::CSS.new(input, @module_opts).render)
+      rescue ::Sass::SyntaxError => e
+        raise e if @options[:trace]
+        raise "Syntax error on line #{get_line e}: #{e.message}\n  Use --trace for backtrace"
       end
     end
   end

data/lib/haml/html.rb

@@ -80,6 +80,8 @@ module Haml
           template = template.read
         end
 
+        Haml::Util.check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+
         if @options[:rhtml]
           match_to_html(template, /<%=(.*?)-?%>/m, 'loud')
           match_to_html(template, /<%-?(.*?)-?%>/m,  'silent')
@@ -128,9 +130,7 @@ module Haml
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
         attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
-        if attrs == nil
-          raise Exception.new("Invalid doctype")
-        end
+        raise Haml::SyntaxError.new("Invalid doctype") if attrs == nil
 
         type, version, strictness = attrs.map { |a| a.downcase }
         if type == "html"

data/lib/haml/util.rb

@@ -129,6 +129,22 @@ module Haml
       Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
     end
 
+    def check_encoding(str)
+      return if ruby1_8?
+      return if str.valid_encoding?
+      encoding = str.encoding
+      newlines = Regexp.new("\r\n|\r|\n".encode(encoding).force_encoding("binary"))
+      str.force_encoding("binary").split(newlines).each_with_index do |line, i|
+        begin
+          line.encode(encoding)
+        rescue Encoding::UndefinedConversionError => e
+          yield <<MSG.rstrip, i + 1
+Invalid #{encoding.name} character #{e.error_char.dump}
+MSG
+        end
+      end
+    end
+
     # Checks to see if a class has a given method.
     # For example:
     #

data/lib/sass/css.rb

@@ -62,11 +62,15 @@ module Sass
     # @option options :old [Boolean] (false)
     #     Whether or not to output old property syntax
     #     (`:color blue` as opposed to `color: blue`).
+    # @option options :filename [String]
+    #     The filename of the CSS file being processed.
+    #     Used for error reporting
     def initialize(template, options = {})
       if template.is_a? IO
         template = template.read
       end
 
+      @line = 1
       @options = options.dup
       # Backwards compatibility
       @options[:old] = true if @options[:alternate] == false
@@ -76,15 +80,16 @@ module Sass
     # Converts the CSS template into Sass code.
     #
     # @return [String] The resulting Sass code
+    # @raise [Sass::SyntaxError] if there's an error parsing the CSS template
     def render
-      begin
-        build_tree.to_sass(0, @options).strip + "\n"
-      rescue Exception => err
-        line = @template.string[0...@template.pos].split("\n").size
-
-        err.backtrace.unshift "(css):#{line}"
-        raise err
+      Haml::Util.check_encoding(@template.string) do |msg, line|
+        raise Sass::SyntaxError.new(msg, :line => line)
       end
+
+      build_tree.to_sass(0, @options).strip + "\n"
+    rescue Sass::SyntaxError => err
+      err.modify_backtrace(:filename => @options[:filename] || '(css)', :line => @line)
+      raise err
     end
 
     private
@@ -120,7 +125,7 @@ module Sass
     def rule
       rule = ""
       loop do
-        token = @template.scan(/(?:[^\{\};\/\s]|\/[^*])+/)
+        token = scan(/(?:[^\{\};\/\s]|\/[^*])+/)
         if token.nil?
           return if rule.empty?
           break
@@ -136,7 +141,7 @@ module Sass
 
       if directive
         node = Tree::DirectiveNode.new(rule)
-        return node if @template.scan(/;/)
+        return node if scan(/;/)
 
         assert_match /\{/
         whitespace
@@ -155,14 +160,14 @@ module Sass
     #
     # @param rule [Tree::RuleNode] The parent node of the properties
     def properties(rule)
-      while @template.scan(/[^:\}\s]+/)
+      while scan(/[^:\}\s]+/)
         name = @template[0]
         whitespace
 
         assert_match /:/
 
         value = ''
-        while @template.scan(/[^;\s\}]+/)
+        while scan(/[^;\s\}]+/)
           value << @template[0] << whitespace
         end
 
@@ -177,12 +182,12 @@ module Sass
     #
     # @return [String] The ignored whitespace
     def whitespace
-      space = @template.scan(/\s*/) || ''
+      space = scan(/\s*/) || ''
 
       # If we've hit a comment,
       # go past it and look for more whitespace
-      if @template.scan(/\/\*/)
-        @template.scan_until(/\*\//)
+      if scan(/\/\*/)
+        scan_until(/\*\//)
         return space + whitespace
       end
       return space
@@ -193,26 +198,42 @@ module Sass
     #
     # @param re [Regexp] The regular expression to assert
     def assert_match(re)
-      if @template.scan(re)
+      if scan(re)
         whitespace
         return
       end
 
-      line = @template.string[0..@template.pos].count "\n"
       pos = @template.pos
 
-      after = @template.string[pos - 15...pos]
+      after = @template.string[[pos - 15, 0].max...pos].gsub(/.*\n/m, '')
       after = "..." + after if pos >= 15
 
       # Display basic regexps as plain old strings
-      expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect
+      string = re.source.gsub(/\\(.)/, '\1')
+      expected = re.source == Regexp.escape(string) ? string.inspect : re.inspect
 
-      was = @template.rest[0...15]
+      was = @template.rest[0...15].gsub(/\n.*/m, '')
       was += "..." if @template.rest.size >= 15
-      raise Exception.new(<<MESSAGE)
-Invalid CSS on line #{line + 1} after #{after.inspect}:
-  expected #{expected}, was #{was.inspect}
-MESSAGE
+      raise Sass::SyntaxError.new(
+        "Invalid CSS after #{after.inspect}: expected #{expected}, was #{was.inspect}")
+    end
+
+    # Identical to `@template.scan`, except that it increments the line count.
+    # `@template.scan` should never be called directly;
+    # this should be used instead.
+    def scan(re)
+      str = @template.scan(re)
+      @line += str.count "\n" if str
+      str
+    end
+
+    # Identical to `@template.scan_until`, except that it increments the line count.
+    # `@template.scan_until` should never be called directly;
+    # this should be used instead.
+    def scan_until(re)
+      str = @template.scan_until(re)
+      @line += str.count "\n" if str
+      str
     end
 
     # Transform

data/lib/sass/engine.rb

@@ -156,6 +156,8 @@ module Sass
     # @return [Sass::Tree::Node] The root of the parse tree.
     # @raise [Sass::SyntaxError] if there's an error in the document
     def to_tree
+      check_encoding(@template) {|msg, line| raise Sass::SyntaxError.new(msg, :line => line)}
+
       root = Tree::RootNode.new(@template)
       append_children(root, tree(tabulate(@template)).first, true)
       root.options = @options

data/test/haml/engine_test.rb

@@ -1084,6 +1084,24 @@ HAML
         o.render
       end
     end
+
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      render(template)
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
   end
 
   private

data/test/haml/html2haml_test.rb

@@ -90,6 +90,28 @@ HAML
 HTML
   end
 
+  # Encodings
+
+  unless Haml::Util.ruby1_8?
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      render(template)
+      assert(false, "Expected exception")
+    rescue Haml::Error => e
+      assert_equal(3, e.line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
+  end
+
   protected
 
   def render(text, options = {})

data/test/sass/css2sass_test.rb

@@ -230,6 +230,62 @@ SASS
 CSS
   end
 
+  # Error reporting
+
+  def test_error_reporting
+    css2sass("foo")
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => err
+    assert_equal(1, err.sass_line)
+    assert_equal('Invalid CSS after "foo": expected "{", was ""', err.message)
+  end
+
+  def test_error_reporting_in_line
+    css2sass("foo\nbar }\nbaz")
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => err
+    assert_equal(2, err.sass_line)
+    assert_equal('Invalid CSS after "bar ": expected "{", was "}"', err.message)
+  end
+
+  def test_error_truncate_after
+    css2sass("#{"a" * 15}foo")
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => err
+    assert_equal(1, err.sass_line)
+    assert_equal('Invalid CSS after "...aaaaaaaaaaaafoo": expected "{", was ""', err.message)
+  end
+
+  def test_error_truncate_was
+    css2sass("foo }#{"a" * 15}")
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => err
+    assert_equal(1, err.sass_line)
+    assert_equal('Invalid CSS after "foo ": expected "{", was "}aaaaaaaaaaaaaa..."', err.message)
+  end
+
+  # Encodings
+
+  unless Haml::Util.ruby1_8?
+    def test_encoding_error
+      css2sass("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Sass::SyntaxError => e
+      assert_equal(3, e.sass_line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      css2sass(template)
+      assert(false, "Expected exception")
+    rescue Sass::SyntaxError => e
+      assert_equal(3, e.sass_line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
+  end
+
   private
 
   def css2sass(string, opts={})

data/test/sass/engine_test.rb

@@ -901,6 +901,28 @@ a
 SASS
   end
 
+  # Encodings
+
+  unless Haml::Util.ruby1_8?
+    def test_encoding_error
+      render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+      assert(false, "Expected exception")
+    rescue Sass::SyntaxError => e
+      assert_equal(3, e.sass_line)
+      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+    end
+
+    def test_ascii_incompatible_encoding_error
+      template = "foo\nbar\nb_z".encode("utf-16le")
+      template[9] = "\xFE".force_encoding("utf-16le")
+      render(template)
+      assert(false, "Expected exception")
+    rescue Sass::SyntaxError => e
+      assert_equal(3, e.sass_line)
+      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
+    end
+  end
+
   private
   
   def render(sass, options = {})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.3.39
+  version: 2.3.40
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -44,8 +44,8 @@ extensions: []
 
 extra_rdoc_files: 
 - README.md
-- REVISION
 - VERSION
+- REVISION
 - CONTRIBUTING
 - MIT-LICENSE
 - VERSION_NAME
@@ -257,8 +257,8 @@ files:
 - init.rb
 - .yardopts
 - README.md
-- REVISION
 - VERSION
+- REVISION
 - CONTRIBUTING
 - MIT-LICENSE
 - VERSION_NAME