sass 3.1.21 → 3.2.0.alpha.3

data/VERSION_DATE

@@ -1 +0,0 @@
-11 August 2012 00:38:15 UTC

data/lib/sass/logger.rb

@@ -1,15 +0,0 @@
-module Sass::Logger
-
-end
-
-require "sass/logger/log_level"
-require "sass/logger/base"
-
-module Sass
-
-  class << self
-    attr_accessor :logger
-  end
-
-  self.logger = Sass::Logger::Base.new
-end

data/lib/sass/logger/base.rb

@@ -1,32 +0,0 @@
-require 'sass/logger/log_level'
-
-class Sass::Logger::Base
-  
-  include Sass::Logger::LogLevel
-
-  attr_accessor :log_level
-  attr_accessor :disabled
-
-  log_level :trace
-  log_level :debug
-  log_level :info
-  log_level :warn
-  log_level :error
-
-  def initialize(log_level = :debug)
-    self.log_level = log_level
-  end
-
-  def logging_level?(level)
-    !disabled && self.class.log_level?(level, log_level)
-  end
-
-  def log(level, message)
-    self._log(level, message) if logging_level?(level)
-  end
-
-  def _log(level, message)
-    Kernel::warn(message)
-  end
-
-end

data/lib/sass/logger/log_level.rb

@@ -1,49 +0,0 @@
-module Sass
-  module Logger
-    module LogLevel
-
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        def inherited(subclass)
-          subclass.log_levels = subclass.superclass.log_levels.dup
-        end
-
-        def log_levels
-          @log_levels ||= {}
-        end
-
-        def log_levels=(levels)
-          @log_levels = levels
-        end
-
-        def log_level?(level, min_level)
-          log_levels[level] >= log_levels[min_level]
-        end
-
-        def log_level(name, options = {})
-          if options[:prepend]
-            level = log_levels.values.min
-            level = level.nil? ? 0 : level - 1
-          else
-            level = log_levels.values.max
-            level = level.nil? ? 0 : level + 1
-          end
-          log_levels.update(name => level)
-          define_logger(name)
-        end
-
-        def define_logger(name, options = {})
-          class_eval %Q{
-            def #{name}(message)
-              #{options.fetch(:to, :log)}(#{name.inspect}, message)
-            end
-          }
-        end
-      end
-      
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# A visitor for copying the full structure of a Sass tree.
-class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
-  protected
-
-  def visit(node)
-    super(node.dup)
-  end
-
-  def visit_children(parent)
-    parent.children = parent.children.map {|c| visit(c)}
-    parent
-  end
-
-  def visit_debug(node)
-    node.expr = node.expr.deep_copy
-    yield
-  end
-
-  def visit_each(node)
-    node.list = node.list.deep_copy
-    yield
-  end
-
-  def visit_extend(node)
-    node.selector = node.selector.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
-    yield
-  end
-
-  def visit_for(node)
-    node.from = node.from.deep_copy
-    node.to = node.to.deep_copy
-    yield
-  end
-
-  def visit_function(node)
-    node.args = node.args.map {|k, v| [k.deep_copy, v && v.deep_copy]}
-    yield
-  end
-
-  def visit_if(node)
-    node.expr = node.expr.deep_copy if node.expr
-    node.else = visit(node.else) if node.else
-    yield
-  end
-
-  def visit_mixindef(node)
-    node.args = node.args.map {|k, v| [k.deep_copy, v && v.deep_copy]}
-    yield
-  end
-
-  def visit_mixin(node)
-    node.args = node.args.map {|a| a.deep_copy}
-    node.keywords = Hash[node.keywords.map {|k, v| [k, v.deep_copy]}]
-    yield
-  end
-
-  def visit_prop(node)
-    node.name = node.name.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
-    node.value = node.value.deep_copy
-    yield
-  end
-
-  def visit_return(node)
-    node.expr = node.expr.deep_copy
-    yield
-  end
-
-  def visit_rule(node)
-    node.rule = node.rule.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
-    yield
-  end
-
-  def visit_variable(node)
-    node.expr = node.expr.deep_copy
-    yield
-  end
-
-  def visit_warn(node)
-    node.expr = node.expr.deep_copy
-    yield
-  end
-
-  def visit_while(node)
-    node.expr = node.expr.deep_copy
-    yield
-  end
-end

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

