xass 0.1.0 → 0.1.1

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

@@ -1,316 +0,0 @@
-# A visitor for converting a Sass tree into a source string.
-class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
-  # Runs the visitor on a tree.
-  #
-  # @param root [Tree::Node] The root node of the Sass tree.
-  # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
-  # @param format [Symbol] `:sass` or `:scss`.
-  # @return [String] The Sass or SCSS source for the tree.
-  def self.visit(root, options, format)
-    new(options, format).send(:visit, root)
-  end
-
-  protected
-
-  def initialize(options, format)
-    @options = options
-    @format = format
-    @tabs = 0
-    # 2 spaces by default
-    @tab_chars = @options[:indent] || "  "
-  end
-
-  def visit_children(parent)
-    @tabs += 1
-    return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
-    (@format == :sass ? "\n" : " {\n") + super.join.rstrip + (@format == :sass ? "\n" : "\n#{ @tab_chars * (@tabs-1)}}\n")
-  ensure
-    @tabs -= 1
-  end
-
-  # Ensures proper spacing between top-level nodes.
-  def visit_root(node)
-    Sass::Util.enum_cons(node.children + [nil], 2).map do |child, nxt|
-      visit(child) +
-        if nxt &&
-            (child.is_a?(Sass::Tree::CommentNode) &&
-              child.line + child.lines + 1 == nxt.line) ||
-            (child.is_a?(Sass::Tree::ImportNode) && nxt.is_a?(Sass::Tree::ImportNode) &&
-              child.line + 1 == nxt.line) ||
-            (child.is_a?(Sass::Tree::VariableNode) && nxt.is_a?(Sass::Tree::VariableNode) &&
-              child.line + 1 == nxt.line)
-          ""
-        else
-          "\n"
-        end
-    end.join.rstrip + "\n"
-  end
-
-  def visit_charset(node)
-    "#{tab_str}@charset \"#{node.name}\"#{semi}\n"
-  end
-
-  def visit_comment(node)
-    value = interp_to_src(node.value)
-    content = if @format == :sass
-      content = value.gsub(/\*\/$/, '').rstrip
-      if content =~ /\A[ \t]/
-        # Re-indent SCSS comments like this:
-        #     /* foo
-        #   bar
-        #       baz */
-        content.gsub!(/^/, '   ')
-        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
-      end
-
-      content =
-        unless content.include?("\n")
-          content
-        else
-          content.gsub!(/\n( \*|\/\/)/, "\n  ")
-          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
-          sep = node.type == :silent ? "\n//" : "\n *"
-          if spaces >= 2
-            content.gsub(/\n  /, sep)
-          else
-            content.gsub(/\n#{' ' * spaces}/, sep)
-          end
-        end
-
-      content.gsub!(/\A\/\*/, '//') if node.type == :silent
-      content.gsub!(/^/, tab_str)
-      content.rstrip + "\n"
-    else
-      spaces = (@tab_chars * [@tabs - value[/^ */].size, 0].max)
-      content = if node.type == :silent
-        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-      else
-        value
-      end.gsub(/^/, spaces) + "\n"
-      content
-    end
-    content
-  end
-
-  def visit_debug(node)
-    "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
-  end
-
-  def visit_directive(node)
-    res = "#{tab_str}#{interp_to_src(node.value)}"
-    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2');
-    return res + "#{semi}\n" unless node.has_children
-    res + yield + "\n"
-  end
-
-  def visit_each(node)
-    "#{tab_str}@each $#{dasherize(node.var)} in #{node.list.to_sass(@options)}#{yield}"
-  end
-
-  def visit_extend(node)
-    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}#{" !optional" if node.optional?}\n"
-  end
-
-  def visit_for(node)
-    "#{tab_str}@for $#{dasherize(node.var)} from #{node.from.to_sass(@options)} " +
-      "#{node.exclusive ? "to" : "through"} #{node.to.to_sass(@options)}#{yield}"
-  end
-
-  def visit_function(node)
-    args = node.args.map do |v, d|
-      d ? "#{v.to_sass(@options)}: #{d.to_sass(@options)}" : v.to_sass(@options)
-    end.join(", ")
-    if node.splat
-      args << ", " unless node.args.empty?
-      args << node.splat.to_sass(@options) << "..."
-    end
-
-    "#{tab_str}@function #{dasherize(node.name)}(#{args})#{yield}"
-  end
-
-  def visit_if(node)
-    name =
-      if !@is_else; "if"
-      elsif node.expr; "else if"
-      else; "else"
-      end
-    @is_else = false
-    str = "#{tab_str}@#{name}"
-    str << " #{node.expr.to_sass(@options)}" if node.expr
-    str << yield
-    @is_else = true
-    str << visit(node.else) if node.else
-    str
-  ensure
-    @is_else = false
-  end
-
-  def visit_import(node)
-    quote = @format == :scss ? '"' : ''
-    "#{tab_str}@import #{quote}#{node.imported_filename}#{quote}#{semi}\n"
-  end
-
-  def visit_media(node)
-    "#{tab_str}@media #{media_interp_to_src(node.query)}#{yield}"
-  end
-
-  def visit_supports(node)
-    "#{tab_str}@#{node.name} #{node.condition.to_src(@options)}#{yield}"
-  end
-
-  def visit_cssimport(node)
-    if node.uri.is_a?(Sass::Script::Node)
-      str = "#{tab_str}@import #{node.uri.to_sass(@options)}"
-    else
-      str = "#{tab_str}@import #{node.uri}"
-    end
-    str << " #{interp_to_src(node.query)}" unless node.query.empty?
-    "#{str}#{semi}\n"
-  end
-
-  def visit_mixindef(node)
-    args =
-      if node.args.empty? && node.splat.nil?
-        ""
-      else
-        str = '('
-        str << node.args.map do |v, d|
-          if d
-            "#{v.to_sass(@options)}: #{d.to_sass(@options)}"
-          else
-            v.to_sass(@options)
-          end
-        end.join(", ")
-
-        if node.splat
-          str << ", " unless node.args.empty?
-          str << node.splat.to_sass(@options) << '...'
-        end
-
-        str << ')'
-      end
-
-    "#{tab_str}#{@format == :sass ? '=' : '@mixin '}#{dasherize(node.name)}#{args}#{yield}"
-  end
-
-  def visit_mixin(node)
-    arg_to_sass = lambda do |arg|
-      sass = arg.to_sass(@options)
-      sass = "(#{sass})" if arg.is_a?(Sass::Script::List) && arg.separator == :comma
-      sass
-    end
-
-    unless node.args.empty? && node.keywords.empty? && node.splat.nil?
-      args = node.args.map(&arg_to_sass).join(", ")
-      keywords = Sass::Util.hash_to_a(node.keywords).
-        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}.join(', ')
-      if node.splat
-        splat = (args.empty? && keywords.empty?) ? "" : ", "
-        splat = "#{splat}#{arg_to_sass[node.splat]}..."
-      end
-      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
-    end
-    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
-  end
-
-  def visit_content(node)
-    "#{tab_str}@content#{semi}\n"
-  end
-
-  def visit_prop(node)
-    res = tab_str + node.declaration(@options, @format)
-    return res + semi + "\n" if node.children.empty?
-    res + yield.rstrip + semi + "\n"
-  end
-
-  def visit_return(node)
-    "#{tab_str}@return #{node.expr.to_sass(@options)}#{semi}\n"
-  end
-
-  def visit_rule(node)
-    if @format == :sass
-      name = selector_to_sass(node.rule)
-      name = "\\" + name if name[0] == ?:
-      name.gsub(/^/, tab_str) + yield
-    elsif @format == :scss
-      name = selector_to_scss(node.rule)
-      res = name + yield
-      if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.type == :silent
-        res.slice!(-3..-1)
-        res << "\n" << tab_str << "}\n"
-      end
-      res
-    end
-  end
-
-  def visit_variable(node)
-    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}#{' !default' if node.guarded}#{semi}\n"
-  end
-
-  def visit_warn(node)
-    "#{tab_str}@warn #{node.expr.to_sass(@options)}#{semi}\n"
-  end
-
-  def visit_while(node)
-    "#{tab_str}@while #{node.expr.to_sass(@options)}#{yield}"
-  end
-
-  private
-
-  def interp_to_src(interp)
-    interp.map do |r|
-      next r if r.is_a?(String)
-      "\#{#{r.to_sass(@options)}}"
-    end.join
-  end
-
-  # Like interp_to_src, but removes the unnecessary `#{}` around the keys and
-  # values in media expressions.
-  def media_interp_to_src(interp)
-    Sass::Util.enum_with_index(interp).map do |r, i|
-      next r if r.is_a?(String)
-      before, after = interp[i-1], interp[i+1]
-      if before.is_a?(String) && after.is_a?(String) &&
-          ((before[-1] == ?( && after[0] == ?:) ||
-           (before =~ /:\s*/ && after[0] == ?)))
-        r.to_sass(@options)
-      else
-        "\#{#{r.to_sass(@options)}}"
-      end
-    end.join
-  end
-
-  def selector_to_src(sel)
-    @format == :sass ? selector_to_sass(sel) : selector_to_scss(sel)
-  end
-
-  def selector_to_sass(sel)
-    sel.map do |r|
-      if r.is_a?(String)
-        r.gsub(/(,)?([ \t]*)\n\s*/) {$1 ? "#{$1}#{$2}\n" : " "}
-      else
-        "\#{#{r.to_sass(@options)}}"
-      end
-    end.join
-  end
-
-  def selector_to_scss(sel)
-    interp_to_src(sel).gsub(/^[ \t]*/, tab_str).gsub(/[ \t]*$/, '')
-  end
-
-  def semi
-    @format == :sass ? "" : ";"
-  end
-
-  def tab_str
-    @tab_chars * @tabs
-  end
-
-  def dasherize(s)
-    if @options[:dasherize]
-      s.gsub('_', '-')
-    else
-      s
-    end
-  end
-end

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

