xass 0.1.0

data/lib/sass/tree/root_node.rb

@@ -0,0 +1,78 @@
+require 'csspool'
+
+module Sass
+  module Tree
+    # A static node that is the root node of the Sass document.
+    class RootNode < Node
+      # The Sass template from which this node was created
+      #
+      # @param template [String]
+      attr_reader :template
+
+      # @param template [String] The Sass template from which this node was created
+      def initialize(template)
+        super()
+        @template = template
+      end
+
+      # Runs the dynamic Sass code *and* computes the CSS for the tree.
+      # @see #to_s
+      def render
+        Visitors::CheckNesting.visit(self)
+        result = Visitors::Perform.visit(self)
+        Visitors::CheckNesting.visit(result) # Check again to validate mixins
+        result, extends = Visitors::Cssize.visit(result)
+        Visitors::Extend.visit(result, extends)
+        extended_result(result.to_s)
+      end
+
+      private
+
+      def calculate_selector(selector, name)
+        class_prefix = calculate_class_prefix(name)
+        doc = CSSPool.CSS("#{selector} {}")
+        replace_class(doc, class_prefix)
+        doc_to_selector(doc)
+      end
+
+      def calculate_class_prefix(name)
+        names = name.split('/')
+        names = names[0...(names.index { |x| x.start_with?('_') } || -1)]
+        return '' if names.empty?
+        "#{names.join('__')}___"
+      end
+
+      def replace_class(doc, prefix)
+        doc.rule_sets[0].selectors.map do |selector|
+          selector.simple_selectors.each do |simple_selector|
+            simple_selector.additional_selectors.each do |additional_selector|
+              case additional_selector
+              when CSSPool::Selectors::Class
+                additional_selector.name = "#{prefix}#{additional_selector.name}"
+              when CSSPool::Selectors::PseudoClass
+                d = CSSPool.CSS("#{additional_selector.extra} {}")
+                replace_class(d, prefix)
+                additional_selector.extra = doc_to_selector(d)
+              end
+            end
+          end
+        end
+      end
+
+      def doc_to_selector(doc)
+        doc.to_css.split("\n")[0][0...-1].strip.gsub('\00002e', '.')
+      end
+
+      def extended_result(result)
+        result.split('/*').map { |x|
+          next x if x.strip.empty?
+          a, b = x.split("\n", 2)
+          m = a.match(/\/app\/assets\/stylesheets\/([^. ]+)\./)
+          next "#{a}\n#{b}" unless m
+          selector = calculate_selector(b.split("\n")[0].strip[0...-1].strip, m[1])
+          "#{a}\n#{selector} {\n#{b.split("\n", 2)[1]}"
+        }.join('/*')
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -0,0 +1,132 @@
+require 'pathname'
+require 'uri'
+
+module Sass::Tree
+  # A static node reprenting a CSS rule.
+  #
+  # @see Sass::Tree
+  class RuleNode < Node
+    # The character used to include the parent selector
+    PARENT = '&'
+
+    # The CSS selector for this rule,
+    # interspersed with {Sass::Script::Node}s
+    # representing `#{}`-interpolation.
+    # Any adjacent strings will be merged together.
+    #
+    # @return [Array<String, Sass::Script::Node>]
+    attr_accessor :rule
+
+    # The CSS selector for this rule,
+    # without any unresolved interpolation
+    # but with parent references still intact.
+    # It's only set once {Tree::Node#perform} has been called.
+    #
+    # @return [Selector::CommaSequence]
+    attr_accessor :parsed_rules
+
+    # The CSS selector for this rule,
+    # without any unresolved interpolation or parent references.
+    # It's only set once {Tree::Visitors::Cssize} has been run.
+    #
+    # @return [Selector::CommaSequence]
+    attr_accessor :resolved_rules
+
+    # How deep this rule is indented
+    # relative to a base-level rule.
+    # This is only greater than 0 in the case that:
+    #
+    # * This node is in a CSS tree
+    # * The style is :nested
+    # * This is a child rule of another rule
+    # * The parent rule has properties, and thus will be rendered
+    #
+    # @return [Fixnum]
+    attr_accessor :tabs
+
+    # Whether or not this rule is the last rule in a nested group.
+    # This is only set in a CSS tree.
+    #
+    # @return [Boolean]
+    attr_accessor :group_end
+
+    # The stack trace.
+    # This is only readable in a CSS tree as it is written during the perform step
+    # and only when the :trace_selectors option is set.
+    #
+    # @return [Array<String>]
+    attr_accessor :stack_trace
+
+    # @param rule [Array<String, Sass::Script::Node>]
+    #   The CSS rule. See \{#rule}
+    def initialize(rule)
+      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
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && rule == other.rule && super
+    end
+
+    # Adds another {RuleNode}'s rules to this one's.
+    #
+    # @param node [RuleNode] The other node
+    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
+    def continued?
+      last = @rule.last
+      last.is_a?(String) && last[-1] == ?,
+    end
+
+    # A hash that will be associated with this rule in the CSS document
+    # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
+    # This data is used by e.g. [the FireSass Firebug extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
+    #
+    # @return [{#to_s => #to_s}]
+    def debug_info
+      {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
+       :line => self.line}
+    end
+
+    # A rule node is invisible if it has only placeholder selectors.
+    def invisible?
+      resolved_rules.members.all? {|seq| seq.has_placeholder?}
+    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/supports_node.rb

