spree 0.7.1 → 0.8.0

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

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

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

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

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

@@ -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/vendor/gems/haml-2.1.0/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/vendor/gems/haml-2.1.0/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 = []
+      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

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

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

@@ -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.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

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