haml 3.1.0.alpha.33 → 3.1.0.alpha.36

data/vendor/sass/lib/sass/importers/rails.rb

@@ -0,0 +1,75 @@
+module Sass
+  module Importers
+    # An importer that wraps the Rails 3.1 view infrastructure.
+    # Loads Sass files as though they were views in Rails.
+    # Currently doesn't support caching.
+    #
+    # This is different from standard Rails rendering
+    # in that Sass doesn't have a concept of importing partials
+    # as a distinct action from importing other Sass files.
+    # Imports within Rails behave more like Sass imports:
+    # they will first attempt to find a non-partial file,
+    # and failing that will fall back on a partial.
+    #
+    # Each importer instance is local to a single request for a single view.
+    # It contains the ActionView::LookupContext for that request,
+    # as well as the controller prefix for the view being generated.
+    class Rails < Base
+      # Creates a new Rails importer that imports files as Rails views.
+      def initialize; end
+
+      # @see Base#find_relative
+      def find_relative(uri, base, options)
+        find_(uri, base.split('/')[0...-1].join('/'), options)
+      end
+
+      # @see Base#find
+      def find(uri, options)
+        find_(uri, nil, options)
+      end
+
+      # @see Base#mtime
+      def mtime(uri, options)
+        return unless template =
+          find_template(uri, nil, !:partial, options) ||
+          find_template(uri, nil, :partial, options)
+        template.updated_at
+      end
+
+      # @see Base#key
+      def key(uri, options)
+        [self.class.name + ":" + uri.split('/')[0...-1].join('/'),
+          uri.split('/')[-1] + "." + options[:syntax].to_s]
+      end
+
+      # @see Base#to_s
+      def to_s
+        "(Rails importer)"
+      end
+
+      private
+
+      def find_(uri, prefix, options)
+        prepare_template(
+          find_template(uri, prefix, !:partial, options) ||
+            find_template(uri, prefix, :partial, options),
+          options)
+      end
+
+      def find_template(uri, prefix, partial, options)
+        return options[:_rails_lookup_context].
+          find_all(uri, prefix, partial).
+          find {|t| t.handler.is_a?(Sass::Plugin::TemplateHandler)}
+      end
+
+      def prepare_template(template, options)
+        return unless template
+        options[:syntax] = template.handler.syntax
+        options[:filename] = template.virtual_path
+        options[:_rails_filename] = template.identifier
+        options[:importer] = self
+        Sass::Engine.new(template.source, options)
+      end
+    end
+  end
+end

data/vendor/sass/lib/sass/less.rb

@@ -251,7 +251,7 @@ WARNING
         e, rest = _to_sass_tree_plus_minus_eq(arr)
         until rest.empty?
           e2, rest = _to_sass_tree_plus_minus_eq(rest)
-          e = Sass::Script::Operation.new(e, e2, :concat)
+          e = Sass::Script::Operation.new(e, e2, :space)
         end
         return e
       end

data/vendor/sass/lib/sass/plugin/compiler.rb

@@ -318,7 +318,10 @@ module Sass::Plugin
       # Finally, write the file
       flag = 'w'
       flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
-      File.open(css, flag) {|file| file.print(result)}
+      File.open(css, flag) do |file|
+        file.set_encoding(result.encoding) unless Sass::Util.ruby1_8?
+        file.print(result)
+      end
     end
 
     def try_delete_css(css)

data/vendor/sass/lib/sass/plugin/configuration.rb

@@ -31,7 +31,7 @@ module Sass
       # @return [{Symbol => Object}]
       def options
         @options ||= default_options.dup
-        @options[:cache_store] ||= Sass::FileCacheStore.new(@options[:cache_location])
+        @options[:cache_store] ||= Sass::CacheStores::Filesystem.new(@options[:cache_location])
         @options
       end
 
@@ -113,7 +113,9 @@ module Sass
         return if options[:template_location].is_a?(Array)
         options[:template_location] =
           case options[:template_location]
