simple-templater 0.0.1.3 → 0.0.1.4

data/gems/gems/haml-2.2.16/lib/sass/tree/node.rb

@@ -0,0 +1,251 @@
+module Sass
+  # A namespace for nodes in the Sass parse tree.
+  #
+  # The Sass parse tree has two states.
+  # When it's first parsed, it has nodes for mixin definitions
+  # and for loops and so forth,
+  # in addition to nodes for CSS rules and properties.
+  #
+  # However, {Tree::Node#perform} returns a different sort of tree.
+  # This tree maps more closely to the resulting CSS document
+  # than it does to the original Sass document.
+  # It still has nodes for CSS rules and properties,
+  # but it doesn't have any dynamic-generation-related nodes.
+  #
+  # Nodes that only appear in the pre-perform state are called **dynamic nodes**;
+  # those that appear in both states are called **static nodes**.
+  module Tree
+    # This class doubles as the root node of the parse tree
+    # and the superclass of all other parse-tree nodes.
+    class Node
+      # The child nodes of this node.
+      #
+      # @return [Array<Tree::Node>]
+      attr_accessor :children
+
+      # The line of the document on which this node appeared.
+      #
+      # @return [Fixnum]
+      attr_accessor :line
+
+      # The name of the document on which this node appeared.
+      #
+      # @return [String]
+      attr_writer :filename
+
+      # The options hash for the node.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [{Symbol => Object}]
+      attr_reader :options
+
+      def initialize
+        @children = []
+      end
+
+      # Sets the options hash for the node and all its children.
+      #
+      # @param options [{Symbol => Object}] The options
+      # @see #options
+      def options=(options)
+        children.each {|c| c.options = options}
+        @options = options
+      end
+
+      # The name of the document on which this node appeared.
+      #
+      # @return [String]
+      def filename
+        @filename || @options[:filename]
+      end
+
+      # Appends a child to the node.
+      #
+      # @param child [Tree::Node] The child node
+      # @raise [Sass::SyntaxError] if `child` is invalid
+      # @see #invalid_child?
+      def <<(child)
+        if msg = invalid_child?(child)
+          raise Sass::SyntaxError.new(msg, child.line)
+        end
+        @children << child
+      end
+
+      # Return the last child node.
+      #
+      # We need this because {Tree::Node} duck types as an Array for {Sass::Engine}.
+      #
+      # @return [Tree::Node] The last child node
+      def last
+        children.last
+      end
+
+      # Compares this node and another object (only other {Tree::Node}s will be equal).
+      # This does a structural comparison;
+      # if the contents of the nodes and all the child nodes are equivalent,
+      # then the nodes are as well.
+      #
+      # Only static nodes need to override this.
+      #
+      # @param other [Object] The object to compare with
+      # @return [Boolean] Whether or not this node and the other object
+      #   are the same
+      # @see Sass::Tree
+      def ==(other)
+        self.class == other.class && other.children == children
+      end
+
+      # Runs the dynamic Sass code *and* computes the CSS for the tree.
+      #
+      # @see #perform
+      # @see #to_s
+      def render
+        perform(Environment.new).to_s
+      end
+
+      # True if \{#to\_s} will return `nil`;
+      # that is, if the node shouldn't be rendered.
+      # Should only be called in a static tree.
+      #
+      # @return [Boolean]
+      def invisible?; false; end
+
+      # Computes the CSS corresponding to this Sass tree.
+      #
+      # Only static-node subclasses need to implement \{#to\_s}.
+      #
+      # This may return `nil`, but it will only do so if \{#invisible?} is true.
+      #
+      # @return [String, nil] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def to_s
+        result = String.new
+        children.each do |child|
+          if child.is_a? PropNode
+            message = "Properties aren't allowed at the root of a document." +
+              child.pseudo_class_selector_message
+            raise Sass::SyntaxError.new(message, child.line)
+          else
+            next if child.invisible?
+            child_str = child.to_s(1)
+            result << child_str + (style == :compressed ? '' : "\n")
+          end
+        end
+        result.rstrip!
+        return "" if result.empty?
+        return result + "\n"
+      rescue Sass::SyntaxError => e; e.add_metadata(filename, line)
+      end
+
+      # Runs the dynamic Sass code:
+      # mixins, variables, control directives, and so forth.
+      # This doesn't modify this node or any of its children.
+      #
+      # \{#perform} shouldn't be overridden directly;
+      # if you want to return a new node (or list of nodes),
+      # override \{#\_perform};
+      # if you want to destructively modify this node,
+      # override \{#perform!}.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Tree::Node] The resulting tree of static nodes
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def perform(environment)
+        environment.options = @options if self.class == Tree::Node
+        _perform(environment)
+      rescue Sass::SyntaxError => e; e.add_metadata(filename, line)
+      end
+
+      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [Symbol]
+      def style
+        @options[:style]
+      end
+
+      protected
+
+      # Runs any dynamic Sass code in this particular node.
+      # This doesn't modify this node or any of its children.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Tree::Node, Array<Tree::Node>] The resulting static nodes
+      # @see #perform
+      # @see Sass::Tree
+      def _perform(environment)
+        node = dup
+        node.perform!(environment)
+        node
+      end
+
+      # Destructively runs dynamic Sass code in this particular node.
+      # This *does* modify this node,
+      # but will be run non-destructively by \{#\_perform\}.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @see #perform
+      def perform!(environment)
+        self.children = perform_children(Environment.new(environment))
+      end
+
+      # Non-destructively runs \{#perform} on all children of the current node.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Array<Tree::Node>] The resulting static nodes
+      def perform_children(environment)
+        children.map {|c| c.perform(environment)}.flatten
+      end
+
+      # Replaces SassScript in a chunk of text (via `#{}`)
+      # with the resulting value.
+      #
+      # @param text [String] The text to interpolate
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [String] The interpolated text
+      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
+
+      # @see Haml::Shared.balance
+      # @raise [Sass::SyntaxError] if the brackets aren't balanced
+      def balance(*args)
+        res = Haml::Shared.balance(*args)
+        return res if res
+        raise Sass::SyntaxError.new("Unbalanced brackets.", line)
+      end
+
+      # Returns an error message if the given child node is invalid,
+      # and false otherwise.
+      #
+      # By default, all child nodes are valid.
+      # This is expected to be overriden by subclasses
+      # for which some children are invalid.
+      #
+      # @param child [Tree::Node] A potential child node
+      # @return [Boolean, String] Whether or not the child node is valid,
+      #   as well as the error message to display if it is invalid
+      def invalid_child?(child)
+        false
+      end
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/tree/prop_node.rb

