xass 0.1.0 → 0.1.1

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

@@ -1,228 +0,0 @@
-# A visitor for converting a Sass tree into CSS.
-class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
-  protected
-
-  def initialize
-    @tabs = 0
-  end
-
-  def visit(node)
-    super
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  def with_tabs(tabs)
-    old_tabs, @tabs = @tabs, tabs
-    yield
-  ensure
-    @tabs = old_tabs
-  end
-
-  def visit_root(node)
-    result = String.new
-    node.children.each do |child|
-      next if child.invisible?
-      child_str = visit(child)
-      result << child_str + (node.style == :compressed ? '' : "\n")
-    end
-    result.rstrip!
-    return "" if result.empty?
-    result << "\n"
-    unless Sass::Util.ruby1_8? || result.ascii_only?
-      if node.children.first.is_a?(Sass::Tree::CharsetNode)
-        begin
-          encoding = node.children.first.name
-          # Default to big-endian encoding, because we have to decide somehow
-          encoding << 'BE' if encoding =~ /\Autf-(16|32)\Z/i
-          result = result.encode(Encoding.find(encoding))
-        rescue EncodingError
-        end
-      end
-
-      result = "@charset \"#{result.encoding.name}\";#{
-        node.style == :compressed ? '' : "\n"
-      }".encode(result.encoding) + result
-    end
-    result
-  rescue Sass::SyntaxError => e
-    e.sass_template ||= node.template
-    raise e
-  end
-
-  def visit_charset(node)
-    "@charset \"#{node.name}\";"
-  end 
-
-  def visit_comment(node)
-    return if node.invisible?
-    spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
-
-    content = node.resolved_value.gsub(/^/, spaces)
-    content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"} if node.type == :silent
-    content.gsub!(/\n +(\* *(?!\/))?/, ' ') if (node.style == :compact || node.style == :compressed) && node.type != :loud
-    content
-  end
-
-  def visit_directive(node)
-    was_in_directive = @in_directive
-    tab_str = '  ' * @tabs
-    return tab_str + node.resolved_value + ";" unless node.has_children
-    return tab_str + node.resolved_value + " {}" if node.children.empty?
-    @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
-    result = if node.style == :compressed
-               "#{node.resolved_value}{"
-             else
-               "#{tab_str}#{node.resolved_value} {" + (node.style == :compact ? ' ' : "\n")
-             end
-    was_prop = false
-    first = true
-    node.children.each do |child|
-      next if child.invisible?
-      if node.style == :compact
-        if child.is_a?(Sass::Tree::PropNode)
-          with_tabs(first || was_prop ? 0 : @tabs + 1) {result << visit(child) << ' '}
-        else
-          result[-1] = "\n" if was_prop
-          rendered = with_tabs(@tabs + 1) {visit(child).dup}
-          rendered = rendered.lstrip if first
-          result << rendered.rstrip + "\n"
-        end
-        was_prop = child.is_a?(Sass::Tree::PropNode)
-        first = false
-      elsif node.style == :compressed
-        result << (was_prop ? ";" : "") << with_tabs(0) {visit(child)}
-        was_prop = child.is_a?(Sass::Tree::PropNode)
-      else
-        result << with_tabs(@tabs + 1) {visit(child)} + "\n"
-      end
-    end
-    result.rstrip + if node.style == :compressed
-                      "}"
-                    else
-                      (node.style == :expanded ? "\n" : " ") + "}\n"
-                    end
-  ensure
-    @in_directive = was_in_directive
-  end
-
-  def visit_media(node)
-    str = with_tabs(@tabs + node.tabs) {visit_directive(node)}
-    str.gsub!(/\n\Z/, '') unless node.style == :compressed || node.group_end
-    str
-  end
-
-  def visit_supports(node)
-    visit_media(node)
-  end
-
-  def visit_cssimport(node)
-    visit_directive(node)
-  end
-
-  def visit_prop(node)
-    return if node.resolved_value.empty?
-    tab_str = '  ' * (@tabs + node.tabs)
-    if node.style == :compressed
-      "#{tab_str}#{node.resolved_name}:#{node.resolved_value}"
-    else
-      "#{tab_str}#{node.resolved_name}: #{node.resolved_value};"
-    end
-  end
-
-  def visit_rule(node)
-    with_tabs(@tabs + node.tabs) do
-      rule_separator = node.style == :compressed ? ',' : ', '
-      line_separator =
-        case node.style
-          when :nested, :expanded; "\n"
-          when :compressed; ""
-          else; " "
-        end
-      rule_indent = '  ' * @tabs
-      per_rule_indent, total_indent = [:nested, :expanded].include?(node.style) ? [rule_indent, ''] : ['', rule_indent]
-
-      joined_rules = node.resolved_rules.members.map do |seq|
-        next if seq.has_placeholder?
-        rule_part = seq.to_a.join
-        if node.style == :compressed
-          rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
-          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
-          rule_part.strip!
-        end
-        rule_part
-      end.compact.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
-      if node.style != :compressed
-        if node.options[:debug_info] && !@in_directive
-          to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
-        elsif node.options[:trace_selectors]
-          to_return << "#{old_spaces}/* "
-          to_return << node.stack_trace.join("\n   #{old_spaces}")
-          to_return << " */\n"
-        elsif node.options[:line_comments]
-          to_return << "#{old_spaces}/* line #{node.line}"
-
-          if node.filename
-            relative_filename = if node.options[:css_filename]
-              begin
-                Pathname.new(node.filename).relative_path_from(
-                  Pathname.new(File.dirname(node.options[:css_filename]))).to_s
-              rescue ArgumentError
-                nil
-              end
-            end
-            relative_filename ||= node.filename
-            to_return << ", #{relative_filename}"
-          end
-
-          to_return << " */\n"
-        end
-      end
-
-      if node.style == :compact
-        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(' ')}
-        to_return << "#{total_rule} { #{properties} }#{"\n" if node.group_end}"
-      elsif node.style == :compressed
-        properties = with_tabs(0) {node.children.map {|a| visit(a)}.join(';')}
-        to_return << "#{total_rule}{#{properties}}"
-      else
-        properties = with_tabs(@tabs + 1) {node.children.map {|a| visit(a)}.join("\n")}
-        end_props = (node.style == :expanded ? "\n" + old_spaces : ' ')
-        to_return << "#{total_rule} {\n#{properties}#{end_props}}#{"\n" if node.group_end}"
-      end
-
-      to_return
-    end
-  end
-
-  private
-
-  def debug_info_rule(debug_info, options)
-    node = Sass::Tree::DirectiveNode.resolved("@media -sass-debug-info")
-    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
-      rule = Sass::Tree::RuleNode.new([""])
-      rule.resolved_rules = Sass::Selector::CommaSequence.new(
-        [Sass::Selector::Sequence.new(
-            [Sass::Selector::SimpleSequence.new(
-                [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)],
-                false)
-            ])
-        ])
-      prop = Sass::Tree::PropNode.new([""], Sass::Script::String.new(''), :new)
-      prop.resolved_name = "font-family"
-      prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
-      rule << prop
-      node << rule
-    end
-    node.options = options.merge(:debug_info => false, :line_comments => false, :style => :compressed)
-    node
-  end
-end

data/lib/sass/tree/warn_node.rb

@@ -1,18 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a Sass `@warn` statement.
-    #
-    # @see Sass::Tree
-    class WarnNode < Node
-      # The expression to print.
-      # @return [Script::Node]
-      attr_accessor :expr
-
-      # @param expr [Script::Node] The expression to print
-      def initialize(expr)
-        @expr = expr
-        super()
-      end
-    end
-  end
-end

data/lib/sass/tree/while_node.rb

@@ -1,18 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A dynamic node representing a Sass `@while` loop.
-  #
-  # @see Sass::Tree
-  class WhileNode < Node
-    # The parse tree for the continuation expression.
-    # @return [Script::Node]
-    attr_accessor :expr
-
-    # @param expr [Script::Node] See \{#expr}
-    def initialize(expr)
-      @expr = expr
-      super()
-    end
-  end
-end

data/lib/sass/util/multibyte_string_scanner.rb

@@ -1,155 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

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