haml 3.1.0.alpha.19 → 3.1.0.alpha.22

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-3.1.0.alpha.19
+3.1.0.alpha.22

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.19
+3.1.0.alpha.22

data/lib/haml/precompiler.rb

@@ -1,4 +1,5 @@
 require 'strscan'
+require 'cgi'
 require 'haml/shared'
 
 module Haml

data/lib/haml/template/plugin.rb

@@ -2,12 +2,17 @@
 # using the > 2.0.1 template handler API.
 
 module Haml
-  class Plugin < Haml::Util.av_template_class(:Handler)
-    if (defined?(ActionView::TemplateHandlers) &&
-        defined?(ActionView::TemplateHandlers::Compilable)) ||
-       (defined?(ActionView::Template) &&
-        defined?(ActionView::Template::Handlers) &&
-        defined?(ActionView::Template::Handlers::Compilable))
+  # In Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they do.
+  # To avoid messy logic figuring this out, we just inherit from whatever the ERB handler does.
+  class Plugin < Haml::Util.av_template_class(:Handlers)::ERB.superclass
+    if ((defined?(ActionView::TemplateHandlers) &&
+          defined?(ActionView::TemplateHandlers::Compilable)) ||
+        (defined?(ActionView::Template) &&
+          defined?(ActionView::Template::Handlers) &&
+          defined?(ActionView::Template::Handlers::Compilable))) &&
+        # In Rails 3.1+, we don't need to include Compilable.
+        Haml::Util.av_template_class(:Handlers)::ERB.include?(
+          Haml::Util.av_template_class(:Handlers)::Compilable)
       include Haml::Util.av_template_class(:Handlers)::Compilable
     end
 
@@ -29,6 +34,11 @@ module Haml
       Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
     end
 
+    # In Rails 3.1+, #call takes the place of #compile
+    def self.call(template)
+      new.compile(template)
+    end
+
     def cache_fragment(block, name = {}, options = nil)
       @view.fragment_for(block, name, options) do
         eval("_hamlout.buffer", block.binding)

data/vendor/sass/doc-src/SASS_CHANGELOG.md

