middleman 0.13.1 → 0.13.2.pre

data/lib/middleman/vendor/gems/ruby/1.8/gems/haml-2.2.17/lib/sass/script/funcall.rb

@@ -1,50 +0,0 @@
-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/ruby/1.8/gems/haml-2.2.17/lib/sass/script/functions.rb

@@ -1,257 +0,0 @@
-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 is generally a bad idea;
-  # since Sass files are by default only compiled once,
-  # dynamic code is not a great fit.
-  #
-  # If you really, really need to compile Sass on each request,
-  # first make sure you have adequate caching set up.
-  # Then you can use {Sass::Engine} to render the code,
-  # using the {file:SASS_REFERENCE.md#custom-option `options` parameter}
-  # to pass in data that {EvaluationContext#options can be accessed}
-  # from your Sass functions.
-  #
-  # 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
-      # The options hash for the {Sass::Engine} that is processing the function call
-      #
-      # @return [{Symbol => Object}]
-      attr_reader :options
-
-      # @param options [{Symbol => Object}] See \{#options}
-      def initialize(options)
-        @options = options
-
-        # We need to include this individually in each instance
-        # because of an icky Ruby restriction
-        class << self; include Sass::Script::Functions; end
-      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/ruby/1.8/gems/haml-2.2.17/lib/sass/script/lexer.rb

@@ -1,191 +0,0 @@
-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