aliddle-sass 1.0

data/lib/sass/util/multibyte_string_scanner.rb

@@ -0,0 +1,155 @@
+require 'strscan'
+
+if Sass::Util.ruby1_8?
+  Sass::Util::MultibyteStringScanner = StringScanner
+else
+  if Sass::Util.rbx?
+    # Rubinius's StringScanner class implements some of its methods in terms of
+    # others, which causes us to double-count bytes in some cases if we do
+    # straightforward inheritance. To work around this, we use a delegate class.
+    require 'delegate'
+    class Sass::Util::MultibyteStringScanner < DelegateClass(StringScanner)
+      def initialize(str)
+        super(StringScanner.new(str))
+        @mb_pos = 0
+        @mb_matched_size = nil
+        @mb_last_pos = nil
+      end
+
+      def is_a?(klass)
+        __getobj__.is_a?(klass) || super
+      end
+    end
+  else
+    class Sass::Util::MultibyteStringScanner < StringScanner
+      def initialize(str)
+        super
+        @mb_pos = 0
+        @mb_matched_size = nil
+        @mb_last_pos = nil
+      end
+    end
+  end
+
+  # A wrapper of the native StringScanner class that works correctly with
+  # multibyte character encodings. The native class deals only in bytes, not
+  # characters, for methods like [#pos] and [#matched_size]. This class deals
+  # only in characters, instead.
+  class Sass::Util::MultibyteStringScanner
+    def self.new(str)
+      return StringScanner.new(str) if str.ascii_only?
+      super
+    end
+
+    alias_method :byte_pos, :pos
+    alias_method :byte_matched_size, :matched_size
+
+    def check(pattern); _match super; end
+    def check_until(pattern); _matched super; end
+    def getch; _forward _match super; end
+    def match?(pattern); _size check(pattern); end
+    def matched_size; @mb_matched_size; end
+    def peek(len); string[@mb_pos, len]; end
+    alias_method :peep, :peek
+    def pos; @mb_pos; end
+    alias_method :pointer, :pos
+    def rest_size; rest.size; end
+    def scan(pattern); _forward _match super; end
+    def scan_until(pattern); _forward _matched super; end
+    def skip(pattern); _size scan(pattern); end
+    def skip_until(pattern); _matched _size scan_until(pattern); end
+
+    def get_byte
+      raise "MultibyteStringScanner doesn't support #get_byte."
+    end
+
+    def getbyte
+      raise "MultibyteStringScanner doesn't support #getbyte."
+    end
+
+    def pos=(n)
+      @mb_last_pos = nil
+
+      # We set position kind of a lot during parsing, so we want it to be as
+      # efficient as possible. This is complicated by the fact that UTF-8 is a
+      # variable-length encoding, so it's difficult to find the byte length that
+      # corresponds to a given character length.
+      #
+      # Our heuristic here is to try to count the fewest possible characters. So
+      # if the new position is close to the current one, just count the
+      # characters between the two; if the new position is closer to the
+      # beginning of the string, just count the characters from there.
+      if @mb_pos - n < @mb_pos / 2
+        # New position is close to old position
+        byte_delta = @mb_pos > n ? -string[n...@mb_pos].bytesize : string[@mb_pos...n].bytesize
+        super(byte_pos + byte_delta)
+      else
+        # New position is close to BOS
+        super(string[0...n].bytesize)
+      end
+      @mb_pos = n
+    end
+
+    def reset
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+
+    def scan_full(pattern, advance_pointer_p, return_string_p)
+      res = _match super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      return res if return_string_p
+    end
+
+    def search_full(pattern, advance_pointer_p, return_string_p)
+      res = super(pattern, advance_pointer_p, true)
+      _forward res if advance_pointer_p
+      _matched((res if return_string_p))
+    end
+
+    def string=(str)
+      @mb_pos = 0
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+
+    def terminate
+      @mb_pos = string.size
+      @mb_matched_size = nil
+      @mb_last_pos = nil
+      super
+    end
+    alias_method :clear, :terminate
+
+    def unscan
+      super
+      @mb_pos = @mb_last_pos
+      @mb_last_pos = @mb_matched_size = nil
+    end
+
+    private
+
+    def _size(str)
+      str && str.size
+    end
+
+    def _match(str)
+      @mb_matched_size = str && str.size
+      str
+    end
+
+    def _matched(res)
+      _match matched
+      res
+    end
+
+    def _forward(str)
+      @mb_last_pos = @mb_pos
+      @mb_pos += str.size if str
+      str
+    end
+  end
+end

data/lib/sass/util/subset_map.rb