-          when nil; [[File.join(options[:css_location], 'sass'), options[:css_location]]]
+          when nil
+            options[:css_location] ?
+              [[File.join(options[:css_location], 'sass'), options[:css_location]]] : []
           when String; [[options[:template_location], options[:css_location]]]
           else; options[:template_location].to_a
           end

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

@@ -24,11 +24,21 @@ module Sass
     # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
     # That's all there is to it!
     class Rack
+      # The delay, in seconds, between update checks.
+      # Useful when many resources are requested for a single page.
+      # `nil` means no delay at all.
+      #
+      # @return [Float]
+      attr_accessor :dwell
+
       # Initialize the middleware.
       #
       # @param app [#call] The Rack application
-      def initialize(app)
+      # @param dwell [Float] See \{#dwell}
+      def initialize(app, dwell = 1.0)
         @app = app
+        @dwell = dwell
+        @check_after = Time.now.to_f
       end
 
       # Process a request, checking the Sass stylesheets for changes
@@ -37,7 +47,10 @@ module Sass
       # @param env The Rack request environment
       # @return [(#to_i, {String => String}, Object)] The Rack response
       def call(env)
-        Sass::Plugin.check_for_updates
+        if @dwell.nil? || Time.now.to_f > @check_after
+          Sass::Plugin.check_for_updates
+          @check_after = Time.now.to_f + @dwell if @dwell
+        end
         @app.call(env)
       end
     end

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

@@ -4,21 +4,101 @@ unless defined?(Sass::RAILS_LOADED)
   module Sass::Plugin::Configuration
     # Different default options in a rails envirionment.
     def default_options
-      @default_options ||= {
-        :always_update      => false,
-        :template_location => Sass::Util.rails_root + '/public/stylesheets/sass',
-        :css_location      => Sass::Util.rails_root + '/public/stylesheets',
-        :cache_location    => Sass::Util.rails_root + '/tmp/sass-cache',
-        :always_check      => Sass::Util.rails_env == "development",
+      return @default_options if @default_options
+      opts = {
         :quiet             => Sass::Util.rails_env != "production",
-        :full_exception    => Sass::Util.rails_env != "production"
-      }.freeze
+        :full_exception    => Sass::Util.rails_env != "production",
+        :cache_location    => Sass::Util.rails_root + '/tmp/sass-cache'
+      }
+
+      if Sass::Util.ap_geq?('3.1.0.beta')
+        require 'sass/importers/rails'
+        require 'sass/cache_stores/active_support'
+        opts.merge!(:load_paths => [Sass::Importers::Rails.new])
+        opts.merge!(:cache_store => Sass::CacheStores::ActiveSupport.new(Rails.cache)) if Rails.cache
+      else
+        opts.merge!(
+          :always_update      => false,
+          :template_location => Sass::Util.rails_root + '/public/stylesheets/sass',
+          :css_location      => Sass::Util.rails_root + '/public/stylesheets',
+          :always_check      => Sass::Util.rails_env == "development")
+      end
+
+      @default_options = opts.freeze
     end
   end
 
   Sass::Plugin.options.reverse_merge!(Sass::Plugin.default_options)
 
