middleman 0.11.5 → 0.12.0.pre

data/lib/middleman/vendor/gems/gems/haml-2.2.14/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.any? {|t| t =~ /:in `(block in )?(#{name}|perform)'$/}
+        raise Sass::SyntaxError.new("#{e.message} for `#{name}'")
+      end
+    end
+  end
+end

data/lib/middleman/vendor/gems/gems/haml-2.2.14/lib/sass/script/functions.rb

@@ -0,0 +1,250 @@
+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.
+  #
+  # \{#rgb}
+  # : Converts an `rgb(red, green, blue)` 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.
+  #
+  # 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}.
+  #
+  # 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
+
+      # 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 =~ /^__/ }
+
+
+    # Creates a {Color} object from red, green, and blue values.
+    # @param red
+    #   A number between 0 and 255 inclusive,
+    #   or between 0% and 100% inclusive
+    # @param green
+    #   A number between 0 and 255 inclusive,
+    #   or between 0% and 100% inclusive
+    # @param blue
+    #   A number between 0 and 255 inclusive,
+    #   or between 0% and 100% inclusive
+    def rgb(red, green, blue)
+      assert_type red, :Number
+      assert_type green, :Number
+      assert_type blue, :Number
+
+      rgb = [red, green, blue].map do |c|
+        v = c.value
+        if c.numerator_units == ["%"] && c.denominator_units.empty?
+          next v * 255 / 100.0 if (0..100).include?(v)
+          raise ArgumentError.new("Color value #{c} must be between 0% and 100% inclusive")
+        else
+          next v if (0..255).include?(v)
+          raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
+        end
+      end
+      Color.new(rgb)
+    end
+
+    # Creates a {Color} object from hue, saturation, and lightness.
+    # Uses the algorithm from 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)
+      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
+      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.inspect} 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)
+      assert_type value, :Number
+      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

data/lib/middleman/vendor/gems/gems/haml-2.2.14/lib/sass/script/lexer.rb

@@ -0,0 +1,191 @@
+require 'strscan'
+
+module Sass
+  module Script
+    # The lexical analyzer for SassScript.
+    # It takes a raw string and converts it to individual tokens
+    # that are easier to parse.
+    class Lexer
+      # A struct containing information about an individual token.
+      #
+      # `type`: [{Symbol}]
+      # : The type of token.
+      #
+      # `value`: [{Object}]
+      # : The Ruby object corresponding to the value of the token.
+      #
+      # `line`: [{Fixnum}]
+      # : The line of the source file on which the token appears.
+      #
+      # `offset`: [{Fixnum}]
+      # : The number of bytes into the line the SassScript token appeared.
+      Token = Struct.new(:type, :value, :line, :offset)
+
+      # A hash from operator strings to the corresponding token types.
+      OPERATORS = {
+        '+' => :plus,
+        '-' => :minus,
+        '*' => :times,
+        '/' => :div,
+        '%' => :mod,
+        '=' => :single_eq,
+        '(' => :lparen,
+        ')' => :rparen,
+        ',' => :comma,
+        'and' => :and,
+        'or' => :or,
+        'not' => :not,
+        '==' => :eq,
+        '!=' => :neq,
+        '>=' => :gte,
+        '<=' => :lte,
+        '>' => :gt,
+        '<' => :lt,
+        '#{' => :begin_interpolation,
+        '}' => :end_interpolation,
+      }
+
+      # A list of operator strings ordered with longer names first
+      # so that `>` and `<` don't clobber `>=` and `<=`.
+      OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
+
+      # A hash of regular expressions that are used for tokenizing.
+      REGULAR_EXPRESSIONS = {
+        :whitespace => /\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("|")})/,
+        :bool => /(true|false)\b/,
+        :op => %r{(#{Regexp.union(*OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + (s =~ /\w$/ ? '(?:\b|$)' : ''))})})}
+      }
+
+      # @param str [String, StringScanner] The source text to lex
+      # @param line [Fixnum] The line on which the SassScript appears.
+      #   Used for error reporting
+      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
+      #   Used for error reporting
+      def initialize(str, line, offset, filename)
+        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
+        @line = line
+        @offset = offset
+        @filename = filename
+        @prev = nil
+      end
+
+      # Moves the lexer forward one token.
+      #
+      # @return [Token] The token that was moved past
+      def next
+        @tok ||= read_token
+        @tok, tok = nil, @tok
+        @prev = tok
+        return tok
+      end
+
+      # Returns the next token without moving the lexer forward.
+      #
+      # @return [Token] The next token
+      def peek
+        @tok ||= read_token
+      end
+
+      # @return [Boolean] Whether or not there's more source text to lex.
+      def done?
+        whitespace unless after_interpolation?
+        @scanner.eos? && @tok.nil?
+      end
+
+      private
+
+      def read_token
+        return if done?
+
+        value = token
+        unless value
+          raise SyntaxError.new("Syntax error in '#{@scanner.string}' at character #{current_position}.")
+        end
+        Token.new(value.first, value.last, @line, last_match_position)
+      end
+
+      def whitespace
+        @scanner.scan(REGULAR_EXPRESSIONS[:whitespace])
+      end
+
+      def token
+        return string('') if after_interpolation?
+        variable || string || number || color || bool || op || ident
+      end
+
+      def variable
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:variable])
+        [:const, @scanner[1]]
+      end
+
+      def ident
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:ident])
+        [:ident, s.gsub(/\\(.)/, '\1')]
+      end
+
+      def string(start_char = '"')
+        return unless @scanner.scan(/#{start_char}#{REGULAR_EXPRESSIONS[:string_end]}/)
+        [:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1"))]
+      end
+
+      def begin_interpolation
+        @scanner.scan
+      end
+
+      def number
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:number])
+        value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
+        value = -value if @scanner[1]
+        [:number, Script::Number.new(value, Array(@scanner[4]))]
+      end
+
+      def color
+        return unless @scanner.scan(REGULAR_EXPRESSIONS[:color])
+        value = if @scanner[4]
+                  color = Color::HTML4_COLORS[@scanner[4].downcase]
+                else
+                  (1..3).map {|i| @scanner[i]}.map {|num| num.ljust(2, num).to_i(16)}
+                end
+        [:color, Script::Color.new(value)]
+      end
+
+      def bool
+        return unless s = @scanner.scan(REGULAR_EXPRESSIONS[:bool])
+        [:bool, Script::Bool.new(s == 'true')]
+      end
+
+      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
+
+      def current_position
+        @offset + @scanner.pos + 1
+      end
+
+      def last_match_position
+        current_position - @scanner.matched_size
+      end
+
+      def after_interpolation?
+        @prev && @prev.type == :end_interpolation
+      end
+    end
+  end
+end