haml 2.2.24 → 3.0.0.beta.1

data/lib/haml/html/erb.rb

@@ -0,0 +1,141 @@
+require 'cgi'
+require 'erubis'
+require 'ruby_parser'
+
+module Haml
+  class HTML
+    # A class for converting ERB code into a format that's easier
+    # for the {Haml::HTML} Hpricot-based parser to understand.
+    #
+    # Uses [Erubis](http://www.kuwata-lab.com/erubis)'s extensible parsing powers
+    # to parse the ERB in a reliable way,
+    # and [ruby_parser](http://parsetree.rubyforge.org/)'s Ruby knowledge
+    # to figure out whether a given chunk of Ruby code starts a block or not.
+    #
+    # The ERB tags are converted to HTML tags in the following way.
+    # `<% ... %>` is converted into `<haml:silent> ... </haml:silent>`.
+    # `<%= ... %>` is converted into `<haml:loud> ... </haml:loud>`.
+    # Finally, if either of these opens a Ruby block,
+    # `<haml:block> ... </haml:block>` will wrap the entire contents of the block -
+    # that is, everything that should be indented beneath the previous silent or loud tag.
+    class ERB < Erubis::Basic::Engine
+      # Compiles an ERB template into a HTML document containing `haml:` tags.
+      #
+      # @param template [String] The ERB template
+      # @return [String] The output document
+      # @see Haml::HTML::ERB
+      def self.compile(template)
+        new(template).src
+      end
+
+      # `html2haml` doesn't support HTML-escaped expressions.
+      def escaped_expr(code)
+        raise Haml::Error.new("html2haml doesn't support escaped expressions.")
+      end
+
+      # The ERB-to-Hamlized-HTML conversion has no preamble.
+      def add_preamble(src); end
+
+      # The ERB-to-Hamlized-HTML conversion has no postamble.
+      def add_postamble(src); end
+
+      # Concatenates the text onto the source buffer.
+      #
+      # @param src [String] The source buffer
+      # @param text [String] The raw text to add to the buffer
+      def add_text(src, text)
+        src << text
+      end
+
+      # Concatenates a silent Ruby statement onto the source buffer.
+      # This uses the `<haml:silent>` tag,
+      # and may close and/or open a Ruby block with the `<haml:block>` tag.
+      #
+      # In particular, a block is closed if this statement is some form of `end`,
+      # opened if it's a block opener like `do`, `if`, or `begin`,
+      # and both closed and opened if it's a mid-block keyword
+      # like `else` or `when`.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby statement to add to the buffer
+      def add_stmt(src, code)
+        src << '</haml:block>' if block_closer?(code) || mid_block?(code)
+        src << '<haml:silent>' << h(code) << '</haml:silent>' unless code.strip == "end"
+        src << '<haml:block>' if block_opener?(code) || mid_block?(code)
+      end
+
+      # Concatenates a Ruby expression that's printed to the document
+      # onto the source buffer.
+      # This uses the `<haml:silent>` tag,
+      # and may open a Ruby block with the `<haml:block>` tag.
+      # An expression never closes a block.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby expression to add to the buffer
+      def add_expr_literal(src, code)
+        src << '<haml:loud>' << h(code) << '</haml:loud>'
+        src << '<haml:block>' if block_opener?(code)
+      end
+
+      # `html2haml` doesn't support debugging expressions.
+      def add_expr_debug(src, code)
+        raise Haml::Error.new("html2haml doesn't support debugging expressions.")
+      end
+
+      private
+
+      # HTML-escaped some text (in practice, always Ruby code).
+      # A utility method.
+      #
+      # @param text [String] The text to escape
+      # @return [String] The escaped text
+      def h(text)
+        CGI.escapeHTML(text)
+      end
+
+      # Returns whether the code is valid Ruby code on its own.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def valid_ruby?(code)
+        RubyParser.new.parse(code)
+      rescue Racc::ParseError => e
+        false
+      end
+
+      # Checks if a string of Ruby code opens a block.
+      # This could either be something like `foo do |a|`
+      # or a keyword that requires a matching `end`
+      # like `if`, `begin`, or `case`.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_opener?(code)
+        valid_ruby?(code + "\nend") ||
+          valid_ruby?(code + "\nwhen foo\nend")
+      end
+
+      # Checks if a string of Ruby code closes a block.
+      # This is always `end` followed optionally by some method calls.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_closer?(code)
+        valid_ruby?("begin\n" + code)
+      end
+
+      # Checks if a string of Ruby code comes in the middle of a block.
+      # This could be a keyword like `else`, `rescue`, or `when`,
+      # or even `end` with a method call that takes a block.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def mid_block?(code)
+        return if valid_ruby?(code)
+        valid_ruby?("if foo\n#{code}\nend") || # else, elsif
+          valid_ruby?("begin\n#{code}\nend") || # rescue, ensure
+          valid_ruby?("case foo\n#{code}\nend") # when
+      end
+    end
+  end
+end