@@ -0,0 +1,121 @@
+module Sass::Tree
+  # A static node reprenting a CSS property.
+  #
+  # @see Sass::Tree
+  class PropNode < Node
+    # The name of the property.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The value of the property,
+    # either a plain string or a SassScript parse tree.
+    #
+    # @return [String, Script::Node]
+    attr_accessor :value
+
+    # @param name [String] See \{#name}
+    # @param value [String] See \{#value}
+    # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
+    #   `:old` if it uses `:a b`-style syntax
+    def initialize(name, value, prop_syntax)
+      @name = name
+      @value = value
+      @prop_syntax = prop_syntax
+      super()
+    end
+
+    # Compares the names and values of two properties.
+    #
+    # @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 && name == other.name && value == other.value && super
+    end
+
+    # Computes the CSS for the property.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param parent_name [String] The name of the parent property (e.g. `text`) or nil
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the property uses invalid syntax
+    def to_s(tabs, parent_name = nil)
+      if @options[:property_syntax] == :old && @prop_syntax == :new
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.", @line)
+      elsif @options[:property_syntax] == :new && @prop_syntax == :old
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.", @line)
+      end
+
+      if value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+      
+      if value.empty? && children.empty?
+        message = "Invalid property: #{declaration.dump} (no value)." +
+          pseudo_class_selector_message
+        raise Sass::SyntaxError.new(message, @line)
+      end
+      
+      join_string = case style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
+      to_return = ''
+      if !value.empty?
+        to_return << "#{spaces}#{real_name}:#{style == :compressed ? '' : ' '}#{value};#{join_string}"
+      end
+      
+      children.each do |kid|
+        next if kid.invisible?
+        to_return << kid.to_s(tabs, real_name) << join_string
+      end
+      
+      (style == :compressed && parent_name) ? to_return : to_return[0...-1]
+    end
+
+    # Returns a appropriate message indicating how to escape pseudo-class selectors.
+    # This only applies for old-style properties with no value,
+    # so returns the empty string if this is new-style.
+    #
+    # @return [String] The message
+    def pseudo_class_selector_message
+      return "" if @prop_syntax == :new || !value.empty?
+      "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
+    end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the property.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @name = interpolate(@name, environment)
+      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      super
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {PropNode} only allows other {PropNode}s and {CommentNode}s as children.
+    # @param child [Tree::Node] A potential child node
+    # @return [String] An error message if the child is invalid, or nil otherwise
+    def invalid_child?(child)
+      if !child.is_a?(PropNode) && !child.is_a?(CommentNode)
+        "Illegal nesting: Only properties may be nested beneath properties."
+      end
+    end
+
+    private
+
+    def declaration
+      (@prop_syntax == :new ? "#{name}: #{value}" : ":#{name} #{value}").strip
+    end
+  end
+end

data/gems/gems/haml-2.2.16/lib/sass/tree/rule_node.rb