@@ -1,42 +0,0 @@
-# A visitor for performing selector inheritance on a static CSS tree.
-#
-# Destructively modifies the tree.
-class Sass::Tree::Visitors::Extend < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
-  #                                       Sass::Tree::Visitors::Cssize::Extend}]
-  #   The extensions to perform on this tree.
-  # @return [Object] The return value of \{#visit} for the root node.
-  def self.visit(root, extends)
-    return if extends.empty?
-    new(extends).send(:visit, root)
-  end
-
-  protected
-
-  def initialize(extends)
-    @parent_directives = []
-    @extends = extends
-  end
-
-  # If an exception is raised, this adds proper metadata to the backtrace.
-  def visit(node)
-    super(node)
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  # Keeps track of the current parent directives.
-  def visit_children(parent)
-    @parent_directives.push parent if parent.is_a?(Sass::Tree::DirectiveNode)
-    super
-  ensure
-    @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
-  end
-
-  # Applies the extend to a single rule's selector.
-  def visit_rule(node)
-    node.resolved_rules = node.resolved_rules.do_extend(@extends, @parent_directives)
-  end
-end

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

@@ -1,97 +0,0 @@
-# A visitor for setting options on the Sass tree
-class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @param options [{Symbol => Object}] The options has to set.
-  def self.visit(root, options); new(options).send(:visit, root); end
-
-  protected
-
-  def initialize(options)
-    @options = options
-  end
-
-  def visit(node)
-    node.instance_variable_set('@options', @options)
-    super
-  end
-
-  def visit_debug(node)
-    node.expr.options = @options
-    yield
-  end
-
-  def visit_each(node)
-    node.list.options = @options
-    yield
-  end
-
-  def visit_extend(node)
-    node.selector.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
-    yield
-  end
-
-  def visit_for(node)
-    node.from.options = @options
-    node.to.options = @options
-    yield
-  end
-
-  def visit_function(node)
-    node.args.each do |k, v|
-      k.options = @options
-      v.options = @options if v
-    end
-    yield
-  end
-
-  def visit_if(node)
-    node.expr.options = @options if node.expr
-    visit(node.else) if node.else
-    yield
-  end
-
-  def visit_mixindef(node)
-    node.args.each do |k, v|
-      k.options = @options
-      v.options = @options if v
-    end
-    yield
-  end
-
-  def visit_mixin(node)
-    node.args.each {|a| a.options = @options}
-    node.keywords.each {|k, v| v.options = @options}
-    yield
-  end
-
-  def visit_prop(node)
-    node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
-    node.value.options = @options
-    yield
-  end
-
-  def visit_return(node)
-    node.expr.options = @options
-    yield
-  end
-
-  def visit_rule(node)
-    node.rule.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
-    yield
-  end
-
-  def visit_variable(node)
-    node.expr.options = @options
-    yield
-  end
-
-  def visit_warn(node)
-    node.expr.options = @options
-    yield
-  end
-
-  def visit_while(node)
-    node.expr.options = @options
-    yield
-  end
-end

data/lib/sass/util/multibyte_string_scanner.rb

@@ -1,134 +0,0 @@
-require 'strscan'
-
-if Sass::Util.ruby1_8?
-  Sass::Util::MultibyteStringScanner = StringScanner
-else
-  # 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 < StringScanner
-    def self.new(str)
-      return StringScanner.new(str) if str.ascii_only?
-      super
-    end
-
-    def initialize(str)
-      super
-      @mb_pos = 0
-      @mb_matched_size = nil
-      @mb_last_pos = nil
-    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