haml-edge 2.3.93 → 2.3.94

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.93
+2.3.94

data/README.md

@@ -60,7 +60,7 @@ Then any Sass files in `public/stylesheets/sass`
 will be compiled CSS files in `public/stylesheets` on every request.
 
 To use Haml and Sass programatically,
-check out the [YARD documentation](http://haml-lang.com/docs/yardoc).
+check out the [YARD documentation](http://haml-lang.com/docs/yardoc/).
 
 ## Formatting
 

data/Rakefile

@@ -203,6 +203,7 @@ task :release_edge do
 
     sh %{rubyforge login}
     sh %{rubyforge add_release haml haml-edge "Bleeding Edge (v#{edge_version})" pkg/haml-edge-#{edge_version}.gem}
+    sh %{gem push pkg/haml-edge-#{edge_version}.gem}
   end
 end
 
@@ -222,6 +223,17 @@ end
 begin
   require 'yard'
 
+  namespace :yard do
+    task :sass do
+      require File.dirname(__FILE__) + '/lib/sass'
+      Dir[File.dirname(__FILE__) + "/yard/default/**/*.sass"].each do |sass|
+        File.open(sass.gsub(/sass$/, 'css'), 'w') do |f|
+          f.write(Sass::Engine.new(File.read(sass)).render)
+        end
+      end
+    end
+  end
+
   YARD::Rake::YardocTask.new do |t|
     t.files = FileList.new('lib/**/*.rb') do |list|
       list.exclude('lib/haml/template/*.rb')
@@ -231,12 +243,14 @@ begin
     t.options += FileList.new('yard/*.rb').to_a.map {|f| ['-e', f]}.flatten
     files = FileList.new('doc-src/*').to_a.sort_by {|s| s.size} + %w[MIT-LICENSE VERSION]
     t.options << '--files' << files.join(',')
+    t.options << '--template-path' << File.dirname(__FILE__) + '/yard'
   end
-  Rake::Task['yardoc'].instance_variable_set('@comment', nil)
+  Rake::Task['yard'].prerequisites.insert(0, 'yard:sass')
+  Rake::Task['yard'].instance_variable_set('@comment', nil)
 
   desc "Generate Documentation"
-  task :doc => :yardoc
-  task :redoc => :yardoc
+  task :doc => :yard
+  task :redoc => :yard
 rescue LoadError
   desc "Generate Documentation"
   task :doc => :rdoc

data/VERSION

@@ -1 +1 @@
-2.3.93
+2.3.94

data/lib/haml/helpers.rb

@@ -339,7 +339,7 @@ MESSAGE
     end
 
     # @deprecated This will be removed in version 2.4.
-    # @see \{#haml\_concat}
+    # @see #haml_concat
     def puts(*args)
       warn <<END
 DEPRECATION WARNING:

data/lib/haml/html/erb.rb

@@ -23,7 +23,7 @@ module Haml
       #
       # @param template [String] The ERB template
       # @return [String] The output document
-      # @see {Haml::HTML::ERB}
+      # @see Haml::HTML::ERB
       def self.compile(template)
         new(template).src
       end

data/lib/haml/precompiler.rb

@@ -10,10 +10,10 @@ module Haml
     # Designates an XHTML/XML element.
     ELEMENT         = ?%
 
-    # Designates a <tt><div></tt> element with the given class.
+    # Designates a `<div>` element with the given class.
     DIV_CLASS       = ?.
 
-    # Designates a <tt><div></tt> element with the given id.
+    # Designates a `<div>` element with the given id.
     DIV_ID          = ?#
 
     # Designates an XHTML/XML comment.
@@ -77,7 +77,7 @@ module Haml
     #   - else
     #     %p no!
     #
-    # The block is ended after <tt>%p no!</tt>, because <tt>else</tt>
+    # The block is ended after `%p no!`, because `else`
     # is a member of this array.
     MID_BLOCK_KEYWORD_REGEX = /^-\s*(#{%w[else elsif rescue ensure when end].join('|')})\b/
 
@@ -201,7 +201,7 @@ END
     # Processes a single line of Haml.
     #
     # This method doesn't return anything; it simply processes the line and
-    # adds the appropriate code to <tt>@precompiled</tt>.
+    # adds the appropriate code to `@precompiled`.
     def process_line(text, index)
       @index = index + 1
 
@@ -246,7 +246,13 @@ END
         # It's important to preserve tabulation modification for keywords
         # that involve choosing between posible blocks of code.
         if %w[else elsif when].include?(keyword)
-          @dont_indent_next_line, @dont_tab_up_next_text = @to_close_stack.last[1..2]
+          # @to_close_stack may not have a :script on top
+          # when the preceding "- if" has nothing nested
+          if @to_close_stack.last && @to_close_stack.last.first == :script
+            @dont_indent_next_line, @dont_tab_up_next_text = @to_close_stack.last[1..2]
+          else
+            push_and_tabulate([:script, @dont_indent_next_line, @dont_tab_up_next_text])
+          end
 
           # when is unusual in that either it will be indented twice,
           # or the case won't have created its own indentation
@@ -278,7 +284,7 @@ END
       text[MID_BLOCK_KEYWORD_REGEX, 1]
     end
 
-    # Evaluates <tt>text</tt> in the context of the scope object, but
+    # Evaluates `text` in the context of the scope object, but
     # does not output the result.
     def push_silent(text, can_suppress = false)
       flush_merged_text
@@ -286,7 +292,7 @@ END
       @precompiled << "#{text};"
     end
 
-    # Adds <tt>text</tt> to <tt>@buffer</tt> with appropriate tabulation
+    # Adds `text` to `@buffer` with appropriate tabulation
     # without parsing it.
     def push_merged_text(text, tab_change = 0, indent = true)
       text = !indent || @dont_indent_next_line || @options[:ugly] ? text : "#{'  ' * @output_tabs}#{text}"
@@ -294,7 +300,7 @@ END
       @dont_indent_next_line = false
     end
 
-    # Concatenate <tt>text</tt> to <tt>@buffer</tt> without tabulation.
+    # Concatenate `text` to `@buffer` without tabulation.
     def concat_merged_text(text)
       @to_merge << [:text, text, 0]
     end
@@ -356,18 +362,18 @@ END
       end
     end
 
-    # Adds +text+ to <tt>@buffer</tt> while flattening text.
+    # Adds +text+ to `@buffer` while flattening text.
     def push_flat(line)
       text = line.full.dup
       text = "" unless text.gsub!(/^#{@flat_spaces}/, '')
       @filter_buffer << "#{text}\n"
     end
 
-    # Causes <tt>text</tt> to be evaluated in the context of
-    # the scope object and the result to be added to <tt>@buffer</tt>.
+    # Causes `text` to be evaluated in the context of
+    # the scope object and the result to be added to `@buffer`.
     #
-    # If <tt>opts[:preserve_script]</tt> is true, Haml::Helpers#find_and_flatten is run on
-    # the result before it is added to <tt>@buffer</tt>
+    # If `opts[:preserve_script]` is true, Haml::Helpers#find_and_flatten is run on
+    # the result before it is added to `@buffer`
     def push_script(text, opts = {})
       raise SyntaxError.new("There's no Ruby code for = to evaluate.") if text.empty?
       return if options[:suppress_eval]
@@ -400,7 +406,7 @@ END
         !(opts[:in_tag] || opts[:nuke_inner_whitespace] || @options[:ugly])])
     end
 
-    # Causes <tt>text</tt> to be evaluated, and Haml::Helpers#find_and_flatten
+    # Causes `text` to be evaluated, and Haml::Helpers#find_and_flatten
     # to be run on it afterwards.
     def push_flat_script(text, options = {})
       flush_merged_text
@@ -416,13 +422,13 @@ END
       push_and_tabulate([:haml_comment])
     end
 
-    # Closes the most recent item in <tt>@to_close_stack</tt>.
+    # Closes the most recent item in `@to_close_stack`.
     def close
       tag, *rest = @to_close_stack.pop
       send("close_#{tag}", *rest)
     end
 
-    # Puts a line in <tt>@precompiled</tt> that will add the closing tag of
+    # Puts a line in `@precompiled` that will add the closing tag of
     # the most recently opened tag.
     def close_element(value)
       tag, nuke_outer_whitespace, nuke_inner_whitespace = value
@@ -474,8 +480,8 @@ END
       @template_tabs -= 1
     end
 
-    # Iterates through the classes and ids supplied through <tt>.</tt>
-    # and <tt>#</tt> syntax, and returns a hash with them as attributes,
+    # 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)
       attributes = {}
@@ -672,7 +678,7 @@ END
     end
 
     # Parses a line that will render as an XHTML tag, and adds the code that will
-    # render that tag to <tt>@precompiled</tt>.
+    # render that tag to `@precompiled`.
     def render_tag(line)
       tag_name, attributes, attributes_hashes, object_ref, nuke_outer_whitespace,
         nuke_inner_whitespace, action, value, last_line = parse_tag(line)
@@ -803,7 +809,7 @@ END
     end
 
     # Renders a line that creates an XHTML tag and has an implicit div because of
-    # <tt>.</tt> or <tt>#</tt>.
+    # `.` or `#`.
     def render_div(line)
       render_tag('%div' + line)
     end
@@ -991,8 +997,8 @@ END
       !flat? && @next_line.tabs > @line.tabs
     end
 
-    # Pushes value onto <tt>@to_close_stack</tt> and increases
-    # <tt>@template_tabs</tt>.
+    # Pushes value onto `@to_close_stack` and increases
+    # `@template_tabs`.
     def push_and_tabulate(value)
       @to_close_stack.push(value)
       @template_tabs += 1

data/lib/haml/util.rb

@@ -103,6 +103,17 @@ module Haml
       end
     end
 
+    # Restricts a number to falling within a given range.
+    # Returns the number if it falls within the range,
+    # or the closest value in the range if it doesn't.
+    #
+    # @param value [Numeric]
+    # @param range [Range<Numeric>]
+    # @return [Numeric]
+    def restrict(value, range)
+      [[value, range.first].max, range.last].min
+    end
+
     # Concatenates all strings that are adjacent in an array,
     # while leaving other elements as they are.
     # For example:
@@ -186,6 +197,14 @@ module Haml
       Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
     end
 
+    # Checks that the encoding of a string is valid in Ruby 1.9.
+    # If it's not, yields an error string describing the invalid character
+    # and the line on which it occurrs.
+    #
+    # @param str [String] The string of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
     def check_encoding(str)
       return if ruby1_8?
       return if str.valid_encoding?

data/lib/sass/engine.rb

@@ -107,15 +107,15 @@ module Sass
     # Includes named mixin declared using MIXIN_DEFINITION_CHAR
     MIXIN_INCLUDE_CHAR    = ?+
 
-    # The regex that matches properties of the form <tt>name: prop</tt>.
+    # The regex that matches properties of the form `name: prop`.
     PROPERTY_NEW_MATCHER = /^[^\s:"\[]+\s*[=:](\s|$)/
 
     # The regex that matches and extracts data from
-    # properties of the form <tt>name: prop</tt>.
+    # properties of the form `name: prop`.
     PROPERTY_NEW = /^([^\s=:"]+)(\s*=|:)(?:\s+|$)(.*)/
 
     # The regex that matches and extracts data from
-    # properties of the form <tt>:name prop</tt>.
+    # properties of the form `:name prop`.
     PROPERTY_OLD = /^:([^\s=:"]+)\s*(=?)(?:\s+|$)(.*)/
 
     # The default options for Sass::Engine.

data/lib/sass/error.rb

@@ -31,6 +31,10 @@ module Sass
     # : The name of the file in which the exception was raised,
     #   or `nil` if no filename is available.
     #
+    # `:mixin`
+    # : The name of the mixin in which the exception was raised,
+    #   or `nil` if it wasn't raised in a mixin.
+    #
     # `:line`
     # : The line of the file on which the error occurred. Never nil.
     #
@@ -57,11 +61,19 @@ module Sass
     # The name of the file in which the exception was raised.
     # This could be `nil` if no filename is available.
     #
-    # @return [String]
+    # @return [String, nil]
     def sass_filename
       sass_backtrace.first[:filename]
     end
 
+    # The name of the mixin in which the error occurred.
+    # This could be `nil` if the error occurred outside a mixin.
+    #
+    # @return [Fixnum]
+    def sass_mixin
+      sass_backtrace.first[:mixin]
+    end
+
     # The line of the Sass template on which the error occurred.
     #
     # @return [Fixnum]
@@ -77,15 +89,29 @@ module Sass
       sass_backtrace << attrs.reject {|k, v| v.nil?}
     end
 
-    # Modify the top Sass backtrace entry (that is, the last one)
+    # Modify the top Sass backtrace entries
+    # (that is, the most deeply nested ones)
     # to have the given attributes.
-    # If that entry already has one of the given attributes set,
-    # that takes precendence.
+    #
+    # Specifically, this goes through the backtrace entries
+    # from most deeply nested to least,
+    # setting the given attributes for each entry.
+    # If an entry already has one of the given attributes set,
+    # the pre-existing attribute takes precedence
+    # and is not used for less deeply-nested entries
+    # (even if they don't have that attribute set).
     #
     # @param attrs [Hash<Symbol, Object>] The information to add to the backtrace entry.
     #   See \{#sass\_backtrace}
     def modify_backtrace(attrs)
-      sass_backtrace[-1] = attrs.reject {|k, v| v.nil?}.merge(sass_backtrace.last)
+      attrs = attrs.reject {|k, v| v.nil?}
+      # Move backwards through the backtrace
+      (0...sass_backtrace.size).to_a.reverse.each do |i|
+        entry = sass_backtrace[i]
+        sass_backtrace[i] = attrs.merge(entry)
+        attrs.reject! {|k, v| entry.include?(k)}
+        break if attrs.empty?
+      end
     end
 
     # @return [String] The error message
@@ -99,7 +125,10 @@ module Sass
     # @return [Array<String>]
     def backtrace
       return nil if super.nil?
-      sass_backtrace.map {|h| "#{h[:filename] || "(sass)"}:#{h[:line]}"} + super
+      sass_backtrace.map do |h|
+        "#{h[:filename] || "(sass)"}:#{h[:line]}" +
+          (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
+      end + super
     end
 
     # Returns a string representation of the Sass backtrace.
@@ -111,7 +140,8 @@ module Sass
       "Syntax error: #{message}" +
         Haml::Util.enum_with_index(sass_backtrace).map do |entry, i|
         "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
-          " of #{entry[:filename] || default_filename}"
+          " of #{entry[:filename] || default_filename}" +
+          (entry[:mixin] ? ", in `#{entry[:mixin]}'" : "")
       end.join
     end
 

data/lib/sass/files.rb

@@ -1,5 +1,6 @@
 require 'digest/sha1'
 require 'pathname'
+require 'fileutils'
 
 module Sass
   # This module contains various bits of functionality

data/lib/sass/script/color.rb

@@ -5,7 +5,7 @@ module Sass::Script
   class Color < Literal
     class << self; include Haml::Util; end
 
-    # A hash from color names to [red, green, blue] value arrays.
+    # A hash from color names to `[red, green, blue]` value arrays.
     HTML4_COLORS = map_vals({
         'black'   => 0x000000,
         'silver'  => 0xc0c0c0,
@@ -24,7 +24,7 @@ module Sass::Script
         'teal'    => 0x008080,
         'aqua'    => 0x00ffff
       }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
-    # A hash from [red, green, blue] value arrays to color names.
+    # A hash from `[red, green, blue]` value arrays to color names.
     HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
 
     # Constructs an RGB or RGBA color object.
@@ -70,7 +70,7 @@ module Sass::Script
     # This is 1 unless otherwise defined.
     #
     # @return [Fixnum]
-    attr_accessor :alpha
+    attr_reader :alpha
 
     # Returns whether this color object is translucent;
     # that is, whether the alpha channel is non-1.
@@ -115,7 +115,7 @@ END
     #
     # For example:
     #
-    #     Color.new([10, 20, 30].with(:blue => 40)
+    #     Color.new([10, 20, 30]).with(:blue => 40)
     #       #=> rgb(10, 40, 30)
     #     Color.new([126, 126, 126]).with(:red => 0, :green => 255)
     #       #=> rgb(0, 255, 126)
@@ -189,10 +189,7 @@ END
     # {Color}
     # : Multiplies each of the RGB color channels together.
     #
-    # {Literal}
-    # : See {Literal#times}.
-    #
-    # @param other [Literal] The right-hand side of the operator
+    # @param other [Number, Color] The right-hand side of the operator
     # @return [Color] The resulting color
     # @raise [Sass::SyntaxError] if `other` is a number with units
     def times(other)
@@ -235,10 +232,7 @@ END
     # {Color}
     # : Takes each of this color's RGB color channels modulo the other color's.
     #
-    # {Literal}
-    # : See {Literal#mod}.
-    #
-    # @param other [Literal] The right-hand side of the operator
+    # @param other [Number, Color] The right-hand side of the operator
     # @return [Color] The resulting color
     # @raise [Sass::SyntaxError] if `other` is a number with units
     def mod(other)

data/lib/sass/script/functions.rb

@@ -275,52 +275,50 @@ module Sass::Script
     alias_method :opacity, :alpha
 
     # Makes a color more opaque.
-    # Takes a color and an amount between `0%` and `100%`
-    # and returns a color that's that much closer to opaque.
+    # Takes a color and an amount between 0 and 1,
+    # and returns a color with the opacity increased by that value.
     #
-    # For example, `50%` will make the color twice as opaque:
+    # For example:
     #
-    #     opacify(rgba(0, 0, 0, 0.5), 50%) => rgba(0, 0, 0, 0.75)
-    #     opacify(rgba(0, 0, 0, 0.8), 50%) => rgba(0, 0, 0, 0.9)
-    #     opacify(rgba(0, 0, 0, 0.2), 50%) => rgba(0, 0, 0, 0.8)
+    #     opacify(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.6)
+    #     opacify(rgba(0, 0, 17, 0.8), 0.2) => #001
     #
-    # Specifically, `opacify(color, n%)` will make the color
-    # `n%` closer to fully opaque.
+    # @param color [Color]
+    # @param amount [Number]
+    # @raise [ArgumentError] If `color` isn't a color,
+    #   or `number` isn't a number between 0 and 1
     def opacify(color, amount)
       assert_type color, :Color
       assert_type amount, :Number
-      unless (0..100).include?(amount.value)
-        raise ArgumentError.new("Amount #{amount} must be between 0% and 100%")
+      unless (0..1).include?(amount.value)
+        raise ArgumentError.new("Amount #{amount} must be between 0 and 1")
       end
 
-      color = color.dup
-      color.alpha += (1 - color.alpha) * (amount.value / 100.0)
-      color
+      color.with(:alpha => Haml::Util.restrict(color.alpha + amount.value, 0..1))
     end
     alias_method :fade_in, :opacify
 
     # Makes a color more transparent.
-    # Takes a color and an amount between `0%` and `100%`
-    # and returns a color that's that much closer to transparent.
+    # Takes a color and an amount between 0 and 1,
+    # and returns a color with the opacity decreased by that value.
     #
-    # For example, `50%` will make the color twice as transparent:
+    # For example:
     #
-    #     opacify(rgba(0, 0, 0, 0.5), 50%) => rgba(0, 0, 0, 0.25)
-    #     opacify(rgba(0, 0, 0, 0.8), 50%) => rgba(0, 0, 0, 0.4)
-    #     opacify(rgba(0, 0, 0, 0.2), 50%) => rgba(0, 0, 0, 0.1)
+    #     transparentize(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.4)
+    #     transparentize(rgba(0, 0, 0, 0.8), 0.2) => rgba(0, 0, 0, 0.6)
     #
-    # Specifically, `transparentize(color, n%)` will make the color
-    # `n%` closer to fully transparent.
+    # @param color [Color]
+    # @param amount [Number]
+    # @raise [ArgumentError] If `color` isn't a color,
+    #   or `number` isn't a number between 0 and 1
     def transparentize(color, amount)
       assert_type color, :Color
       assert_type amount, :Number
-      unless (0..100).include?(amount.value)
-        raise ArgumentError.new("Amount #{amount} must be between 0% and 100%")
+      unless (0..1).include?(amount.value)
+        raise ArgumentError.new("Amount #{amount} must be between 0 and 1")
       end
 
-      color = color.dup
-      color.alpha *= 1 - (amount.value / 100.0)
-      color
+      color.with(:alpha => Haml::Util.restrict(color.alpha - amount.value, 0..1))
     end
     alias_method :fade_out, :transparentize