haml 1.7.2 → 1.8.0

data/lib/haml/template.rb

@@ -4,24 +4,7 @@ require 'active_support'
 require 'action_view'
 
 module Haml
-  # This class interfaces with ActionView
-  # to make Haml usable as a Ruby on Rails plugin.
-  # It usually shouldn't need to be used by end users.
-  # Just in case, though, here's what you might do to render
-  # <tt>templates/index.haml</tt>:
-  #
-  #   ActionView::Base.register_template_handler("haml", Haml::Template)
-  #   base = ActionView::Base.new("templates")
-  #   base.render("index")
-  #
-  # Or, if you want to really get into the nitty-gritty:
-  #
-  #   base = ActionView::Base.new
-  #   template = Haml::Template.new(base)
-  #   template.render("templates/index.haml")
-  #
   class Template
-
     class << self
       @@options = {}
 
@@ -35,65 +18,29 @@ module Haml
         @@options = value
       end
     end
-
-    # Creates a new Haml::Template object that uses <tt>view</tt>
-    # to render its templates.
-    def initialize(view)
-      @view = view
-    end
-
-    # Renders the file at the location <tt>template</tt>,
-    # with <tt>local_assigns</tt> available as local variables within the template.
-    # Returns the result as a string.
-    def render(template, local_assigns={})
-      @view.instance_eval do
-        evaluate_assigns
-      end
-
-      options = @@options.dup
-      locals = options[:locals] || {}
-      locals.merge! local_assigns
-      options[:locals] = locals
-
-      if @view.haml_inline
-        engine = Haml::Engine.new(template, options)
-      else
-        options[:filename] ||= template
-        engine = Haml::Engine.new(File.read(template), options)
-      end
-
-      yield_proc = @view.instance_eval do
-        proc { |*name| instance_variable_get("@content_for_#{name.first || 'layout'}") }
-      end
-
-      engine.to_html(@view) { |*args| yield_proc.call(*args) }
-
-    end
   end
 end
 
-# This module refers to the ActionView module that's part of Ruby on Rails.
-# Haml can be used as an alternate templating engine for it,
-# and includes several modifications to make it more Haml-friendly.
-# The documentation can be found
-# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
-module ActionView
-  class Base # :nodoc:
-    attr :haml_inline
-
-    alias_method :read_template_file_old, :read_template_file
-    def read_template_file(template_path, extension)
-      if extension =~ /haml/i
-        template_path
-      else
-        read_template_file_old(template_path, extension)
-      end
-    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)
+  require 'haml/template/plugin'
+else
+  require 'haml/template/patch'
+end
 
-    alias_method :render_template_old, :render_template
-    def render_template(template_extension, template, file_path = nil, local_assigns = {})
-      @haml_inline = !template.nil?
-      render_template_old(template_extension, template, file_path, local_assigns)
-    end
+if defined?(RAILS_ROOT)
+  # Update init.rb to the current version
+  # if it's out of date.
+  #
+  # We can probably remove this as of v1.9,
+  # because the new init file is sufficiently flexible
+  # to not need updating.
+  rails_init_file = File.join(RAILS_ROOT, 'vendor', 'plugins', 'haml', 'init.rb')
+  haml_init_file = File.join(File.dirname(__FILE__), '..', '..', 'init.rb')
+  if File.exists?(rails_init_file)
+    require 'fileutils'
+    FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
   end
 end

data/lib/haml/template/patch.rb

@@ -0,0 +1,51 @@
+# This file makes Haml work with Rails
+# by monkeypatching the core template-compilation methods.
+# This is necessary for versions <= 2.0.1 because the template handler API
+# wasn't sufficiently powerful to deal with caching and so forth.
+
+# This module refers to the ActionView module that's part of Ruby on Rails.
+# Haml can be used as an alternate templating engine for it,
+# and includes several modifications to make it more Haml-friendly.
+# The documentation can be found
+# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
+module ActionView
+  class Base # :nodoc:
+    def delegate_template_exists_with_haml(template_path)
+      template_exists?(template_path, :haml) && [:haml]
+    end
+    alias_method :delegate_template_exists_without_haml, :delegate_template_exists?
+    alias_method :delegate_template_exists?, :delegate_template_exists_with_haml
+
+    def compile_template_with_haml(extension, template, file_name, local_assigns)
+      return compile_haml(template, file_name, local_assigns) if extension.to_s == "haml"
+      compile_template_without_haml(extension, template, file_name, local_assigns)
+    end
+    alias_method :compile_template_without_haml, :compile_template
+    alias_method :compile_template, :compile_template_with_haml
+
+    def compile_haml(template, file_name, local_assigns)
+      render_symbol = assign_method_name(:haml, template, file_name)
+      locals = local_assigns.keys
+      
+      @@template_args[render_symbol] ||= {}
+      locals_keys = @@template_args[render_symbol].keys | locals
+      @@template_args[render_symbol] = locals_keys.inject({}) { |h, k| h[k] = true; h }
+
+      options = Haml::Template.options.dup
+      options[:filename] = file_name || 'compiled-template'
+
+      begin
+        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals)
+      rescue Exception => e
+        if logger
+          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+        end
+
+        raise TemplateError.new(@base_path, file_name || template, @assigns, template, e)
+      end
+
+      @@compile_time[render_symbol] = Time.now
+    end
+  end
+end