data/lib/haml/precompiler.rb

@@ -146,7 +146,6 @@ END
     class Line < Struct.new(:text, :unstripped, :full, :index, :precompiler, :eod)
       alias_method :eod?, :eod
 
-      # @private
       def tabs
         line = self
         @tabs ||= precompiler.instance_eval do
@@ -332,15 +331,23 @@ END
     def flush_merged_text
       return if @to_merge.empty?
 
-      text, tab_change = @to_merge.inject(["", 0]) do |(str, mtabs), (type, val, tabs)|
+      str = ""
+      mtabs = 0
+      newlines = 0
+      @to_merge.each do |type, val, tabs|
         case type
         when :text
-          [str << val.inspect[1...-1], mtabs + tabs]
+          str << val.inspect[1...-1]
+          mtabs += tabs
         when :script
           if mtabs != 0 && !@options[:ugly]
             val = "_hamlout.adjust_tabs(#{mtabs}); " + val
           end
-          [str << "\#{#{val}}", 0]
+          str << "\#{#{"\n" * newlines}#{val}}"
+          mtabs = 0
+          newlines = 0
+        when :newlines
+          newlines += val
         else
           raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Precompiler@to_merge.")
         end
@@ -348,10 +355,11 @@ END
 
       @precompiled <<
         if @options[:ugly]
-          "_hamlout.buffer << \"#{text}\";"
+          "_hamlout.buffer << \"#{str}\";"
         else
-          "_hamlout.push_text(\"#{text}\", #{tab_change}, #{@dont_tab_up_next_text.inspect});"
+          "_hamlout.push_text(\"#{str}\", #{mtabs}, #{@dont_tab_up_next_text.inspect});"
         end
+      @precompiled << "\n" * newlines
       @to_merge = []
       @dont_tab_up_next_text = false
     end
@@ -396,14 +404,14 @@ END
 
       no_format = @options[:ugly] &&
         !(opts[:preserve_script] || opts[:preserve_tag] || opts[:escape_html])
-      output_temp = "(haml_very_temp = haml_temp; haml_temp = nil; haml_very_temp)"
-      out = "_hamlout.#{static_method_name(:format_script, *args)}(#{output_temp});"
+      output_expr = "(#{text}\n)"
+      static_method = "_hamlout.#{static_method_name(:format_script, *args)}"
 
       # Prerender tabulation unless we're in a tag
       push_merged_text '' unless opts[:in_tag]
 
       unless block_opened?
-        @to_merge << [:script, no_format ? "#{text}\n" : "haml_temp = #{text}\n#{out}"]
+        @to_merge << [:script, no_format ? "#{text}\n" : "#{static_method}(#{output_expr});"]
         concat_merged_text("\n") unless opts[:in_tag] || opts[:nuke_inner_whitespace]
         @newlines -= 1
         return
@@ -413,7 +421,7 @@ END
 
       push_silent "haml_temp = #{text}"
       newline_now
