radiantcms-couchrest_model 0.1.3 → 0.1.4

data/vendor/plugins/haml/lib/sass/plugin/rack.rb

@@ -1,3 +1,5 @@
+require 'sass/plugin'
+
 module Sass
   module Plugin
     # Rack middleware for compiling Sass code.
@@ -29,6 +31,7 @@ module Sass
       # @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
@@ -40,8 +43,23 @@ module Sass
         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) && 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) && defined?(ActionDispatch::Callbacks.to_prepare)
+          ActionDispatch::Callbacks.skip_callback(:prepare, :__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
-
-require 'sass/plugin'

data/vendor/plugins/haml/lib/sass/plugin/rails.rb

@@ -1,23 +1,16 @@
 unless defined?(Sass::RAILS_LOADED)
   Sass::RAILS_LOADED = true
 
-  # Reverse-merging (we're in Rails, anyway) so we dont' clobber what's already been defined further up-stream
-  Sass::Plugin.options.reverse_merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
-                                      :css_location      => Haml::Util.rails_root + '/public/stylesheets',
-                                      :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
-                                      :always_check      => Haml::Util.rails_env == "development",
-                                      :quiet             => Haml::Util.rails_env != "production",
-                                      :full_exception    => Haml::Util.rails_env != "production")
+  Sass::Plugin.options.merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
+                              :css_location      => Haml::Util.rails_root + '/public/stylesheets',
+                              :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
+                              :always_check      => Haml::Util.rails_env != "production",
+                              :full_exception    => Haml::Util.rails_env != "production")
 
-  if defined?(ActionController::Metal)
-    # Rails >= 3.0
-    require 'sass/plugin/rack'
-    Rails.configuration.middleware.use(Sass::Plugin::Rack)
-  elsif defined?(ActionController::Dispatcher) &&
-      defined?(ActionController::Dispatcher.middleware)
-    # Rails >= 2.3
-    require 'sass/plugin/rack'
-    ActionController::Dispatcher.middleware.use(Sass::Plugin::Rack)
+  if defined?(ActionDispatch::Callbacks) &&
+      defined?(ActionDispatch::Callbacks.to_prepare)
+    # Rails >= 3.0.0
+    ActionDispatch::Callbacks.to_prepare(:sass_process) {Sass::Plugin.check_for_updates}
   else
     module ActionController
       class Base

data/vendor/plugins/haml/lib/sass/repl.rb

@@ -35,7 +35,7 @@ module Sass
       case text
       when Script::MATCH
         name = $1
-        guarded = $3 == '||=' || $4
+        guarded = $2 == '||='
         val = Script::Parser.parse($3, @line, text.size - $3.size)
 
         unless guarded && environment.var(name)

data/vendor/plugins/haml/lib/sass/script.rb

@@ -12,11 +12,30 @@ module Sass
   #
   # This module contains code that handles the parsing and evaluation of SassScript.
   module Script
+    # The character that begins a variable.
+    # @private
+    VARIABLE_CHAR = ?!
+
     # The regular expression used to parse variables.