data/lib/haml/template/plugin.rb

@@ -0,0 +1,21 @@
+# This file makes Haml work with Rails
+# using the > 2.0.1 template handler API.
+
+module Haml
+  class Template
+    def self.line_offset
+      1
+    end
+
+    def initialize(view)
+      @view = view
+    end
+
+    def compile(template)
+      options = Haml::Template.options.dup
+      Haml::Engine.new(template, options).send(:precompiled_with_ambles, [])
+    end
+  end
+end
+
+ActionView::Base.register_template_handler(:haml, Haml::Template)

data/lib/sass.rb

@@ -82,6 +82,15 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     <attribute>
 #     ...
 #
+# Like CSS, you can stretch rules over multiple lines.
+# However, unlike CSS, you can only do this if each line but the last
+# ends with a comma.
+# For example:
+#
+#   .users #userTab,
+#   .posts #postsTab
+#     <attributes>
+#
 # === Attributes
 #
 # There are two different ways to write CSS attrbibutes.
@@ -117,6 +126,10 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     color: #00ff00;
 #     width: 97% }
 #
+# By default, either attribute syntax may be used.
+# If you want to force one or the other,
+# see the :attribute_syntax option below.
+#
 # === Nested Rules
 #
 # Rules can also be nested within each other.
@@ -461,6 +474,21 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #   #awesome.rule {
 #     awesomeness: very; }
 #
+# You can also nest text beneath a comment to comment out a whole block.
+# For example:
+#
+#   // A very awesome rule
+#   #awesome.rule
+#     // Don't use these attributes
+#       color: green
+#       font-size: 10em
+#     color: red
+#
+# becomes
+#
+#   #awesome.rule {
+#     color: red; }
+#
 # === Loud Comments
 #
 # "Loud" comments are just as easy as silent ones.
@@ -480,6 +508,26 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     /* An equally awesome attribute. */
 #     awesomeness: very; }
 #
+# You can also nest content beneath loud comments. For example:
+#
+#   #pbj
+#     /* This rule describes
+#       the styling of the element
+#       that represents
+#       a peanut butter and jelly sandwich.
+#     :background-image url(/images/pbj.png)
+#     :color red
+#
+# becomes
+#
+#   #pbj {
+#     /* This rule describes
+#      * the styling of the element
+#      * that represents
+#      * a peanut butter and jelly sandwich. */
+#     background-image: url(/images/pbj.png);
+#     color: red; }
+#
 # == Output Style
 #
 # Although the default CSS style that Sass outputs is very nice,
@@ -555,6 +603,16 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 #   .huge { font-size: 10em; font-weight: bold; text-decoration: underline; } 
 #
+# === <tt>:compressed</tt>
+#
+# Compressed style takes up the minimum amount of space possible,
+# having no whitespace except that necessary to separate selectors
+# and a newline at the end of the file.
+# It's not meant to be human-readable.
+# For example:
+#
+#   #main{color:#fff;background-color:#000}#main p{width:10em}.huge{font-size:10em;font-weight:bold;text-decoration:underline} 
+#
 # == Sass Options
 #
 # Options can be set by setting the hash <tt>Sass::Plugin.options</tt>
@@ -565,6 +623,24 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # [<tt>:style</tt>]             Sets the style of the CSS output.
 #                               See the section on Output Style, above.
 #
+# [<tt>:attribute_syntax</tt>]  Forces the document to use one syntax for attributes.
+#                               If the correct syntax isn't used, an error is thrown.
+#                               <tt>:normal</tt> forces the use of a colon
+#                               before the attribute name.
+#                               For example: <tt>:color #0f3</tt>
+#                               or <tt>:width = !main_width</tt>.
+#                               <tt>:alternate</tt> forces the use of a colon or equals sign
+#                               after the attribute name.
+#                               For example: <tt>color: #0f3</tt>
+#                               or <tt>width = !main_width</tt>.
+#                               By default, either syntax is valid.
+#                               
+# [<tt>:never_update</tt>]      Whether the CSS files should never be updated,
+#                               even if the template file changes.
+#                               Setting this to true may give small performance gains.
+#                               It always defaults to false.
+#                               Only has meaning within Ruby on Rails or Merb.
+#
 # [<tt>:always_update</tt>]     Whether the CSS files should be updated every
 #                               time a controller is accessed,
 #                               as opposed to only when the template has been modified.
@@ -576,9 +652,8 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #                               as opposed to only when the Rails server starts.
 #                               If a Sass template has been updated,
 #                               it will be recompiled and will overwrite the corresponding CSS file.
