sass 3.1.0.alpha.214 → 3.1.0.alpha.216

data/REVISION

@@ -1 +1 @@
-e18890b4746317cad3919e6461554eb0415b12fc
+d4f5f05b36ae3e07d9c417174bf655b8f62969d9

data/VERSION

@@ -1 +1 @@
-3.1.0.alpha.214
+3.1.0.alpha.216

data/lib/sass/cache_stores.rb

@@ -12,3 +12,4 @@ end
 require 'sass/cache_stores/base'
 require 'sass/cache_stores/filesystem'
 require 'sass/cache_stores/memory'
+require 'sass/cache_stores/chain'

data/lib/sass/cache_stores/base.rb

@@ -48,7 +48,7 @@ module Sass
       # @param sha [String] The checksum for the contents that are being stored.
       # @param obj [Object] The object to cache.
       def store(key, sha, root)
-        _store(key, Sass::VERSION, sha, Sass::Util.dump(root))
+        _store(key, Sass::VERSION, sha, Marshal.dump(root))
       end
 
       # Retrieve a {Sass::Tree::RootNode}.
@@ -58,7 +58,7 @@ module Sass
       # @return [Object] The cached object.
       def retrieve(key, sha)
         contents = _retrieve(key, Sass::VERSION, sha)
-        Sass::Util.load(contents) if contents
+        Marshal.load(contents) if contents
       rescue EOFError, TypeError, ArgumentError => e
         Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
       end

data/lib/sass/cache_stores/chain.rb

@@ -0,0 +1,33 @@
+module Sass
+  module CacheStores
+    # A meta-cache that chains multiple caches together.
+    # Specifically:
+    #
+    # * All `#store`s are passed to all caches.
+    # * `#retrieve`s are passed to each cache until one has a hit.
+    # * When one cache has a hit, the value is `#store`d in all earlier caches.
+    class Chain < Base
+      # Create a new cache chaining the given caches.
+      #
+      # @param caches [Array<Sass::CacheStores::Base>] The caches to chain.
+      def initialize(*caches)
+        @caches = caches
+      end
+
+      # @see Base#store
+      def store(key, sha, obj)
+        @caches.each {|c| c.store(key, sha, obj)}
+      end
+
+      # @see Base#retrieve
+      def retrieve(key, sha)
+        @caches.each_with_index do |c, i|
+          next unless obj = c.retrieve(key, sha)
+          @caches[0...i].each {|c| c.store(key, sha, obj)}
+          return obj
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/sass/cache_stores/memory.rb

@@ -24,22 +24,18 @@ module Sass
         @contents = {}
       end
 
-      # @see Base#_retrieve
-      def _retrieve(key, version, sha)
+      # @see Base#retrieve
+      def retrieve(key, sha)
         if @contents.has_key?(key)
-          return unless @contents[key][:version] == version
           return unless @contents[key][:sha] == sha
-          return @contents[key][:contents]
+          obj = @contents[key][:obj]
+          obj.respond_to?(:deep_copy) ? obj.deep_copy : obj.dup
         end
       end
-      
-      # @see Base#_store
-      def _store(key, version, sha, contents)
-        @contents[key] = {
-          :version => version,
-          :sha => sha,
-          :contents => contents
-        }
+
+      # @see Base#store
+      def store(key, sha, obj)
+        @contents[key] = {:sha => sha, :obj => obj}
       end
       
       # Destructively clear the cache.

data/lib/sass/engine.rb

@@ -164,7 +164,8 @@ module Sass
       # Tracks the original filename of the top-level Sass file
       options[:original_filename] = options[:original_filename] || options[:filename]
 
-      options[:cache_store] ||= Sass::CacheStores::Filesystem.new(options[:cache_location])
+      options[:cache_store] ||= Sass::CacheStores::Chain.new(
+        Sass::CacheStores::Memory.new, Sass::CacheStores::Filesystem.new(options[:cache_location]))
       # Support both, because the docs said one and the other actually worked
       # for quite a long time.
       options[:line_comments] ||= options[:line_numbers]