-    MATCH = /^[!\$](#{Sass::SCSS::RX::IDENT})\s*((?:\|\|)?=|:)\s*(.+?)(!(?i:default))?$/
+    # @private
+    MATCH = /^!([a-zA-Z_]\w*)\s*((?:\|\|)?=)\s*(.+)/
 
     # The regular expression used to validate variables without matching.
-    VALIDATE = /^[!\$]#{Sass::SCSS::RX::IDENT}$/
+    # @private
+    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
     #
@@ -25,39 +44,19 @@ module Sass
     #   Used for error reporting
     # @param offset [Fixnum] The number of characters in on `line` that the SassScript started.
     #   Used for error reporting
-    # @param options [{Symbol => Object}] An options hash;
-    #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+    # @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, options = {})
-      Parser.parse(value, line, offset, options)
+    def self.parse(value, line, offset, filename = nil)
+      Parser.parse(value, line, offset, filename)
     rescue Sass::SyntaxError => e
-      e.message << ": #{value.inspect}." if e.message == "SassScript error"
-      e.modify_backtrace(:line => line, :filename => options[:filename])
+      if e.message == "SassScript error"
+        e.instance_eval do
+          @message += ": #{value.dump}."
+        end
+      end
+      e.sass_line = line
       raise e
     end
-
-    # @private
-    def self.var_warning(varname, line, offset, filename)
-      Haml::Util.haml_warn <<MESSAGE
-DEPRECATION WARNING:
-On line #{line}, character #{offset}#{" of '#{filename}'" if filename}
-Variables with ! have been deprecated and will be removed in version 3.2.
-Use \"$#{varname}\" instead.
-
-You can use `sass-convert --in-place --from sass2 file.sass' to convert files automatically.
-MESSAGE
-    end
-
-    # @private
-    def self.equals_warning(types, name, val, guarded, line, offset, filename)
-      Haml::Util.haml_warn <<MESSAGE
-DEPRECATION WARNING:
-On line #{line}#{", character #{offset}" if offset}#{" of '#{filename}'" if filename}
-Setting #{types} with #{"||" if guarded}= has been deprecated and will be removed in version 3.2.
-Use "#{name}: #{val}#{" !default" if guarded}" instead.
-
-You can use `sass-convert --in-place --from sass2 file.sass' to convert files automatically.
-MESSAGE
-    end
   end
 end

data/vendor/plugins/haml/lib/sass/script/bool.rb

@@ -10,9 +10,8 @@ module Sass::Script
     alias_method :to_bool, :value
 
     # @return [String] "true" or "false"
-    def to_s(opts = {})
+    def to_s
       @value.to_s
     end
-    alias_method :to_sass, :to_s
   end
 end

data/vendor/plugins/haml/lib/sass/script/color.rb

@@ -2,23 +2,11 @@ require 'sass/script/literal'
 
 module Sass::Script
   # A SassScript object representing a CSS color.
-  #
-  # A color may be represented internally as RGBA, HSLA, or both.
-  # It's originally represented as whatever its input is;
-  # if it's created with RGB values, it's represented as RGBA,
-  # and if it's created with HSL values, it's represented as HSLA.
-  # Once a property is accessed that requires the other representation --
-  # for example, \{#red} for an HSL color --
-  # that component is calculated and cached.
-  #
-  # The alpha channel of a color is independent of its RGB or HSL representation.
-  # It's always stored, as 1 if nothing else is specified.
-  # If only the alpha channel is modified using \{#with},
-  # the cached RGB and HSL values are retained.
   class Color < Literal
     class << self; include Haml::Util; end
 
     # A hash from color names to `[red, green, blue]` value arrays.
+    # @private
     HTML4_COLORS = map_vals({
         'black'   => 0x000000,
         'silver'  => 0xc0c0c0,
@@ -38,154 +26,27 @@ module Sass::Script
         'aqua'    => 0x00ffff
       }) {|color| (0..2).map {|n| color >> (n << 3) & 0xff}.reverse}
     # A hash from `[red, green, blue]` value arrays to color names.
+    # @private
     HTML4_COLORS_REVERSE = map_hash(HTML4_COLORS) {|k, v| [v, k]}
 
-    # Constructs an RGB or HSL color object,
-    # optionally with an alpha channel.
-    # 
-    # The RGB values must be between 0 and 255.
-    # The saturation and lightness values must be between 0 and 100.
-    # The alpha value must be between 0 and 1.
+    # 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.
     #
-    # @raise [Sass::SyntaxError] if any color value isn't in the specified range
-    #
-    # @overload initialize(attrs)
-    #   The attributes are specified as a hash.
-    #   This hash must contain either `:hue`, `:saturation`, and `:value` keys,
-    #   or `:red`, `:green`, and `:blue` keys.
-    #   It cannot contain both HSL and RGB keys.
-    #   It may also optionally contain an `:alpha` key.
-    #
-    #   @param attrs [{Symbol => Numeric}] A hash of color attributes to values
-    #   @raise [ArgumentError] if not enough attributes are specified,
-    #     or both RGB and HSL attributes are specified
-    #
-    # @overload initialize(rgba)
-    #   The attributes are specified as an array.
-    #   This overload only supports RGB or RGBA colors.
-    #
-    #   @param rgba [Array<Numeric>] A three- or four-element array
-    #     of the red, green, blue, and optionally alpha values (respectively)
-    #     of the color
-    #   @raise [ArgumentError] if not enough attributes are specified
-    def initialize(attrs, allow_both_rgb_and_hsl = false)
-      super(nil)
-
-      if attrs.is_a?(Array)
-        unless (3..4).include?(attrs.size)
-          raise ArgumentError.new("Color.new(array) expects a three- or four-element array")
-        end
-
-        red, green, blue = attrs[0...3].map {|c| c.to_i}
-        @attrs = {:red => red, :green => green, :blue => blue}
-        @attrs[:alpha] = attrs[3] ? attrs[3].to_f : 1
-      else
-        attrs = attrs.reject {|k, v| v.nil?}
-        hsl = [:hue, :saturation, :lightness] & attrs.keys
-        rgb = [:red, :green, :blue] & attrs.keys
-        if !allow_both_rgb_and_hsl && !hsl.empty? && !rgb.empty?
-          raise ArgumentError.new("Color.new(hash) may not have both HSL and RGB keys specified")
-        elsif hsl.empty? && rgb.empty?
-          raise ArgumentError.new("Color.new(hash) must have either HSL or RGB keys specified")
-        elsif !hsl.empty? && hsl.size != 3
-          raise ArgumentError.new("Color.new(hash) must have all three HSL values specified")
-        elsif !rgb.empty? && rgb.size != 3
-          raise ArgumentError.new("Color.new(hash) must have all three RGB values specified")
-        end
-
-        @attrs = attrs
-        @attrs[:hue] %= 360 if @attrs[:hue]
-        @attrs[:alpha] ||= 1
-      end
-
-      [:red, :green, :blue].each do |k|
-        next if @attrs[k].nil?
-        @attrs[k] = @attrs[k].to_i
-        next if (0..255).include?(@attrs[k])
-        raise Sass::SyntaxError.new("#{k.to_s.capitalize} value must be between 0 and 255")
-      end
-
-      [:saturation, :lightness].each do |k|
-        next if @attrs[k].nil?
-        @attrs[k] = 0 if @attrs[k] < 0.00001 && @attrs[k] > -0.00001
-        @attrs[k] = 100 if @attrs[k] - 100 < 0.00001 && @attrs[k] - 100 > -0.00001
-        next if (0..100).include?(@attrs[k])
-        raise Sass::SyntaxError.new("#{k.to_s.capitalize} must be between 0 and 100")
-      end
-
-      unless (0..1).include?(@attrs[:alpha])
-        raise Sass::SyntaxError.new("Alpha channel must be between 0 and 1")
-      end
-    end
-
-    # The red component of the color.
-    #
-    # @return [Fixnum]
-    def red
-      hsl_to_rgb!
-      @attrs[:red]
-    end
-
-    # The green component of the color.
-    #
-    # @return [Fixnum]
-    def green
-      hsl_to_rgb!
-      @attrs[:green]
-    end
-
-    # The blue component of the color.
-    #
-    # @return [Fixnum]
-    def blue
-      hsl_to_rgb!
-      @attrs[:blue]
-    end
-
-    # The hue component of the color.
-    #
-    # @return [Numeric]
-    def hue
-      rgb_to_hsl!
-      @attrs[:hue]
-    end
-
-    # The saturation component of the color.
-    #
-    # @return [Numeric]
-    def saturation
-      rgb_to_hsl!
-      @attrs[:saturation]
-    end
-
-    # The lightness component of the color.
-    #
-    # @return [Numeric]
-    def lightness
-      rgb_to_hsl!
-      @attrs[:lightness]
-    end
-
-    # The alpha channel (opacity) of the color.
-    # This is 1 unless otherwise defined.
-    #
-    # @return [Fixnum]
-    def alpha
-      @attrs[:alpha]
-    end
-
-    # Returns whether this color object is translucent;
-    # that is, whether the alpha channel is non-1.
-    #
-    # @return [Boolean]
-    def alpha?
-      alpha < 1
+    # @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 3.2.
     # @see #rgb
     def value
-      Haml::Util.haml_warn <<END
+      warn <<END
 DEPRECATION WARNING:
 The Sass::Script::Color #value attribute is deprecated and will be
 removed in version 3.2. Use the #rgb attribute instead.
@@ -198,31 +59,10 @@ END
     # @return [Array<Fixnum>] A frozen three-element array of the red, green, and blue
     #   values (respectively) of the color
     def rgb
-      [red, green, blue].freeze
-    end
-
-    # Returns the hue, saturation, and lightness components of the color.
-    #
-    # @return [Array<Fixnum>] A frozen three-element array of the
-    #   hue, saturation, and lightness values (respectively) of the color
-    def hsl
-      [hue, saturation, lightness].freeze
-    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 && alpha == other.alpha)
+      @value
     end
 
     # Returns a copy of this color with one or more channels changed.
