haml 3.0.0.beta.3 → 3.0.0.rc.1

data/lib/haml/root.rb

@@ -1,3 +1,7 @@
 module Haml
+  # The root directory of the Haml source tree.
+  # This may be overridden by the package manager
+  # if the lib directory is separated from the main source tree.
+  # @api public
   ROOT_DIR = File.expand_path("../../..", __FILE__)
 end

data/lib/haml/template.rb

@@ -1,4 +1,6 @@
 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.

data/lib/haml/util.rb

@@ -3,6 +3,7 @@ require 'set'
 require 'enumerator'
 require 'stringio'
 require 'haml/root'
+require 'haml/util/subset_map'
 
 module Haml
   # A module containing various useful functions.
@@ -10,6 +11,7 @@ module Haml
     extend self
 
     # An array of ints representing the Ruby version number.
+    # @api public
     RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
 
     # Returns the path of a file relative to the Haml root directory.
@@ -135,6 +137,33 @@ module Haml
       end
     end
 
+    # Intersperses a value in an enumerable, as would be done with `Array#join`
+    # but without concatenating the array together afterwards.
+    #
+    # @param enum [Enumerable]
+    # @param val
+    # @return [Array]
+    def intersperse(enum, val)
+      enum.inject([]) {|a, e| a << e << val}[0...-1]
+    end
+
+    # Substitutes a sub-array of one array with another sub-array.
+    #
+    # @param ary [Array] The array in which to make the substitution
+    # @param from [Array] The sequence of elements to replace with `to`
+    # @param to [Array] The sequence of elements to replace `from` with
+    def substitute(ary, from, to)
+      res = ary.dup
+      i = 0
+      while i < res.size
+        if res[i...i+from.size] == from
+          res[i...i+from.size] = to
+        end
+        i += 1
+      end
+      res
+    end
+
     # Destructively strips whitespace from the beginning and end
     # of the first and last elements, respectively,
     # in the array (if those elements are strings).
@@ -147,6 +176,23 @@ module Haml
       arr
     end
 
+    # Return an array of all possible paths through the given arrays.
+    #
+    # @param arrs [Array<Array>]
+    # @return [Array<Arrays>]
+    #
+    # @example
+    # paths([[1, 2], [3, 4], [5]]) #=>
+    #   # [[1, 3, 5],
+    #   #  [2, 3, 5],
+    #   #  [1, 4, 5],
+    #   #  [2, 4, 5]]
+    def paths(arrs)
+      arrs.inject([[]]) do |paths, arr|
+        arr.map {|e| paths.map {|path| path + [e]}}.flatten(1)
+      end
+    end
+
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -237,6 +283,30 @@ 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`,
@@ -282,6 +352,10 @@ 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

data/lib/haml/util/subset_map.rb

@@ -0,0 +1,101 @@
+require 'set'
+
+module Haml
+  module Util
+    # A map from sets to values.
+    # A value is \{#\[]= set} by providing a set (the "set-set") and a value,
+    # which is then recorded as corresponding to that set.
+    # Values are \{#\[] accessed} by providing a set (the "get-set")
+    # and returning all values that correspond to set-sets
+    # that are subsets of the get-set.
+    #
+    # SubsetMap preserves the order of values as they're inserted.
+    #
+    # @example
+    # ssm = SubsetMap.new
+    # ssm[Set[1, 2]] = "Foo"
+    # ssm[Set[2, 3]] = "Bar"
+    # ssm[Set[1, 2, 3]] = "Baz"
+    #
+    # ssm[Set[1, 2, 3]] #=> ["Foo", "Bar", "Baz"]
+    class SubsetMap
+      # Creates a new, empty SubsetMap.
+      def initialize
+        @hash = {}
+        @vals = []
+      end
+
+      # Whether or not this SubsetMap has any key-value pairs.
+      #
+      # @return [Boolean]
+      def empty?
+        @hash.empty?
+      end
+
+      # Associates a value with a set.
+      # When `set` or any of its supersets is accessed,
+      # `value` will be among the values returned.
+      #
+      # Note that if the same `set` is passed to this method multiple times,
+      # all given `value`s will be associated with that `set`.
+      #
+      # This runs in `O(n)` time, where `n` is the size of `set`.
+      #
+      # @param set [#to_set] The set to use as the map key. May not be empty.
+      # @param value [Object] The value to associate with `set`.
+      # @raise [ArgumentError] If `set` is empty.
+      def []=(set, value)
+        raise ArgumentError.new("SubsetMap keys may not be empty.") if set.empty?
+
+        index = @vals.size
+        @vals << value
+        set.each do |k|
+          @hash[k] ||= []
+          @hash[k] << [set, set.to_set, index]
+        end
+      end
+
+      # Returns all values associated with subsets of `set`.
+      #
+      # In the worst case, this runs in `O(m*max(n, log m))` time,
+      # where `n` is the size of `set`
+      # and `m` is the number of assocations in the map.
+      # However, unless many keys in the map overlap with `set`,
+      # `m` will typically be much smaller.
+      #
+      # @param set [Set] The set to use as the map key.
+      # @return [Array<(Object, #to_set)>] An array of pairs,
+      #   where the first value is the value associated with a subset of `set`,
+      #   and the second value is that subset of `set`
+      #   (or whatever `#to_set` object was used to set the value)
+      #   This array is in insertion order.
+      # @see #[]
+      def get(set)
+        res = set.map do |k|
+          next unless subsets = @hash[k]
+          subsets.map do |subenum, subset, index|
+            next unless subset.subset?(set)
+            [index, subenum]
+          end
+        end
+        res.flatten!(1)
+        res.compact!
+        res.uniq!
+        res.sort!
+        res.map! {|i, s| [@vals[i], s]}
+        return res
+      end
+
+      # Same as \{#get}, but doesn't return the subsets of the argument
+      # for which values were found.
+      #
+      # @param set [Set] The set to use as the map key.
+      # @return [Array] The array of all values
+      #   associated with subsets of `set`, in insertion order.
+      # @see #get
+      def [](set)
+        get(set).map {|v, _| v}
+      end
+    end
+  end
+end