@@ -333,7 +334,15 @@ module Sass
       end
 
       root.options = @options
-      @options[:cache_store].store(key, sha, root) if @options[:cache] && key && sha
+      if @options[:cache] && key && sha
+        begin
+          old_options = root.options
+          root.options = {:importer => root.options[:importer]}
+          @options[:cache_store].store(key, sha, root)
+        ensure
+          root.options = old_options
+        end
+      end
       root
     rescue SyntaxError => e
       e.modify_backtrace(:filename => @options[:filename], :line => @line)

data/lib/sass/script/funcall.rb

@@ -75,15 +75,15 @@ module Sass
       # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
       def _perform(environment)
         args = @args.map {|a| a.perform(environment)}
-        keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
         if fn = environment.function(@name)
+          keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
           return perform_sass_fn(fn, args, keywords)
         end
 
         ruby_name = @name.tr('-', '_')
-        args = construct_ruby_args(ruby_name, args, keywords)
+        args = construct_keyword_args(ruby_name, args, environment) unless @keywords.empty?
 
-        unless Sass::Util.has?(:public_instance_method, Functions, ruby_name) && ruby_name !~ /^__/
+        unless Functions.callable?(ruby_name)
           opts(to_literal(args))
         else
           opts(Functions::EvaluationContext.new(environment.options).send(ruby_name, *args))
@@ -102,7 +102,9 @@ module Sass
 
       private
 
-      def construct_ruby_args(name, args, keywords)
+      def construct_keyword_args(name, args, environment)
+        keywords = Sass::Util.map_hash(@keywords) {|k, v| [k, v.perform(environment)]}
+
         unless signature = Functions.signature(name.to_sym, args.size, keywords.size)
           return args if keywords.empty?
           raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")

data/lib/sass/script/functions.rb

@@ -93,12 +93,12 @@ module Sass::Script
   # \{#adjust adjust-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Increase or decrease any of the components of a color.
   #
+  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
+  # : Fluidly scale one or more components of a color.
+  #
   # \{#change_color change-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
   # : Changes one or more properties of a color.
   #
-  # \{#scale_color scale-color($color, \[$red\], \[$green\], \[$blue\], \[$hue\], \[$saturation\], \[$lightness\], \[$alpha\]}
-  # : Scales one or more properties of a color by a percentage value.
-  #
   # ## String Functions
   #
   # \{#unquote unquote($string)}
@@ -295,6 +295,8 @@ module Sass::Script
     # That means that all instance methods of {EvaluationContext}
     # are available to use in functions.
     class EvaluationContext
+      include Functions
+
       # The options hash for the {Sass::Engine} that is processing the function call
       #
       # @return [{Symbol => Object}]
@@ -303,10 +305,6 @@ module Sass::Script
       # @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
@@ -330,8 +328,32 @@ module Sass::Script
       end
     end
 
-    instance_methods.each { |m| undef_method m unless m.to_s =~ /^__/ }
+    class << self
+      FUNCTIONS = Set.new
 
+      # Returns whether user function with a given name exists.
+      #
+      # @param function_name [String]
+      # @return [Boolean]
+      def callable?(function_name)
+        FUNCTIONS.include?(function_name)
+      end
+
+      private
+      def include(*args)
+        r = super
+        update_callable_functions
+        # We have to re-include ourselves into EvaluationContext to work around
+        # an icky Ruby restriction.
+        EvaluationContext.send :include, self
+        r
+      end
+
+      def update_callable_functions
+        FUNCTIONS.clear
+        public_instance_methods.each {|function_name| FUNCTIONS << function_name.to_s}
+      end
+    end
 
     # Creates a {Color} object from red, green, and blue values.
     #