@@ -1,241 +0,0 @@
-# A visitor for converting a static Sass tree into a static CSS tree.
-class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
-  # @param root [Tree::Node] The root node of the tree to visit.
-  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
-  #   *and* the extensions defined for this tree
-  def self.visit(root); super; end
-
-  protected
-
-  # Returns the immediate parent of the current node.
-  # @return [Tree::Node]
-  attr_reader :parent
-
-  def initialize
-    @parent_directives = []
-    @extends = Sass::Util::SubsetMap.new
-  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 node.
-  def visit_children(parent)
-    with_parent parent do
-      parent.children = super.flatten
-      parent
-    end
-  end
-
-  MERGEABLE_DIRECTIVES = [Sass::Tree::MediaNode]
-
-  # Runs a block of code with the current parent node
-  # replaced with the given node.
-  #
-  # @param parent [Tree::Node] The new parent for the duration of the block.
-  # @yield A block in which the parent is set to `parent`.
-  # @return [Object] The return value of the block.
-  def with_parent(parent)
-    if parent.is_a?(Sass::Tree::DirectiveNode)
-      if MERGEABLE_DIRECTIVES.any? {|klass| parent.is_a?(klass)}
-        old_parent_directive = @parent_directives.pop
-      end
-      @parent_directives.push parent
-    end
-
-    old_parent, @parent = @parent, parent
-    yield
-  ensure
-    @parent_directives.pop if parent.is_a?(Sass::Tree::DirectiveNode)
-    @parent_directives.push old_parent_directive if old_parent_directive
-    @parent = old_parent
-  end
-
-  # In Ruby 1.8, ensures that there's only one `@charset` directive
-  # and that it's at the top of the document.
-  #
-  # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
-  #   *and* the extensions defined for this tree
-  def visit_root(node)
-    yield
-
-    if parent.nil?
-      # In Ruby 1.9 we can make all @charset nodes invisible
-      # and infer the final @charset from the encoding of the final string.
-      if Sass::Util.ruby1_8?
-        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.unshift charset if charset
-      end
-
-      imports_to_move = []
-      import_limit = nil
-      i = -1
-      node.children.reject! do |n|
-        i += 1
-        if import_limit
-          next false unless n.is_a?(Sass::Tree::CssImportNode)
-          imports_to_move << n
-          next true
-        end
-
-        if !n.is_a?(Sass::Tree::CommentNode) &&
-            !n.is_a?(Sass::Tree::CharsetNode) &&
-            !n.is_a?(Sass::Tree::CssImportNode)
-          import_limit = i
-        end
-
-        false
-      end
-
-      if import_limit
-        node.children = node.children[0...import_limit] + imports_to_move +
-          node.children[import_limit..-1]
-      end
-    end
-
-    return node, @extends
-  rescue Sass::SyntaxError => e
-    e.sass_template ||= node.template
-    raise e
-  end
-
-  # A simple struct wrapping up information about a single `@extend` instance. A
-  # single [ExtendNode] can have multiple Extends if either the parent node or
-  # the extended selector is a comma sequence.
-  #
-  # @attr extender [Sass::Selector::Sequence]
-  #   The selector of the CSS rule containing the `@extend`.
-  # @attr target [Array<Sass::Selector::Simple>] The selector being `@extend`ed.
-  # @attr node [Sass::Tree::ExtendNode] The node that produced this extend.
-  # @attr directives [Array<Sass::Tree::DirectiveNode>]
-  #   The directives containing the `@extend`.
-  # @attr result [Symbol]
-  #   The result of this extend. One of `:not_found` (the target doesn't exist
-  #   in the document), `:failed_to_unify` (the target exists but cannot be
-  #   unified with the extender), or `:succeeded`.
-  Extend = Struct.new(:extender, :target, :node, :directives, :result)
-
-  # Registers an extension in the `@extends` subset map.
-  def visit_extend(node)
-    node.resolved_selector.members.each do |seq|
-      if seq.members.size > 1
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
-      end
-
-      sseq = seq.members.first
-      if !sseq.is_a?(Sass::Selector::SimpleSequence)
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
-      elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend parent selectors")
-      end
-
-      sel = sseq.members
-      parent.resolved_rules.members.each do |member|
-        if !member.members.last.is_a?(Sass::Selector::SimpleSequence)
-          raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
-        end
-
-        @extends[sel] = Extend.new(member, sel, node, @parent_directives.dup, :not_found)
-      end
-    end
-
-    []
-  end
-
-  # Modifies exception backtraces to include the imported file.
-  def visit_import(node)
-    # Don't use #visit_children to avoid adding the import node to the list of parents.
-    node.children.map {|c| visit(c)}.flatten
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:filename => node.children.first.filename)
-    e.add_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  # Bubbles the `@media` directive up through RuleNodes
-  # and merges it with other `@media` directives.
-  def visit_media(node)
-    yield unless bubble(node)
-    media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
-    node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
-    media = media.select {|n| n.resolved_query = n.resolved_query.merge(node.resolved_query)}
-    (node.children.empty? ? [] : [node]) + media
-  end
-
-  # Bubbles the `@supports` directive up through RuleNodes.
-  def visit_supports(node)
-    yield unless bubble(node)
-    node
-  end
-
-  # Asserts that all the traced children are valid in their new location.
-  def visit_trace(node)
-    # Don't use #visit_children to avoid adding the trace node to the list of parents.
-    node.children.map {|c| visit(c)}.flatten
-  rescue Sass::SyntaxError => e
-    e.modify_backtrace(:mixin => node.name, :filename => node.filename, :line => node.line)
-    e.add_backtrace(:filename => node.filename, :line => node.line)
-    raise e
-  end
-
-  # Converts nested properties into flat properties
-  # and updates the indentation of the prop node based on the nesting level.
-  def visit_prop(node)
-    if parent.is_a?(Sass::Tree::PropNode)
-      node.resolved_name = "#{parent.resolved_name}-#{node.resolved_name}"
-      node.tabs = parent.tabs + (parent.resolved_value.empty? ? 0 : 1) if node.style == :nested
-    end
-
-    yield
-
-    result = node.children.dup
-    if !node.resolved_value.empty? || node.children.empty?
-      node.send(:check!)
-      result.unshift(node)
-    end
-
-    result
-  end
-
-  # Resolves parent references and nested selectors,
-  # and updates the indentation of the rule node based on the nesting level.
-  def visit_rule(node)
-    parent_resolved_rules = parent.is_a?(Sass::Tree::RuleNode) ? parent.resolved_rules : nil
-    # It's possible for resolved_rules to be set if we've duplicated this node during @media bubbling
-    node.resolved_rules ||= node.parsed_rules.resolve_parent_refs(parent_resolved_rules)
-
-    yield
-
-    rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles?}
-    props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles? || c.invisible?}
-
-    unless props.empty?
-      node.children = props
-      rules.each {|r| r.tabs += 1} if node.style == :nested
-      rules.unshift(node)
-    end
-
-    rules.last.group_end = true unless parent.is_a?(Sass::Tree::RuleNode) || rules.empty?
-
-    rules
-  end
-
-  private
-
-  def bubble(node)
-    return unless parent.is_a?(Sass::Tree::RuleNode)
-    new_rule = parent.dup
-    new_rule.children = node.children
-    node.children = with_parent(node) {Array(visit(new_rule))}
-    # If the last child is actually the end of the group,
-    # the parent's cssize will set it properly
-    node.children.last.group_end = false unless node.children.empty?
-    true
-  end
-end

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

@@ -1,102 +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
-
-  def visit_directive(node)
-    node.value = node.value.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
-    yield
-  end
-
-  def visit_media(node)
-    node.query = node.query.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}
-    yield
-  end
-
-  def visit_supports(node)
-    node.condition = node.condition.deep_copy
-    yield
-  end
-end