data/lib/sass.rb

@@ -16,6 +16,7 @@ module Sass
 
   # A string representing the version of Sass.
   # A more fine-grained representation is available from {Haml::Version#version Sass.version}.
+  # @api public
   VERSION = version[:string] unless defined?(Sass::VERSION)
 end
 

data/lib/sass/engine.rb

@@ -9,12 +9,14 @@ require 'sass/tree/directive_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
 require 'sass/tree/mixin_node'
+require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
 require 'sass/tree/for_node'
 require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
+require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
 require 'sass/scss'
@@ -79,60 +81,49 @@ 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.
+    # @api public
     DEFAULT_OPTIONS = {
       :style => :nested,
       :load_paths => ['.'],
@@ -382,7 +373,10 @@ WARNING
           # if we're using the new property syntax
           Tree::RuleNode.new(parse_interp(line.text))
         else
-          parse_property(line, PROPERTY_OLD)
+          name, eq, value = line.text.scan(PROPERTY_OLD)[0]
+          raise SyntaxError.new("Invalid property: \"#{line.text}\".",
+            :line => @line) if name.nil? || value.nil?
+          parse_property(name, parse_interp(name), eq, value, :old, line)
         end
       when ?!, ?$
         parse_variable(line)
@@ -401,20 +395,29 @@ WARNING
           parse_mixin_include(line, root)
         end
       else
-        if line.text =~ PROPERTY_NEW_MATCHER
-          parse_property(line, PROPERTY_NEW)
-        else
-          Tree::RuleNode.new(parse_interp(line.text))
-        end
+        parse_property_or_rule(line)
       end
     end
 
-    def parse_property(line, property_regx)
-      name, eq, value = line.text.scan(property_regx)[0]
+    def parse_property_or_rule(line)
+      scanner = StringScanner.new(line.text)
+      hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
+      parser = Sass::SCSS::SassParser.new(scanner, @line)
 
-      raise SyntaxError.new("Invalid property: \"#{line.text}\".",
-        :line => @line) if name.nil? || value.nil?
+      unless res = parser.parse_interp_ident
+        return Tree::RuleNode.new(parse_interp(line.text))
+      end
+      res.unshift(hack_char) if hack_char
+
+      name = line.text[0...scanner.pos]
+      if scanner.scan(/\s*([:=])(?:\s|$)/)
+        parse_property(name, res, scanner[1], scanner.rest, :new, line)
+      else
+        Tree::RuleNode.new(res + parse_interp(scanner.rest))
+      end
+    end
 
+    def parse_property(name, parsed_name, eq, value, prop, line)
       if value.strip.empty?
         expr = Sass::Script::String.new("")
       else
@@ -427,9 +430,7 @@ WARNING
             @line, line.offset + 1, @options[:filename])
         end
       end
