haml-edge 2.1.1

data/lib/sass/tree/directive_node.rb

@@ -0,0 +1,50 @@
+module Sass::Tree
+  class DirectiveNode < Node
+    attr_accessor :value
+
+    def initialize(value, options)
+      @value = value
+      super(options)
+    end
+
+    def to_s(tabs)
+      if children.empty?
+        value + ";"
+      else
+        result = if @style == :compressed
+                   "#{value}{"
+                 else
+                   "#{'  ' * (tabs - 1)}#{value} {" + (@style == :compact ? ' ' : "\n")
+                 end
+        was_attr = false
+        first = true
+        children.each do |child|
+          if @style == :compact
+            if child.is_a?(AttrNode)
+              result << "#{child.to_s(first || was_attr ? 1 : tabs + 1)} "
+            else
+              if was_attr
+                result[-1] = "\n"
+              end
+              rendered = child.to_s(tabs + 1)
+              rendered.lstrip! if first
+              result << rendered
+            end
+            was_attr = child.is_a?(AttrNode)
+            first = false
+          elsif @style == :compressed
+            result << (was_attr ? ";#{child.to_s(1)}" : child.to_s(1))
+            was_attr = child.is_a?(AttrNode)
+          else
+            result << child.to_s(tabs + 1) + "\n"
+          end
+        end
+        result.rstrip + if @style == :compressed
+                          "}"
+                        else
+                          (@style == :expanded ? "\n" : " ") + "}\n"
+                        end
+      end
+    end
+  end
+end

data/lib/sass/tree/file_node.rb

@@ -0,0 +1,27 @@
+module Sass
+  module Tree
+    class FileNode < Node
+      def initialize(filename, children, options)
+        @filename = filename
+        super(options)
+        self.children = children
+      end
+
+      def to_s(*args)
+        super()
+      rescue Sass::SyntaxError => e
+        e.add_backtrace_entry(@filename)
+        raise e
+      end
+
+      protected
+
+      def perform!(environment)
+        self.children = perform_children(environment)
+      rescue Sass::SyntaxError => e
+        e.add_backtrace_entry(@filename)
+        raise e
+      end
+    end
+  end
+end

data/lib/sass/tree/for_node.rb

@@ -0,0 +1,29 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class ForNode < Node
+    def initialize(var, from, to, exclusive, options)
+      @var = var
+      @from = from
+      @to = to
+      @exclusive = exclusive
+      super(options)
+    end
+
+    protected
+
+    def _perform(environment)
+      from = @from.perform(environment).to_i
+      to = @to.perform(environment).to_i
+      range = Range.new(from, to, @exclusive)
+
+      children = []
+      environment = Sass::Environment.new(environment)
+      range.each do |i|
+        environment.set_local_var(@var, Sass::Script::Number.new(i))
+        children += perform_children(environment)
+      end
+      children
+    end
+  end
+end

data/lib/sass/tree/if_node.rb

@@ -0,0 +1,27 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class IfNode < Node
+    attr_accessor :else
+
+    def initialize(expr, options)
+      @expr = expr
+      @last_else = self
+      super(options)
+    end
+
+    def add_else(node)
+      @last_else.else = node
+      @last_else = node
+    end
+
+    protected
+
+    def _perform(environment)
+      environment = Sass::Environment.new(environment)
+      return perform_children(environment) if @expr.nil? || @expr.perform(environment).to_bool
+      return @else.perform(environment) if @else
+      []
+    end
+  end
+end

data/lib/sass/tree/mixin_def_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    class MixinDefNode < Node
+      def initialize(name, args, options)
+        @name = name
+        @args = args
+        super(options)
+      end
+
+      private
+
+      def _perform(environment)
+        environment.set_mixin(@name, Sass::Mixin.new(@name, @args, environment, children))
+        []
+      end
+    end
+  end
+end

data/lib/sass/tree/mixin_node.rb

