haml 1.5.2 → 1.7.0

data/lib/haml/template.rb

@@ -40,7 +40,6 @@ module Haml
     # to render its templates.
     def initialize(view)
       @view = view
-      @@precompiled_templates ||= {}
     end
 
     # Renders the file at the location <tt>template</tt>,
@@ -60,13 +59,7 @@ module Haml
         engine = Haml::Engine.new(template, options)
       else
         options[:filename] ||= template
-        if @precompiled = get_precompiled(template)
-          options[:precompiled] ||= @precompiled
-          engine = Haml::Engine.new("", options)
-        else
-          engine = Haml::Engine.new(File.read(template), options)
-          set_precompiled(template, engine.precompiled)
-        end
+        engine = Haml::Engine.new(File.read(template), options)
       end
 
       yield_proc = @view.instance_eval do
@@ -76,24 +69,6 @@ module Haml
       engine.to_html(@view) { |*args| yield_proc.call(*args) }
 
     end
-    
-    private
-
-    # Gets the cached, precompiled version of the template at location <tt>filename</tt>
-    # as a string.
-    def get_precompiled(filename)
-      # Do we have it on file? Is it new enough?
-      if (precompiled, precompiled_on = @@precompiled_templates[filename]) &&
-             (precompiled_on == File.mtime(filename).to_i)
-        precompiled
-      end
-    end
-
-    # Sets the cached, precompiled version of the template at location <tt>filename</tt>
-    # to <tt>precompiled</tt>.
-    def set_precompiled(filename, precompiled)
-      @@precompiled_templates[filename] = [precompiled, File.mtime(filename).to_i]
-    end
   end
 end
 

data/lib/haml/util.rb

