spree 0.8.0 → 0.8.1

data/vendor/gems/haml-2.1.0/lib/sass/environment.rb

@@ -1,33 +0,0 @@
-module Sass
-  class Environment
-    attr_reader :parent
-
-    def initialize(parent = nil)
-      @vars = {}
-      @mixins = {}
-      @parent = parent
-    end
-
-    def self.inherited_hash(name)
-      class_eval <<RUBY, __FILE__, __LINE__ + 1
-        def #{name}(name)
-          @#{name}s[name] || @parent && @parent.#{name}(name)
-        end
-
-        def set_#{name}(name, value)
-          if @parent && @parent.#{name}(name)
-            @parent.set_#{name}(name, value)
-          else
-            @#{name}s[name] = value
-          end
-        end
-
-        def set_local_#{name}(name, value)
-          @#{name}s[name] = value
-        end
-RUBY
-    end
-    inherited_hash :var
-    inherited_hash :mixin
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/error.rb

@@ -1,35 +0,0 @@
-module Sass
-  # Sass::SyntaxError encapsulates information about the exception,
-  # such as the line of the Sass template it was raised on
-  # and the Sass file that was being parsed (if applicable).
-  # It also provides a handy way to rescue only exceptions raised
-  # because of a faulty template.
-  class SyntaxError < StandardError
-    # The line of the Sass template on which the exception was thrown.
-    attr_accessor :sass_line
-
-    # The name of the file that was being parsed when the exception was raised.
-    # This will be nil unless Sass is being used as an ActionView plugin.
-    attr_reader :sass_filename
-
-    # Creates a new SyntaxError.
-    # +lineno+ should be the line of the Sass template on which the error occurred.
-    def initialize(msg, lineno = nil)
-      @message = msg
-      @sass_line = lineno
-    end
-
-    # Adds a properly formatted entry to the exception's backtrace.
-    # +filename+ should be the file in which the error occurred,
-    # if applicable (defaults to "(sass)").
-    def add_backtrace_entry(filename) # :nodoc:
-      @sass_filename ||= filename
-      self.backtrace ||= []
-      self.backtrace.unshift "#{@sass_filename || '(sass)'}:#{@sass_line}"
-    end
-
-    def to_s # :nodoc:
-      @message
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/plugin.rb

