haml-edge 2.3.100 → 2.3.148

data/lib/haml/html.rb

@@ -85,6 +85,7 @@ end
 
 # Haml monkeypatches various Hpricot classes
 # to add methods for conversion to Haml.
+# @private
 module Hpricot
   # @see Hpricot
   module Node
@@ -145,9 +146,11 @@ module Haml
     end
     alias_method :to_haml, :render
 
+    # @private
     TEXT_REGEXP = /^(\s*).*$/
 
     # @see Hpricot
+    # @private
     class ::Hpricot::Doc
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
@@ -156,6 +159,7 @@ module Haml
     end
 
     # @see Hpricot
+    # @private
     class ::Hpricot::XMLDecl
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
@@ -164,6 +168,7 @@ module Haml
     end
 
     # @see Hpricot
+    # @private
     class ::Hpricot::CData
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
@@ -174,16 +179,18 @@ module Haml
     end
 
     # @see Hpricot
+    # @private
     class ::Hpricot::DocType
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
-        attrs = public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
+        attrs = public_id.nil? ? ["", "", ""] :
+          public_id.scan(/DTD\s+([^\s]+)\s*([^\s]*)\s*([^\s]*)\s*\/\//)[0]
         raise Haml::SyntaxError.new("Invalid doctype") if attrs == nil
 
         type, version, strictness = attrs.map { |a| a.downcase }
         if type == "html"
-          version = "1.0"
-          strictness = "transitional"
+          version = ""
+          strictness = "strict" if strictness == ""
         end
 
         if version == "1.0" || version.empty?
@@ -194,7 +201,7 @@ module Haml
           strictness = nil
         end
 
-        version = " #{version}" if version
+        version = " #{version.capitalize}" if version
         strictness = " #{strictness.capitalize}" if strictness
 
         "#{tabulate(tabs)}!!!#{version}#{strictness}\n"
@@ -202,6 +209,7 @@ module Haml
     end
 
     # @see Hpricot
+    # @private
     class ::Hpricot::Comment
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)
@@ -220,6 +228,7 @@ module Haml
     end
 
     # @see Hpricot
+    # @private
     class ::Hpricot::Elem
       # @see Haml::HTML::Node#to_haml
       def to_haml(tabs, options)

data/lib/haml/precompiler.rb

@@ -8,46 +8,60 @@ module Haml
     include Haml::Util
 
     # Designates an XHTML/XML element.
+    # @private
     ELEMENT         = ?%
 
     # Designates a `<div>` element with the given class.
+    # @private
     DIV_CLASS       = ?.
 
     # Designates a `<div>` element with the given id.
+    # @private
     DIV_ID          = ?#
 
     # Designates an XHTML/XML comment.
+    # @private
     COMMENT         = ?/
 
     # Designates an XHTML doctype or script that is never HTML-escaped.
+    # @private
     DOCTYPE         = ?!
 
     # Designates script, the result of which is output.
+    # @private
     SCRIPT          = ?=
 
     # Designates script that is always HTML-escaped.
+    # @private
     SANITIZE        = ?&
 
     # Designates script, the result of which is flattened and output.
+    # @private
     FLAT_SCRIPT     = ?~
 
     # Designates script which is run but not output.
+    # @private
     SILENT_SCRIPT   = ?-
 
     # When following SILENT_SCRIPT, designates a comment that is not output.
+    # @private
     SILENT_COMMENT  = ?#
 
     # Designates a non-parsed line.
+    # @private
     ESCAPE          = ?\\
 
     # Designates a block of filtered text.
+    # @private
     FILTER          = ?:
 
     # Designates a non-parsed line. Not actually a character.
+    # @private
     PLAIN_TEXT      = -1
 
     # Keeps track of the ASCII values of the characters that begin a
     # specially-interpreted line.
