simple-templater 0.0.1.4 → 0.0.1.5

data/gems/gems/haml-2.2.16/lib/sass/script/color.rb

@@ -1,220 +0,0 @@
-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]}
-
-    # Creates a new color from RGB components.
-    # *Note*: when modifying the components of an existing color,
-    # use \{#with} rather than creating a new color object.
-    # This preserves forwards-compatiblity for alpha channels and such.
-    #
-    # @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.freeze)
-    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 frozen three-element array of the red, green, and blue
-    #   values (respectively) of the color
-    def rgb
-      @value
-    end
-
-    # Returns a copy of this color with one or more channels changed.
-    #
-    # For example:
-    #
-    #     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)
-    #
-    # @param attrs [{Symbol => Fixnum}]
-    #   A map of channel names (`:red`, `:green`, or `:blue`) to values
-    # @return [Color] The new Color object
-    def with(attrs)
-      Color.new([
-          attrs[:red] || rgb[0],
-          attrs[:green] || rgb[1],
-          attrs[:blue] || rgb[2],
-        ])
-    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.
-    #
-    # @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)
-      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.
-    #
-    # @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)
-      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[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
-
-    private
-
-    def piecewise(other, operation)
-      other_num = other.is_a? Number
-      if other_num && !other.unitless?
-        raise Sass::SyntaxError.new("Cannot add a number with units (#{other}) to a color (#{self}).") 
-      end
-
-      result = []
-      for i in (0...3)
-        res = rgb[i].send(operation, other_num ? other.value : other.rgb[i])
-        result[i] = [ [res, 255].min, 0 ].max
-      end
-      with(:red => result[0], :green => result[1], :blue => result[2])
-    end
-  end
-end

data/gems/gems/haml-2.2.16/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/gems/gems/haml-2.2.16/lib/sass/script/functions.rb

@@ -1,252 +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 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
-      # 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