haml-edge 2.3.80 → 2.3.81

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.80
+2.3.81

data/README.md

@@ -49,6 +49,16 @@ To do so, just add
 to `config/dependencies.rb` (or `config/init.rb` in a flat/very flat Merb application).
 Then it'll work just like it does in Rails.
 
+Sass can also be used with any Rack-enabled web framework.
+To do so, just add
+
+    require 'sass/plugin/rack'
+    use Sass::Plugin::Rack
+
+to `config.ru`.
+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).
 

data/VERSION

@@ -1 +1 @@
-2.3.80
+2.3.81

data/lib/haml/filters.rb

@@ -200,6 +200,23 @@ END
       end
     end
 
+    # Surrounds the filtered text with `<style>` and CDATA tags.
+    # Useful for including inline CSS.
+    module Css
+      include Base
+
+      # @see Base#render_with_options
+      def render_with_options(text, options)
+        <<END
+<style type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}>
+  /*<![CDATA[*/
+    #{text.rstrip.gsub("\n", "\n    ")}
+  /*]]>*/
+</style>
+END
+      end
+    end
+
     # Surrounds the filtered text with CDATA tags.
     module Cdata
       include Base

data/lib/haml/html.rb

@@ -227,7 +227,11 @@ module Haml
         if name == "script" &&
             (attr_hash['type'].nil? || attr_hash['type'] == "text/javascript") &&
             (attr_hash.keys - ['type']).empty?
-          return script_to_haml(tabs, options)
+          return to_haml_filter(:javascript, tabs, options)
+        elsif name == "style" &&
+            (attr_hash['type'].nil? || attr_hash['type'] == "text/css") &&
+            (attr_hash.keys - ['type']).empty?
+          return to_haml_filter(:css, tabs, options)
         end
 
         output = tabulate(tabs)
@@ -333,7 +337,7 @@ module Haml
         end
       end
 
-      def script_to_haml(tabs, options)
+      def to_haml_filter(filter, tabs, options)
         content =
           if children.first.is_a?(::Hpricot::CData)
             children.first.content
@@ -348,7 +352,7 @@ module Haml
           content.gsub!(/^#{original_indent}/, tabulate(tabs + 1))
         end
 
-        "#{tabulate(tabs)}:javascript\n#{content}"
+        "#{tabulate(tabs)}:#{filter}\n#{content}"
       end
 
       def static_attribute?(name, options)

data/lib/sass/plugin/merb.rb

@@ -27,11 +27,7 @@ unless defined?(Sass::MERB_LOADED)
 
     class Merb::Rack::Application
       def call_with_sass(env)
-        if !Sass::Plugin.checked_for_updates ||
-            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-          Sass::Plugin.update_stylesheets
-        end
-
+        Sass::Plugin.check_for_updates
         call_without_sass(env)
       end
       alias_method :call_without_sass, :call
@@ -42,11 +38,7 @@ unless defined?(Sass::MERB_LOADED)
 
     class MerbHandler
       def process_with_sass(request, response)
-        if !Sass::Plugin.checked_for_updates ||
-            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-          Sass::Plugin.update_stylesheets
-        end
-
+        Sass::Plugin.check_for_updates
         process_without_sass(request, response)
       end
       alias_method :process_without_sass, :process

data/lib/sass/plugin/rack.rb

@@ -0,0 +1,65 @@
+require 'sass/plugin'
+
+module Sass
+  module Plugin
+    # Rack middleware for compiling Sass code.
+    #
+    # ## Activate
+    #
+    #     require 'sass/plugin/rack'
+    #     use Sass::Plugin::Rack
+    #
+    # ## Customize
+    #
+    #     Sass::Plugin.options.merge(
+    #       :cache_location => './tmp/sass-cache',
+    #       :never_update => environment != :production,
+    #       :full_exception => environment != :production)
+    #
+    # {file:SASS_REFERENCE.md#options See the Reference for more options}.
+    #
+    # ## Use
+    #
+    # Put your Sass files in `public/stylesheets/sass`.
+    # Your CSS will be generated in `public/stylesheets`,
+    # and regenerated every request if necessary.
+    # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
+    # That's all there is to it!
+    class Rack
+      # Initialize the middleware.
+      #
+      # @param app [#call] The Rack application
+      def initialize(app)
+        @app = app
+        self.class.disable_native_plugin!
+      end
+
+      # Process a request, checking the Sass stylesheets for changes
+      # and updating them if necessary.
+      #
+      # @param env The Rack request environment
+      # @return [(#to_i, Hash<String, String>, Object)] The Rack response
+      def call(env)
+        Sass::Plugin.check_for_updates
+        @app.call(env)
+      end
+
+      # Disable the native Rails or Merb plugins, if they're enabled.
+      # This is automatically done once the Rack plugin is activated.
+      # This is done so that the stylesheets aren't checked twice for each request.
+      def self.disable_native_plugin!
+        if defined?(Merb::Rack::Application) &&
+            Haml::Util.has?(:instance_method, Merb::Rack::Application, :call_without_sass)
+          Merb::Rack::Application.instance_eval {alias_method :call, :call_without_sass}
+        end
+
+        if defined?(ActionDispatch::Callbacks.to_prepare)
+          ActionDispatch::Callbacks.instance_eval {undef :__sass_process}
+        elsif defined?(ActionController::Base) &&
+            Haml::Util.has?(:instance_method, ActionController::Base, :sass_old_process)
+          ActionController::Base.instance_eval {alias_method :process, :sass_old_process}
+        end
+      end
+    end
+  end
+end

data/lib/sass/plugin/rails.rb

@@ -9,7 +9,7 @@ unless defined?(Sass::RAILS_LOADED)
 
   if defined?(ActionDispatch::Callbacks.to_prepare)
     # Rails >= 3.0.0
-    ActionDispatch::Callbacks.to_prepare {Sass::Plugin.check_for_updates}
+    ActionDispatch::Callbacks.to_prepare(:sass_process) {Sass::Plugin.check_for_updates}
   else
     module ActionController
       class Base

data/lib/sass/plugin.rb

@@ -1,4 +1,4 @@
-require 'sass/engine'
+require 'sass'
 
 module Sass
   # This module handles the compilation of Sass files.
@@ -7,7 +7,9 @@ module Sass
   #
   # This module is used as the primary interface with Sass
   # when it's used as a plugin for various frameworks.
-  # Currently Rails and Merb are supported out of the box.
+  # All Rack-enabled frameworks are supported out of the box.
+  # The plugin is {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
+  # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
   module Plugin
     include Haml::Util
     extend self

data/lib/sass/script/color.rb

@@ -27,13 +27,61 @@ module Sass::Script
     # A hash from [red, green, blue] value arrays to color names.
     HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
 
+    # The red component of the color.
+    #
+    # @return [Fixnum]
+    attr_reader :red
+
+    # The green component of the color.
+    #
+    # @return [Fixnum]
+    attr_reader :green
+
+    # The blue component of the color.
+    #
+    # @return [Fixnum]
+    attr_reader :blue
+
     # @param rgb [Array<Fixnum>] A three-element array of the red, green, and blue values (respectively)
     #   of the color
     # @raise [Sass::SyntaxError] if any color value isn't between 0 and 255
     def initialize(rgb)
       rgb = rgb.map {|c| c.to_i}
       raise Sass::SyntaxError.new("Color values must be between 0 and 255") if rgb.any? {|c| c < 0 || c > 255}
-      super(rgb)
+      @red = rgb[0]
+      @green = rgb[1]
+      @blue = rgb[2]
+      super(nil)
+    end
+
+    # @deprecated This will be removed in version 2.6.
+    # @see #rgb
+    def value
+      warn <<END
+DEPRECATION WARNING:
+The Sass::Script::Color #value attribute is deprecated and will be
+removed in version 2.6. Use the #rgb attribute instead.
+END
+      rgb
+    end
+
+    # Returns the red, green, and blue components of the color.
+    #
+    # @return [Array<Fixnum>] A three-element array of the red, green, and blue
+    #   values (respectively) of the color
+    def rgb
+      [red, green, blue]
+    end
+
+    # The SassScript `==` operation.
+    # **Note that this returns a {Sass::Script::Bool} object,
+    # not a Ruby boolean**.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Bool] True if this literal is the same as the other,
+    #   false otherwise
+    def eq(other)
+      Sass::Script::Bool.new(other.is_a?(Color) && rgb == other.rgb)
     end
 
     # The SassScript `+` operation.
@@ -157,8 +205,8 @@ module Sass::Script
     #
     # @return [String] The string representation
     def to_s
-      return HTML4_COLORS_REVERSE[@value] if HTML4_COLORS_REVERSE[@value]
-      red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') }
+      return HTML4_COLORS_REVERSE[rgb] if HTML4_COLORS_REVERSE[rgb]
+      red, green, blue = rgb.map { |num| num.to_s(16).rjust(2, '0') }
       "##{red}#{green}#{blue}"
     end
     alias_method :inspect, :to_s
@@ -167,17 +215,16 @@ module Sass::Script
 
     def piecewise(other, operation)
       other_num = other.is_a? Number
-      other_val = other.value
       if other_num && !other.unitless?
         raise Sass::SyntaxError.new("Cannot add a number with units (#{other}) to a color (#{self}).") 
       end
 
-      rgb = []
+      result = []
       for i in (0...3)
-        res = @value[i].send(operation, other_num ? other_val : other_val[i])
-        rgb[i] = [ [res, 255].min, 0 ].max
+        res = rgb[i].send(operation, other_num ? other.value : other.rgb[i])
+        result[i] = [ [res, 255].min, 0 ].max
       end
-      Color.new(rgb)
+      Color.new(result)
     end
   end
 end

data/lib/sass/script/funcall.rb

@@ -42,7 +42,7 @@ module Sass
 
         return Functions::EvaluationContext.new(environment.options).send(name, *args)
       rescue ArgumentError => e
-        raise e unless e.backtrace.first =~ /:in `(block in )?(#{name}|perform)'$/
+        raise e unless e.backtrace.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
         raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
       end
     end

data/lib/sass/script/functions.rb

@@ -26,10 +26,29 @@ module Sass::Script
   # \{#abs}
   # : Returns the absolute value of a number.
   #
-  # You can add your own functions to this module,
-  # but there are a few things to keep in mind.
+  # These functions are described in more detail below.
+  #
+  # ## Adding Custom Functions
+  #
+  # New Sass functions can be added by adding Ruby methods to this module.
+  # For example:
+  #
+  #     module Sass::Script::Functions
+  #       def reverse(string)
+  #         assert_type string, :String
+  #         Sass::Script::String.new(string.value.reverse)
+  #       end
+  #     end
+  #
+  # There are a few things to keep in mind when modifying this module.
   # First of all, the arguments passed are {Sass::Script::Literal} objects.
   # Literal objects are also expected to be returned.
+  # This means that Ruby values must be unwrapped and wrapped.
+  #
+  # Most Literal objects support the {Sass::Script::Literal#value value} accessor
+  # for getting their Ruby values.
+  # Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb},
+  # {Sass::Script::Color#red red}, {Sass::Script::Color#blue green}, or {Sass::Script::Color#blue blue}.
   #
   # Second, making Ruby functions accessible from Sass introduces the temptation
   # to do things like database access within stylesheets.
@@ -57,6 +76,22 @@ module Sass::Script
       def initialize(options)
         @options = options
       end
+
+      # Asserts that the type of a given SassScript value
+      # is the expected type (designated by a symbol).
+      # For example:
+      #
+      #     assert_type value, :String
+      #     assert_type value, :Number
+      #
+      # Valid types are `:Bool`, `:Color`, `:Number`, and `:String`.
+      #
+      # @param value [Sass::Script::Literal] A SassScript value
+      # @param type [Symbol] The name of the type the value is expected to be
+      def assert_type(value, type)
+        return if value.is_a?(Sass::Script.const_get(type))
+        raise ArgumentError.new("#{value.inspect} is not a #{type.to_s.downcase}")
+      end
     end
 
     instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
@@ -70,6 +105,10 @@ module Sass::Script
     # @param blue
     #   A number between 0 and 255 inclusive
     def rgb(red, green, blue)
+      assert_type red, :Number
+      assert_type green, :Number
+      assert_type blue, :Number
+
       [red.value, green.value, blue.value].each do |v|
         next unless v < 0 || v > 255
         raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
@@ -78,7 +117,7 @@ module Sass::Script
     end
 
     # Creates a {Color} object from hue, saturation, and lightness
-    # as per the CSS3 spec (http://www.w3.org/TR/css3-color/#hsl-color).
+    # as per the [CSS3 spec](http://www.w3.org/TR/css3-color/#hsl-color).
     #
     # @param hue [Number] The hue of the color.
     #   Should be between 0 and 360 degrees, inclusive
@@ -89,6 +128,10 @@ module Sass::Script
     # @return [Color] The resulting color
     # @raise [ArgumentError] if `saturation` or `lightness` are out of bounds
     def hsl(hue, saturation, lightness)
+      assert_type hue, :Number
+      assert_type saturation, :Number
+      assert_type lightness, :Number
+
       original_s = saturation
       original_l = lightness
       # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
@@ -107,6 +150,36 @@ module Sass::Script
                  hue_to_rgb(m1, m2, h - 1.0/3)].map { |c| (c * 0xff).round })
     end
 
+    # Returns the red component of a color.
+    #
+    # @param color [Color]
+    # @return [Number]
+    # @raise [ArgumentError] If `color` isn't a color
+    def red(color)
+      assert_type color, :Color
+      Sass::Script::Number.new(color.red)
+    end
+
+    # Returns the green component of a color.
+    #
+    # @param color [Color]
+    # @return [Number]
+    # @raise [ArgumentError] If `color` isn't a color
+    def green(color)
+      assert_type color, :Color
+      Sass::Script::Number.new(color.green)
+    end
+
+    # Returns the blue component of a color.
+    #
+    # @param color [Color]
+    # @return [Number]
+    # @raise [ArgumentError] If `color` isn't a color
+    def blue(color)
+      assert_type color, :Color
+      Sass::Script::Number.new(color.blue)
+    end
+
     # Converts a decimal number to a percentage.
     # For example:
     #
@@ -117,7 +190,7 @@ module Sass::Script
     # @raise [ArgumentError] If `value` isn't a unitless number
     def percentage(value)
       unless value.is_a?(Sass::Script::Number) && value.unitless?
-        raise ArgumentError.new("#{value} is not a unitless number")
+        raise ArgumentError.new("#{value.inspect} is not a unitless number")
       end
       Sass::Script::Number.new(value.value * 100, ['%'])
     end
@@ -180,10 +253,7 @@ module Sass::Script
     # another numeric value with the same units.
     # It yields a number to a block to perform the operation and return a number
     def numeric_transformation(value)
-      unless value.is_a?(Sass::Script::Number)
-        calling_function = Haml::Util.caller_info[2]
-        raise Sass::SyntaxError.new("#{value} is not a number for `#{calling_function}'")
-      end
+      assert_type value, :Number
       Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
     end
 

data/lib/sass/script/lexer.rb

@@ -52,11 +52,11 @@ module Sass
       # A hash of regular expressions that are used for tokenizing.
       REGULAR_EXPRESSIONS = {
         :whitespace => /\s*/,
-        :variable => /!(\w+)/,
-        :ident => /(\\.|\#\{|[^\s\\+\-*\/%(),=!])+/,
+        :variable => /!([\w-]+)/,
+        :ident => /(\\.|\#\{|[^\s\\+*\/%(),=!])+/,
         :string_end => /((?:\\.|\#[^{]|[^"\\#])*)(?:"|(?=#\{))/,
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
-        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})/,
+        :color => /\##{"([0-9a-fA-F]{1,2})" * 3}|(#{Color::HTML4_COLORS.keys.join("|")})(?!\()/,
         :bool => /(true|false)\b/,
         :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
       }
@@ -162,16 +162,6 @@ module Sass
       def op
         prev_chr = @scanner.string[@scanner.pos - 1].chr
         return unless op = @scanner.scan(REGULAR_EXPRESSIONS[:op])
-        if @prev && op == '-' && prev_chr !~ /\s/ &&
-            [:bool, :ident, :const].include?(@prev.type)
-          warn(<<END)
-DEPRECATION WARNING:
-On line #{@line}, character #{last_match_position}#{" of '#{@filename}'" if @filename}
-- will be allowed as part of variable names in version 2.4.
-Please add whitespace to separate it from the previous token.
-END
-        end
-
         [OPERATORS[op]]
       end
 

data/test/haml/engine_test.rb

@@ -909,6 +909,21 @@ END
 END
   end
 
+  def test_css_filter
+    assert_equal(<<CSS, render(<<SASS))
+<style type='text/css'>
+  /*<![CDATA[*/
+    #foo {
+      bar: baz; }
+  /*]]>*/
+</style>
+CSS
+:css
+  #foo {
+    bar: baz; }
+SASS
+  end
+
   def test_local_assigns_dont_modify_class
     assert_equal("bar\n", render("= foo", :locals => {:foo => 'bar'}))
     assert_equal(nil, defined?(foo))

data/test/haml/html2haml/erb_tests.rb

@@ -59,6 +59,21 @@ HAML
 HTML
   end
 
+  def test_erb_in_style
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+:css
+  foo {
+      bar: \#{"baz"};
+  }
+HAML
+<style type="text/css">
+    foo {
+        bar: <%= "baz" %>;
+    }
+</style>
+HTML
+  end
+
   def test_erb_in_line
     assert_equal 'foo bar #{baz}', render_erb('foo bar <%= baz %>')
     assert_equal 'foo bar #{baz}! Bang.', render_erb('foo bar <%= baz %>! Bang.')

data/test/haml/html2haml_test.rb

@@ -198,6 +198,21 @@ HAML
 HTML
   end
 
+  def test_style_to_css_filter
+    assert_equal(<<HAML.rstrip, render_erb(<<HTML))
+:css
+  foo {
+      bar: baz;
+  }
+HAML
+<style type="text/css">
+    foo {
+        bar: baz;
+    }
+</style>
+HTML
+  end
+
   def test_inline_conditional_comment
     assert_equal(<<HAML.rstrip, render(<<HTML))
 /[if foo] bar baz

data/test/sass/data/hsl-rgb.txt

@@ -0,0 +1,319 @@
+hsl(0, 100%, 50%)
+hsl(60, 100%, 50%)
+hsl(120, 100%, 50%)
+hsl(180, 100%, 50%)
+hsl(240, 100%, 50%)
+hsl(300, 100%, 50%)
+====
+rgb(255, 0, 0)
+rgb(255, 255, 0)
+rgb(0, 255, 0)
+rgb(0, 255, 255)
+rgb(0, 0, 255)
+rgb(255, 0, 255)
+
+hsl(-360, 100%, 50%)
+hsl(-300, 100%, 50%)
+hsl(-240, 100%, 50%)
+hsl(-180, 100%, 50%)
+hsl(-120, 100%, 50%)
+hsl(-60, 100%, 50%)
+====
+rgb(255, 0, 0)
+rgb(255, 255, 0)
+rgb(0, 255, 0)
+rgb(0, 255, 255)
+rgb(0, 0, 255)
+rgb(255, 0, 255)
+
+hsl(360, 100%, 50%)
+hsl(420, 100%, 50%)
+hsl(480, 100%, 50%)
+hsl(540, 100%, 50%)
+hsl(600, 100%, 50%)
+hsl(660, 100%, 50%)
+====
+rgb(255, 0, 0)
+rgb(255, 255, 0)
+rgb(0, 255, 0)
+rgb(0, 255, 255)
+rgb(0, 0, 255)
+rgb(255, 0, 255)
+
+hsl(6120, 100%, 50%)
+hsl(-9660, 100%, 50%)
+hsl(99840, 100%, 50%)
+hsl(-900, 100%, 50%)
+hsl(-104880, 100%, 50%)
+hsl(2820, 100%, 50%)
+====
+rgb(255, 0, 0)
+rgb(255, 255, 0)
+rgb(0, 255, 0)
+rgb(0, 255, 255)
+rgb(0, 0, 255)
+rgb(255, 0, 255)
+
+hsl(0, 100%, 50%)
+hsl(12, 100%, 50%)
+hsl(24, 100%, 50%)
+hsl(36, 100%, 50%)
+hsl(48, 100%, 50%)
+hsl(60, 100%, 50%)
+hsl(72, 100%, 50%)
+hsl(84, 100%, 50%)
+hsl(96, 100%, 50%)
+hsl(108, 100%, 50%)
+hsl(120, 100%, 50%)
+====
+rgb(255, 0, 0)
+rgb(255, 51, 0)
+rgb(255, 102, 0)
+rgb(255, 153, 0)
+rgb(255, 204, 0)
+rgb(255, 255, 0)
+rgb(204, 255, 0)
+rgb(153, 255, 0)
+rgb(102, 255, 0)
+rgb(51, 255, 0)
+rgb(0, 255, 0)
+
+hsl(120, 100%, 50%)
+hsl(132, 100%, 50%)
+hsl(144, 100%, 50%)
+hsl(156, 100%, 50%)
+hsl(168, 100%, 50%)
+hsl(180, 100%, 50%)
+hsl(192, 100%, 50%)
+hsl(204, 100%, 50%)
+hsl(216, 100%, 50%)
+hsl(228, 100%, 50%)
+hsl(240, 100%, 50%)
+====
+rgb(0, 255, 0)
+rgb(0, 255, 51)
+rgb(0, 255, 102)
+rgb(0, 255, 153)
+rgb(0, 255, 204)
+rgb(0, 255, 255)
+rgb(0, 204, 255)
+rgb(0, 153, 255)
+rgb(0, 102, 255)
+rgb(0, 51, 255)
+rgb(0, 0, 255)
+
+hsl(240, 100%, 50%)
+hsl(252, 100%, 50%)
+hsl(264, 100%, 50%)
+hsl(276, 100%, 50%)
+hsl(288, 100%, 50%)
+hsl(300, 100%, 50%)
+hsl(312, 100%, 50%)
+hsl(324, 100%, 50%)
+hsl(336, 100%, 50%)
+hsl(348, 100%, 50%)
+hsl(360, 100%, 50%)
+====
+rgb(0, 0, 255)
+rgb(51, 0, 255)
+rgb(102, 0, 255)
+rgb(153, 0, 255)
+rgb(204, 0, 255)
+rgb(255, 0, 255)
+rgb(255, 0, 204)
+rgb(255, 0, 153)
+rgb(255, 0, 102)
+rgb(255, 0, 51)
+rgb(255, 0, 0)
+
+hsl(0, 20%, 50%)
+hsl(0, 60%, 50%)
+hsl(0, 100%, 50%)
+====
+rgb(153, 102, 102)
+rgb(204, 51, 51)
+rgb(255, 0, 0)
+
+hsl(60, 20%, 50%)
+hsl(60, 60%, 50%)
+hsl(60, 100%, 50%)
+====
+rgb(153, 153, 102)
+rgb(204, 204, 51)
+rgb(255, 255, 0)
+
+hsl(120, 20%, 50%)
+hsl(120, 60%, 50%)
+hsl(120, 100%, 50%)
+====
+rgb(102, 153, 102)
+rgb(51, 204, 51)
+rgb(0, 255, 0)
+
+hsl(180, 20%, 50%)
+hsl(180, 60%, 50%)
+hsl(180, 100%, 50%)
+====
+rgb(102, 153, 153)
+rgb(51, 204, 204)
+rgb(0, 255, 255)
+
+hsl(240, 20%, 50%)
+hsl(240, 60%, 50%)
+hsl(240, 100%, 50%)
+====
+rgb(102, 102, 153)
+rgb(51, 51, 204)
+rgb(0, 0, 255)
+
+hsl(300, 20%, 50%)
+hsl(300, 60%, 50%)
+hsl(300, 100%, 50%)
+====
+rgb(153, 102, 153)
+rgb(204, 51, 204)
+rgb(255, 0, 255)
+
+hsl(0, 100%, 0%)
+hsl(0, 100%, 10%)
+hsl(0, 100%, 20%)
+hsl(0, 100%, 30%)
+hsl(0, 100%, 40%)
+hsl(0, 100%, 50%)
+hsl(0, 100%, 60%)
+hsl(0, 100%, 70%)
+hsl(0, 100%, 80%)
+hsl(0, 100%, 90%)
+hsl(0, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(51, 0, 0)
+rgb(102, 0, 0)
+rgb(153, 0, 0)
+rgb(204, 0, 0)
+rgb(255, 0, 0)
+rgb(255, 51, 51)
+rgb(255, 102, 102)
+rgb(255, 153, 153)
+rgb(255, 204, 204)
+rgb(255, 255, 255)
+
+hsl(60, 100%, 0%)
+hsl(60, 100%, 10%)
+hsl(60, 100%, 20%)
+hsl(60, 100%, 30%)
+hsl(60, 100%, 40%)
+hsl(60, 100%, 50%)
+hsl(60, 100%, 60%)
+hsl(60, 100%, 70%)
+hsl(60, 100%, 80%)
+hsl(60, 100%, 90%)
+hsl(60, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(51, 51, 0)
+rgb(102, 102, 0)
+rgb(153, 153, 0)
+rgb(204, 204, 0)
+rgb(255, 255, 0)
+rgb(255, 255, 51)
+rgb(255, 255, 102)
+rgb(255, 255, 153)
+rgb(255, 255, 204)
+rgb(255, 255, 255)
+
+hsl(120, 100%, 0%)
+hsl(120, 100%, 10%)
+hsl(120, 100%, 20%)
+hsl(120, 100%, 30%)
+hsl(120, 100%, 40%)
+hsl(120, 100%, 50%)
+hsl(120, 100%, 60%)
+hsl(120, 100%, 70%)
+hsl(120, 100%, 80%)
+hsl(120, 100%, 90%)
+hsl(120, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(0, 51, 0)
+rgb(0, 102, 0)
+rgb(0, 153, 0)
+rgb(0, 204, 0)
+rgb(0, 255, 0)
+rgb(51, 255, 51)
+rgb(102, 255, 102)
+rgb(153, 255, 153)
+rgb(204, 255, 204)
+rgb(255, 255, 255)
+
+hsl(180, 100%, 0%)
+hsl(180, 100%, 10%)
+hsl(180, 100%, 20%)
+hsl(180, 100%, 30%)
+hsl(180, 100%, 40%)
+hsl(180, 100%, 50%)
+hsl(180, 100%, 60%)
+hsl(180, 100%, 70%)
+hsl(180, 100%, 80%)
+hsl(180, 100%, 90%)
+hsl(180, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(0, 51, 51)
+rgb(0, 102, 102)
+rgb(0, 153, 153)
+rgb(0, 204, 204)
+rgb(0, 255, 255)
+rgb(51, 255, 255)
+rgb(102, 255, 255)
+rgb(153, 255, 255)
+rgb(204, 255, 255)
+rgb(255, 255, 255)
+
+hsl(240, 100%, 0%)
+hsl(240, 100%, 10%)
+hsl(240, 100%, 20%)
+hsl(240, 100%, 30%)
+hsl(240, 100%, 40%)
+hsl(240, 100%, 50%)
+hsl(240, 100%, 60%)
+hsl(240, 100%, 70%)
+hsl(240, 100%, 80%)
+hsl(240, 100%, 90%)
+hsl(240, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(0, 0, 51)
+rgb(0, 0, 102)
+rgb(0, 0, 153)
+rgb(0, 0, 204)
+rgb(0, 0, 255)
+rgb(51, 51, 255)
+rgb(102, 102, 255)
+rgb(153, 153, 255)
+rgb(204, 204, 255)
+rgb(255, 255, 255)
+
+hsl(300, 100%, 0%)
+hsl(300, 100%, 10%)
+hsl(300, 100%, 20%)
+hsl(300, 100%, 30%)
+hsl(300, 100%, 40%)
+hsl(300, 100%, 50%)
+hsl(300, 100%, 60%)
+hsl(300, 100%, 70%)
+hsl(300, 100%, 80%)
+hsl(300, 100%, 90%)
+hsl(300, 100%, 100%)
+====
+rgb(0, 0, 0)
+rgb(51, 0, 51)
+rgb(102, 0, 102)
+rgb(153, 0, 153)
+rgb(204, 0, 204)
+rgb(255, 0, 255)
+rgb(255, 51, 255)
+rgb(255, 102, 255)
+rgb(255, 153, 255)
+rgb(255, 204, 255)
+rgb(255, 255, 255)

data/test/sass/functions_test.rb

@@ -3,44 +3,17 @@ require File.dirname(__FILE__) + '/../../lib/sass'
 require 'sass/script'
 
 class SassFunctionTest < Test::Unit::TestCase
-  def test_hsl
-    # These tests adapted from the w3c browser tests
-    # http://www.w3.org/Style/CSS/Test/CSS3/Color/20070927/html4/t040204-hsl-h-rotating-b.htm
-    red = [255, 0, 0]
-    assert_rgb_hsl(red, ['0', '100%', '50%'])
-    assert_rgb_hsl(red, ['-360', '100%', '50%'])
-    assert_rgb_hsl(red, ['360', '100%', '50%'])
-    assert_rgb_hsl(red, ['6120', '100%', '50%'])
-
-    yellow = [255, 255, 0]
-    assert_rgb_hsl(yellow, ['60', '100%', '50%'])
-    assert_rgb_hsl(yellow, ['-300', '100%', '50%'])
-    assert_rgb_hsl(yellow, ['420', '100%', '50%'])
-    assert_rgb_hsl(yellow, ['-9660', '100%', '50%'])
-
-    green = [0, 255, 0]
-    assert_rgb_hsl(green, ['120', '100%', '50%'])
-    assert_rgb_hsl(green, ['-240', '100%', '50%'])
-    assert_rgb_hsl(green, ['480', '100%', '50%'])
-    assert_rgb_hsl(green, ['99840', '100%', '50%'])
-
-    cyan = [0, 255, 255]
-    assert_rgb_hsl(cyan, ['180', '100%', '50%'])
-    assert_rgb_hsl(cyan, ['-180', '100%', '50%'])
-    assert_rgb_hsl(cyan, ['540', '100%', '50%'])
-    assert_rgb_hsl(cyan, ['-900', '100%', '50%'])
-
-    blue = [0, 0, 255]
-    assert_rgb_hsl(blue, ['240', '100%', '50%'])
-    assert_rgb_hsl(blue, ['-120', '100%', '50%'])
-    assert_rgb_hsl(blue, ['600', '100%', '50%'])
-    assert_rgb_hsl(blue, ['-104880', '100%', '50%'])
-
-    purple = [255, 0, 255]
-    assert_rgb_hsl(purple, ['300', '100%', '50%'])
-    assert_rgb_hsl(purple, ['-60', '100%', '50%'])
-    assert_rgb_hsl(purple, ['660', '100%', '50%'])
-    assert_rgb_hsl(purple, ['2820', '100%', '50%'])
+  # Tests taken from:
+  #   http://www.w3.org/Style/CSS/Test/CSS3/Color/20070927/html4/t040204-hsl-h-rotating-b.htm
+  #   http://www.w3.org/Style/CSS/Test/CSS3/Color/20070927/html4/t040204-hsl-values-b.htm
+  File.read(File.dirname(__FILE__) + "/data/hsl-rgb.txt").split("\n\n").each do |chunk|
+    hsls, rgbs = chunk.strip.split("====")
+    hsls.strip.split("\n").zip(rgbs.strip.split("\n")) do |hsl, rgb|
+      method = "test_hsl: #{hsl} = #{rgb}"
+      define_method(method) do
+        assert_equal(evaluate(rgb), evaluate(hsl))
+      end
+    end
   end
 
   def test_hsl_checks_bounds
@@ -48,13 +21,22 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_error_message("Lightness 256 must be between 0% and 100% for `hsl'", "hsl(10, 10, 256%)");
   end
 
+  def test_hsl_checks_types
+    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(\"foo\", 10, 12)");
+    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(10, \"foo\", 12)");
+    assert_error_message("\"foo\" is not a number for `hsl'", "hsl(10, 10, \"foo\")");
+  end
+
   def test_percentage
     assert_equal("50%",  evaluate("percentage(.5)"))
     assert_equal("100%", evaluate("percentage(1)"))
     assert_equal("25%",  evaluate("percentage(25px / 100px)"))
+  end
+
+  def test_percentage_checks_types
     assert_error_message("25px is not a unitless number for `percentage'", "percentage(25px)")
     assert_error_message("#cccccc is not a unitless number for `percentage'", "percentage(#ccc)")
-    assert_error_message("string is not a unitless number for `percentage'", %Q{percentage("string")})
+    assert_error_message("\"string\" is not a unitless number for `percentage'", %Q{percentage("string")})
   end
 
   def test_round
@@ -69,14 +51,14 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("4",   evaluate("floor(4.8)"))
     assert_equal("4px", evaluate("floor(4.8px)"))
 
-    assert_error_message("foo is not a number for `floor'", "floor(\"foo\")")
+    assert_error_message("\"foo\" is not a number for `floor'", "floor(\"foo\")")
   end
 
   def test_ceil
     assert_equal("5",   evaluate("ceil(4.1)"))
     assert_equal("5px", evaluate("ceil(4.8px)"))
 
-    assert_error_message("a is not a number for `ceil'", "ceil(\"a\")")
+    assert_error_message("\"a\" is not a number for `ceil'", "ceil(\"a\")")
   end
 
   def test_abs
@@ -92,7 +74,9 @@ class SassFunctionTest < Test::Unit::TestCase
     assert_equal("#123456", evaluate("rgb(18, 52, 86)"))
     assert_equal("#beaded", evaluate("rgb(190, 173, 237)"))
     assert_equal("#00ff7f", evaluate("rgb(0, 255, 127)"))
+  end
 
+  def test_rgb_tests_bounds
     assert_error_message("Color value 256 must be between 0 and 255 inclusive for `rgb'",
       "rgb(256, 1, 1)")
     assert_error_message("Color value 256 must be between 0 and 255 inclusive for `rgb'",
@@ -105,13 +89,38 @@ class SassFunctionTest < Test::Unit::TestCase
       "rgb(-1, 1, 1)")
   end
 
-  private
+  def test_rgb_tests_types
+    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(\"foo\", 10, 12)");
+    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(10, \"foo\", 12)");
+    assert_error_message("\"foo\" is not a number for `rgb'", "rgb(10, 10, \"foo\")");
+  end
 
-  def assert_rgb_hsl(rgb, hsl)
-    hsl = hsl.map {|v| Sass::Script::Parser.parse v, 0, 0 }
-    assert_equal(rgb, Sass::Script::Functions::EvaluationContext.new({}).hsl(*hsl).value)
+  def test_red
+    assert_equal("18", evaluate("red(#123456)"))
   end
 
+  def test_red_exception
+    assert_error_message("12 is not a color for `red'", "red(12)")
+  end
+
+  def test_green
+    assert_equal("52", evaluate("green(#123456)"))
+  end
+
+  def test_green_exception
+    assert_error_message("12 is not a color for `green'", "green(12)")
+  end
+
+  def test_blue
+    assert_equal("86", evaluate("blue(#123456)"))
+  end
+
+  def test_blue_exception
+    assert_error_message("12 is not a color for `blue'", "blue(12)")
+  end
+
+  private
+
   def evaluate(value)
     Sass::Script::Parser.parse(value, 0, 0).perform(Sass::Environment.new).to_s
   end

data/test/sass/script_test.rb

@@ -102,22 +102,8 @@ WARN
     assert_equal "public_instance_methods()", resolve("public_instance_methods()")
   end
 
-  def test_hyphen_warning
-    a = Sass::Script::String.new("a")
-    b = Sass::Script::String.new("b")
-    assert_warning(<<WARN) {eval("!a-!b", {}, env("a" => a, "b" => b))}
-DEPRECATION WARNING:
-On line 1, character 3 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 2.4.
-Please add whitespace to separate it from the previous token.
-WARN
-
-    assert_warning(<<WARN) {eval("true-false")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 2.4.
-Please add whitespace to separate it from the previous token.
-WARN
+  def test_hyphenated_variables
+    assert_equal("a-b", resolve("!a-b", {}, env("a-b" => Sass::Script::String.new("a-b"))))
   end
 
   def test_ruby_equality
@@ -225,6 +211,12 @@ WARN
     assert_equal "true", resolve("1.1cm == 11mm")
   end
 
+  # Regression Tests
+
+  def test_funcall_has_higher_precedence_than_color_name
+    assert_equal "teal(12)", resolve("teal(12)")
+  end
+
   private
 
   def resolve(str, opts = {}, environment = env)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.3.80
+  version: 2.3.81
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -86,6 +86,7 @@ files:
 - lib/sass/plugin
 - lib/sass/plugin/merb.rb
 - lib/sass/plugin/rails.rb
+- lib/sass/plugin/rack.rb
 - lib/sass/repl.rb
 - lib/sass/script.rb
 - lib/sass/script
@@ -197,6 +198,8 @@ files:
 - test/sass/css2sass_test.rb
 - test/sass/engine_test.rb
 - test/sass/functions_test.rb
+- test/sass/data
+- test/sass/data/hsl-rgb.txt
 - test/sass/more_results
 - test/sass/more_results/more1.css
 - test/sass/more_results/more1_with_line_comments.css