@@ -0,0 +1,35 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class MixinNode < Node
+    def initialize(name, args, options)
+      @name = name
+      @args = args
+      super(options)
+    end
+
+    protected
+
+    def _perform(environment)
+      raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.", @line) unless mixin = environment.mixin(@name)
+
+      raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
+Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
+ but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
+END
+
+      environment = mixin.args.zip(@args).
+        inject(Sass::Environment.new(mixin.environment)) do |env, ((name, default), value)|
+        env.set_local_var(name,
+          if value
+            value.perform(environment)
+          elsif default
+            default.perform(env)
+          end)
+        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter !#{name}.") unless env.var(name)
+        env
+      end
+      mixin.tree.map {|c| c.perform(environment)}.flatten
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -0,0 +1,99 @@
+module Sass
+  module Tree
+    class Node
+      attr_accessor :children
+      attr_accessor :line
+      attr_accessor :filename
+
+      def initialize(options)
+        @options = options
+        @style = options[:style]
+        @children = []
+      end
+
+      def <<(child)
+        if msg = invalid_child?(child)
+          raise Sass::SyntaxError.new(msg, child.line)
+        end
+        @children << child
+      end
+
+      # We need this because Node duck types as an Array in engine.rb
+      def last
+        children.last
+      end
+
+      def ==(other)
+        self.class == other.class && other.children == children
+      end
+
+      def to_s
+        result = String.new
+        children.each do |child|
+          if child.is_a? AttrNode
+            raise Sass::SyntaxError.new('Attributes aren\'t allowed at the root of a document.', child.line)
+          else
+            child_str = child.to_s(1)
+            next unless child_str && child_str.length > 0
+            result << child_str + (@style == :compressed ? '' : "\n")
+          end
+        end
+        @style == :compressed ? result+"\n" : result[0...-1]
+      end
+
+      def perform(environment)
+        _perform(environment)
+      rescue Sass::SyntaxError => e
+        e.sass_line ||= line
+        raise e
+      end
+
+      protected
+
+      def _perform(environment)
+        node = dup
+        node.perform!(environment)
+        node
+      end
+
+      def perform!(environment)
+        self.children = perform_children(Environment.new(environment))
+      end
+
+      def perform_children(environment)
+        children.map {|c| c.perform(environment)}.flatten
+      end
+
+      def interpolate(text, environment)
+        res = ''
+        rest = Haml::Shared.handle_interpolation text do |scan|
+          escapes = scan[2].size
+          res << scan.matched[0...-2 - escapes]
+          if escapes % 2 == 1
+            res << "\\" * (escapes - 1) << '#{'
+          else
+            res << "\\" * [0, escapes - 1].max
+            res << Script::Parser.new(scan, line, scan.pos - scan.matched_size, filename).
+              parse_interpolated.perform(environment).to_s
+          end
+        end
+        res + rest
+      end
+
+      def balance(*args)
+        res = Haml::Shared.balance(*args)
+        return res if res
+        raise Sass::SyntaxError.new("Unbalanced brackets.", line)
+      end
+
+      private
+
+      # This method should be overridden by subclasses to return an error message
+      # if the given child node is invalid,
+      # and false or nil otherwise.
+      def invalid_child?(child)
+        false
+      end
+    end
+  end
+end

data/lib/sass/tree/rule_node.rb