-#                               Defaults to false if Rails is running in production mode,
-#                               true otherwise.
-#                               Only has meaning within Ruby on Rails.
+#                               Defaults to false in production mode, true otherwise.
+#                               Only has meaning within Ruby on Rails or Merb.
 #
 # [<tt>:full_exception</tt>]    Whether an error in the Sass code
 #                               should cause Sass to provide a detailed description.

data/lib/sass/constant.rb

@@ -25,12 +25,13 @@ module Sass
       ?* => :times,
       ?/ => :div,
       ?% => :mod,
+      CONSTANT_CHAR => :const,
       STRING_CHAR => :str,
       ESCAPE_CHAR => :esc
     }
 
     # The regular expression used to parse constants
-    MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }}]+)\s*=\s*(.+)/
+    MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }.join}]+)\s*=\s*(.+)/
     
     # First-order operations
     FIRST_ORDER = [:times, :div, :mod]
@@ -58,7 +59,7 @@ module Sass
       def tokenize(value)
         escaped = false
         is_string = false
-        negative_okay = true
+        beginning_of_token = true
         str = ''
         to_return = []
         
@@ -100,22 +101,35 @@ module Sass
               symbol = SYMBOLS[byte]
 
               # Adjacent values without an operator should be concatenated
-              if (symbol.nil? || symbol == :open) &&
+              if (symbol.nil? || symbol == :open || symbol == :const) &&
                   last && (!last.is_a?(Symbol) || last == :close)
                 to_return << :concat
               end
 
+              # String then open with no whitespace means funcall
+              if symbol == :open && !str.empty?
+                str = reset_str.call
+                to_return << :funcall
+              end
+
               # Time for a unary minus!
-              if negative_okay && symbol == :minus
-                negative_okay = true
+              if beginning_of_token && symbol == :minus
+                beginning_of_token = true
                 to_return << :neg
                 next
               end
 
+              # Is this a constant?
+              if beginning_of_token && symbol == :const
+                beginning_of_token = true
+                to_return << :const
+                next
+              end
+
               # Are we looking at an operator?
-              if symbol && (str.empty? || symbol != :mod)
+              if symbol && (symbol != :mod || str.empty?)
                 str = reset_str.call
-                negative_okay = true
+                beginning_of_token = true
                 to_return << symbol
                 next
               end
@@ -123,7 +137,7 @@ module Sass
           end
           
           escaped = false
-          negative_okay = false
+          beginning_of_token = false
           str << byte.chr
         end
         
@@ -138,7 +152,7 @@ module Sass
         parenthesize_helper(0, value, value.length)[0]
       end
       
-      def parenthesize_helper(i, value, value_len)
+      def parenthesize_helper(i, value, value_len, return_after_expr = false)
         to_return = []
         beginning = i
         token = value[i]
@@ -151,17 +165,32 @@ module Sass
             to_return << sub
           elsif token == :neg
             if value[i + 1].nil?
-              raise Sass::SyntaxError("Unterminated unary minus.")
+              # This is never actually reached, but we'll leave it in just in case.
+              raise Sass::SyntaxError.new("Unterminated unary minus.")
             elsif value[i + 1] == :open
               to_return.push(*value[beginning...i])
               sub, i = parenthesize_helper(i + 2, value, value_len)
               beginning = i
               to_return << [:neg, sub]
+            elsif value[i + 1].is_a?(::Symbol)
+              to_return.push(*value[beginning...i])
+              sub, i = parenthesize_helper(i + 1, value, value_len, true)
+              beginning = i
+              to_return << [:neg, sub]
             else
               to_return.push(*value[beginning...i])
               to_return << [:neg, value[i + 1]]
               beginning = i = i + 2
             end
+            return to_return[0], i if return_after_expr
+          elsif token == :const
+            raise Sass::SyntaxError.new("Unterminated constant.") if value[i + 1].nil?
+            raise Sass::SyntaxError.new("Invalid constant.") unless value[i + 1].is_a?(::String)
+
+            to_return.push(*value[beginning...i])
+            to_return << [:const, value[i + 1]]
+            beginning = i = i + 2
+            return to_return[0], i if return_after_expr
           else
             i += 1
           end
@@ -185,11 +214,13 @@ module Sass
           elsif value.is_a? Operation
             value
           else
-            Literal.parse(insert_constant(value, constants))
+            Literal.parse(value)
           end
         elsif value.length == 2
           if value[0] == :neg
             Operation.new(Sass::Constant::Number.new('0'), operationalize(value[1], constants), :minus)
+          elsif value[0] == :const
+            Literal.parse(get_constant(value[1], constants))
           else
             raise SyntaxError.new("Constant arithmetic error")
           end
@@ -204,14 +235,9 @@ module Sass
         end
       end
       
-      def insert_constant(value, constants)
-        to_return = value
-        if value[0] == CONSTANT_CHAR
-          to_return = constants[value[1..-1]]
-          unless to_return
-            raise SyntaxError.new("Undefined constant: \"#{value}\"")
-          end
-        end
+      def get_constant(value, constants)
+        to_return = constants[value]
+        raise SyntaxError.new("Undefined constant: \"!#{value}\"") unless to_return
         to_return
       end
     end