@@ -1,203 +0,0 @@
-require 'sass/engine'
-require 'pathname'
-
-module Sass
-  # This module contains methods to aid in using Sass
-  # as a stylesheet-rendering plugin for various systems.
-  # Currently Rails/ActionController and Merb are supported out of the box.
-  module Plugin
-    class << self
-      @@options = {
-        :css_location       => './public/stylesheets',
-        :always_update      => false,
-        :always_check       => true,
-        :full_exception     => true
-      }
-      @@checked_for_updates = false
-
-      # Whether or not Sass has *ever* checked if the stylesheets need updates
-      # (in this Ruby instance).
-      def checked_for_updates
-        @@checked_for_updates
-      end
-
-      # Gets various options for Sass. See README.rdoc for details.
-      #--
-      # TODO: *DOCUMENT OPTIONS*
-      #++
-      def options
-        @@options
-      end
-
-      # Sets various options for Sass.
-      def options=(value)
-        @@options.merge!(value)
-      end
-
-      # Get the options ready to be passed to the Sass::Engine
-      def engine_options(additional_options = {})
-        opts = options.dup.merge(additional_options)
-        opts[:load_paths] = load_paths(opts)
-        opts
-      end
-
-      # Checks each stylesheet in <tt>options[:css_location]</tt>
-      # to see if it needs updating,
-      # and updates it using the corresponding template
-      # from <tt>options[:templates]</tt>
-      # if it does.
-      def update_stylesheets
-        return if options[:never_update]
-
-        @@checked_for_updates = true
-        template_locations.zip(css_locations).each do |template_location, css_location|
-
-          Dir.glob(File.join(template_location, "**", "*.sass")).each do |file|
-            # Get the relative path to the file with no extension
-            name = file.sub(template_location + "/", "")[0...-5]
-
-            if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name, template_location, css_location))
-              update_stylesheet(name, template_location, css_location)
-            end
-          end
-        end
-      end
-
-      private
-
-      def update_stylesheet(name, template_location, css_location)
-        css = css_filename(name, css_location)
-        File.delete(css) if File.exists?(css)
-
-        filename = template_filename(name, template_location)
-        engine = Engine.new(File.read(filename), engine_options(:css_filename => css, :filename => filename))
-        result = begin
-                   engine.render
-                 rescue Exception => e
-                   exception_string(e)
-                 end
-
-        # Create any directories that might be necessary
-        mkpath(css_location, name)
-
-        # Finally, write the file
-        File.open(css, 'w') do |file|
-          file.print(result)
-        end
-      end
-      
-      # Create any successive directories required to be able to write a file to: File.join(base,name)
-      def mkpath(base, name)
-        dirs = [base]
-        name.split(File::SEPARATOR)[0...-1].each { |dir| dirs << File.join(dirs[-1],dir) }
-        dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
-      end
-
-      def load_paths(opts = options)
-        (opts[:load_paths] || []) + template_locations
-      end
-      
-      def template_locations
-        location = (options[:template_location] || File.join(options[:css_location],'sass'))
-        if location.is_a?(String)
-          [location]
-        else
-          location.to_a.map { |l| l.first }
-        end
-      end
-      
-      def css_locations
-        if options[:template_location] && !options[:template_location].is_a?(String)
-          options[:template_location].to_a.map { |l| l.last }
-        else
-          [options[:css_location]]
-        end
-      end
-
-      def exception_string(e)
-        if options[:full_exception]
-          e_string = "#{e.class}: #{e.message}"
-
-          if e.is_a? Sass::SyntaxError
-            e_string << "\non line #{e.sass_line}"
-
-            if e.sass_filename
-              e_string << " of #{e.sass_filename}"
-
-              if File.exists?(e.sass_filename)
-                e_string << "\n\n"
-
-                min = [e.sass_line - 5, 0].max
-                begin
-                  File.read(e.sass_filename).rstrip.split("\n")[
-                    min .. e.sass_line + 5
-                  ].each_with_index do |line, i|
-                    e_string << "#{min + i + 1}: #{line}\n"
-                  end
-                rescue
-                  e_string << "Couldn't read sass file: #{e.sass_filename}"
-                end
-              end
-            end
-          end
-          <<END
-/*
-#{e_string}
-
-Backtrace:\n#{e.backtrace.join("\n")}
-*/
-body:before {
-  white-space: pre;
-  font-family: monospace;
-  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
-END
-          # Fix an emacs syntax-highlighting hiccup: '
-        else
-          "/* Internal stylesheet error */"
-        end
-      end
-
-      def template_filename(name, path)
-        "#{path}/#{name}.sass"
-      end
-
-      def css_filename(name, path)
-        "#{path}/#{name}.css"
-      end
-
-      def forbid_update?(name)
-        name.sub(/^.*\//, '')[0] == ?_
-      end
-
-      def stylesheet_needs_update?(name, template_path, css_path)
-        css_file = css_filename(name, css_path)
-        template_file = template_filename(name, template_path)
-        if !File.exists?(css_file)
-          return true
-        else
-          css_mtime = File.mtime(css_file)
-          File.mtime(template_file) > css_mtime ||
-            dependencies(template_file).any?(&dependency_updated?(css_mtime))
-        end
-      end
-
-      def dependency_updated?(css_mtime)
-        lambda do |dep|
-          File.mtime(dep) > css_mtime ||
-            dependencies(dep).any?(&dependency_updated?(css_mtime))
-        end
-      end
-
-      def dependencies(filename)
-        File.readlines(filename).grep(/^@import /).map do |line|
-          line[8..-1].split(',').map do |inc|
-            Sass::Engine.find_file_to_import(inc.strip, [File.dirname(filename)] + load_paths)
-          end
-        end.flatten.grep(/\.sass$/)
-      end
-    end
-  end
-end
-
-require 'sass/plugin/rails' if defined?(ActionController)
-require 'sass/plugin/merb'  if defined?(Merb::Plugins)

data/vendor/gems/haml-2.1.0/lib/sass/plugin/merb.rb

@@ -1,56 +0,0 @@
-unless defined?(Sass::MERB_LOADED)
-  Sass::MERB_LOADED = true
-
-  version = Merb::VERSION.split('.').map { |n| n.to_i }
-  if version[0] <= 0 && version[1] < 5
-    root = MERB_ROOT
-    env  = MERB_ENV
-  else
-    root = Merb.root.to_s
-    env  = Merb.environment
-  end
-
-  Sass::Plugin.options.merge!(:template_location  => root + '/public/stylesheets/sass',
-                              :css_location       => root + '/public/stylesheets',
-                              :always_check       => env != "production",
-                              :full_exception     => env != "production")
-  config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
-
-  if defined? config.symbolize_keys!
-    config.symbolize_keys!
-  end
-
-  Sass::Plugin.options.merge!(config)
-
-  if version[0] > 0 || version[1] >= 9
-
-    class Merb::Rack::Application # :nodoc:
-      def call_with_sass(env)
-        if !Sass::Plugin.checked_for_updates ||
-            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-          Sass::Plugin.update_stylesheets
-        end
-
-        call_without_sass(env)
-      end
-      alias_method :call_without_sass, :call
-      alias_method :call, :call_with_sass
-    end
-
-  else
-
-    class MerbHandler # :nodoc:
-      def process_with_sass(request, response)
-        if !Sass::Plugin.checked_for_updates ||
-            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-          Sass::Plugin.update_stylesheets
-        end
-
-        process_without_sass(request, response)
-      end
-      alias_method :process_without_sass, :process
-      alias_method :process, :process_with_sass
-    end
-
-  end
-end

data/vendor/gems/haml-2.1.0/lib/sass/plugin/rails.rb

@@ -1,24 +0,0 @@
-unless defined?(Sass::RAILS_LOADED)
-  Sass::RAILS_LOADED = true
-
-  Sass::Plugin.options.merge!(:template_location  => RAILS_ROOT + '/public/stylesheets/sass',
-                              :css_location       => RAILS_ROOT + '/public/stylesheets',
-                              :always_check       => RAILS_ENV != "production",
-                              :full_exception     => RAILS_ENV != "production")
-
-  # :stopdoc:
-  module ActionController
-    class Base
-      alias_method :sass_old_process, :process
-      def process(*args)
-        if !Sass::Plugin.checked_for_updates ||
-            Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
-          Sass::Plugin.update_stylesheets
-        end
-
-        sass_old_process(*args)
-      end
-    end
-  end
-  # :startdoc:
-end

data/vendor/gems/haml-2.1.0/lib/sass/repl.rb

@@ -1,51 +0,0 @@
-require 'readline'
-
-module Sass
-  class Repl
-    def initialize(options = {})
-      @options = options
-    end
-
-    def run
-      environment = Environment.new
-      environment.set_var('important', Script::String.new('!important'))
-      @line = 0
-      loop do
-        @line += 1
-        unless text = Readline.readline('>> ')
-          puts
-          return
-        end
-
-        Readline::HISTORY << text
-        parse_input(environment, text)
-      end
-    end
-
-    private
-
-    def parse_input(environment, text)
-      case text
-      when Script::MATCH
-        name = $1
-        guarded = $2 == '||='
-        val = Script::Parser.parse($3, @line, text.size - $3.size)
-
-        unless guarded && environment.var(name)
-          environment.set_var(name, val.perform(environment))
-        end
-
-        p environment.var(name)
-      else
-        p Script::Parser.parse(text, @line, 0).perform(environment)
-      end
-    rescue Sass::SyntaxError => e
-      puts "SyntaxError: #{e.message}"
-      if @options[:trace]
-        e.backtrace.each do |e|
-          puts "\tfrom #{e}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'strscan'
-require 'sass/script/variable'
-require 'sass/script/funcall'
-require 'sass/script/operation'
-require 'sass/script/literal'
-require 'sass/script/parser'
-
-module Sass
-  # This module contains various SassScript-related functionality.
-  module Script
-    # :stopdoc:
-    # The character that begins a variable.
-    VARIABLE_CHAR = ?!
-
-    # The regular expression used to parse variables
-    MATCH = /^!(\w+)\s*((?:\|\|)?=)\s*(.+)/
-
-    # The regular expression used to validate variables without matching
-    VALIDATE = /^!\w+$/
-
-    def self.resolve(value, line, offset, environment)
-      parse(value, line, offset).perform(environment).to_s
-    end
-
-    def self.parse(value, line, offset, filename = nil)
-      Parser.parse(value, line, offset, filename)
-    rescue Sass::SyntaxError => e
-      if e.message == "SassScript error"
-        e.instance_eval do
-          @message += ": #{value.dump}."
-        end
-      end
-      e.sass_line = line
-      raise e
-    end
-    # :startdoc:
-  end
-end