spree 0.8.0 → 0.8.1

data/vendor/gems/haml-2.1.0/lib/sass/script/variable.rb

@@ -1,20 +0,0 @@
-module Sass
-  module Script
-    class Variable # :nodoc:
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-
-      def inspect
-        "!#{name}"
-      end
-
-      def perform(environment)
-        (val = environment.var(name)) && (return val)
-        raise SyntaxError.new("Undefined variable: \"!#{name}\".")
-      end
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/attr_node.rb

@@ -1,64 +0,0 @@
-module Sass::Tree
-  class AttrNode < Node
-    attr_accessor :name, :value
-    
-    def initialize(name, value, options)
-      @name = name
-      @value = value
-      super(options)
-    end
-
-    def ==(other)
-      self.class == other.class && name == other.name && value == other.value && super
-    end
-
-    def to_s(tabs, parent_name = nil)
-      if value[-1] == ?;
-        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump} (This isn't CSS!).", @line)
-      end
-      real_name = name
-      real_name = "#{parent_name}-#{real_name}" if parent_name
-      
-      if value.empty? && children.empty?
-        raise Sass::SyntaxError.new("Invalid attribute: #{declaration.dump}.", @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|
-        to_return << kid.to_s(tabs, real_name) << join_string
-      end
-      
-      (@style == :compressed && parent_name) ? to_return : to_return[0...-1]
-    end
-
-    protected
-    
-    def perform!(environment)
-      @name = interpolate(@name, environment)
-      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
-      super
-    end
-
-    private
-
-    def declaration
-      ":#{name} #{value}"
-    end
-
-    def invalid_child?(child)
-      if !child.is_a?(AttrNode) && !child.is_a?(CommentNode)
-        "Illegal nesting: Only attributes may be nested beneath attributes."
-      end
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/comment_node.rb

@@ -1,34 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  class CommentNode < Node
-    attr_accessor :value
-
-    def initialize(value, options)
-      @value = value[2..-1].strip
-      super(options)
-    end
-
-    def ==(other)
-      self.value == other.value && super
-    end
-
-    def silent?
-      !!@options[:silent]
-    end
-
-    def to_s(tabs = 0, parent_name = nil)
-      return if (@style == :compressed || silent?)
-
-      spaces = '  ' * (tabs - 1)
-      spaces + "/* " + ([value] + children.map {|c| c.text}).
-        join(@style == :compact ? ' ' : "\n#{spaces} * ") + " */"
-    end
-
-    protected
-
-    def _perform(environment)
-      self
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/debug_node.rb

@@ -1,22 +0,0 @@
-module Sass
-  module Tree
-    class DebugNode < Node
-      def initialize(expr, options)
-        @expr = expr
-        super(options)
-      end
-
-      protected
-
-      def _perform(environment)
-        res = @expr.perform(environment)
-        if filename
-          STDERR.puts "#{filename}:#{line} DEBUG: #{res}"
-        else
-          STDERR.puts "Line #{line} DEBUG: #{res}"
-        end
-        []
-      end
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/directive_node.rb

@@ -1,50 +0,0 @@
-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/vendor/gems/haml-2.1.0/lib/sass/tree/file_node.rb

@@ -1,27 +0,0 @@
-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/vendor/gems/haml-2.1.0/lib/sass/tree/for_node.rb

@@ -1,29 +0,0 @@
-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 = []
-      range.each do |i|
-        environment = Sass::Environment.new(environment)
-        environment.set_local_var(@var, Sass::Script::Number.new(i))
-        children += perform_children(environment)
-      end
-      children
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/if_node.rb

@@ -1,27 +0,0 @@
-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/vendor/gems/haml-2.1.0/lib/sass/tree/mixin_def_node.rb

@@ -1,18 +0,0 @@
-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/vendor/gems/haml-2.1.0/lib/sass/tree/mixin_node.rb

@@ -1,34 +0,0 @@
-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, (arg, value)|
-        env.set_local_var(arg[:name],
-          if value
-            value.perform(environment)
-          elsif arg[:default_value]
-            arg[:default_value].perform(env)
-          end)
-        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter !#{arg[:name]}.") unless env.var(arg[:name])
-        env
-      end
-      mixin.tree.map {|c| c.perform(environment)}.flatten
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/tree/node.rb

@@ -1,99 +0,0 @@
-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.matchedsize, 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/vendor/gems/haml-2.1.0/lib/sass/tree/rule_node.rb

@@ -1,120 +0,0 @@
-module Sass::Tree
-  class RuleNode < Node
-    # The character used to include the parent selector
-    PARENT = '&'
-
-    attr_accessor :rule
-
-    def initialize(rule, options)
-      @rule = rule
-      super(options)
-    end
-
-    def ==(other)
-      self.class == other.class && rules == other.rules && super
-    end
-
-    def rules
-      Array(rule)
-    end
-
-    def add_rules(node)
-      self.rule = rules
-      self.rule += node.rules
-    end
-
-    def continued?
-      rule[-1] == ?,
-    end
-
-    def to_s(tabs, super_rules = nil)
-      attributes = []
-      sub_rules = []
-
-      rule_split = /\s*,\s*/
-      rule_separator = @style == :compressed ? ',' : ', '
-      line_separator = [:nested, :expanded].include?(@style) ? ",\n" : rule_separator
-      rule_indent = '  ' * (tabs - 1)
-      total_rule = if super_rules
-        super_rules.split(",\n").map do |super_line|
-          super_line.strip.split(rule_split).map do |super_rule|
-            self.rules.map do |line|
-              rule_indent + line.gsub(/,$/, '').split(rule_split).map do |rule|
-                if rule.include?(PARENT)
-                  rule.gsub(PARENT, super_rule)
-                else
-                  "#{super_rule} #{rule}"
-                end
-              end.join(rule_separator)
-            end.join(line_separator)
-          end.join(rule_separator)
-        end.join(line_separator)
-      elsif self.rules.any? { |r| r.include?(PARENT) }
-        raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", line)
-      else
-        per_rule_indent, total_indent = [:nested, :expanded].include?(@style) ? [rule_indent, ''] : ['', rule_indent]
-        total_indent + self.rules.map do |r|
-          per_rule_indent + r.gsub(/,$/, '').gsub(rule_split, rule_separator).rstrip
-        end.join(line_separator)
-      end
-
-      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, total_rule)
-      end
-
-      to_return
-    end
-
-    protected
-
-    def perform!(environment)
-      self.rule = rules.map {|r| interpolate(r, environment)}
-      super
-    end
-  end
-end