-      Tree::PropNode.new(
-        parse_interp(name), expr,
-        property_regx == PROPERTY_OLD ? :old : :new)
+      Tree::PropNode.new(parse_interp(name), expr, prop)
     end
 
     def parse_variable(line)
@@ -500,6 +501,12 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::DebugNode.new(parse_script(value, :offset => offset))
+      elsif directive == "extend"
+        raise SyntaxError.new("Invalid extend directive '@extend': expected expression.") unless value
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath extend directives.",
+          :line => @line + 1) unless line.children.empty?
+        offset = line.offset + line.text.index(value).to_i
+        Tree::ExtendNode.new(parse_interp(value, offset))
       elsif directive == "warn"
         raise SyntaxError.new("Invalid warn directive '@warn': expected expression.") unless value
         raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath warn directives.",
@@ -552,7 +559,6 @@ WARNING
       nil
     end
 
-    # @private
     MIXIN_DEF_RE = /^(?:=|@mixin)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_definition(line)
       name, arg_string = line.text.scan(MIXIN_DEF_RE).first
@@ -565,7 +571,6 @@ WARNING
       Tree::MixinDefNode.new(name, args)
     end
 
-    # @private
     MIXIN_INCLUDE_RE = /^(?:\+|@include)\s*(#{Sass::SCSS::RX::IDENT})(.*)$/
     def parse_mixin_include(line, root)
       name, arg_string = line.text.scan(MIXIN_INCLUDE_RE).first
@@ -605,15 +610,15 @@ WARNING
       end
     end
 
-    def parse_interp(text)
-      self.class.parse_interp(text, @line, :filename => @filename)
+    def parse_interp(text, offset = 0)
+      self.class.parse_interp(text, @line, offset, :filename => @filename)
     end
 
     # It's important that this have strings (at least)
     # at the beginning, the end, and between each Script::Node.
     #
     # @private
-    def self.parse_interp(text, line, options)
+    def self.parse_interp(text, line, offset, options)
       res = []
       rest = Haml::Shared.handle_interpolation text do |scan|
         escapes = scan[2].size
@@ -623,7 +628,7 @@ WARNING
         else
           res << "\\" * [0, escapes - 1].max
           res << Script::Parser.new(
-            scan, line, scan.pos - scan.matched_size, options).
+            scan, line, offset + scan.pos - scan.matched_size, options).
             parse_interpolated
         end
       end

data/lib/sass/files.rb

@@ -20,7 +20,7 @@ module Sass
       options = Sass::Engine::DEFAULT_OPTIONS.merge(options)
       text = File.read(filename)
 
-      if options[:cache]
+      if options[:cache] || options[:read_cache]
         compiled_filename = sassc_filename(filename, options)
         sha = Digest::SHA1.hexdigest(text)
 

data/lib/sass/plugin.rb

@@ -231,6 +231,27 @@ module Sass
       end
     end
 
+    # Updates all stylesheets, even those that aren't out-of-date.
+    # Ignores the cache.
+    #
+    # @param individual_files [Array<(String, String)>]
+    #   A list of files to check for updates
+    #   **in addition to those specified by the
+    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
+    #   The first string in each pair is the location of the Sass/SCSS file,
+    #   the second is the location of the CSS file that it should be compiled to.
+    # @see #update_stylesheets
+    def force_update_stylesheets(individual_files = [])
+      old_options = options
+      self.options = options.dup
+      options[:never_update] = false
+      options[:always_update] = true
+      options[:cache] = false
+      update_stylesheets(individual_files)
+    ensure
+      self.options = old_options
+    end
+
     # Watches the template directory (or directories)
     # and updates the CSS files whenever the related Sass/SCSS files change.
     # `watch` never returns.