spree 0.8.0 → 0.8.1

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

@@ -1,22 +0,0 @@
-module Haml
-  # An exception raised by Haml code.
-  class Error < StandardError
-    # :stopdoc:
-
-    # By default, an error is taken to refer to the line of the template
-    # that was being processed when the exception was raised.
-    # However, if line is non-nil, it + 1 is used instead.
-    attr_reader :line
-
-    def initialize(message = nil, line = nil)
-      super(message)
-      @line = line
-    end
-    # :startdoc:
-  end
-
-  # SyntaxError is the type of exception raised when Haml encounters an
-  # ill-formatted document.
-  # It's not particularly interesting, except in that it includes Haml::Error.
-  class SyntaxError < Haml::Error; end
-end

data/vendor/gems/haml-2.1.0/lib/haml/exec.rb

@@ -1,395 +0,0 @@
-require 'optparse'
-require 'fileutils'
-
-module Haml
-  # This module contains code for working with the
-  # haml, sass, and haml2html executables,
-  # such as command-line parsing stuff.
-  # It shouldn't need to be invoked by client code.
-  module Exec # :nodoc:
-    # A class that encapsulates the executable code
-    # for all three executables.
-    class Generic # :nodoc:
-      def initialize(args)
-        @args = args
-        @options = {}
-      end
-
-      def parse!
-        begin
-          @opts = OptionParser.new(&method(:set_opts))
-          @opts.parse!(@args)
-
-          process_result
-
-          @options
-        rescue Exception => e
-          raise e if @options[:trace] || e.is_a?(SystemExit)
-
-          $stderr.puts e.message
-          exit 1
-        end
-        exit 0
-      end
-
-      def to_s
-        @opts.to_s
-      end
-
-      protected
-
-      def get_line(exception)
-        # SyntaxErrors have weird line reporting
-        # when there's trailing whitespace,
-        # which there is for Haml documents.
-        return exception.message.scan(/:(\d+)/).first.first if exception.is_a?(::SyntaxError)
-        exception.backtrace[0].scan(/:(\d+)/).first.first
-      end
-
-      private
-
-      def set_opts(opts)
-        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
-          @options[:input] = $stdin
-        end
-
-        opts.on('--trace', :NONE, 'Show a full traceback on error') do
-          @options[:trace] = true
-        end
-
-        opts.on_tail("-?", "-h", "--help", "Show this message") do
-          puts opts
-          exit
-        end
-
-        opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml #{::Haml.version[:string]}")
-          exit
-        end
-      end
-
-      def process_result
-        input, output = @options[:input], @options[:output]
-        input_file, output_file = if input
-                                    [nil, open_file(ARGV[0], 'w')]
-                                  else
-                                    @options[:filename] = ARGV[0]
-                                    [open_file(ARGV[0]), open_file(ARGV[1], 'w')]
-                                  end
-
-        input  ||= input_file
-        output ||= output_file
-        input  ||= $stdin
-        output ||= $stdout
-
-        @options[:input], @options[:output] = input, output
-      end
-
-      def open_file(filename, flag = 'r')
-        return if filename.nil?
-        File.open(filename, flag)
-      end
-    end
-
-    # A class encapsulating the executable functionality
-    # specific to Haml and Sass.
-    class HamlSass < Generic # :nodoc:
-      def initialize(args)
-        super
-        @options[:for_engine] = {}
-      end
-
-      private
-
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: #{@name.downcase} [options] [INPUT] [OUTPUT]
-
-Description:
-  Uses the #{@name} engine to parse the specified template
-  and outputs the result to the specified file.
-
-Options:
-END
-
-        opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir|
-          original_dir = dir
-
-          dir = File.join(dir, 'vendor', 'plugins')
-
-          unless File.exists?(dir)
-            puts "Directory #{dir} doesn't exist"
-            exit
-          end
-
-          dir = File.join(dir, 'haml')
-
-          if File.exists?(dir)
-            print "Directory #{dir} already exists, overwrite [y/N]? "
-            exit if gets !~ /y/i
-            FileUtils.rm_rf(dir)
-          end
-
-          begin
-            Dir.mkdir(dir)
-          rescue SystemCallError
-            puts "Cannot create #{dir}"
-            exit
-          end
-
-          File.open(File.join(dir, 'init.rb'), 'w') do |file|
-            file.puts "require 'rubygems'"
-            file << File.read(File.dirname(__FILE__) + "/../../init.rb")
-          end
-
-          puts "Haml plugin added to #{original_dir}"
-          exit
-        end
-
-        opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
-          require 'stringio'
-          @options[:check_syntax] = true
-          @options[:output] = StringIO.new
-        end
-
-        super
-      end
-
-      def process_result
-        super
-        @options[:for_engine][:filename] = @options[:filename] if @options[:filename]
-        require File.dirname(__FILE__) + "/../#{@name.downcase}"
-      end
-    end
-
-    # A class encapsulating executable functionality
-    # specific to Sass.
-    class Sass < HamlSass # :nodoc:
-      def initialize(args)
-        super
-        @name = "Sass"
-        @options[:for_engine][:load_paths] = ['.'] + (ENV['SASSPATH'] || '').split(File::PATH_SEPARATOR)
-      end
-
-      def set_opts(opts)
-        super
-
-        opts.on('-t', '--style NAME',
-                'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
-          @options[:for_engine][:style] = name.to_sym
-        end
-        opts.on('-l', '--line-comments',
-                'Line Comments. Emit comments in the generated CSS indicating the corresponding sass line.') do
-          @options[:for_engine][:line_comments] = true
-        end
-        opts.on('-i', '--interactive',
-                'Run an interactive SassScript shell.') do
-          @options[:interactive] = true
-        end
-        opts.on('-I', '--load-path PATH', 'Add a sass import path.') do |path|
-          @options[:for_engine][:load_paths] << path
-        end
-      end
-
-      def process_result
-        if @options[:interactive]
-          require 'sass'
-          require 'sass/repl'
-          ::Sass::Repl.new(@options).run
-          return
-        end
-
-        super
-        input = @options[:input]
-        output = @options[:output]
-
-        template = input.read()
-        input.close() if input.is_a? File
-
-        begin
-          # We don't need to do any special handling of @options[:check_syntax] here,
-          # because the Sass syntax checking happens alongside evaluation
-          # and evaluation doesn't actually evaluate any code anyway.
-          result = ::Sass::Engine.new(template, @options[:for_engine]).render
-        rescue ::Sass::SyntaxError => e
-          raise e if @options[:trace]
-          raise "Syntax error on line #{get_line e}: #{e.message}"
-        end
-
-        output.write(result)
-        output.close() if output.is_a? File
-      end
-    end
-
-    # A class encapsulating executable functionality
-    # specific to Haml.
-    class Haml < HamlSass # :nodoc:
-      def initialize(args)
-        super
-        @name = "Haml"
-        @options[:requires] = []
-        @options[:load_paths] = []
-      end
-
-      def set_opts(opts)
-        super
-
-        opts.on('-t', '--style NAME',
-                'Output style. Can be indented (default) or ugly.') do |name|
-          @options[:for_engine][:ugly] = true if name.to_sym == :ugly
-        end
-
-        opts.on('-f', '--format NAME',
-                'Output format. Can be xhtml (default), html4, or html5.') do |name|
-          @options[:for_engine][:format] = name.to_sym
-        end
-
-        opts.on('-e', '--escape-html',
-                'Escape HTML characters (like ampersands and angle brackets) by default.') do
-          @options[:for_engine][:escape_html] = true
-        end
-
-        opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
-          @options[:requires] << file
-        end
-
-        opts.on('-I', '--load-path PATH', "Same as 'ruby -I'.") do |path|
-          @options[:load_paths] << path
-        end
-
-        opts.on('--debug', "Print out the precompiled Ruby source.") do
-          @options[:debug] = true
-        end
-      end
-
-      def process_result
-        super
-        input = @options[:input]
-        output = @options[:output]
-
-        template = input.read()
-        input.close() if input.is_a? File
-
-        begin
-          engine = ::Haml::Engine.new(template, @options[:for_engine])
-          if @options[:check_syntax]
-            puts "Syntax OK"
-            return
-          end
-
-          @options[:load_paths].each {|p| $LOAD_PATH << p}
-          @options[:requires].each {|f| require f}
-
-          if @options[:debug]
-            puts engine.precompiled
-            puts '=' * 100
-          end
-
-          result = engine.to_html
-        rescue Exception => e
-          raise e if @options[:trace]
-
-          case e
-          when ::Haml::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}"
-          when ::Haml::Error;       raise "Haml error on line #{get_line e}: #{e.message}"
-          else raise "Exception on line #{get_line e}: #{e.message}\n  Use --trace for backtrace."
-          end
-        end
-
-        output.write(result)
-        output.close() if output.is_a? File
-      end
-    end
-
-    # A class encapsulating executable functionality
-    # specific to the html2haml executable.
-    class HTML2Haml < Generic # :nodoc:
-      def initialize(args)
-        super
-
-        @module_opts = {}
-
-        begin
-          require 'haml/html'
-        rescue LoadError => err
-          dep = err.message.scan(/^no such file to load -- (.*)/)[0]
-          puts "Required dependency #{dep} not found!"
-          exit 1
-        end
-      end
-
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: html2haml [options] [INPUT] [OUTPUT]
-
-Description: Transforms an HTML file into corresponding Haml code.
-
-Options:
-END
-
-        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
-          @module_opts[:rhtml] = true
-        end
-
-        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
-          @options[:no_rhtml] = true
-        end
-
-        opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
-          @module_opts[:xhtml] = true
-        end
-
-        super
-      end
-
-      def process_result
-        super
-
-        input = @options[:input]
-        output = @options[:output]
-
-        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
-
-        output.write(::Haml::HTML.new(input, @module_opts).render)
-      end
-    end
-
-    # A class encapsulating executable functionality
-    # specific to the css2sass executable.
-    class CSS2Sass < Generic # :nodoc:
-      def initialize(args)
-        super
-
-        @module_opts = {}
-
-        require 'sass/css'
-      end
-
-      def set_opts(opts)
-        opts.banner = <<END
-Usage: css2sass [options] [INPUT] [OUTPUT]
-
-Description: Transforms a CSS file into corresponding Sass code.
-
-Options:
-END
-
-        opts.on('-a', '--alternate', 'Output using alternative Sass syntax (margin: 1px)') do
-          @module_opts[:alternate] = true
-        end
-
-        super
-      end
-
-      def process_result
-        super
-
-        input = @options[:input]
-        output = @options[:output]
-
-        output.write(::Sass::CSS.new(input, @module_opts).render)
-      end
-    end
-  end
-end