@@ -1325,5 +1347,15 @@ module Sass::Script
       color.with(attr => Sass::Util.restrict(
           color.send(attr).send(op, amount.value), range))
     end
+
+    class << self
+      private
+      def method_added(name)
+        update_callable_functions
+        super
+      end
+    end
+
+    update_callable_functions # generate the initial set
   end
 end

data/lib/sass/selector/sequence.rb

@@ -103,9 +103,7 @@ module Sass
       # @see Simple#to_a
       def to_a
         ary = @members.map {|seq_or_op| seq_or_op.is_a?(SimpleSequence) ? seq_or_op.to_a : seq_or_op}
-        ary = Sass::Util.intersperse(ary, " ")
-        ary = Sass::Util.substitute(ary, [" ", "\n", " "], ["\n"])
-        ary.flatten.compact
+        Sass::Util.intersperse(ary, " ").flatten.compact
       end
 
       # Returns a string representation of the sequence.

data/lib/sass/tree/if_node.rb

@@ -41,23 +41,22 @@ module Sass::Tree
       self.else.options = options if self.else
     end
 
-    # @see Node#_around_dump
-    def _around_dump
-      old_else = @else
-      old_last_else = @last_else
-      @else = Sass::Util.dump(@else)
-      @last_else = (self == @last_else ? nil : Sass::Util.dump(@last_else))
-      super
-    ensure
-      @else = old_else
-      @last_else = old_last_else
+    def _dump(f)
+      Marshal.dump([self.expr, self.else])
     end
 
-    # @see Node#_after_load
-    def _after_load
-      super
-      @else = Sass::Util.load(@else)
-      @last_else = (@last_else ? Sass::Util.load(@last_else) : self)
+    def self._load(data)
+      expr, else_ = Marshal.load(data)
+      node = IfNode.new(expr)
+      node.else = else_
+      node
+    end
+
+    # @see Node#deep_copy
+    def deep_copy
+      node = super
+      node.else = self.else.deep_copy if self.else
+      node
     end
   end
 end

data/lib/sass/tree/node.rb

@@ -180,29 +180,14 @@ module Sass
         Sass::Tree::Visitors::Convert.visit(self, options, :scss)
       end
 
-      # Names of options that are saved when the node is serialized and cached.
-      SAVED_OPTIONS = [:importer]
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _around_dump
-        old_options = @options
-        old_children = @children
-        @options = {}
-        SAVED_OPTIONS.each do |opt|
-          @options[opt] = old_options[opt]
-        end
-        @options = Sass::Util.dump(@options)
-        @children = Sass::Util.dump(@children)
-        yield
-      ensure
-        @options = old_options
-        @children = old_children
-      end
-
-      # Ensures that only {SAVED_OPTIONS} get saved.
-      def _after_load
-        @options = Sass::Util.load(@options)
-        @children = Sass::Util.load(@children)
+      # Return a deep clone of this node.
+      # The child nodes are cloned, but options are not.
+      #
+      # @return [Node]
+      def deep_copy
+        node = dup
+        node.children = children.map {|c| c.deep_copy}
+        node
       end
 
       protected

data/lib/sass/tree/rule_node.rb

@@ -56,9 +56,22 @@ module Sass::Tree
       merged = Sass::Util.merge_adjacent_strings(rule)
       @rule = Sass::Util.strip_string_array(merged)
       @tabs = 0
+      try_to_parse_non_interpolated_rules
       super()
     end
 
+    # If we've precached the parsed selector, set the line on it, too.
+    def line=(line)
+      @parsed_rules.line = line if @parsed_rules
+      super
+    end
+
+    # If we've precached the parsed selector, set the filename on it, too.
+    def filename=(filename)
+      @parsed_rules.filename = filename if @parsed_rules
+      super
+    end
+
     # Compares the contents of two rules.
     #
     # @param other [Object] The object to compare with
@@ -74,6 +87,7 @@ module Sass::Tree
     def add_rules(node)
       @rule = Sass::Util.strip_string_array(
         Sass::Util.merge_adjacent_strings(@rule + ["\n"] + node.rule))