-    # RGB or HSL colors may be changed, but not both at once.
     #
     # For example:
     #
@@ -230,36 +70,16 @@ END
     #       #=> rgb(10, 40, 30)
     #     Color.new([126, 126, 126]).with(:red => 0, :green => 255)
     #       #=> rgb(0, 255, 126)
-    #     Color.new([255, 0, 127]).with(:saturation => 60)
-    #       #=> rgb(204, 51, 127)
-    #     Color.new([1, 2, 3]).with(:alpha => 0.4)
-    #       #=> rgba(1, 2, 3, 0.4)
     #
-    # @param attrs [{Symbol => Numeric}]
-    #   A map of channel names (`:red`, `:green`, `:blue`,
-    #   `:hue`, `:saturation`, `:lightness`, or `:alpha`) to values
+    # @param attrs [{Symbol => Fixnum}]
+    #   A map of channel names (`:red`, `:green`, or `:blue`) to values
     # @return [Color] The new Color object
-    # @raise [ArgumentError] if both RGB and HSL keys are specified
     def with(attrs)
-      attrs = attrs.reject {|k, v| v.nil?}
-      hsl = !([:hue, :saturation, :lightness] & attrs.keys).empty?
-      rgb = !([:red, :green, :blue] & attrs.keys).empty?
-      if hsl && rgb
-        raise ArgumentError.new("Color#with may not have both HSL and RGB keys specified")
-      end
-
-      if hsl
-        [:hue, :saturation, :lightness].each {|k| attrs[k] ||= send(k)}
-      elsif rgb
-        [:red, :green, :blue].each {|k| attrs[k] ||= send(k)}
-      else
-        # If we're just changing the alpha channel,
-        # keep all the HSL/RGB stuff we've calculated
-        attrs = @attrs.merge(attrs)
-      end
-      attrs[:alpha] ||= alpha
-
-      Color.new(attrs, :allow_both_rgb_and_hsl)
+      Color.new([
+          attrs[:red] || rgb[0],
+          attrs[:green] || rgb[1],
+          attrs[:blue] || rgb[2],
+        ])
     end
 
     # The SassScript `+` operation.