@@ -0,0 +1,51 @@
+module Sass::Tree
+  # A static node representing a `@supports` rule.
+  # `@supports` rules behave differently from other directives
+  # in that when they're nested within rules,
+  # they bubble up to top-level.
+  #
+  # @see Sass::Tree
+  class SupportsNode < DirectiveNode
+    # The name, which may include a browser prefix.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The supports condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :condition
+
+    # @see RuleNode#tabs
+    attr_accessor :tabs
+
+    # @see RuleNode#group_end
+    attr_accessor :group_end
+
+    # @param condition [Sass::Supports::Condition] See \{#condition}
+    def initialize(name, condition)
+      @name = name
+      @condition = condition
+      @tabs = 0
+      super('')
+    end
+
+    # @see DirectiveNode#value
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||= "@#{name} #{condition.to_css}"
+    end
+
+    # True when the directive has no visible children.
+    #
+    # @return [Boolean]
+    def invisible?
+      children.all? {|c| c.invisible?}
+    end
+
+    # @see Node#bubbles?
+    def bubbles?; true; end
+  end
+end

data/lib/sass/tree/trace_node.rb

@@ -0,0 +1,32 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A solely static node left over after a mixin include or @content has been performed.
+  # Its sole purpose is to wrap exceptions to add to the backtrace.
+  #
+  # @see Sass::Tree
+  class TraceNode < Node
+    # The name of the trace entry to add.
+    # @return [String]
+    attr_reader :name
+
+    # @param name [String] The name of the trace entry to add.
+    def initialize(name)
+      @name = name
+      self.has_children = true
+      super()
+    end
+
+    # Initializes this node from an existing node.
+    # @param name [String] The name of the trace entry to add.
+    # @param mixin [Node] The node to copy information from.
+    # @return [TraceNode]
+    def self.from_node(name, node)
+      trace = new(name)
+      trace.line = node.line
+      trace.filename = node.filename
+      trace.options = node.options
+      trace
+    end
+  end
+end

data/lib/sass/tree/variable_node.rb