@@ -0,0 +1,109 @@
+require 'set'
+
+module Sass
+  module Util
+    # A map from sets to values.
+    # A value is \{#\[]= set} by providing a set (the "set-set") and a value,
+    # which is then recorded as corresponding to that set.
+    # Values are \{#\[] accessed} by providing a set (the "get-set")
+    # and returning all values that correspond to set-sets
+    # that are subsets of the get-set.
+    #
+    # SubsetMap preserves the order of values as they're inserted.
+    #
+    # @example
+    #   ssm = SubsetMap.new
+    #   ssm[Set[1, 2]] = "Foo"
+    #   ssm[Set[2, 3]] = "Bar"
+    #   ssm[Set[1, 2, 3]] = "Baz"
+    #
+    #   ssm[Set[1, 2, 3]] #=> ["Foo", "Bar", "Baz"]
+    class SubsetMap
+      # Creates a new, empty SubsetMap.
+      def initialize
+        @hash = {}
+        @vals = []
+      end
+
+      # Whether or not this SubsetMap has any key-value pairs.
+      #
+      # @return [Boolean]
+      def empty?
+        @hash.empty?
+      end
+
+      # Associates a value with a set.
+      # When `set` or any of its supersets is accessed,
+      # `value` will be among the values returned.
+      #
+      # Note that if the same `set` is passed to this method multiple times,
+      # all given `value`s will be associated with that `set`.
+      #
+      # This runs in `O(n)` time, where `n` is the size of `set`.
+      #
+      # @param set [#to_set] The set to use as the map key. May not be empty.
+      # @param value [Object] The value to associate with `set`.
+      # @raise [ArgumentError] If `set` is empty.
+      def []=(set, value)
+        raise ArgumentError.new("SubsetMap keys may not be empty.") if set.empty?
+
+        index = @vals.size
+        @vals << value
+        set.each do |k|
+          @hash[k] ||= []
+          @hash[k] << [set, set.to_set, index]
+        end
+      end
+
+      # Returns all values associated with subsets of `set`.
+      #
+      # In the worst case, this runs in `O(m*max(n, log m))` time,
+      # where `n` is the size of `set`
+      # and `m` is the number of assocations in the map.
+      # However, unless many keys in the map overlap with `set`,
+      # `m` will typically be much smaller.
+      #
+      # @param set [Set] The set to use as the map key.
+      # @return [Array<(Object, #to_set)>] An array of pairs,
+      #   where the first value is the value associated with a subset of `set`,
+      #   and the second value is that subset of `set`
+      #   (or whatever `#to_set` object was used to set the value)
+      #   This array is in insertion order.
+      # @see #[]
+      def get(set)
+        res = set.map do |k|
+          next unless subsets = @hash[k]
+          subsets.map do |subenum, subset, index|
+            next unless subset.subset?(set)
+            [index, subenum]
+          end
+        end
+        res = Sass::Util.flatten(res, 1)
+        res.compact!
+        res.uniq!
+        res.sort!
+        res.map! {|i, s| [@vals[i], s]}
+        return res
+      end
+
+      # Same as \{#get}, but doesn't return the subsets of the argument
+      # for which values were found.
+      #
+      # @param set [Set] The set to use as the map key.
+      # @return [Array] The array of all values
+      #   associated with subsets of `set`, in insertion order.
+      # @see #get
+      def [](set)
+        get(set).map {|v, _| v}
+      end
+
+      # Iterates over each value in the subset map. Ignores keys completely. If
+      # multiple keys have the same value, this will return them multiple times.
+      #
+      # @yield [Object] Each value in the map.
+      def each_value
+        @vals.each {|v| yield v}
+      end
+    end
+  end
+end

data/lib/sass/util/test.rb

@@ -0,0 +1,10 @@
+module Sass
+  module Util
+    module Test
+      def skip(msg = nil, bt = caller)
+        super if defined?(super)
+        return
+      end
+    end
+  end
+end

data/lib/sass/version.rb