@@ -376,39 +196,14 @@ END
     # but if the color has a name that's used instead.
     #
     # @return [String] The string representation
-    def to_s(opts = {})
-      return rgba_str if alpha?
-      return smallest if options[:style] == :compressed
+    def to_s
       return HTML4_COLORS_REVERSE[rgb] if HTML4_COLORS_REVERSE[rgb]
-      hex_str
-    end
-    alias_method :to_sass, :to_s
-
-    # Returns a string representation of the color.
-    #
-    # @return [String] The hex value
-    def inspect
-      alpha? ? rgba_str : hex_str
-    end
-
-    private
-
-    def smallest
-      small_hex_str = hex_str.gsub(/^#(.)\1(.)\2(.)\3$/, '#\1\2\3')
-      return small_hex_str unless (color = HTML4_COLORS_REVERSE[rgb]) &&
-        color.size <= small_hex_str.size
-      return color
-    end
-
-    def rgba_str
-      split = options[:style] == :compressed ? ',' : ', '
-      "rgba(#{rgb.join(split)}#{split}#{Number.round(alpha)})"
-    end
-
-    def hex_str
       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
@@ -421,71 +216,7 @@ END
         res = rgb[i].send(operation, other_num ? other.value : other.rgb[i])
         result[i] = [ [res, 255].min, 0 ].max
       end
-
-      if !other_num && other.alpha != alpha
-        raise Sass::SyntaxError.new("Alpha channels must be equal: #{self} #{operation} #{other}")
-      end
-
       with(:red => result[0], :green => result[1], :blue => result[2])
     end
-
-    def hsl_to_rgb!
-      return if @attrs[:red] && @attrs[:blue] && @attrs[:green]
-
-      h = @attrs[:hue] / 360.0
-      s = @attrs[:saturation] / 100.0
-      l = @attrs[:lightness] / 100.0
-
-      # Algorithm from the CSS3 spec: http://www.w3.org/TR/css3-color/#hsl-color.
-      m2 = l <= 0.5 ? l * (s + 1) : l + s - l * s
-      m1 = l * 2 - m2
-      @attrs[:red], @attrs[:green], @attrs[:blue] = [
-        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
-
-    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
-
-    def rgb_to_hsl!
-      return if @attrs[:hue] && @attrs[:saturation] && @attrs[:lightness]
-      r, g, b = [:red, :green, :blue].map {|k| @attrs[k] / 255.0}
-
-      # Algorithm from http://en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV
-      max = [r, g, b].max
-      min = [r, g, b].min
-      d = max - min
-
-      h =
-        case max
-        when min; 0
-        when r; 60 * (g-b)/d
-        when g; 60 * (b-r)/d + 120
-        when b; 60 * (r-g)/d + 240
-        end
-
-      l = (max + min)/2.0
-
-      s =
-        if max == min
-          0
-        elsif l < 0.5
-          d/(2*l)
-        else
-          d/(2 - 2*l)
-        end
-
-      @attrs[:hue] = h % 360
-      @attrs[:saturation] = s * 100
-      @attrs[:lightness] = l * 100
-    end
   end
 end