+      try_to_parse_non_interpolated_rules
     end
 
     # @return [Boolean] Whether or not this rule is continued on the next line
@@ -100,5 +114,16 @@ module Sass::Tree
       {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
        :line => self.line}
     end
+
+    private
+
+    def try_to_parse_non_interpolated_rules
+      if @rule.all? {|t| t.kind_of?(String)}
+        # We don't use real filename/line info because we don't have it yet.
+        # When we get it, we'll set it on the parsed rules if possible.
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, 1)
+        @parsed_rules = parser.parse_selector('') rescue nil
+      end
+    end
   end
 end

data/lib/sass/tree/visitors/perform.rb

@@ -228,7 +228,7 @@ END
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
     parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.line)
-    node.parsed_rules = parser.parse_selector(node.filename)
+    node.parsed_rules ||= parser.parse_selector(node.filename)
     yield
   end
 

data/lib/sass/tree/visitors/to_css.rb

@@ -128,11 +128,15 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       rule_indent = '  ' * @tabs
       per_rule_indent, total_indent = [:nested, :expanded].include?(node.style) ? [rule_indent, ''] : ['', rule_indent]
 
-      total_rule = total_indent + node.resolved_rules.members.
-        map {|seq| seq.to_a.join.gsub(/([^,])\n/m, node.style == :compressed ? '\1 ' : "\\1\n")}.
-        join(rule_separator).split("\n").map do |line|
-        per_rule_indent + line.strip
-      end.join(line_separator)
+      joined_rules = node.resolved_rules.members.map do |seq|
+        rule_part = seq.to_a.join
+        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
+        rule_part
+      end.join(rule_separator)
+
+      joined_rules.sub!(/\A\s*/, per_rule_indent)
+      joined_rules.gsub!(/\s*\n\s*/, "#{line_separator}#{per_rule_indent}")
+      total_rule = total_indent << joined_rules
 
       to_return = ''
       old_spaces = '  ' * @tabs

data/lib/sass/util.rb

@@ -270,47 +270,6 @@ module Sass
       version_gt(v1, v2) || !version_gt(v2, v1)
     end
 