-  if defined?(ActionController::Metal)
+  # Disable this for now, until we figure out how to get Rails
+  # to pass in the view.
+  if Sass::Util.ap_geq?('3.1.0.beta')
+    class Sass::Plugin::TemplateHandler
+      attr_reader :syntax
+
+      def initialize(syntax)
+        @syntax = syntax
+      end
+
+      def handles_encoding?; true; end
+
+      def call(template, view)
+        engine = Sass::Engine.new(template.source,
+          Sass::Plugin.engine_options.merge(
+            :syntax => @syntax,
+            :filename => template.virtual_path,
+            :_rails_lookup_context => view.lookup_context,
+            :importer => Sass::Importers::Rails.new))
+
+        template.data[:sass_importers] = engine.dependencies.map do |e|
+          [e.options[:filename], e.options[:importer]]
+        end
+
+        stylesheet =
+          begin
+            engine.render
+          rescue Sass::SyntaxError => e
+            Sass::Plugin::TemplateHandler.munge_exception e, view.lookup_context
+            Sass::SyntaxError.exception_to_css(e, Sass::Plugin.engine_options)
+          end
+
+        <<RUBY
+begin
+  if Sass::Plugin::TemplateHandler.dependencies_changed?(
+      @_template.data[:sass_importers], #{Time.now.to_i}, lookup_context)
+    @_template.expire!
+    @_template.rerender(self)
+  else
+    #{stylesheet.inspect}
+  end
+rescue Sass::SyntaxError => e
+  Sass::Plugin::TemplateHandler.munge_exception e, lookup_context
+  Sass::SyntaxError.exception_to_css(e, Sass::Plugin.engine_options)
+end
+RUBY
+      end
+
+      def self.dependencies_changed?(deps, since, lookup_context)
+        opts = Sass::Plugin.engine_options.merge(:_rails_lookup_context => lookup_context)
+        deps.any? do |d, i|
+          return true unless time = i.mtime(d, opts)
+          time.to_i > since
+        end
+      end
+
+      def self.munge_exception(e, lookup_context)
+        importer = Sass::Importers::Rails.new
+        opts = Sass::Plugin.engine_options.merge(:_rails_lookup_context => lookup_context)
+        e.sass_backtrace.each do |bt|
+          next unless engine = importer.find(bt[:filename], opts)
+          bt[:filename] = engine.options[:_rails_filename]
+        end
+      end
+    end
+
+    ActionView::Template.register_template_handler(:sass, Sass::Plugin::TemplateHandler.new(:sass))
+    ActionView::Template.register_template_handler(:scss, Sass::Plugin::TemplateHandler.new(:scss))
+  elsif defined?(ActionController::Metal)
     # Rails >= 3.0
     require 'sass/plugin/rack'
     Rails.configuration.middleware.use(Sass::Plugin::Rack)

data/vendor/sass/lib/sass/plugin/staleness_checker.rb

@@ -53,6 +53,7 @@ module Sass
       # @param css_file [String] The location of the CSS file to check.
       # @param template_file [String] The location of the Sass or SCSS template
       #   that is compiled to `css_file`.
+      # @return [Boolean] Whether the stylesheet needs to be updated.
       def stylesheet_needs_update?(css_file, template_file)
         template_file = File.expand_path(template_file)
         begin
@@ -61,8 +62,19 @@ module Sass
           return true
         end
 
-        dependency_updated?(css_mtime).call(
-          template_file, @options[:filesystem_importer].new("."))
+        stylesheet_modified_since?(template_file, css_mtime)
+      end
+
+      # Returns whether a Sass or SCSS stylesheet has been modified since a given time.
+      #
+      # @param template_file [String] The location of the Sass or SCSS template.
+      # @param mtime [Fixnum] The modification time to check against.
+      # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
+      #   Defaults to the filesystem importer.
+      # @return [Boolean] Whether the stylesheet has been modified.
+      def stylesheet_modified_since?(template_file, mtime, importer = nil)
+        importer ||= @options[:filesystem_importer].new(".")
+        dependency_updated?(mtime).call(template_file, importer)
       end
 
       # Returns whether or not a given CSS file is out of date
@@ -75,10 +87,26 @@ module Sass
       # @param css_file [String] The location of the CSS file to check.
       # @param template_file [String] The location of the Sass or SCSS template
       #   that is compiled to `css_file`.
+      # @return [Boolean] Whether the stylesheet needs to be updated.
       def self.stylesheet_needs_update?(css_file, template_file)
         new(Plugin.engine_options).stylesheet_needs_update?(css_file, template_file)
       end
 
+      # Returns whether a Sass or SCSS stylesheet has been modified since a given time.
+      #
+      # The distinction between this method and the instance-level \{#stylesheet\_modified\_since?}
+      # is that the instance method preserves mtime and stale-dependency caches,
+      # so it's better to use when checking multiple stylesheets at once.
+      #
+      # @param template_file [String] The location of the Sass or SCSS template.
+      # @param mtime [Fixnum] The modification time to check against.
+      # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
+      #   Defaults to the filesystem importer.
+      # @return [Boolean] Whether the stylesheet has been modified.
+      def self.stylesheet_modified_since?(template_file, mtime, importer = nil)
+        new(Plugin.engine_options).stylesheet_modified_since?(template_file, mtime, importer)
+      end
+
       private
 
       def dependencies_stale?(uri, importer, css_mtime)

data/vendor/sass/lib/sass/script/css_parser.rb

@@ -22,7 +22,7 @@ module Sass
       end
 
       # Short-circuit all the SassScript-only productions
-      alias_method :interpolation, :concat
+      alias_method :interpolation, :space
       alias_method :or_expr, :div
       alias_method :unary_div, :ident
       alias_method :paren, :string

data/vendor/sass/lib/sass/script/functions.rb

@@ -113,6 +113,17 @@ module Sass::Script
   # \{#abs abs($value)}
   # : Returns the absolute value of a number.
   #
+  # ## List Functions {#list-functions}
+  #
+  # \{#length length($list)}
+  # : Returns the length of a list.
+  #
+  # \{#nth nth($list, $n)}
+  # : Returns a specific item in a list.
+  #
+  # \{#join join($list1, $list2, \[$separator\])}
+  # : Joins together two lists into one.
+  #
   # ## Introspection Functions
   #
   # \{#type_of type-of($value)}
@@ -705,7 +716,7 @@ module Sass::Script
     #   mix(#f00, #00f) => #7f007f
     #   mix(#f00, #00f, 25%) => #3f00bf
     #   mix(rgba(255, 0, 0, 0.5), #00f) => rgba(63, 0, 191, 0.75)
-    # @overload mix(color1, color2, weight = 50%)
+    # @overload mix(color1, color2, weight: 50%)
     #   @param color1 [Color]
     #   @param color2 [Color]
     #   @param weight [Number] between 0% and 100%
@@ -912,7 +923,7 @@ module Sass::Script
     #   round(10.6px) => 11px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def round(value)
       numeric_transformation(value) {|n| n.round}
     end
@@ -925,7 +936,7 @@ module Sass::Script
     #   ciel(10.6px) => 11px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def ceil(value)
       numeric_transformation(value) {|n| n.ceil}
     end
@@ -938,7 +949,7 @@ module Sass::Script
     #   floor(10.6px) => 10px
     # @param value [Number] The number
     # @return [Number] The rounded number
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def floor(value)
       numeric_transformation(value) {|n| n.floor}
     end
@@ -951,12 +962,122 @@ module Sass::Script
     #   abs(-10px) => 10px
     # @param value [Number] The number
     # @return [Number] The absolute value
-    # @raise [Sass::SyntaxError] if `value` isn't a number
+    # @raise [ArgumentError] if `value` isn't a number
     def abs(value)
       numeric_transformation(value) {|n| n.abs}
     end
     declare :abs, [:value]
 
+    # Return the length of a list.
+    #
+    # @example
+    #   length(10px) => 1
+    #   length(10px 20px 30px) => 3
+    # @param list [Literal] The list
+    # @return [Number] The length
+    def length(list)
+      Sass::Script::Number.new(list.to_a.size)
+    end
+    declare :length, [:list]
+
+    # Gets the nth item in a list.
+    #
+    # Note that unlike some languages, the first item in a Sass list is number 1,
+    # the second number 2, and so forth.
+    #
+    # @example
+    #   nth(10px 20px 30px, 1) => 10px
+    #   nth((Helvetica, Arial, sans-serif), 3) => sans-serif
+    # @param list [Literal] The list
+    # @param n [Number] The index into the list
+    # @return [Literal] The nth item in the list
+    # @raise [ArgumentError] If `n` isn't an integer between 1 and the list's length.
+    def nth(list, n)
+      assert_type n, :Number
+      if !n.int?
+        raise ArgumentError.new("List index #{n} must be an integer")
+      elsif n.to_i < 1
+        raise ArgumentError.new("List index #{n} must be greater than or equal to 1")
+      elsif n.to_i > (size = list.to_a.size)
+        raise ArgumentError.new("List index is #{n} but list is only #{size} item#{'s' if size != 1} long")
+      end
+
+      list.to_a[n.to_i - 1]
+    end
+    declare :nth, [:list, :n]
+
+    # Joins together two lists into a new list.
+    #
+    # Unless the `$separator` argument is passed,
+    # if one list is comma-separated and one is space-separated,
+    # the first parameter's separator is used for the resulting list.
+    # If the lists have only one item each, spaces are used for the resulting list.
+    #
+    # @example
+    #   join(10px 20px, 30px 40px) => 10px 20px 30px 40px
+    #   join((blue, red), (#abc, #def)) => blue, red, #abc, #def
+    #   join(10px, 20px) => 10px 20px
+    #   join(10px, 20px, comma) => 10px, 20px
+    #   join((blue, red), (#abc, #def), space) => blue red #abc #def
+    # @overload join(list1, list2, separator: auto)
+    #   @param list1 [Literal] The first list to join
+    #   @param list2 [Literal] The second list to join
+    #   @param separator [String] How the list separator (comma or space) should be determined.
+    #     If this is `comma` or `space`, that is always the separator;
+    #     if this is `auto` (the default), the separator is determined as explained above.
+    def join(list1, list2, separator = Sass::Script::String.new("auto"))
+      assert_type separator, :String
+      unless %w[auto space comma].include?(separator.value)
+        raise ArgumentError.new("Separator name must be space, comma, or auto")
+      end
+      sep1 = list1.separator if list1.is_a?(Sass::Script::List)
+      sep2 = list2.separator if list2.is_a?(Sass::Script::List)
+      Sass::Script::List.new(
+        list1.to_a + list2.to_a,
+        if separator.value == 'auto'
+          sep1 || sep2 || :space
+        else
+          separator.value.to_sym
+        end)
+    end
+    declare :join, [:list1, :list2]
+    declare :join, [:list1, :list2, :separator]
+
+    # Appends a single value onto the end of a list.
+    #
+    # Unless the `$separator` argument is passed,
+    # if the list has only one item,
+    # the resulting list will be space-separated.
+    #
+    # @example
+    #   append(10px 20px, 30px) => 10px 20px 30px
+    #   append((blue, red), green) => blue, red, green
+    #   append(10px 20px, 30px 40px) => 10px 20px (30px 40px)
+    #   join(10px, 20px, comma) => 10px, 20px
+    #   join((blue, red), green, space) => blue red green
+    # @overload join(list, val, separator: auto)
+    #   @param list1 [Literal] The first list to join
+    #   @param list2 [Literal] The second list to join
+    #   @param separator [String] How the list separator (comma or space) should be determined.
+    #     If this is `comma` or `space`, that is always the separator;
+    #     if this is `auto` (the default), the separator is determined as explained above.
+    def append(list, val, separator = Sass::Script::String.new("auto"))
+      assert_type separator, :String
+      unless %w[auto space comma].include?(separator.value)
+        raise ArgumentError.new("Separator name must be space, comma, or auto")
+      end
+      sep = list.separator if list.is_a?(Sass::Script::List)
+      Sass::Script::List.new(
+        list.to_a + [val],
+        if separator.value == 'auto'
+          sep || :space
+        else
+          separator.value.to_sym
+        end)
+    end
+    declare :append, [:list, :val]
+    declare :append, [:list, :val, :separator]
+
     private
 
     # This method implements the pattern of transforming a numeric value into