@@ -7,6 +7,37 @@
 
 * Add an {Sass::Script::Functions#invert `invert` function} that takes the inverse of colors.
 
+* Many performance optimizations have been made by [thedarkone](http://github.com/thedarkone).
+
+### Keyword Arguments
+
+Both mixins and Sass functions now support the ability to pass in keyword arguments.
+For example, with mixins:
+
+    @mixin border-radius($value, $moz: true, $webkit: true, $css3: true) {
+      @if $moz { -moz-border-radius: $value }
+      @if $webkit { -webkit-border-radius: $value }
+      @if $css3 { border-radius: $value }
+    }
+
+    @include border-radius(10px, $webkit: false);
+
+And with functions:
+
+    p {
+      color: hsl($hue: 180, $saturation: 78%, lightness: 57%);
+    }
+
+Keyword arguments are of the form `$name: value` and come after normal arguments.
+They can be used for either optional or required arguments.
+For mixins, the names are the same as the argument names for the mixins.
+For functions, the names are defined along with the functions.
+The argument names for the built-in functions are listed
+{Sass::Script::Functions in the function documentation}.
+
+Sass functions defined in Ruby can use the {Sass::Script::Functions.declare} method
+to declare the names of the arguments they take.
+
 ### Backwards Incompatibilities -- Must Read!
 
 * When `@import` is given a path without `.sass`, `.scss`, or `.css` extension,
@@ -18,6 +49,16 @@
   This flag hasn't been necessary since Rails 2.0.
   Existing Rails 2.0 installations will continue to work.
 
+## 3.0.22
+
+[Tagged on GitHub](http://github.com/nex3/haml/commit/3.0.22).
+
+* Remove `vendor/sass`, which snuck into the gem by mistake
+  and was causing trouble for Heroku users (thanks to [Jacques Crocker](http://railsjedi.com/)).
+
+* `sass-convert` now understands better when it's acceptable
+  to remove parentheses from expressions.
+
 ## 3.0.21
 
 [Tagged on GitHub](http://github.com/nex3/haml/commit/3.0.21).

data/vendor/sass/doc-src/SASS_REFERENCE.md

@@ -275,8 +275,9 @@ Available options are:
   This is useful to set if the Sass template is embedded in a Ruby file.
 
 {#load_paths-option} `:load_paths`
-: An array of filesystem paths which should be searched
+: An array of filesystem paths or importers which should be searched
   for Sass templates imported with the [`@import`](#import) directive.
+  These may be strings, `Pathname` objects, or subclasses of {Sass::Importers::Base}.
   This defaults to the working directory and, in Rack, Rails, or Merb,
   whatever `:template_location` is.
 
@@ -851,7 +852,7 @@ SassScript defines some useful functions
 that are called using the normal CSS function syntax:
 
     p {
-      color: hsl(0, 100%, 0.5);
+      color: hsl(0, 100%, 50%);
     }
 
 is compiled to:
@@ -859,7 +860,23 @@ is compiled to:
     p {
       color: #ff0000; }
 
-See {Sass::Script::Functions} for a full listing of Sass functions,
+#### Keyword Arguments
+
+Sass functions can also be called using explicit keyword arguments.
+The above example can also be written as:
+
+    p {
+      color: hsl($hue: 0, $saturation: 100%, $lightness: 50%);
+    }
+
+While this is less concise, it can make the stylesheet easier to read.
+It also allows functions to present more flexible interfaces,
+providing many arguments without becoming difficult to call.
+
+Named arguments can be passed in any order, and arguments with default values can be omitted.
+Since the named arguments are variable names, underscores and dashes can be used interchangeably.
+
+See {Sass::Script::Functions} for a full listing of Sass functions and their argument names,
 as well as instructions on defining your own in Ruby.
 
 ### Interpolation: `#{}` {#interpolation_}
@@ -1591,6 +1608,21 @@ is compiled to:
       border-width: 2in;
       border-style: dashed; }
 
+#### Keyword Arguments
+
+Mixins can also be included using explicit keyword arguments.
+For instance, we the above example could be written as:
+
+    p { @include sexy-border($color: blue); }
+    h1 { @include sexy-border($color: blue, $width: 2in); }
+
+While this is less concise, it can make the stylesheet easier to read.
+It also allows functions to present more flexible interfaces,
+providing many arguments without becoming difficult to call.
+
+Named arguments can be passed in any order, and arguments with default values can be omitted.
+Since the named arguments are variable names, underscores and dashes can be used interchangeably.
+
 ## Output Style
 
 Although the default CSS style that Sass outputs is very nice
@@ -1682,9 +1714,8 @@ Using these features requires a strong understanding of Ruby.
 
 ### Defining Custom Sass Functions
 
-The same way that Sass defines new functions for use in Sass stylesheets is available
-to users who which to do so. For more information see the [source
-documentation](/docs/yardoc/Sass/Script/Functions.html#adding_custom_functions).
+Users can define their own Sass functions using the Ruby API.
+For more information, see the [source documentation](Sass/Script/Functions.html#adding_custom_functions).
 
 ### Cache Stores
 

data/vendor/sass/lib/sass.rb

@@ -43,17 +43,21 @@ module Sass
   # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
   #
   # @overload compile_file(filename, options = {})
+  #   Return the compiled CSS rather than writing it to a file.
+  #
   #   @return [String] The compiled CSS.
   #
   # @overload compile_file(filename, css_filename, options = {})
+  #   Write the compiled CSS to a file.
+  #
   #   @param css_filename [String] The location to which to write the compiled CSS.
   def self.compile_file(filename, *args)
     options = args.last.is_a?(Hash) ? args.pop : {}
-    css_filename ||= args.shift
-    options[:css_filename] = css_filename
+    css_filename = args.shift
     result = Sass::Engine.for_file(filename, options).render
     if css_filename
-      open(css_filename,"w") {|css_file| css_file.write(result) }
+      options[:css_filename] ||= css_filename
+      open(css_filename,"w") {|css_file| css_file.write(result)}
       nil
     else
       result

data/vendor/sass/lib/sass/engine.rb

@@ -158,8 +158,8 @@ module Sass
       options[:line_comments] ||= options[:line_numbers]
 
       options[:load_paths] = options[:load_paths].map do |p|
-        next p unless p.is_a?(String)
-        options[:filesystem_importer].new(p)
+        next p unless p.is_a?(String) || (defined?(Pathname) && p.is_a?(Pathname))
+        options[:filesystem_importer].new(p.to_s)
       end
 
       # Backwards compatibility
@@ -731,11 +731,11 @@ WARNING
       raise SyntaxError.new("Invalid mixin include \"#{line.text}\".") if name.nil?
 
       offset = line.offset + line.text.size - arg_string.size
-      args = Script::Parser.new(arg_string.strip, @line, offset, @options).
+      args, keywords = Script::Parser.new(arg_string.strip, @line, offset, @options).
         parse_mixin_include_arglist
       raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath mixin directives.",
         :line => @line + 1) unless line.children.empty?
-      Tree::MixinNode.new(name, args)
+      Tree::MixinNode.new(name, args, keywords)
     end
 
     def parse_script(script, options = {})

data/vendor/sass/lib/sass/environment.rb

@@ -22,12 +22,12 @@ module Sass
 
     # @param parent [Environment] See \{#parent}
     def initialize(parent = nil)
-      @vars = {}
-      @mixins = {}
       @parent = parent
-      @stack = [] unless parent
-      @mixins_in_use = Set.new unless parent
-      set_var("important", Script::String.new("!important")) unless @parent
+      unless parent
+        @stack = []
+        @mixins_in_use = Set.new
+        set_var("important", Script::String.new("!important"))
+      end
     end
 
     # The options hash.
@@ -35,7 +35,7 @@ module Sass
     #
     # @return [{Symbol => Object}]
     def options
-      @options || (parent && parent.options) || {}
+      @options || parent_options || {}
     end
 
     # Push a new stack frame onto the mixin/include stack.
@@ -53,13 +53,13 @@ module Sass
     #   `:line`
     #   : The line of the file on which the lexical scope changed. Never nil.
     def push_frame(frame_info)
-      if stack.last && stack.last[:prepared]
-        stack.last.delete(:prepared)
-        stack.last.merge!(frame_info)
+      top_of_stack = stack.last
+      if top_of_stack && top_of_stack.delete(:prepared)
+        top_of_stack.merge!(frame_info)
       else
-        stack.push(frame_info)
+        stack.push(top_of_stack = frame_info)
       end
-      mixins_in_use << stack.last[:mixin] if stack.last[:mixin] && !stack.last[:prepared]
+      mixins_in_use << top_of_stack[:mixin] if top_of_stack[:mixin] && !top_of_stack[:prepared]
     end
 
     # Like \{#push\_frame}, but next time a stack frame is pushed,
@@ -93,28 +93,36 @@ module Sass
       @mixins_in_use ||= @parent.mixins_in_use
     end
 
+    private
+
+    def parent_options
+      @parent_options ||= @parent && @parent.options
+    end
+
     class << self
       private
+      UNDERSCORE, DASH = '_', '-'
 
       # Note: when updating this,
       # update sass/yard/inherited_hash.rb as well.
       def inherited_hash(name)
         class_eval <<RUBY, __FILE__, __LINE__ + 1
           def #{name}(name)
-            _#{name}(name.gsub('_', '-'))
+            _#{name}(name.tr(UNDERSCORE, DASH))
           end
 
           def _#{name}(name)
-            @#{name}s[name] || @parent && @parent._#{name}(name)
+            (@#{name}s && @#{name}s[name]) || @parent && @parent._#{name}(name)
           end
           protected :_#{name}
 
           def set_#{name}(name, value)
-            name = name.gsub('_', '-')
+            name = name.tr(UNDERSCORE, DASH)
             @#{name}s[name] = value unless try_set_#{name}(name, value)
           end
 
           def try_set_#{name}(name, value)
+            @#{name}s ||= {}
             if @#{name}s.include?(name)
               @#{name}s[name] = value
               true
@@ -127,7 +135,8 @@ module Sass
           protected :try_set_#{name}
 
           def set_local_#{name}(name, value)
-            @#{name}s[name.gsub('_', '-')] = value
+            @#{name}s ||= {}
+            @#{name}s[name.tr(UNDERSCORE, DASH)] = value
           end
 RUBY
       end

data/vendor/sass/lib/sass/less.rb

@@ -246,24 +246,43 @@ WARNING
       private
 
       LESS_TO_SASS_OPERATORS = {"-" => :minus, "+" => :plus, "*" => :times, "/" => :div, "=" => :single_eq}
+
       def _to_sass_tree(arr)
-        return Sass::Script::UnaryOperation.new(_to_sass_tree(arr[1..-1]), :minus) if arr[0] == "-"
-        _to_sass_tree2(*_sass_split(arr))
+        e, rest = _to_sass_tree_plus_minus_eq(arr)
+        until rest.empty?
+          e2, rest = _to_sass_tree_plus_minus_eq(rest)
+          e = Sass::Script::Operation.new(e, e2, :concat)
+        end
+        return e
       end
 
-      def _to_sass_tree2(first, rest)
-        return first if rest.empty?
-        if rest[0].is_a?(Operator)
+      def _to_sass_tree_plus_minus_eq(arr)
+        e, rest = _to_sass_tree_times_div(arr)
+        while rest[0] && rest[0].is_a?(Operator) && %w[+ - =].include?(rest[0])
           op = LESS_TO_SASS_OPERATORS[rest[0]]
-          if op == :times || op == :div
-            second, rest = _sass_split(rest[1..-1])
-            return _to_sass_tree2(Sass::Script::Operation.new(first, second, op), rest)
-          else
-            return Sass::Script::Operation.new(first, _to_sass_tree(rest[1..-1]), op)
-          end
+          e2, rest = _to_sass_tree_times_div(rest[1..-1])
+          e = Sass::Script::Operation.new(e, e2, op)
         end
+        return e, rest
+      end
 
-        Sass::Script::Operation.new(first, _to_sass_tree(rest), :concat)
+      def _to_sass_tree_times_div(arr)
+        e, rest = _to_sass_tree_unary(arr)
+        while rest[0] && rest[0].is_a?(Operator) && %w[* /].include?(rest[0])
+          op = LESS_TO_SASS_OPERATORS[rest[0]]
+          e2, rest = _to_sass_tree_unary(rest[1..-1])
+          e = Sass::Script::Operation.new(e, e2, op)
+        end
+        return e, rest
+      end
+
+      def _to_sass_tree_unary(arr)
+        if arr[0] == "-"
+          first, rest = _sass_split(arr[1..-1])
+          return Sass::Script::UnaryOperation.new(first, :minus), rest
+        else
+          return _sass_split(arr[0..-1])
+        end
       end
 
       def _sass_split(arr)

data/vendor/sass/lib/sass/plugin/staleness_checker.rb

@@ -121,7 +121,7 @@ module Sass
       end
 
       def dependency_updated?(css_mtime)
-        lambda do |uri, importer|
+        Proc.new do |uri, importer|
           mtime(uri, importer) > css_mtime ||
             dependencies_stale?(uri, importer, css_mtime)
         end

data/vendor/sass/lib/sass/script/funcall.rb

@@ -1,4 +1,5 @@
-require File.join(File.dirname(__FILE__), 'functions')
+require 'sass/script/functions'
+
 module Sass
   module Script
     # A SassScript parse node representing a function call.
@@ -17,6 +18,11 @@ module Sass
       # @return [Array<Script::Node>]
       attr_reader :args
 
+      # The keyword arguments to the function.
+      #
+      # @return [{String => Script::Node}]
+      attr_reader :keywords
+
       # Don't set the context for child nodes if this is `url()`,
       # since `url()` allows quoted strings.
       #
@@ -27,21 +33,29 @@ module Sass
       end
 
       # @param name [String] See \{#name}
-      # @param name [Array<Script::Node>] See \{#args}
-      def initialize(name, args)
+      # @param args [Array<Script::Node>] See \{#args}
+      # @param keywords [{String => Script::Node}] See \{#keywords}
+      def initialize(name, args, keywords)
         @name = name
         @args = args
+        @keywords = keywords
         super()
       end
 
       # @return [String] A string representation of the function call
       def inspect
-        "#{name}(#{args.map {|a| a.inspect}.join(', ')})"
+        args = @args.map {|a| a.inspect}.join(', ')
+        keywords = @keywords.sort_by {|k, v| k}.
+            map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
+        "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
 
       # @see Node#to_sass
       def to_sass(opts = {})
-        "#{dasherize(name, opts)}(#{args.map {|a| a.to_sass(opts)}.join(', ')})"
+        args = @args.map {|a| a.to_sass(opts)}.join(', ')
+        keywords = @keywords.sort_by {|k, v| k}.
+          map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
+        "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
 
       # Returns the arguments to the function.
@@ -49,7 +63,7 @@ module Sass
       # @return [Array<Node>]
       # @see Node#children
       def children
-        @args
+        @args + @keywords.values
       end
 
       protected
@@ -60,10 +74,13 @@ module Sass
       # @return [Literal] The SassScript object that is the value of the function call
       # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
       def _perform(environment)
-        args = self.args.map {|a| a.perform(environment)}
-        ruby_name = name.gsub('-', '_')
+        args = @args.map {|a| a.perform(environment)}
+        keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+        ruby_name = @name.tr('-', '_')
+        args = construct_ruby_args(ruby_name, args, keywords)
+
         unless Sass::Util.has?(:public_instance_method, Functions, ruby_name) && ruby_name !~ /^__/
-          opts(Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})"))
+          opts(Script::String.new("#{name}(#{args.join(', ')})"))
         else
           opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
         end
@@ -71,6 +88,31 @@ module Sass
         raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
+
+      def construct_ruby_args(name, args, keywords)
+        return args if keywords.empty?
+        unless signature = Functions.signature(name.to_sym, args.size, keywords.size)
+          raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
+        end
+
+        args = args + signature.args[args.size..-1].map do |argname|
+          if keywords.has_key?(argname)
+            keywords.delete(argname)
+          else
+            raise Sass::SyntaxError, "Function #{name} requires an argument named $#{argname}"
+          end
+        end
+
+        if keywords.size > 0
+          if signature.var_kwargs
+            args << Sass::Util.map_hash(keywords) {|k, v| [k.to_sym, v]}
+          else
+            raise Sass::SyntaxError, "Function #{name} doesn't take an argument named $#{keywords.keys.sort.first}"
+          end
+        end
+
+        args
+      end
     end
   end
 end