data/vendor/gems/haml-2.1.0/lib/haml/filters.rb

@@ -1,276 +0,0 @@
-module Haml
-  # The module containing the default filters,
-  # as well as the base module,
-  # Haml::Filters::Base.
-  module Filters
-    # Returns a hash of defined filters.
-    def self.defined
-      @defined ||= {}
-    end
-
-    # The base module for Haml filters.
-    # User-defined filters should be modules including this module.
-    #
-    # A user-defined filter should override either Base#render or Base #compile.
-    # Base#render is the most common.
-    # It takes a string, the filter source,
-    # and returns another string,
-    # the result of the filter.
-    # For example:
-    #
-    #   module Haml::Filters::Sass
-    #     include Haml::Filters::Base
-    #
-    #     def render(text)
-    #       ::Sass::Engine.new(text).render
-    #     end
-    #   end
-    #
-    # For details on overriding #compile, see its documentation.
-    #
-    module Base
-      def self.included(base) # :nodoc:
-        Filters.defined[base.name.split("::").last.downcase] = base
-        base.extend(base)
-        base.instance_variable_set "@lazy_requires", nil
-      end
-
-      # Takes a string, the source text that should be passed to the filter,
-      # and returns the string resulting from running the filter on <tt>text</tt>.
-      #
-      # This should be overridden in most individual filter modules
-      # to render text with the given filter.
-      # If compile is overridden, however, render doesn't need to be.
-      def render(text)
-        raise Error.new("#{self.inspect}#render not defined!")
-      end
-
-      # Same as render, but takes the Haml options hash as well.
-      # It's only safe to rely on options made available in Haml::Engine#options_for_buffer.
-      def render_with_options(text, options)
-        render(text)
-      end
-
-      def internal_compile(*args) # :nodoc:
-        resolve_lazy_requires
-        compile(*args)
-      end
-
-      # compile should be overridden when a filter needs to have access
-      # to the Haml evaluation context.
-      # Rather than applying a filter to a string at compile-time,
-      # compile uses the Haml::Precompiler instance to compile the string to Ruby code
-      # that will be executed in the context of the active Haml template.
-      #
-      # Warning: the Haml::Precompiler interface is neither well-documented
-      # nor guaranteed to be stable.
-      # If you want to make use of it,
-      # you'll probably need to look at the source code
-      # and should test your filter when upgrading to new Haml versions.
-      def compile(precompiler, text)
-        resolve_lazy_requires
-        filter = self
-        precompiler.instance_eval do
-          if contains_interpolation?(text)
-            return if options[:suppress_eval]
-
-            push_script <<RUBY
-find_and_preserve(#{filter.inspect}.render_with_options(#{unescape_interpolation(text)}, _hamlout.options))
-RUBY
-            return
-          end
-
-          rendered = Haml::Helpers::find_and_preserve(filter.render_with_options(text, precompiler.options), precompiler.options[:preserve])
-
-          if !options[:ugly]
-            push_text(rendered.rstrip.gsub("\n", "\n#{'  ' * @output_tabs}"))
-          else
-            push_text(rendered.rstrip)
-          end
-        end
-      end
-
-      # This becomes a class method of modules that include Base.
-      # It allows the module to specify one or more Ruby files
-      # that Haml should try to require when compiling the filter.
-      #
-      # The first file specified is tried first,
-      # then the second, etc.
-      # If none are found, the compilation throws an exception.
-      #
-      # For example:
-      #
-      #   module Haml::Filters::Markdown
-      #     lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
-      #
-      #     ...
-      #   end
-      #
-      def lazy_require(*reqs)
-        @lazy_requires = reqs
-      end
-
-      private
-
-      def resolve_lazy_requires
-        return unless @lazy_requires
-
-        @lazy_requires[0...-1].each do |req|
-          begin
-            @required = req
-            require @required
-            return
-          rescue LoadError; end # RCov doesn't see this, but it is run
-        end
-
-        begin
-          @required = @lazy_requires[-1]
-          require @required
-        rescue LoadError => e
-          classname = self.name.match(/\w+$/)[0]
-
-          if @lazy_requires.size == 1
-            raise Error.new("Can't run #{classname} filter; required file '#{@lazy_requires.first}' not found")
-          else
-            raise Error.new("Can't run #{classname} filter; required #{@lazy_requires.map { |r| "'#{r}'" }.join(' or ')}, but none were found")
-          end
-        end
-      end
-    end
-  end
-end
-
-# :stopdoc:
-
-begin
-  require 'rubygems'
-rescue LoadError; end
-
-module Haml
-  module Filters
-    module Plain
-      include Base
-
-      def render(text); text; end
-    end
-
-    module Javascript
-      include Base
-
-      def render_with_options(text, options)
-        <<END
-<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>
-  //<![CDATA[
-    #{text.rstrip.gsub("\n", "\n    ")}
-  //]]>
-</script>
-END
-      end
-    end
-
-    module Cdata
-      include Base
-
-      def render(text)
-        "<![CDATA[#{("\n" + text).rstrip.gsub("\n", "\n    ")}\n]]>"
-      end
-    end
-
-    module Escaped
-      include Base
-
-      def render(text)
-        Haml::Helpers.html_escape text
-      end
-    end
-
-    module Ruby
-      include Base
-      lazy_require 'stringio'
-
-      def compile(precompiler, text)
-        return if precompiler.options[:suppress_eval]
-        precompiler.instance_eval do
-          push_silent <<-FIRST.gsub("\n", ';') + text + <<-LAST.gsub("\n", ';')
-            _haml_old_stdout = $stdout
-            $stdout = StringIO.new(_hamlout.buffer, 'a')
-          FIRST
-            _haml_old_stdout, $stdout = $stdout, _haml_old_stdout
-            _haml_old_stdout.close
-          LAST
-        end
-      end
-    end
-
-    module Preserve
-      include Base
-
-      def render(text)
-        Haml::Helpers.preserve text
-      end
-    end
-
-    module Sass
-      include Base
-      lazy_require 'sass/plugin'
-
-      def render(text)
-        ::Sass::Engine.new(text, ::Sass::Plugin.engine_options).render
-      end
-    end
-
-    module ERB
-      include Base
-      lazy_require 'erb'
-
-      def compile(precompiler, text)
-        return if precompiler.options[:suppress_eval]
-        src = ::ERB.new(text).src.sub(/^#coding:.*?\n/, '').
-          sub(/^_erbout = '';/, "").gsub("\n", ';')
-        precompiler.send(:push_silent, src)
-      end
-    end
-
-    module Textile
-      include Base
-      lazy_require 'redcloth'
-
-      def render(text)
-        ::RedCloth.new(text).to_html(:textile)
-      end
-    end
-    RedCloth = Textile
-    Filters.defined['redcloth'] = RedCloth
-
-    # Uses BlueCloth or RedCloth to provide only Markdown (not Textile) parsing
-    module Markdown
-      include Base
-      lazy_require 'rdiscount', 'peg_markdown', 'maruku', 'bluecloth'
-
-      def render(text)
-        engine = case @required
-                 when 'rdiscount'
-                   ::RDiscount
-                 when 'peg_markdown'
-                   ::PEGMarkdown
-                 when 'maruku'
-                   ::Maruku
-                 when 'bluecloth'
-                   ::BlueCloth
-                 end
-        engine.new(text).to_html
-      end
-    end
-
-    module Maruku
-      include Base
-      lazy_require 'maruku'
-
-      def render(text)
-        ::Maruku.new(text).to_html
-      end
-    end
-  end
-end
-
-# :startdoc: