haml 2.0.10 → 2.2.0

data/lib/sass/plugin/merb.rb

@@ -10,10 +10,11 @@ unless defined?(Sass::MERB_LOADED)
     env  = Merb.environment
   end
 
-  Sass::Plugin.options.merge!(:template_location  => root + '/public/stylesheets/sass',
-                              :css_location       => root + '/public/stylesheets',
-                              :always_check       => env != "production",
-                              :full_exception     => env != "production")
+  Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass',
+                              :css_location      => root + '/public/stylesheets',
+                              :cache_location    => root + '/tmp/sass-cache',
+                              :always_check      => env != "production",
+                              :full_exception    => env != "production")
   config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
 
   if defined? config.symbolize_keys!
@@ -24,7 +25,7 @@ unless defined?(Sass::MERB_LOADED)
 
   if version[0] > 0 || version[1] >= 9
 
-    class Merb::Rack::Application # :nodoc:
+    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]
@@ -39,7 +40,7 @@ unless defined?(Sass::MERB_LOADED)
 
   else
 
-    class MerbHandler # :nodoc:
+    class MerbHandler
       def process_with_sass(request, response)
         if !Sass::Plugin.checked_for_updates ||
             Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]

data/lib/sass/plugin/rails.rb

@@ -1,12 +1,12 @@
 unless defined?(Sass::RAILS_LOADED)
   Sass::RAILS_LOADED = true
 
-  Sass::Plugin.options.merge!(:template_location  => RAILS_ROOT + '/public/stylesheets/sass',
-                              :css_location       => RAILS_ROOT + '/public/stylesheets',
-                              :always_check       => RAILS_ENV != "production",
-                              :full_exception     => RAILS_ENV != "production")
+  Sass::Plugin.options.merge!(:template_location => RAILS_ROOT + '/public/stylesheets/sass',
+                              :css_location      => RAILS_ROOT + '/public/stylesheets',
+                              :cache_location    => RAILS_ROOT + '/tmp/sass-cache',
+                              :always_check      => RAILS_ENV != "production",
+                              :full_exception    => RAILS_ENV != "production")
 
-  # :stopdoc:
   module ActionController
     class Base
       alias_method :sass_old_process, :process
@@ -20,5 +20,4 @@ unless defined?(Sass::RAILS_LOADED)
       end
     end
   end
-  # :startdoc:
 end

data/lib/sass/repl.rb

@@ -0,0 +1,58 @@
+require 'readline'
+
+module Sass
+  # Runs a SassScript read-eval-print loop.
+  # It presents a prompt on the terminal,
+  # reads in SassScript expressions,
+  # evaluates them,
+  # and prints the result.
+  class Repl
+    # @param options [Hash<Symbol, Object>] An options hash.
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Starts the read-eval-print loop.
+    def run
+      environment = Environment.new
+      environment.set_var('important', Script::String.new('!important'))
+      @line = 0
+      loop do
+        @line += 1
+        unless text = Readline.readline('>> ')
+          puts
+          return
+        end
+
+        Readline::HISTORY << text
+        parse_input(environment, text)
+      end
+    end
+
+    private
+
+    def parse_input(environment, text)
+      case text
+      when Script::MATCH
+        name = $1
+        guarded = $2 == '||='
+        val = Script::Parser.parse($3, @line, text.size - $3.size)
+
+        unless guarded && environment.var(name)
+          environment.set_var(name, val.perform(environment))
+        end
+
+        p environment.var(name)
+      else
+        p Script::Parser.parse(text, @line, 0).perform(environment)
+      end
+    rescue Sass::SyntaxError => e
+      puts "SyntaxError: #{e.message}"
+      if @options[:trace]
+        e.backtrace.each do |e|
+          puts "\tfrom #{e}"
+        end
+      end
+    end
+  end
+end

data/lib/sass/script.rb

@@ -0,0 +1,59 @@
+require 'strscan'
+require 'sass/script/node'
+require 'sass/script/variable'
+require 'sass/script/funcall'
+require 'sass/script/operation'
+require 'sass/script/literal'
+require 'sass/script/parser'
+
+module Sass
+  # SassScript is code that's embedded in Sass documents
+  # to allow for property values to be computed from variables.
+  #
+  # This module contains code that handles the parsing and evaluation of SassScript.
+  module Script
+    # The character that begins a variable.
+    VARIABLE_CHAR = ?!
+
+    # The regular expression used to parse variables.
+    MATCH = /^!([a-zA-Z_]\w*)\s*((?:\|\|)?=)\s*(.+)/
+
+    # The regular expression used to validate variables without matching.
+    VALIDATE = /^![a-zA-Z_]\w*$/
+
+    # Parses and evaluates a string of SassScript.
+    #
+    # @param value [String] The SassScript
+    # @param line [Fixnum] The number of the line on which the SassScript appeared.
+    #   Used for error reporting
+    # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
+    #   Used for error reporting
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [String] The string result of evaluating the SassScript
+    def self.resolve(value, line, offset, environment)
+      parse(value, line, offset).perform(environment).to_s
+    end
+
+    # Parses a string of SassScript
+    #
+    # @param value [String] The SassScript
+    # @param line [Fixnum] The number of the line on which the SassScript appeared.
+    #   Used for error reporting
+    # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
+    #   Used for error reporting
+    # @param filename [String] The path to the file in which the SassScript appeared.
+    #   Used for error reporting
+    # @return [Script::Node] The root node of the parse tree
+    def self.parse(value, line, offset, filename = nil)
+      Parser.parse(value, line, offset, filename)
+    rescue Sass::SyntaxError => e
+      if e.message == "SassScript error"
+        e.instance_eval do
+          @message += ": #{value.dump}."
+        end
+      end
+      e.sass_line = line
+      raise e
+    end
+  end
+end

data/lib/sass/script/bool.rb

@@ -0,0 +1,17 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  # A SassScript object representing a boolean (true or false) value.
+  class Bool < Literal
+    # The Ruby value of the boolean.
+    #
+    # @return [Boolean]
+    attr_reader :value
+    alias_method :to_bool, :value
+
+    # @return [String] "true" or "false"
+    def to_s
+      @value.to_s
+    end
+  end
+end

data/lib/sass/script/color.rb

@@ -0,0 +1,183 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  # A SassScript object representing a CSS color.
+  class Color < Literal
+    class << self; include Haml::Util; end
+
+    # A hash from color names to [red, green, blue] value arrays.
+    HTML4_COLORS = map_vals({
+        '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
+      }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
+    # A hash from [red, green, blue] value arrays to color names.
+    HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
+
+    # @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)
+    end
+
+    # The SassScript `+` operation.
+    # Its functionality depends on the type of its argument:
+    #
+    # {Number}
+    # : Adds the number to each of the RGB color channels.
+    #
+    # {Color}
+    # : Adds each of the RGB color channels together.
+    #
+    # {Literal}
+    # : See {Literal#plus}.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Color] The resulting color
+    # @raise [Sass::SyntaxError] if `other` is a number with units
+    def plus(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :+)
+      else
+        super
+      end
+    end
+
+    # The SassScript `-` operation.
+    # Its functionality depends on the type of its argument:
+    #
+    # {Number}
+    # : Subtracts the number from each of the RGB color channels.
+    #
+    # {Color}
+    # : Subtracts each of the other color's RGB color channels from this color's.
+    #
+    # {Literal}
+    # : See {Literal#minus}.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Color] The resulting color
+    # @raise [Sass::SyntaxError] if `other` is a number with units
+    def minus(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :-)
+      else
+        super
+      end
+    end
+
+    # The SassScript `*` operation.
+    # Its functionality depends on the type of its argument:
+    #
+    # {Number}
+    # : Multiplies the number by each of the RGB color channels.
+    #
+    # {Color}
+    # : Multiplies each of the RGB color channels together.
+    #
+    # {Literal}
+    # : See {Literal#times}.
+    #
+    # @param other [Literal] 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)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :*)
+      else
+        raise NoMethodError.new(nil, :times)
+      end
+    end
+
+    # The SassScript `/` operation.
+    # Its functionality depends on the type of its argument:
+    #
+    # {Number}
+    # : Divides each of the RGB color channels by the number.
+    #
+    # {Color}
+    # : Divides each of this color's RGB color channels by the other color's.
+    #
+    # {Literal}
+    # : See {Literal#div}.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Color] The resulting color
+    # @raise [Sass::SyntaxError] if `other` is a number with units
+    def div(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :/)
+      else
+        super
+      end
+    end
+
+    # The SassScript `%` operation.
+    # Its functionality depends on the type of its argument:
+    #
+    # {Number}
+    # : Takes each of the RGB color channels module the number.
+    #
+    # {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
+    # @return [Color] The resulting color
+    # @raise [Sass::SyntaxError] if `other` is a number with units
+    def mod(other)
+      if other.is_a?(Sass::Script::Number) || other.is_a?(Sass::Script::Color)
+        piecewise(other, :%)
+      else
+        raise NoMethodError.new(nil, :mod)
+      end
+    end
+
+    # Returns a string representation of the color.
+    # This is usually the color's hex value,
+    # but if the color has a name that's used instead.
+    #
+    # @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') }
+      "##{red}#{green}#{blue}"
+    end
+    alias_method :inspect, :to_s
+
+    private
+
+    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 = []
+      for i in (0...3)
+        res = @value[i].send(operation, other_num ? other_val : other_val[i])
+        rgb[i] = [ [res, 255].min, 0 ].max
+      end
+      Color.new(rgb)
+    end
+  end
+end

data/lib/sass/script/funcall.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'functions')
+module Sass
+  module Script
+    # A SassScript parse node representing a function call.
+    #
+    # A function call either calls one of the functions in {Script::Functions},
+    # or if no function with the given name exists
+    # it returns a string representation of the function call.
+    class Funcall < Node
+      # The name of the function.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # The arguments to the function.
+      #
+      # @return [Array<Script::Node>]
+      attr_reader :args
+
+      # @param name [String] See \{#name}
+      # @param name [Array<Script::Node>] See \{#args}
+      def initialize(name, args)
+        @name = name
+        @args = args
+      end
+
+      # @return [String] A string representation of the function call
+      def inspect
+        "#{name}(#{args.map {|a| a.inspect}.join(', ')})"
+      end
+
+      # Evaluates the function call.
+      #
+      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+      # @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)}
+        unless Haml::Util.has?(:public_instance_method, Functions, name) && name !~ /^__/
+          return Script::String.new("#{name}(#{args.map {|a| a.perform(environment)}.join(', ')})")
+        end
+
+        return Functions::EvaluationContext.new(environment.options).send(name, *args)
+      rescue ArgumentError => e
+        raise e unless e.backtrace.first =~ /:in `(#{name}|perform)'$/
+        raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+      end
+    end
+  end
+end

data/lib/sass/script/functions.rb

@@ -0,0 +1,198 @@
+module Sass::Script
+  # Methods in this module are accessible from the SassScript context.
+  # For example, you can write
+  #
+  #     !color = hsl(120, 100%, 50%)
+  #
+  # and it will call {Sass::Script::Functions#hsl}.
+  #
+  # The following functions are provided:
+  #
+  # \{#hsl}
+  # : Converts an `hsl(hue, saturation, lightness)` triplet into a color.
+  #
+  # \{#percentage}
+  # : Converts a unitless number to a percentage.
+  #
+  # \{#round}
+  # : Rounds a number to the nearest whole number.
+  #
+  # \{#ceil}
+  # : Rounds a number up to the nearest whole number.
+  #
+  # \{#floor}
+  # : Rounds a number down to the nearest whole number.
+  #
+  # \{#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.
+  # First of all, the arguments passed are {Sass::Script::Literal} objects.
+  # Literal objects are also expected to be returned.
+  #
+  # Second, making Ruby functions accessible from Sass introduces the temptation
+  # to do things like database access within stylesheets.
+  # This temptation must be resisted.
+  # Keep in mind that Sass stylesheets are only compiled once
+  # at a somewhat indeterminate time
+  # and then left as static CSS files.
+  # Any dynamic CSS should be left in `<style>` tags in the HTML.
+  #
+  # Within one of the functions in this module,
+  # methods of {EvaluationContext} can be used.
+  module Functions
+    # The context in which methods in {Script::Functions} are evaluated.
+    # That means that all instance methods of {EvaluationContext}
+    # are available to use in functions.
+    class EvaluationContext
+      include Sass::Script::Functions
+
+      # The options hash for the {Sass::Engine} that is processing the function call
+      #
+      # @return [Hash<Symbol, Object>]
+      attr_reader :options
+
+      # @param options [Hash<Symbol, Object>] See \{#options}
+      def initialize(options)
+        @options = options
+      end
+    end
+
+    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+
+
+    # Creates a {Color} object from red, green, and blue values.
+    # @param red
+    #   A number between 0 and 255 inclusive
+    # @param green
+    #   A number between 0 and 255 inclusive
+    # @param blue
+    #   A number between 0 and 255 inclusive
+    def rgb(red, green, blue)
+      [red.value, green.value, blue.value].each do |v|
+        raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive") if v <= 0 || v >= 255
+      end
+      Color.new([red.value, green.value, blue.value])
+    end
+
+    # Creates a {Color} object from hue, saturation, and lightness
+    # 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
+    # @param saturation [Number] The saturation of the color.
+    #   Must be between `0%` and `100%`, inclusive
+    # @param lightness [Number] The lightness of the color.
+    #   Must be between `0%` and `100%`, inclusive
+    # @return [Color] The resulting color
+    # @raise [ArgumentError] if `saturation` or `lightness` are out of bounds
+    def hsl(hue, saturation, lightness)
+      original_s = saturation
+      original_l = lightness
+      # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
+      h, s, l = [hue, saturation, lightness].map { |a| a.value }
+      raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") if s < 0 || s > 100
+      raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") if l < 0 || l > 100
+
+      h = (h % 360) / 360.0
+      s /= 100.0
+      l /= 100.0
+
+      m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s
+      m1 = l * 2 - m2
+      Color.new([hue_to_rgb(m1, m2, h + 1.0/3),
+                 hue_to_rgb(m1, m2, h),
+                 hue_to_rgb(m1, m2, h - 1.0/3)].map { |c| (c * 0xff).round })
+    end
+
+    # Converts a decimal number to a percentage.
+    # For example:
+    #
+    #     percentage(100px / 50px) => 200%
+    #
+    # @param value [Number] The decimal number to convert to a percentage
+    # @return [Number] The percentage
+    # @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")
+      end
+      Sass::Script::Number.new(value.value * 100, ['%'])
+    end
+
+    # Rounds a number to the nearest whole number.
+    # For example:
+    #
+    #     round(10.4px) => 10px
+    #     round(10.6px) => 11px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def round(value)
+      numeric_transformation(value) {|n| n.round}
+    end
+
+    # Rounds a number up to the nearest whole number.
+    # For example:
+    #
+    #     ciel(10.4px) => 11px
+    #     ciel(10.6px) => 11px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def ceil(value)
+      numeric_transformation(value) {|n| n.ceil}
+    end
+
+    # Rounds down to the nearest whole number.
+    # For example:
+    #
+    #     floor(10.4px) => 10px
+    #     floor(10.6px) => 10px
+    #
+    # @param value [Number] The number
+    # @return [Number] The rounded number
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def floor(value)
+      numeric_transformation(value) {|n| n.floor}
+    end
+
+    # Finds the absolute value of a number.
+    # For example:
+    #
+    #     abs(10px) => 10px
+    #     abs(-10px) => 10px
+    #
+    # @param value [Number] The number
+    # @return [Number] The absolute value
+    # @raise [Sass::SyntaxError] if `value` isn't a number
+    def abs(value)
+      numeric_transformation(value) {|n| n.abs}
+    end
+
+    private
+
+    # This method implements the pattern of transforming a numeric value into
+    # 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 = caller.first.scan(/`([^']+)'/).first.first
+        raise Sass::SyntaxError.new("#{value} is not a number for `#{calling_function}'")
+      end
+      Sass::Script::Number.new(yield(value.value), value.numerator_units, value.denominator_units)
+    end
+
+    def hue_to_rgb(m1, m2, h)
+      h += 1 if h < 0
+      h -= 1 if h > 1
+      return m1 + (m2 - m1) * h * 6 if h * 6 < 1
+      return m2 if h * 2 < 1
+      return m1 + (m2 - m1) * (2.0/3 - h) * 6 if h * 3 < 2
+      return m1
+    end
+  end
+end