@@ -0,0 +1,18 @@
+# This file contains various useful bits of code
+# that are shared between Haml and Sass.
+
+class Hash # :nodoc:
+  # Same as Hash#merge!,
+  # but recursively merges sub-hashes
+  def rec_merge!(other)
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        myval.rec_merge!(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+end

data/lib/sass.rb

@@ -77,12 +77,27 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # === Attributes
 #
-# The syntax for attributes is also slightly different.
+# There are two different ways to write CSS attrbibutes.
+# The first is very similar to the how you're used to writing them:
+# with a colon between the name and the value.
+# However, Sass attributes don't have semicolons at the end;
+# each attribute is on its own line, so they aren't necessary.
+# For example:
+#
+#   #main p
+#     color: #00ff00
+#     width: 97%
+#
+# is compiled to:
+#
+#   #main p {
+#     color: #00ff00;
+#     width: 97% }
+#
+# The second syntax for attributes is slightly different.
 # The colon is at the beginning of the attribute,
 # rather than between the name and the value,
 # so it's easier to tell what elements are attributes just by glancing at them.
-# Attributes also don't have semicolons at the end;
-# each attribute is on its own line, so they aren't necessary.
 # For example:
 #
 #   #main p
@@ -142,6 +157,57 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     #main pre {
 #       font-size: 3em; }
 #
+# === Referencing Parent Rules
+#
+# In addition to the default behavior of inserting the parent selector
+# as a CSS parent of the current selector
+# (e.g. above, "#main" is the parent of "p"),
+# you can have more fine-grained control over what's done with the parent selector
+# by using the ampersand character "&" in your selectors.
+#
+# The ampersand is automatically replaced by the parent selector,
+# instead of having it prepended.
+# This allows you to cleanly create pseudo-attributes:
+#
+#   a
+#     :font-weight bold
+#     :text-decoration none
+#     &:hover
+#       :text-decoration underline
+#     &:visited
+#       :font-weight normal
+#
+# Which would become:
+#
+#   a {
+#     font-weight: bold;
+#     text-decoration: none; }
+#     a:hover {
+#       text-decoration: underline; }
+#     a:visited {
+#       font-weight: normal; }
+#
+# It also allows you to add selectors at the base of the hierarchy,
+# which can be useuful for targeting certain styles to certain browsers:
+#
+#   #main
+#     :width 90%
+#     #sidebar
+#       :float left
+#       :margin-left 20%
+#       .ie6 &
+#         :margin-left 40%
+#
+# Which would become:
+#
+#   #main {
+#     width: 90%; }
+#     #main #sidebar {
+#       float: left;
+#       margin-left: 20%; }
+#       .ie6 #main #sidebar {
+#         margin-left: 40%; }
+#
 # === Attribute Namespaces
 #
 # CSS has quite a few attributes that are in "namespaces;"
@@ -232,6 +298,10 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #
 # === Colors
 #
+# Colors may be written as three- or six-digit hex numbers prefixed
+# by a pound sign (#), or as HTML4 color names. For example,
+# "#ff0", "#ffff00" and "yellow" all refer to the same color.
+#
 # Not only can arithmetic be done between colors and other colors,
 # but it can be done between colors and normal numbers.
 # In this case, the operation is done piecewise one each of the
@@ -301,6 +371,108 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 #     #main h6 {
 #       font: italic small-caps bold 1.1em sans-serif; }
 #
+# == Directives
+#
+# Directives allow the author to directly issue instructions to the Sass compiler.
+# They're prefixed with an at sign, "<tt>@</tt>",
+# followed by the name of the directive,
+# a space, and any arguments to it -
+# just like CSS directives.
+# For example:
+#
+#   @import red.sass
+#
+# === Import
+#
+# Currently, the only directive is the "import" directive.
+# It works in a very similar way to the CSS import directive,
+# and sometimes compiles to a literal CSS "@import".
+#
+# Sass can import either other Sass files or plain CSS files.
+# If it imports a Sass file,
+# not only are the rules from that file included,
+# but all constants in that file are made available in the current file.
+#
+# Sass looks for other Sass files in the working directory,
+# and the Sass file directory under Rails.
+# Additional search directories may be specified
+# using the :load_paths option (see below).
+#
+# Sass can also import plain CSS files.
+# In this case, it doesn't literally include the content of the files;
+# rather, it uses the built-in CSS "@import" directive to tell the client program
+# to import the files.
+#
+# The import directive can take either a full filename
+# or a filename without an extension.
+# If an extension isn't provided,
+# Sass will try to find a Sass file with the given basename in the load paths,
+# and, failing that, will assume a relevant CSS file will be available.
+#
+# For example,
+#
+#   @import foo.sass
+#
+# would compile to
+#
+#   .foo
+#     :color #f00
+#
+# whereas
+#
+#   @import foo.css
+#
+# would compile to
+#
+#   @import foo.css
+#
+# Finally,
+#
+#  @import foo
+#
+# might compile to either,
+# depending on whether a file called "foo.sass" existed.
+#
+# == Comments
+#
+# === Silent Comments
+#
+# It's simple to add "silent" comments,
+# which don't output anything to the CSS document,
+# to a Sass document.
+# Simply use the familiar C-style notation for a one-line comment, "//",
+# at the normal indentation level and all text following it won't be output.
+# For example:
+#
+#   // A very awesome rule.
+#   #awesome.rule
+#     // An equally awesome attribute.
+#     :awesomeness very
+#
+# becomes
+#
+#   #awesome.rule {
+#     awesomeness: very; }
+#
+# === Loud Comments
+#
+# "Loud" comments are just as easy as silent ones.
+# These comments output to the document as CSS comments,
+# and thus use the same opening sequence: "/*".
+# For example:
+#
+#   /* A very awesome rule.
+#   #awesome.rule
+#     /* An equally awesome attribute.
+#     :awesomeness very
+#
+# becomes
+#
+#   /* A very awesome rule. */
+#   #awesome.rule {
+#     /* An equally awesome attribute. */
+#     awesomeness: very; }
+#
 # == Output Style
 #
 # Although the default CSS style that Sass outputs is very nice,
@@ -412,6 +584,12 @@ $LOAD_PATH << dir unless $LOAD_PATH.include?(dir)
 # [<tt>:filename</tt>]          The filename of the file being rendered.
 #                               This is used solely for reporting errors,
 #                               and is automatically set when using Rails.
+#
+# [<tt>:load_paths</tt>]        An array of filesystem paths which should be searched
+#                               for Sass templates imported with the "@import" directive.
+#                               This defaults to the working directory and, in Rails,
+#                               whatever <tt>:template_location</tt> is
+#                               (by default <tt>RAILS_ROOT + "/public/stylesheets/sass"</tt>).
 # 
 module Sass; end
 

data/lib/sass/constant.rb

@@ -76,9 +76,11 @@ module Sass
 
             last = to_return[-1]
 
+            # Do we need to open or close a string literal?
             if byte == STRING_CHAR
               is_string = !is_string
 
+              # Adjacent strings should be concatenated
               if is_string && last && (!last.is_a?(Symbol) || last == :close)
                 to_return << :concat
               end
@@ -89,6 +91,7 @@ module Sass
 
             unless is_string
 
+              # Are we looking at whitespace?
               if WHITESPACE.include?(byte)
                 str = reset_str.call
                 next
@@ -96,13 +99,21 @@ module Sass
             
               symbol = SYMBOLS[byte]
 
+              # Adjacent values without an operator should be concatenated
               if (symbol.nil? || symbol == :open) &&
                   last && (!last.is_a?(Symbol) || last == :close)
-                # Two values connected without an operator
                 to_return << :concat
               end
 
-              if symbol && !(negative_okay && symbol == :minus)
+              # Time for a unary minus!
+              if negative_okay && symbol == :minus
+                negative_okay = true
+                to_return << :neg
+                next
+              end
+
+              # Are we looking at an operator?
+              if symbol && (str.empty? || symbol != :mod)
                 str = reset_str.call
                 negative_okay = true
                 to_return << symbol
@@ -132,12 +143,25 @@ module Sass
         beginning = i
         token = value[i]
         
-        while i < value_len && token != :close          
+        while i < value_len && token != :close
           if token == :open
             to_return.push(*value[beginning...i])
             sub, i = parenthesize_helper(i + 1, value, value_len)
             beginning = i
             to_return << sub
+          elsif token == :neg
+            if value[i + 1].nil?
+              raise Sass::SyntaxError("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]
+            else
+              to_return.push(*value[beginning...i])
+              to_return << [:neg, value[i + 1]]
+              beginning = i = i + 2
+            end
           else
             i += 1
           end
@@ -154,17 +178,22 @@ module Sass
       #++
       def operationalize(value, constants)
         value = [value] unless value.is_a?(Array)
-        length = value.length
-        if length == 1
+        if value.length == 1
           value = value[0]
-          if value.is_a? Operation
+          if value.is_a? Array
+            operationalize(value, constants)
+          elsif value.is_a? Operation
             value
           else
             Literal.parse(insert_constant(value, constants))
           end
-        elsif length == 2
-          raise SyntaxError.new("Constant arithmetic error")
-        elsif length == 3
+        elsif value.length == 2
+          if value[0] == :neg
+            Operation.new(Sass::Constant::Number.new('0'), operationalize(value[1], constants), :minus)
+          else
+            raise SyntaxError.new("Constant arithmetic error")
+          end
+        elsif value.length == 3
           Operation.new(operationalize(value[0], constants), operationalize(value[2], constants), value[1])
         else
           if SECOND_ORDER.include?(value[1]) && FIRST_ORDER.include?(value[3])

data/lib/sass/constant/color.rb

@@ -2,11 +2,35 @@ require 'sass/constant/literal'
 
 module Sass::Constant # :nodoc:
   class Color < Literal # :nodoc:
+
+    HTML4_COLORS = {
+      'black'   => 0x000000,
+      'silver'  => 0xc0c0c0,
+      'gray'    => 0x808080,
+      'white'   => 0xffffff,
+      'maroon'  => 0x800000,
+      'red'     => 0xff0000,
+      'purple'  => 0x800080,
+      'fuchsia' => 0xff00ff,
+      'green'   => 0x008000,
+      'lime'    => 0x00ff00,
+      'olive'   => 0x808000,
+      'yellow'  => 0xffff00,
+      'navy'    => 0x000080,
+      'blue'    => 0x0000ff,
+      'teal'    => 0x008080,
+      'aqua'    => 0x00ffff
+    }
   
     REGEXP = /\##{"([0-9a-fA-F]{1,2})" * 3}/
   
     def parse(value)
-      @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, 'f').to_i(16) }
+      if (value =~ REGEXP)
+        @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, num).to_i(16) }
+      else
+        color = HTML4_COLORS[value.downcase]
+        @value = (0..2).map{ |n| color >> (n << 3) & 0xff }.reverse
+      end
     end
     
     def plus(other)

data/lib/sass/constant/literal.rb

@@ -7,19 +7,21 @@ require 'sass/constant/color'
 
 class Sass::Constant::Literal # :nodoc:
   # The regular expression matching numbers.
-  NUMBER  = /^(-?[0-9]*?\.?)([0-9]+)([^0-9\s]*)$/
+  NUMBER  = /^(-?\d*?\.?)(\d+)([^\d\s]*)$/
+
+  html_color_matcher = Sass::Constant::Color::HTML4_COLORS.keys.join '|'
 
   # The regular expression matching colors.
-  COLOR = /^\#(#{"[0-9a-fA-F]" * 3}|#{"[0-9a-fA-F]" * 6})/
+  COLOR = /^\# (?: [\da-f]{3} | [\da-f]{6} ) | #{html_color_matcher}/ix
   
   def self.parse(value)
     case value
-      when NUMBER
-        Sass::Constant::Number.new(value)
-      when COLOR
-        Sass::Constant::Color.new(value)
-      else
-        Sass::Constant::String.new(value)
+    when NUMBER
+      Sass::Constant::Number.new(value)
+    when COLOR
+      Sass::Constant::Color.new(value)
+    else
+      Sass::Constant::String.new(value)
     end
   end