@@ -0,0 +1,223 @@
+require 'pathname'
+
+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 selectors for this rule.
+    # Each string is a selector line, and the lines are meant to be separated by commas.
+    # For example,
+    #
+    #     foo, bar, baz,
+    #     bip, bop, bup
+    #
+    # would be
+    #
+    #     ["foo, bar, baz",
+    #      "bip, bop, bup"]
+    #
+    # @return [Array<String>]
+    attr_accessor :rules
+
+    # The CSS selectors for this rule,
+    # parsed for commas and parent-references.
+    # It's only set once {Tree::Node#perform} has been called.
+    #
+    # It's an array of arrays of arrays.
+    # The first level of arrays represents distinct lines in the Sass file;
+    # the second level represents comma-separated selectors;
+    # the third represents structure within those selectors,
+    # currently only parent-refs (represented by `:parent`).
+    # For example,
+    #
+    #     &.foo, bar, baz,
+    #     bip, &.bop, bup
+    #
+    # would be
+    #
+    #     [[[:parent, "foo"], ["bar"], ["baz"]],
+    #      [["bip"], [:parent, "bop"], ["bup"]]]
+    #
+    # @return [Array<Array<Array<String|Symbol>>>]
+    attr_accessor :parsed_rules
+
+    # @param rule [String] The first CSS rule. See \{#rules}
+    def initialize(rule)
+      @rules = [rule]
+      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 && rules == other.rules && super
+    end
+
+    # Adds another {RuleNode}'s rules to this one's.
+    #
+    # @param node [RuleNode] The other node
+    def add_rules(node)
+      @rules += node.rules
+    end
+
+    # @return [Boolean] Whether or not this rule is continued on the next line
+    def continued?
+      @rules.last[-1] == ?,
+    end
+
+    # Computes the CSS for the rule.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param super_rules [Array<Array<String>>] The rules for the parent node
+    #   (see \{#rules}), or `nil` if there are no parents
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
+    def to_s(tabs, super_rules = nil)
+      resolved_rules = resolve_parent_refs(super_rules)
+
+      properties = []
+      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 + resolved_rules.map do |line|
+        per_rule_indent + line.join(rule_separator)
+      end.join(line_separator)
+
+      children.each do |child|
+        next if child.invisible?
+        if child.is_a? RuleNode
+          sub_rules << child
+        else
+          properties << child
+        end
+      end
+
+      to_return = ''
+      if !properties.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
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+          to_return << "#{total_rule} { #{properties} }\n"
+        elsif style == :compressed
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
+          to_return << "#{total_rule}{#{properties}}"
+        else
+          properties = properties.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+          end_props = (style == :expanded ? "\n" + old_spaces : ' ')
+          to_return << "#{total_rule} {\n#{properties}#{end_props}}\n"
+        end
+      end
+
+      tabs += 1 unless properties.empty? || style != :nested
+      sub_rules.each do |sub|
+        to_return << sub.to_s(tabs, resolved_rules)
+      end
+
+      to_return
+    end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the rule,
+    # and parses the selectors for commas.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @parsed_rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      super
+    end
+
+    private
+
+    def resolve_parent_refs(super_rules)
+      if super_rules.nil?
+        return @parsed_rules.map 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
+      end
+
+      new_rules = []
+      super_rules.each do |super_line|
+        @parsed_rules.each do |line|
+          new_rules << []
+
+          super_line.each do |super_rule|
+            line.each do |rule|
+              rule = [:parent, " ", *rule] unless rule.include?(:parent)
+
+              new_rules.last << rule.map do |segment|
+                next segment unless segment == :parent
+                super_rule
+              end.join
+            end
+          end
+        end
+      end
+      new_rules
+    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/gems/gems/haml-2.2.16/lib/sass/tree/variable_node.rb

@@ -0,0 +1,34 @@
+module Sass
+  module Tree
+    # A dynamic node representing a variable definition.
+    #
+    # @see Sass::Tree
+    class VariableNode < Node
+      # @param name [String] The name of the variable
+      # @param expr [Script::Node] The parse tree for the initial variable value
+      # @param guarded [Boolean] Whether this is a guarded variable assignment (`||=`)
+      def initialize(name, expr, guarded)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        super()
+      end
+
+      protected
+
+      # Loads the new variable value into the environment.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      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/gems/gems/haml-2.2.16/lib/sass/tree/while_node.rb

@@ -0,0 +1,31 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@while` loop.
+  #
+  # @see Sass::Tree
+  class WhileNode < Node
+    # @param expr [Script::Node] The parse tree for the continue expression
+    def initialize(expr)
+      @expr = expr
+      super()
+    end
+
+    protected
+
+    # Runs the child nodes until the continue expression becomes false.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    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

data/gems/gems/haml-2.2.16/lib/sass.rb

@@ -0,0 +1,24 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'haml/version'
+
+# The module that contains everything Sass-related:
+#
+# * {Sass::Engine} is the class used to render Sass within Ruby code.
+# * {Sass::Plugin} is interfaces with web frameworks (Rails and Merb in particular).
+# * {Sass::SyntaxError} is raised when Sass encounters an error.
+# * {Sass::CSS} handles conversion of CSS to Sass.
+#
+# Also see the {file:SASS_REFERENCE.md full Sass reference}.
+module Sass
+  extend Haml::Version
+
+  # A string representing the version of Sass.
+  # A more fine-grained representation is available from {Sass.version}.
+  VERSION = version[:string] unless defined?(Sass::VERSION)
+end
+
+require 'haml/util'
+require 'sass/engine'
+require 'sass/plugin' if defined?(Merb::Plugins)

data/gems/gems/haml-2.2.16/rails/init.rb

@@ -0,0 +1 @@
+Kernel.load File.join(File.dirname(__FILE__), '..', 'init.rb')