@@ -0,0 +1,30 @@
+module Sass
+  module Tree
+    # A dynamic node representing a variable definition.
+    #
+    # @see Sass::Tree
+    class VariableNode < Node
+      # The name of the variable.
+      # @return [String]
+      attr_reader :name
+
+      # The parse tree for the variable value.
+      # @return [Script::Node]
+      attr_accessor :expr
+
+      # Whether this is a guarded variable assignment (`!default`).
+      # @return [Boolean]
+      attr_reader :guarded
+
+      # @param name [String] The name of the variable
+      # @param expr [Script::Node] See \{#expr}
+      # @param guarded [Boolean] See \{#guarded}
+      def initialize(name, expr, guarded)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        super()
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# Visitors are used to traverse the Sass parse tree.
+# Visitors should extend {Visitors::Base},
+# which provides a small amount of scaffolding for traversal.
+module Sass::Tree::Visitors
+  # The abstract base class for Sass visitors.
+  # Visitors should extend this class,
+  # then implement `visit_*` methods for each node they care about
+  # (e.g. `visit_rule` for {RuleNode} or `visit_for` for {ForNode}).
+  # These methods take the node in question as argument.
+  # They may `yield` to visit the child nodes of the current node.
+  #
+  # *Note*: due to the unusual nature of {Sass::Tree::IfNode},
+  # special care must be taken to ensure that it is properly handled.
+  # In particular, there is no built-in scaffolding
+  # for dealing with the return value of `@else` nodes.
+  #
+  # @abstract
+  class Base
+    # Runs the visitor on a tree.
+    #
+    # @param root [Tree::Node] The root node of the Sass tree.
+    # @return [Object] The return value of \{#visit} for the root node.
+    def self.visit(root)
+      new.send(:visit, root)
+    end
+
+    protected
+
+    # Runs the visitor on the given node.
+    # This can be overridden by subclasses that need to do something for each node.
+    #
+    # @param node [Tree::Node] The node to visit.
+    # @return [Object] The return value of the `visit_*` method for this node.
+    def visit(node)
+      method = "visit_#{node_name node}"
+      if self.respond_to?(method, true)
+        self.send(method, node) {visit_children(node)}
+      else
+        visit_children(node)
+      end
+    end
+
+    # Visit the child nodes for a given node.
+    # This can be overridden by subclasses that need to do something
+    # with the child nodes' return values.
+    #
+    # This method is run when `visit_*` methods `yield`,
+    # and its return value is returned from the `yield`.
+    #
+    # @param parent [Tree::Node] The parent node of the children to visit.
+    # @return [Array<Object>] The return values of the `visit_*` methods for the children.
+    def visit_children(parent)
+      parent.children.map {|c| visit(c)}
+    end
+
+    NODE_NAME_RE = /.*::(.*?)Node$/
+
+    # Returns the name of a node as used in the `visit_*` method.
+    #
+    # @param [Tree::Node] node The node.
+    # @return [String] The name.
+    def node_name(node)
+      @@node_names ||= {}
+      @@node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
+    end
+
+    # `yield`s, then runs the visitor on the `@else` clause if the node has one.
+    # This exists to ensure that the contents of the `@else` clause get visited.
+    def visit_if(node)
+      yield
+      visit(node.else) if node.else
+      node
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# A visitor for checking that all nodes are properly nested.
+class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
+  protected
+
+  def initialize
+    @parents = []
+  end
+
+  def visit(node)
+    if error = @parent && (
+        try_send("invalid_#{node_name @parent}_child?", @parent, node) ||
+        try_send("invalid_#{node_name node}_parent?", @parent, node))
+      raise Sass::SyntaxError.new(error)
+    end
+    super
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  CONTROL_NODES = [Sass::Tree::EachNode, Sass::Tree::ForNode, Sass::Tree::IfNode,
+    Sass::Tree::WhileNode, Sass::Tree::TraceNode]
+  SCRIPT_NODES = [Sass::Tree::ImportNode] + CONTROL_NODES
+  def visit_children(parent)
+    old_parent = @parent
+    @parent = parent unless is_any_of?(parent, SCRIPT_NODES) ||
+      (parent.bubbles? && !old_parent.is_a?(Sass::Tree::RootNode))
+    @parents.push parent
+    super
+  ensure
+    @parent = old_parent
+    @parents.pop
+  end
+
+  def visit_root(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.sass_template ||= node.template
+    raise e
+  end
+
+  def visit_import(node)
+    yield
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => node.children.first.filename)
+    e.add_backtrace(:filename => node.filename, :line => node.line)
+    raise e
+  end
+
+  def visit_mixindef(node)
+    @current_mixin_def, old_mixin_def = node, @current_mixin_def
+    yield
+  ensure
+    @current_mixin_def = old_mixin_def
+  end
+
+  def invalid_content_parent?(parent, child)
+    if @current_mixin_def
+      @current_mixin_def.has_content = true
+      nil
+    else
+      "@content may only be used within a mixin."
+    end
+  end
+
+  def invalid_charset_parent?(parent, child)
+    "@charset may only be used at the root of a document." unless parent.is_a?(Sass::Tree::RootNode)
+  end
+
+  VALID_EXTEND_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
+  def invalid_extend_parent?(parent, child)
+    unless is_any_of?(parent, VALID_EXTEND_PARENTS)
+      return "Extend directives may only be used within rules."
+    end
+  end
+
+  INVALID_IMPORT_PARENTS = CONTROL_NODES +
+    [Sass::Tree::MixinDefNode, Sass::Tree::MixinNode]
+  def invalid_import_parent?(parent, child)
+    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+      return "Import directives may not be used within control directives or mixins."
+    end
+    return if parent.is_a?(Sass::Tree::RootNode)
+    return "CSS import directives may only be used at the root of a document." if child.css_import?
+  rescue Sass::SyntaxError => e
+    e.modify_backtrace(:filename => child.imported_file.options[:filename])
+    e.add_backtrace(:filename => child.filename, :line => child.line)
+    raise e
+  end
+
+  def invalid_mixindef_parent?(parent, child)
+    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+      return "Mixins may not be defined within control directives or other mixins."
+    end
+  end
+
+  def invalid_function_parent?(parent, child)
+    unless (@parents.map {|p| p.class} & INVALID_IMPORT_PARENTS).empty?
+      return "Functions may not be defined within control directives or other mixins."
+    end
+  end
+
+  VALID_FUNCTION_CHILDREN = [
+    Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::ReturnNode,
+    Sass::Tree::VariableNode, Sass::Tree::WarnNode
+  ] + CONTROL_NODES
+  def invalid_function_child?(parent, child)
+    unless is_any_of?(child, VALID_FUNCTION_CHILDREN)
+      "Functions can only contain variable declarations and control directives."
+    end
+  end
+
+  VALID_PROP_CHILDREN = [Sass::Tree::CommentNode, Sass::Tree::PropNode, Sass::Tree::MixinNode] + CONTROL_NODES
+  def invalid_prop_child?(parent, child)
+    unless is_any_of?(child, VALID_PROP_CHILDREN)
+      "Illegal nesting: Only properties may be nested beneath properties."
+    end
+  end
+
+  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::PropNode,
+                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode,
+                        Sass::Tree::MixinNode]
+  def invalid_prop_parent?(parent, child)
+    unless is_any_of?(parent, VALID_PROP_PARENTS)
+      "Properties are only allowed within rules, directives, mixin includes, or other properties." + child.pseudo_class_selector_message
+    end
+  end
+
+  def invalid_return_parent?(parent, child)
+    "@return may only be used within a function." unless parent.is_a?(Sass::Tree::FunctionNode)
+  end
+
+  private
+
+  def is_any_of?(val, classes)
+    for c in classes
+      return true if val.is_a?(c)
+    end
+    return false
+  end
+
+  def try_send(method, *args)
+    return unless respond_to?(method, true)
+    send(method, *args)
+  end
+end
+