+    # @private
     SPECIAL_CHARACTERS   = [
       ELEMENT,
       DIV_CLASS,
@@ -64,6 +78,7 @@ module Haml
 
     # The value of the character that designates that a line is part
     # of a multiline string.
+    # @private
     MULTILINE_CHAR_VALUE = ?|
 
     # Regex to match keywords that appear in the middle of a Ruby block
@@ -79,12 +94,15 @@ module Haml
     #
     # The block is ended after `%p no!`, because `else`
     # is a member of this array.
+    # @private
     MID_BLOCK_KEYWORD_REGEX = /^-\s*(#{%w[else elsif rescue ensure when end].join('|')})\b/
 
     # The Regex that matches a Doctype command.
+    # @private
     DOCTYPE_REGEX = /(\d(?:\.\d)?)?[\s]*([a-z]*)/i
 
     # The Regex that matches a literal string or symbol value
+    # @private
     LITERAL_VALUE_REGEX = /:(\w*)|(["'])((?![\\#]|\2).|\\.)*\2/
 
     private
@@ -124,6 +142,7 @@ END
       end.join(';') + ';'
     end
 
+    # @private
     class Line < Struct.new(:text, :unstripped, :full, :index, :precompiler, :eod)
       alias_method :eod?, :eod
 
@@ -480,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
@@ -663,7 +684,7 @@ END
         return name, [:dynamic, var]
       end
 
-      re = /((?:\\.|\#[^{]|[^#{quote}\\#])*#?)(#{quote}|#\{)/
+      re = /((?:\\.|\#(?!\{)|[^#{quote}\\#])*)(#{quote}|#\{)/
       content = []
       loop do
         return false unless scanner.scan(re)
@@ -733,7 +754,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)

data/lib/haml/template/plugin.rb

@@ -2,8 +2,11 @@
 # using the > 2.0.1 template handler API.
 
 module Haml
-  class Plugin < ActionView::TemplateHandler
-    include ActionView::TemplateHandlers::Compilable if defined?(ActionView::TemplateHandlers::Compilable)
+  class Plugin < Haml::Util.av_template_class(:Handler)
+    if defined?(ActionView::TemplateHandlers::Compilable) ||
+        defined?(ActionView::Template::Handlers::Compilable)
+      include Haml::Util.av_template_class(:Handlers)::Compilable
+    end
 
     def compile(template)
       options = Haml::Template.options.dup
@@ -38,7 +41,8 @@ end.register_template_handler(:haml, Haml::Plugin)
 # In Rails 2.0.2, ActionView::TemplateError took arguments
 # that we can't fill in from the Haml::Plugin context.
 # Thus, we've got to monkeypatch ActionView::Base to catch the error.
-if ActionView::TemplateError.instance_method(:initialize).arity == 5
+if defined?(ActionView::TemplateError) &&
+    ActionView::TemplateError.instance_method(:initialize).arity == 5
   class ActionView::Base
     def compile_template(handler, template, file_name, local_assigns)
       render_symbol = assign_method_name(handler, template, file_name)

data/lib/haml/template.rb

@@ -28,7 +28,7 @@ module Haml
 
       Haml::Precompiler.module_eval do
         def precompiled_method_return_value_with_haml_xss
-          "(#{precompiled_method_return_value_without_haml_xss}).html_safe!"
+          "::Haml::Util.html_safe(#{precompiled_method_return_value_without_haml_xss})"
         end
         alias_method :precompiled_method_return_value_without_haml_xss, :precompiled_method_return_value
         alias_method :precompiled_method_return_value, :precompiled_method_return_value_with_haml_xss
@@ -39,14 +39,14 @@ module Haml
   end
 end
 
-if defined?(RAILS_ENV) && RAILS_ENV == "production"
+if Haml::Util.rails_env == "production"
   Haml::Template.options[:ugly] = true
 end
 
 # Decide how we want to load Haml into Rails.
 # Patching was necessary for versions <= 2.0.1,
 # but we can make it a normal handler for higher versions.
-if defined?(ActionView::TemplateHandler)
+if defined?(ActionView::TemplateHandler) || defined?(ActionView::Template::Handler)
   require 'haml/template/plugin'
 else
   require 'haml/template/patch'

data/lib/haml/util.rb

@@ -168,6 +168,30 @@ module Haml
       return nil
     end
 
+    # Returns the environment of the Rails application,
+    # if this is running in a Rails context.
+    # Returns `nil` if no such environment is defined.
+    #
+    # @return [String, nil]
+    def rails_env
+      return Rails.env.to_s if defined?(Rails.root)
+      return RAILS_ENV.to_s if defined?(RAILS_ENV)
+      return nil
+    end
+
+    # Returns an ActionView::Template* class.
+    # In pre-3.0 versions of Rails, most of these classes
+    # were of the form `ActionView::TemplateFoo`,
+    # while afterwards they were of the form `ActionView;:Template::Foo`.
+    #
+    # @param name [#to_s] The name of the class to get.
+    #   For example, `:Error` will return `ActionView::TemplateError`
+    #   or `ActionView::Template::Error`.
+    def av_template_class(name)
+      return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
+      return ActionView::Template.const_get(name.to_s)
+    end
+
     ## Rails XSS Safety
 
     # Whether or not ActionView's XSS protection is available and enabled,
@@ -179,6 +203,17 @@ module Haml
       false
     end
 
+    # Returns the given text, marked as being HTML-safe.
+    # With older versions of the Rails XSS-safety mechanism,
+    # this destructively modifies the HTML-safety of `text`.
+    #
+    # @param text [String]
+    # @return [String] `text`, marked as HTML-safe
+    def html_safe(text)
+      return text.html_safe if defined?(ActiveSupport::SafeBuffer)
+      text.html_safe!
+    end
+
     # Assert that a given object (usually a String) is HTML safe
     # according to Rails' XSS handling, if it's loaded.
     #
@@ -188,6 +223,11 @@ module Haml
       raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
     end
 
+    def rails_safe_buffer_class
+      return ActionView::SafeBuffer if defined?(ActionView::SafeBuffer)
+      ActiveSupport::SafeBuffer
+    end
+
     ## Cross-Ruby-Version Compatibility
 
     # Whether or not this is running under Ruby 1.8 or lower.

data/lib/sass/callbacks.rb

@@ -0,0 +1,50 @@
+# A lightweight infrastructure for defining and running callbacks.
+# Callbacks are defined using \{#define\_callback\} at the class level,
+# and called using `run_#{name}` at the instance level.
+#
+# Clients can add callbacks by calling the generated `on_#{name}` method,
+# and passing in a block that's run when the callback is activated.
+#
+# @example Define a callback
+# class Munger
+#   extend Sass::Callbacks
+#   define_callback :string_munged
+#
+#   def munge(str)
+#     res = str.gsub(/[a-z]/, '\1\1')
+#     run_string_munged str, res
+#     res
+#   end
+# end
+#
+# @example Use a callback
+# m = Munger.new
+# m.on_string_munged {|str, res| puts "#{str} was munged into #{res}!"}
+# m.munge "bar" #=> bar was munged into bbaarr!
+module Sass::Callbacks
+  protected
+
+  # Define a callback with the given name.
+  # This will define an `on_#{name}` method
+  # that registers a block,
+  # and a `run_#{name}` method that runs that block
+  # (optionall with some arguments).
+  #
+  # @param name [Symbol] The name of the callback
+  # @return [void]
+  def define_callback(name)
+    class_eval <<RUBY
+def on_#{name}(&block)
+  @_sass_callbacks ||= {}
+  (@_sass_callbacks[#{name.inspect}] ||= []) << block
+end
+
+def run_#{name}(*args)
+  return unless @_sass_callbacks
+  return unless @_sass_callbacks[#{name.inspect}]
+  @_sass_callbacks[#{name.inspect}].each {|c| c[*args]}
+end
+private :run_#{name}
+RUBY
+  end
+end

data/lib/sass/css.rb

@@ -100,7 +100,7 @@ module Sass
     #
     # @return [Tree::Node] The root node of the parsed tree
     def build_tree
-      root = Tree::Node.new
+      root = Tree::RootNode.new(@template.string)
       whitespace
       rules              root
       expand_commas      root

data/lib/sass/engine.rb

@@ -77,45 +77,57 @@ module Sass
     end
 
     # The character that begins a CSS property.
+    # @private
     PROPERTY_CHAR  = ?:
 
     # The character that designates that
     # a property should be assigned to a SassScript expression.
+    # @private
     SCRIPT_CHAR     = ?=
 
     # The character that designates the beginning of a comment,
     # either Sass or CSS.
+    # @private
     COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a Sass comment,
     # which is not output as a CSS comment.
+    # @private
     SASS_COMMENT_CHAR = ?/
 
     # The character that follows the general COMMENT_CHAR and designates a CSS comment,
     # which is embedded in the CSS document.
+    # @private
     CSS_COMMENT_CHAR = ?*
 
     # The character used to denote a compiler directive.
+    # @private
     DIRECTIVE_CHAR = ?@
 
     # Designates a non-parsed rule.
+    # @private
     ESCAPE_CHAR    = ?\\
 
     # Designates block as mixin definition rather than CSS rules to output
+    # @private
     MIXIN_DEFINITION_CHAR = ?=
 
     # Includes named mixin declared using MIXIN_DEFINITION_CHAR
+    # @private
     MIXIN_INCLUDE_CHAR    = ?+
 
     # The regex that matches properties of the form `name: prop`.
+    # @private
     PROPERTY_NEW_MATCHER = /^[^\s:"\[]+\s*[=:](\s|$)/
 
     # The regex that matches and extracts data from
     # properties of the form `name: prop`.
+    # @private
     PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
 
     # The regex that matches and extracts data from
     # properties of the form `:name prop`.
+    # @private
     PROPERTY_OLD = /^:([^\s=:"]+)\s*(=?)(?:\s+|$)(.*)/
 
     # The default options for Sass::Engine.
@@ -130,9 +142,13 @@ module Sass
     # @param options [{Symbol => Object}] An options hash;
     #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
     def initialize(template, options={})
-      @options = DEFAULT_OPTIONS.merge(options)
+      @options = DEFAULT_OPTIONS.merge(options.reject {|k, v| v.nil?})
       @template = template
 
+      # Support both, because the docs said one and the other actually worked
+      # for quite a long time.
+      @options[:line_comments] ||= @options[:line_numbers]
+
       # Backwards compatibility
       @options[:property_syntax] ||= @options[:attribute_syntax]
       case @options[:property_syntax]
@@ -172,6 +188,7 @@ module Sass
 
     def tabulate(string)
       tab_str = nil
+      comment_tab_str = nil
       first = true
       lines = []
       string.gsub(/\r|\n|\r\n|\r\n/, "\n").scan(/^.*?$/).each_with_index do |line, index|
@@ -183,6 +200,12 @@ module Sass
 
         line_tab_str = line[/^\s*/]
         unless line_tab_str.empty?
+          if tab_str.nil?
+            comment_tab_str ||= line_tab_str
+            next if try_comment(line, lines.last, "", comment_tab_str, index)
+            comment_tab_str = nil
+          end
+
           tab_str ||= line_tab_str
 
           raise SyntaxError.new("Indenting at the beginning of the document is illegal.",
@@ -197,9 +220,11 @@ module Sass
           next
         end
 
-        if lines.last && lines.last.comment? && line =~ /^(?:#{tab_str}){#{lines.last.tabs + 1}}(.*)$/
-          lines.last.text << "\n" << $1
+        comment_tab_str ||= line_tab_str
+        if try_comment(line, lines.last, tab_str * (lines.last.tabs + 1), comment_tab_str, index)
           next
+        else
+          comment_tab_str = nil
         end
 
         line_tabs = line_tab_str.scan(tab_str).size
@@ -216,6 +241,21 @@ END
       lines
     end
 
+    def try_comment(line, last, tab_str, comment_tab_str, index)
+      return unless last && last.comment?
+      return unless line =~ /^#{tab_str}/
+      unless line =~ /^(?:#{comment_tab_str})(.*)$/
+        raise SyntaxError.new(<<MSG.strip.gsub("\n", " "), :line => index)
+Inconsistent indentation:
+previous line was indented by #{Haml::Shared.human_indentation comment_tab_str},
+but this line was indented by #{Haml::Shared.human_indentation line[/^\s*/]}.
+MSG
+      end
+
+      last.text << "\n" << $1
+      true
+    end
+
     def tree(arr, i = 0)
       return [], i if arr[i].nil?
 
@@ -313,11 +353,11 @@ END
     def check_for_no_children(node)
       return unless node.is_a?(Tree::RuleNode) && node.children.empty?
       warning = (node.rules.size == 1) ? <<SHORT : <<LONG
-WARNING on line #{node.line}:
+WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
 Selector #{node.rules.first.inspect} doesn't have any properties and will not be rendered.
 SHORT
 
-WARNING on line #{node.line}:
+WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
 Selector
   #{node.rules.join("\n  ")}
 doesn't have any properties and will not be rendered.

data/lib/sass/error.rb

@@ -149,10 +149,13 @@ module Sass
       # Returns an error report for an exception in CSS format.
       #
       # @param e [Exception]
-      # @param full_exception [Boolean] The value of
-      #   \{file:SASS\_REFERENCE.md#full_exception-option `options[:full_exception]`}
+      # @param options [{Symbol => Object}] The options passed to {Sass::Engine#initialize}
+      # @return [String] The error report
+      # @raise [Exception] `e`, if the
+      #   {file:SASS_REFERENCE.md#full_exception-option `:full_exception`} option
+      #   is set to false.
       def exception_to_css(e, options)
-        return "/* Internal stylesheet error */" unless options[:full_exception]
+        raise e unless options[:full_exception]
 
         header = header_string(e, options)
 

data/lib/sass/files.rb

@@ -71,7 +71,14 @@ module Sass
       new_filename = find_full_path("#{filename}.sass", load_paths)
 
       return new_filename if new_filename
-      return filename + '.css' unless was_sass
+      unless was_sass
+        warn <<END
+WARNING: #{filename}.sass not found. Using #{filename}.css instead.
+This behavior is deprecated and will be removed in a future version.
+If you really need #{filename}.css, import it explicitly.
+END
+        return filename + '.css'
+      end
       raise SyntaxError.new("File to import not found or unreadable: #{original_filename}.")
     end
 

data/lib/sass/plugin/rails.rb

@@ -4,8 +4,8 @@ unless defined?(Sass::RAILS_LOADED)
   Sass::Plugin.options.merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
                               :css_location      => Haml::Util.rails_root + '/public/stylesheets',
                               :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
-                              :always_check      => RAILS_ENV != "production",
-                              :full_exception    => RAILS_ENV != "production")
+                              :always_check      => Haml::Util.rails_env != "production",
+                              :full_exception    => Haml::Util.rails_env != "production")
 
   if defined?(Rails.configuration.middleware)
     # Rails >= 3.0