simple-templater 0.0.1.4 → 0.0.1.5

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

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

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

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

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

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

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

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