@@ -0,0 +1,161 @@
+require 'pathname'
+
+module Sass::Tree
+  class RuleNode < Node
+    # The character used to include the parent selector
+    PARENT = '&'
+
+    attr_accessor :rules
+
+    def initialize(rule, options)
+      @rules = [rule]
+      super(options)
+    end
+
+    def ==(other)
+      self.class == other.class && rules == other.rules && super
+    end
+
+    def add_rules(node)
+      @rules += node.rules
+    end
+
+    def continued?
+      @rules.last[-1] == ?,
+    end
+
+    def to_s(tabs, super_rules = nil)
+      resolve_parent_refs!(super_rules)
+
+      attributes = []
+      sub_rules = []
+
+      rule_separator = @style == :compressed ? ',' : ', '
+      line_separator = [:nested, :expanded].include?(@style) ? ",\n" : rule_separator
+      rule_indent = '  ' * (tabs - 1)
+      per_rule_indent, total_indent = [:nested, :expanded].include?(@style) ? [rule_indent, ''] : ['', rule_indent]
+
+      total_rule = total_indent + @rules.map do |line|
+        per_rule_indent + line.join(rule_separator)
+      end.join(line_separator)
+
+      children.each do |child|
+        if child.is_a? RuleNode
+          sub_rules << child
+        else
+          attributes << child
+        end
+      end
+
+      to_return = ''
+      if !attributes.empty?
+        old_spaces = '  ' * (tabs - 1)
+        spaces = '  ' * tabs
+        if @options[:line_comments] && @style != :compressed
+          to_return << "#{old_spaces}/* line #{line}"
+
+          if filename
+            relative_filename = if @options[:css_filename]
+              begin
+                Pathname.new(filename).relative_path_from(  
+                  Pathname.new(File.dirname(@options[:css_filename]))).to_s
+              rescue ArgumentError
+                nil
+              end
+            end
+            relative_filename ||= filename
+            to_return << ", #{relative_filename}"
+          end
+
+          to_return << " */\n"
+        end
+
+        if @style == :compact
+          attributes = attributes.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+          to_return << "#{total_rule} { #{attributes} }\n"
+        elsif @style == :compressed
+          attributes = attributes.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
+          to_return << "#{total_rule}{#{attributes}}"
+        else
+          attributes = attributes.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+          end_attrs = (@style == :expanded ? "\n" + old_spaces : ' ')
+          to_return << "#{total_rule} {\n#{attributes}#{end_attrs}}\n"
+        end
+      end
+
+      tabs += 1 unless attributes.empty? || @style != :nested
+      sub_rules.each do |sub|
+        to_return << sub.to_s(tabs, @rules)
+      end
+
+      to_return
+    end
+
+    protected
+
+    def resolve_parent_refs!(super_rules)
+      if super_rules.nil?
+        @rules.each do |line|
+          line.map! do |rule|
+            if rule.include?(:parent)
+              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", self.line)
+            end
+
+            rule.join
+          end.compact!
+        end
+        return
+      end
+
+      new_rules = []
+      super_rules.each do |super_line|
+        @rules.each do |line|
+          new_rules << []
+
+          super_line.each do |super_rule|
+            line.each do |rule|
+              rule.unshift(:parent, " ") unless rule.include?(:parent)
+
+              new_rules.last << rule.map do |segment|
+                next segment unless segment == :parent
+                super_rule
+              end.join
+            end
+          end
+        end
+      end
+      @rules = new_rules
+    end
+
+    def perform!(environment)
+      @rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      super
+    end
+
+    def parse_selector(text)
+      scanner = StringScanner.new(text)
+      rules = [[]]
+
+      while scanner.rest?
+        rules.last << scanner.scan(/[^",&]*/)
+        case scanner.scan(/./)
+        when '&'; rules.last << :parent
+        when ','
+          scanner.scan(/\s*/)
+          rules << [] if scanner.rest?
+        when '"'
+          rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
+          # We don't want to enforce that strings are closed,
+          # but we do want to consume quotes or trailing backslashes.
+          rules.last << scanner.scan(/./) if scanner.rest?
+        end
+      end
+
+      rules.map! do |l|
+        Haml::Util.merge_adjacent_strings(l).reject {|r| r.is_a?(String) && r.empty?}
+      end
+
+      rules
+    end
+  end
+end

data/lib/sass/tree/variable_node.rb

@@ -0,0 +1,24 @@
+module Sass
+  module Tree
+    class VariableNode < Node
+      def initialize(name, expr, guarded, options)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        super(options)
+      end
+
+      protected
+
+      def _perform(environment)
+        if @guarded && environment.var(@name).nil?
+          environment.set_var(@name, @expr.perform(environment))
+        elsif !@guarded
+          environment.set_var(@name, @expr.perform(environment))
+        end
+
+        []
+      end
+    end
+  end
+end

data/lib/sass/tree/while_node.rb

@@ -0,0 +1,21 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  class WhileNode < Node
+    def initialize(expr, options)
+      @expr = expr
+      super(options)
+    end
+
+    private
+
+    def _perform(environment)
+      children = []
+      new_environment = Sass::Environment.new(environment)
+      while @expr.perform(environment).to_bool
+        children += perform_children(new_environment)
+      end
+      children
+    end
+  end
+end