@@ -0,0 +1,126 @@
+require 'date'
+
+# This is necessary for loading Sass when Haml is required in Rails 3.
+# Once the split is complete, we can remove it.
+require File.dirname(__FILE__) + '/../sass'
+require 'sass/util'
+
+module Sass
+  # Handles Sass version-reporting.
+  # Sass not only reports the standard three version numbers,
+  # but its Git revision hash as well,
+  # if it was installed from Git.
+  module Version
+    include Sass::Util
+
+    # Returns a hash representing the version of Sass.
+    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
+    # The `:name` key has the name of the version.
+    # The `:string` key contains a human-readable string representation of the version.
+    # The `:number` key is the major, minor, and teeny keys separated by periods.
+    # The `:date` key, which is not guaranteed to be defined, is the [DateTime] at which this release was cut.
+    # If Sass is checked out from Git, the `:rev` key will have the revision hash.
+    # For example:
+    #
+    #     {
+    #       :string => "2.1.0.9616393",
+    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
+    #       :number => "2.1.0",
+    #       :date   => DateTime.parse("Apr 30 13:52:01 2009 -0700"),
+    #       :major  => 2, :minor => 1, :teeny => 0
+    #     }
+    #
+    # If a prerelease version of Sass is being used,
+    # the `:string` and `:number` fields will reflect the full version
+    # (e.g. `"2.2.beta.1"`), and the `:teeny` field will be `-1`.
+    # A `:prerelease` key will contain the name of the prerelease (e.g. `"beta"`),
+    # and a `:prerelease_number` key will contain the rerelease number.
+    # For example:
+    #
+    #     {
+    #       :string => "3.0.beta.1",
+    #       :number => "3.0.beta.1",
+    #       :date   => DateTime.parse("Mar 31 00:38:04 2010 -0700"),
+    #       :major => 3, :minor => 0, :teeny => -1,
+    #       :prerelease => "beta",
+    #       :prerelease_number => 1
+    #     }
+    #
+    # @return [{Symbol => String/Fixnum}] The version hash
+    def version
+      return @@version if defined?(@@version)
+
+      numbers = File.read(scope('VERSION')).strip.split('.').
+        map {|n| n =~ /^[0-9]+$/ ? n.to_i : n}
+      name = File.read(scope('VERSION_NAME')).strip
+      @@version = {
+        :major => numbers[0],
+        :minor => numbers[1],
+        :teeny => numbers[2],
+        :name => name
+      }
+
+      if date = version_date
+        @@version[:date] = date
+      end
+
+      if numbers[3].is_a?(String)
+        @@version[:teeny] = -1
+        @@version[:prerelease] = numbers[3]
+        @@version[:prerelease_number] = numbers[4]
+      end
+
+      @@version[:number] = numbers.join('.')
+      @@version[:string] = @@version[:number].dup
+
+      if rev = revision_number
+        @@version[:rev] = rev
+        unless rev[0] == ?(
+          @@version[:string] << "." << rev[0...7]
+        end
+      end
+
+      @@version[:string] << " (#{name})"
+      @@version
+    end
+
+    private
+
+    def revision_number
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        return rev unless rev =~ /^([a-f0-9]+|\(.*\))$/ || rev == '(unknown)'
+      end
+
+      return unless File.exists?(scope('.git/HEAD'))
+      rev = File.read(scope('.git/HEAD')).strip
+      return rev unless rev =~ /^ref: (.*)$/
+
+      ref_name = $1
+      ref_file = scope(".git/#{ref_name}")
+      info_file = scope(".git/info/refs")
+      return File.read(ref_file).strip if File.exists?(ref_file)
+      return unless File.exists?(info_file)
+      File.open(info_file) do |f|
+        f.each do |l|
+          sha, ref = l.strip.split("\t", 2)
+          next unless ref == ref_name
+          return sha
+        end
+      end
+      return nil
+    end
+
+    def version_date
+      return unless File.exists?(scope('VERSION_DATE'))
+      return DateTime.parse(File.read(scope('VERSION_DATE')).strip)
+    end
+  end
+
+  extend Sass::Version
+
+  # A string representing the version of Sass.
+  # A more fine-grained representation is available from Sass.version.
+  # @api public
+  VERSION = version[:string] unless defined?(Sass::VERSION)
+end

data/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')

data/test/Gemfile

@@ -0,0 +1,3 @@
+source :gemcutter
+
+gem 'rake'

data/test/Gemfile.lock

@@ -0,0 +1,10 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake

data/test/sass/cache_test.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+require 'sass/engine'
+
+class CacheTest < Test::Unit::TestCase
+  @@cache_dir = "tmp/file_cache"
+
+  def setup
+    FileUtils.mkdir_p @@cache_dir
+  end
+
+  def teardown
+    FileUtils.rm_rf @@cache_dir
+    clean_up_sassc
+  end
+
+  def test_file_cache_writes_a_file
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+  end
+
+  def test_file_cache_reads_a_file
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_kind_of Sass::Tree::RootNode, file_store.retrieve("asdf/foo.scssc", "fakesha1")
+  end
+
+  def test_file_cache_miss_returns_nil
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
+  end
+
+  def test_sha_change_invalidates_cache_and_cleans_up
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_nil file_store.retrieve("asdf/foo.scssc", "differentsha1")
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+  end
+
+  def test_version_change_invalidates_cache_and_cleans_up
+    file_store = Sass::CacheStores::Filesystem.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    real_version = Sass::VERSION
+    begin
+      Sass::VERSION.replace("a different version")
+      assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
+      assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    ensure
+      Sass::VERSION.replace(real_version)
+    end
+  end
+
+  def test_arbitrary_objects_can_go_into_cache
+    cache = Sass::CacheStores::Memory.new
+    an_object = {:foo => :bar}
+    cache.store("an_object", "", an_object)
+    assert_equal an_object, cache.retrieve("an_object", "")
+  end
+
+  class Unmarshalable
+    def _dump(_)
+      raise 'Unmarshalable'
+    end
+  end
+
+  def test_cache_node_with_unmarshalable_option
+    engine = Sass::Engine.new("foo {a: b + c}",
+      :syntax => :scss, :object => Unmarshalable.new, :filename => 'file.scss',
+      :importer => Sass::Importers::Filesystem.new(absolutize('templates')))
+    engine.to_tree
+  end
+
+  private
+  def root_node
+    Sass::Engine.new(<<-SCSS, :syntax => :scss).to_tree
+      @mixin color($c) { color: $c}
+      div { @include color(red); }
+    SCSS
+  end
+end