-    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
-    # before dumping it, `#_after_dump` afterwards.
-    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
-    #
-    # If any of these methods are undefined, they are not called.
-    #
-    # This will recursively call itself on members of arrays and hashes,
-    # but not of user-defined objects.
-    # This means that user-defined objects that need their members' `#_before_dump` etc. methods called
-    # must call `Haml::Util.dump` and `Haml::Util.load` manually on those members.
-    #
-    # @param obj [Object] The object to dump.
-    # @return [String] The dumped data.
-    def dump(obj)
-      obj._before_dump if obj.respond_to?(:_before_dump)
-      return convert_and_dump(obj) unless obj.respond_to?(:_around_dump)
-      res = nil
-      obj._around_dump {res = convert_and_dump(obj)}
-      res
-    ensure
-      obj._after_dump if obj.respond_to?(:_after_dump)
-    end
-
-    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
-    # after loading it, if it's defined.
-    #
-    # @param data [String] The data to load.
-    # @return [Object] The loaded object.
-    def load(data)
-      obj = Marshal.load(data)
-
-      if obj.is_a?(Array)
-        obj = obj.map {|e| Sass::Util.load(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [Sass::Util.load(k), Sass::Util.load(v)]}
-      end
-
-      obj._after_load if obj.respond_to?(:_after_load)
-      obj
-    end
-
     # Throws a NotImplementedError for an abstract method.
     #
     # @param obj [Object] `self`
@@ -706,14 +665,5 @@ MSG
       return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
       return lcs_backtrace(c, x, y, i-1, j, &block)
     end
-
-    def convert_and_dump(obj)
-      if obj.is_a?(Array)
-        obj = obj.map {|e| dump(e)}
-      elsif obj.is_a?(Hash)
-        obj = map_hash(obj) {|k, v| [dump(k), dump(v)]}
-      end
-      Marshal.dump(obj)
-    end
   end
 end

data/test/sass/importer_test.rb

@@ -5,8 +5,6 @@ require File.dirname(__FILE__) + '/test_helper'
 class ImporterTest < Test::Unit::TestCase
   
   class FruitImporter < Sass::Importers::Base
-    attr_reader :cached
-
     def find(name, context = nil)
       if name =~ %r{fruits/(\w+)(\.s[ac]ss)?}
         fruit = $1
@@ -31,13 +29,6 @@ class ImporterTest < Test::Unit::TestCase
     def key(name, context)
       [self.class.name, name]
     end
-
-    def _around_dump
-      @cached = true
-      yield
-    ensure
-      @cached = false
-    end
   end
 
   # This class proves that you can override the extension scheme for importers
@@ -88,17 +79,4 @@ CSS
   ensure
     FileUtils.rm_rf(absolutize("tmp"))
   end
-
-  def test_caching_importer
-    source = "p\n  foo: bar"
-    importer = FruitImporter.new
-    filename = filename_for_test
-    engine = Sass::Engine.new(source, :filename => filename, :importer => importer)
-    engine.to_tree # Trigger caching
-
-    sha = Digest::SHA1.hexdigest(source)
-    cache = engine.options[:cache_store]
-    cached_tree = cache.retrieve(cache.key(*importer.key(filename, engine.options)), sha)
-    assert cached_tree.options[:importer].cached, "Importer's _around_dump method should have been called"
-  end
 end

data/test/sass/script_test.rb

@@ -198,6 +198,13 @@ SASS
     assert_equal "public_instance_methods()", resolve("public_instance_methods()")
   end
 
+  def test_adding_functions_directly_to_functions_module
+    assert !Functions.callable?('nonexistant')
+    Functions.class_eval { def nonexistant; end }
+    assert Functions.callable?('nonexistant')
+    Functions.send :remove_method, :nonexistant
+  end
+
   def test_default_functions
     assert_equal "url(12)", resolve("url(12)")
     assert_equal 'blam("foo")', resolve('blam("foo")')

data/test/sass/util_test.rb

@@ -5,19 +5,6 @@ require 'pathname'
 class UtilTest < Test::Unit::TestCase
   include Sass::Util
 
-  class Dumpable
-    attr_reader :arr
-    def initialize; @arr = []; end
-    def _before_dump; @arr << :before; end
-    def _after_dump; @arr << :after; end
-    def _around_dump
-      @arr << :around_before
-      yield
-      @arr << :around_after
-    end
-    def _after_load; @arr << :loaded; end
-  end
-
   def test_scope
     assert(File.exist?(scope("Rakefile")))
   end
@@ -253,14 +240,6 @@ class UtilTest < Test::Unit::TestCase
     assert(!version_gt(v2, v1), "Expected #{v2} = #{v1}")
   end
 
-  def test_dump_and_load
-    obj = Dumpable.new
-    data = dump(obj)
-    assert_equal([:before, :around_before, :around_after, :after], obj.arr)
-    obj2 = load(data)
-    assert_equal([:before, :around_before, :loaded], obj2.arr)
-  end
-
   class FooBar
     def foo
       Sass::Util.abstract(self)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  version: 3.1.0.alpha.214
+  version: 3.1.0.alpha.216
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-31 00:00:00 -05:00
+date: 2011-01-13 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -60,6 +60,7 @@ files:
 - lib/sass/cache_stores.rb
 - lib/sass/cache_stores/active_support.rb
 - lib/sass/cache_stores/base.rb
+- lib/sass/cache_stores/chain.rb
 - lib/sass/cache_stores/filesystem.rb
 - lib/sass/cache_stores/memory.rb
 - lib/sass/cache_stores/null.rb