-      push_and_tabulate([:loud, "_hamlout.buffer << #{no_format ? "#{output_temp}.to_s;" : out}",
+      push_and_tabulate([:loud, "_hamlout.buffer << #{no_format ? "haml_temp.to_s;" : "#{static_method}(haml_temp);"}",
         !(opts[:in_tag] || opts[:nuke_inner_whitespace] || @options[:ugly])])
     end
 
@@ -491,10 +499,12 @@ END
       @template_tabs -= 1
     end
 
+    # This is a class method so it can be accessed from {Haml::Helpers}.
+    #
     # Iterates through the classes and ids supplied through `.`
     # and `#` syntax, and returns a hash with them as attributes,
     # that can then be merged with another attributes hash.
-    def parse_class_and_id(list)
+    def self.parse_class_and_id(list)
       attributes = {}
       list.scan(/([#.])([-_a-zA-Z0-9]+)/) do |type, property|
         case type
@@ -531,9 +541,18 @@ END
       quote_escape = attr_wrapper == '"' ? "&quot;" : "&apos;"
       other_quote_char = attr_wrapper == '"' ? "'" : '"'
 
+      if attributes['data'].is_a?(Hash)
+        attributes = attributes.dup
+        attributes =
+          Haml::Util.map_keys(attributes.delete('data')) {|name| "data-#{name}"}.merge(attributes)
+      end
+
       result = attributes.collect do |attr, value|
         next if value.nil?
 
+        value = filter_and_join(value, ' ') if attr == :class
+        value = filter_and_join(value, '_') if attr == :id
+
         if value == true
           next " #{attr}" if is_html
           next " #{attr}=#{attr_wrapper}#{attr}#{attr_wrapper}"
@@ -557,6 +576,11 @@ END
       result.compact.sort.join
     end
 
+    def self.filter_and_join(value, separator)
+      value = [value] unless value.is_a?(Array)
+      return value.flatten.collect {|item| item ? item.to_s : nil}.compact.join(separator)
+    end
+
     def prerender_tag(name, self_close, attributes)
       attributes_string = Precompiler.build_attributes(html?, @options[:attr_wrapper], attributes)
       "<#{name}#{attributes_string}#{self_close && xhtml? ? ' /' : ''}>"
@@ -744,7 +768,7 @@ END
 
       object_ref = "nil" if object_ref.nil? || @options[:suppress_eval]
 
-      attributes = parse_class_and_id(attributes)
+      attributes = Precompiler.parse_class_and_id(attributes)
       attributes_hashes.map! do |syntax, attributes_hash|
         if syntax == :old
           static_attributes = parse_static_hash(attributes_hash)
@@ -761,7 +785,7 @@ END
       raise SyntaxError.new("There's no Ruby code for #{action} to evaluate.", last_line - 1) if parse && value.empty?
       raise SyntaxError.new("Self-closing tags can't have content.", last_line - 1) if self_closing && !value.empty?
 
-      self_closing ||= !!( !block_opened? && value.empty? && @options[:autoclose].include?(tag_name) )
+      self_closing ||= !!(!block_opened? && value.empty? && @options[:autoclose].any? {|t| t === tag_name})
       value = nil if value.empty? && (block_opened? || self_closing)
 
       dont_indent_next_line =
@@ -1030,8 +1054,7 @@ END
 
     def resolve_newlines
       return unless @newlines > 0
-      flush_merged_text unless @to_merge.all? {|type, *_| type == :text}
-      @precompiled << "\n" * @newlines
+      @to_merge << [:newlines, @newlines]
       @newlines = 0
     end
 
@@ -1055,6 +1078,8 @@ END
       when :script
         last[1].gsub!(/\(haml_temp, (.*?)\);$/, '(haml_temp.rstrip, \1);')
         rstrip_buffer! index - 1
+      when :newlines
+        rstrip_buffer! index - 1
       else
         raise SyntaxError.new("[HAML BUG] Undefined entry in Haml::Precompiler@to_merge.")
       end

data/lib/haml/railtie.rb

@@ -3,11 +3,7 @@
 # Yehuda promises there will be soon,
 # and once there is we should switch to that.
 
-if defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load)
-  # Rails 3.0.0.beta.2+
-  ActiveSupport.on_load(:action_view) {Haml.init_rails(binding)}
-elsif defined?(Rails::Railtie)
-  # Rails 3.0.0.beta1
+if defined?(Rails::Railtie)
   module Haml
     class Railtie < Rails::Railtie
       initializer :haml do

data/lib/haml/root.rb

@@ -0,0 +1,3 @@
+module Haml
+  ROOT_DIR = File.expand_path("../../..", __FILE__)
+end

data/lib/haml/template.rb

@@ -1,6 +1,4 @@
 require 'haml/engine'
-require 'haml/helpers/action_view_mods'
-require 'haml/helpers/action_view_extensions'
 
 module Haml
   # The class that keeps track of the global options for Haml within Rails.
@@ -19,11 +17,7 @@ module Haml
     #
     # @return [Boolean] Whether the XSS integration was enabled.
     def try_enabling_xss_integration
-      return false unless (ActionView::Base.respond_to?(:xss_safe?) && ActionView::Base.xss_safe?) ||
-        # We check for ActiveSupport#on_load here because if we're loading Haml that way, it means:
-        # A) we're in Rails 3 so XSS support is always on, and
-        # B) we might be in Rails 3 beta 3 where the load order is broken and xss_safe? is undefined
-        (defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
+      return false unless ActionView::Base.respond_to?(:xss_safe?) && ActionView::Base.xss_safe?
 
       Haml::Template.options[:escape_html] = true
 
@@ -59,14 +53,10 @@ else
   require 'haml/template/patch'
 end
 
-# Enable XSS integration. Use Rails' after_initialize method
+# Enable XSS integration. Use Rails' after_initialize method if possible
 # so that integration will be checked after the rails_xss plugin is loaded
 # (for Rails 2.3.* where it's not enabled by default).
-#
-# If we're running under Rails 3, though, we don't want to use after_intialize,
-# since Haml loading has already been deferred via ActiveSupport.on_load.
-if defined?(Rails.configuration.after_initialize) &&
-    !(defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
+if defined?(Rails.configuration.after_initialize)
   Rails.configuration.after_initialize {Haml::Template.try_enabling_xss_integration}
 else
   Haml::Template.try_enabling_xss_integration
@@ -87,7 +77,7 @@ if Haml::Util.rails_root
       FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
     end
   rescue SystemCallError
-    warn <<END
+    Haml::Util.haml_warn <<END
 HAML WARNING:
 #{rails_init_file} is out of date and couldn't be automatically updated.
 Please run `haml --rails #{File.expand_path(Haml::Util.rails_root)}' to update it.

data/lib/haml/util.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'set'
 require 'enumerator'
 require 'stringio'
+require 'haml/root'
 
 module Haml
   # A module containing various useful functions.
@@ -16,7 +17,7 @@ module Haml
     # @param file [String] The filename relative to the Haml root
     # @return [String] The filename relative to the the working directory
     def scope(file)
-      File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
+      File.join(Haml::ROOT_DIR, file)
     end
 
     # Converts an array of `[key, value]` pairs to a hash.
@@ -103,6 +104,17 @@ module Haml
       end
     end
 
+    # Restricts a number to falling within a given range.
+    # Returns the number if it falls within the range,
+    # or the closest value in the range if it doesn't.
+    #
+    # @param value [Numeric]
+    # @param range [Range<Numeric>]
+    # @return [Numeric]
+    def restrict(value, range)
+      [[value, range.first].max, range.last].min
+    end
+
     # Concatenates all strings that are adjacent in an array,
     # while leaving other elements as they are.
     # For example:
@@ -123,6 +135,29 @@ module Haml
       end
     end
 
+    # Destructively strips whitespace from the beginning and end
+    # of the first and last elements, respectively,
+    # in the array (if those elements are strings).
+    #
+    # @param arr [Array]
+    # @return [Array] `arr`
+    def strip_string_array(arr)
+      arr.first.lstrip! if arr.first.is_a?(String)
+      arr.last.rstrip! if arr.last.is_a?(String)
+      arr
+    end
+
+    # Returns information about the caller of the previous method.
+    #
+    # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
+    # @return [[String, Fixnum, (String, nil)]] An array containing the filename, line, and method name of the caller.
+    #   The method name may be nil
+    def caller_info(entry = caller[1])
+      info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
+      info[1] = info[1].to_i
+      info
+    end
+
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -133,6 +168,26 @@ module Haml
       $stderr = the_real_stderr
     end
 
+    @@silence_warnings = false
+    # Silences all Haml warnings within a block.
+    #
+    # @yield A block in which no Haml warnings will be printed
+    def silence_haml_warnings
+      old_silence_warnings = @@silence_warnings
+      @@silence_warnings = true
+      yield
+    ensure
+      @@silence_warnings = old_silence_warnings
+    end
+
+    # The same as `Kernel#warn`, but is silenced by \{#silence\_haml\_warnings}.
+    #
+    # @param msg [String]
+    def haml_warn(msg)
+      return if @@silence_warnings
+      warn(msg)
+    end
+
     ## Cross Rails Version Compatibility
 
     # Returns the root of the Rails application,
@@ -182,30 +237,6 @@ module Haml
           ActionPack::VERSION::TINY == "0.beta")
     end
 
-    # Returns whether this environment is using ActionPack
-    # version 3.0.0.beta.3 or greater.
-    #
-    # @return [Boolean]
-    def ap_geq_3_beta_3?
-      # The ActionPack module is always loaded automatically in Rails >= 3
-      return false unless defined?(ActionPack) && defined?(ActionPack::VERSION)
-
-      version =
-        if defined?(ActionPack::VERSION::MAJOR)
-          ActionPack::VERSION::MAJOR
-        else
-          # Rails 1.2
-          ActionPack::VERSION::Major
-        end
-      version >= 3 &&
-        ((defined?(ActionPack::VERSION::TINY) &&
-          ActionPack::VERSION::TINY.is_a?(Fixnum) &&
-          ActionPack::VERSION::TINY >= 1) ||
-         (defined?(ActionPack::VERSION::BUILD) &&
-          ActionPack::VERSION::BUILD =~ /beta(\d+)/ &&
-          $1.to_i >= 3))
-    end
-
     # Returns an ActionView::Template* class.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -251,10 +282,6 @@ module Haml
       raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
     end
 
-    # The class for the Rails SafeBuffer XSS protection class.
-    # This varies depending on Rails version.
-    #
-    # @return [Class]
     def rails_safe_buffer_class
       return ActionView::SafeBuffer if defined?(ActionView::SafeBuffer)
       ActiveSupport::SafeBuffer
@@ -269,6 +296,42 @@ module Haml
       Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
     end
 
+    # Checks that the encoding of a string is valid in Ruby 1.9
+    # and cleans up potential encoding gotchas like the UTF-8 BOM.
+    # If it's not, yields an error string describing the invalid character
+    # and the line on which it occurrs.
+    #
+    # @param str [String] The string of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
+    # @return [String] `str`, potentially with encoding gotchas like BOMs removed
+    def check_encoding(str)
+      if ruby1_8?
+        return str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
+      elsif str.valid_encoding?
+        # Get rid of the Unicode BOM if possible
+        if str.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?$/
+          return str.gsub(Regexp.new("\\A\uFEFF".encode(str.encoding.name)), '')
+        else
+          return str
+        end
+      end
+
+      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
+      return str
+    end
+
     # Checks to see if a class has a given method.
     # For example:
     #
@@ -295,6 +358,32 @@ module Haml
       ruby1_8? ? enum.enum_with_index : enum.each_with_index
     end
 
+    # A version of `Enumerable#enum_cons` that works in Ruby 1.8 and 1.9.
+    #
+    # @param enum [Enumerable] The enumerable to get the enumerator for
+    # @param n [Fixnum] The size of each cons
+    # @return [Enumerator] The consed enumerator
+    def enum_cons(enum, n)
+      ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
+    end
+
+    # A version of `Enumerable#enum_slice` that works in Ruby 1.8 and 1.9.
+    #
+    # @param enum [Enumerable] The enumerable to get the enumerator for
+    # @param n [Fixnum] The size of each slice
+    # @return [Enumerator] The consed enumerator
+    def enum_slice(enum, n)
+      ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
+    end
+
+    # Returns the ASCII code of the given character.
+    #
+    # @param c [String] All characters but the first are ignored.
+    # @return [Fixnum] The ASCII code of `c`.
+    def ord(c)
+      ruby1_8? ? c[0] : c.ord
+    end
+
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.
@@ -348,9 +437,10 @@ module Haml
     # @param erb [String] The template for the method code
     def def_static_method(klass, name, args, *vars)
       erb = vars.pop
+      info = caller_info
       powerset(vars).each do |set|
         context = StaticConditionalContext.new(set).instance_eval {binding}
-        klass.class_eval(<<METHOD)
+        klass.class_eval(<<METHOD, info[0], info[1])
 def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
   #{ERB.new(erb).result(context)}
 end