haml 3.0.25 → 3.1.0.alpha.2

data/VERSION

@@ -1 +1 @@
-3.0.25
+3.1.0.alpha.2

data/VERSION_NAME

@@ -1 +1 @@
-Classy Cassidy
+Bleeding Edge

data/init.rb

@@ -13,6 +13,6 @@ rescue LoadError
   end
 end
 
-# Load Haml and Sass.
+# Load Haml.
 # Haml may be undefined if we're running gems:install.
 Haml.init_rails(binding) if defined?(Haml)

data/lib/haml.rb

@@ -13,13 +13,6 @@ require 'haml/version'
 #
 # Also see the {file:HAML_REFERENCE.md full Haml reference}.
 module Haml
-  extend Haml::Version
-
-  # A string representing the version of Haml.
-  # A more fine-grained representation is available from Haml.version.
-  # @api public
-  VERSION = version[:string] unless defined?(Haml::VERSION)
-
   # Initializes Haml for Rails.
   #
   # This method is called by `init.rb`,
@@ -32,13 +25,22 @@ module Haml
   #   This isn't actually used;
   #   it's just passed in in case it needs to be used in the future
   def self.init_rails(binding)
+    # Rails 2.2+
+    if defined?(Rails) && Rails.respond_to?(:configuration) &&
+        Rails.configuration.respond_to?(:after_initialize)
+      Rails.configuration.after_initialize do
+        next if defined?(Sass)
+        autoload(:Sass, 'sass/rails2_shim')
+        # resolve autoload if it looks like they're using Sass without options
+        Sass if File.exist?(File.join(RAILS_ROOT, 'public/stylesheets/sass'))
+      end
+    end
+
     # No &method here for Rails 2.1 compatibility
-    %w[haml/template sass sass/plugin].each {|f| require f}
+    %w[haml/template].each {|f| require f}
   end
 end
 
 require 'haml/util'
-unless $0 =~ /sass(-convert)?$/
-  require 'haml/engine'
-  require 'haml/railtie'
-end
+require 'haml/engine'
+require 'haml/railtie'

data/lib/haml/engine.rb

@@ -190,7 +190,7 @@ module Haml
     ensure
       # Get rid of the current buffer
       scope_object.instance_eval do
-        @haml_buffer = buffer.upper if buffer
+        @haml_buffer = buffer.upper
       end
     end
     alias_method :to_html, :render

data/lib/haml/exec.rb

@@ -2,7 +2,7 @@ require 'optparse'
 require 'fileutils'
 
 module Haml
-  # This module handles the various Haml executables (`haml`, `sass`, `sass-convert`, etc).
+  # This module handles the various Haml executables (`haml` and `haml-convert`).
   module Exec
     # An abstract class that encapsulates the executable code for all three executables.
     class Generic
@@ -89,7 +89,7 @@ module Haml
         end
 
         opts.on_tail("-v", "--version", "Print version") do
-          puts("Haml/Sass #{::Haml.version[:string]}")
+          puts("Haml #{::Haml.version[:string]}")
           exit
         end
       end
@@ -124,18 +124,9 @@ module Haml
       # @param color [Symbol] The name of the color to use for this action.
       #   Can be `:red`, `:green`, or `:yellow`.
       def puts_action(name, color, arg)
-        return if @options[:for_engine][:quiet]
         printf color(color, "%11s %s\n"), name, arg
       end
 
-      # Same as \{Kernel.puts}, but doesn't print anything if the `--quiet` option is set.
-      #
-      # @param args [Array] Passed on to \{Kernel.puts}
-      def puts(*args)
-        return if @options[:for_engine][:quiet]
-        Kernel.puts(*args)
-      end
-
       # Wraps the given string in terminal escapes
       # causing it to have the given color.
       # If terminal esapes aren't supported on this platform,
@@ -164,7 +155,7 @@ module Haml
       end
 
       def handle_load_error(err)
-        dep = err.message[/^no such file to load -- (.*)/, 1]
+        dep = err.message.scan(/^no such file to load -- (.*)/)[0]
         raise err if @options[:trace] || dep.nil? || dep.empty?
         $stderr.puts <<MESSAGE
 Required dependency #{dep} not found!
@@ -175,329 +166,37 @@ MESSAGE
       end
     end
 
-    # An abstrac class that encapsulates the code
-    # specific to the `haml` and `sass` executables.
-    class HamlSass < Generic
+    # The `haml` executable.
+    class Haml < Generic
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
         @options[:for_engine] = {}
+        @options[:requires] = []
+        @options[:load_paths] = []
       end
 
-      protected
-
-      # Tells optparse how to parse the arguments
-      # available for the `haml` and `sass` executables.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can add their own options.
+      # Tells optparse how to parse the arguments.
       #
       # @param opts [OptionParser]
       def set_opts(opts)
+        super
+
         opts.banner = <<END
-Usage: #{@name.downcase} [options] [INPUT] [OUTPUT]
+Usage: haml [options] [INPUT] [OUTPUT]
 
 Description:
-  Uses the #{@name} engine to parse the specified template
-  and outputs the result to the specified file.
+  Converts Haml files to HTML.
 
 Options:
 END
 
-        opts.on('--rails RAILS_DIR', "Install Haml and Sass from the Gem to a Rails project") do |dir|
-          original_dir = dir
-
-          env = File.join(dir, "config", "environment.rb")
-          if File.exists?(File.join(dir, "Gemfile"))
-            puts("haml --rails isn't needed for Rails 3 or greater.",
-              "Add 'gem \"haml\"' to your Gemfile instead.", "",
-              "haml --rails will no longer work in the next version of #{@name}.", "")
-          elsif File.exists?(env) && File.open(env) {|env| env.grep(/config\.gem/)}
-            puts("haml --rails isn't needed for Rails 2.1 or greater.",
-              "Add 'config.gem \"haml\"' to config/environment.rb instead.", "",
-              "haml --rails will no longer work in the next version of #{@name}.", "")
-          end
-
-          dir = File.join(dir, 'vendor', 'plugins')
-
-          unless File.exists?(dir)
-            puts "Directory #{dir} doesn't exist"
-            exit 1
-          end
-
-          dir = File.join(dir, 'haml')
-
-          if File.exists?(dir)
-            print "Directory #{dir} already exists, overwrite [y/N]? "
-            exit 2 if gets !~ /y/i
-            FileUtils.rm_rf(dir)
-          end
-
-          begin
-            Dir.mkdir(dir)
-          rescue SystemCallError
-            puts "Cannot create #{dir}"
-            exit 1
-          end
-
-          File.open(File.join(dir, 'init.rb'), 'w') do |file|
-            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
-
-      # Processes the options set by the command-line arguments.
-      # In particular, sets `@options[:for_engine][:filename]` to the input filename
-      # and requires the appropriate file.
-      #
-      # This is meant to be overridden by subclasses
-      # so they can run their respective programs.
-      def process_result
-        super
-        @options[:for_engine][:filename] = @options[:filename] if @options[:filename]
-        require File.dirname(__FILE__) + "/../#{@name.downcase}"
-      end
-    end
-
-    # The `sass` executable.
-    class Sass < HamlSass
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @name = "Sass"
-        @options[:for_engine][:load_paths] = ['.'] + (ENV['SASSPATH'] || '').split(File::PATH_SEPARATOR)
-      end
-
-      protected
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      def set_opts(opts)
-        super
-
-        opts.on('--scss',
-                'Use the CSS-superset SCSS syntax.') do
-          @options[:for_engine][:syntax] = :scss
-        end
-        opts.on('--watch', 'Watch files or directories for changes.',
-                           'The location of the generated CSS can be set using a colon:',
-                           '  sass --watch input.sass:output.css',
-                           '  sass --watch input-dir:output-dir') do
-          @options[:watch] = true
-        end
-        opts.on('--update', 'Compile files or directories to CSS.',
-                            'Locations are set like --watch.') do
-          @options[:update] = true
-        end
-        opts.on('--stop-on-error', 'If a file fails to compile, exit immediately.',
-                                   'Only meaningful for --watch and --update.') do
-          @options[:stop_on_error] = true
-        end
-        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('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
-          @options[:for_engine][:quiet] = true
-        end
-        opts.on('-g', '--debug-info',
-                'Emit extra information in the generated CSS that can be used by the FireSass Firebug plugin.') do
-          @options[:for_engine][:debug_info] = true
-        end
-        opts.on('-l', '--line-numbers', '--line-comments',
-                'Emit comments in the generated CSS indicating the corresponding sass line.') do
-          @options[:for_engine][:line_numbers] = 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
-        opts.on('-r', '--require LIB', 'Require a Ruby library before running Sass.') do |lib|
-          require lib
-        end
-        opts.on('--cache-location PATH', 'The path to put cached Sass files. Defaults to .sass-cache.') do |loc|
-          @options[:for_engine][:cache_location] = loc
-        end
-        opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
-          @options[:for_engine][:cache] = false
-        end
-
-        unless ::Haml::Util.ruby1_8?
-          opts.on('-E encoding', 'Specify the default encoding for Sass files.') do |encoding|
-            Encoding.default_external = encoding
-          end
-        end
-      end
-
-      # Processes the options set by the command-line arguments,
-      # and runs the Sass compiler appropriately.
-      def process_result
-        if !@options[:update] && !@options[:watch] &&
-            @args.first && colon_path?(@args.first)
-          if @args.size == 1
-            @args = split_colon_path(@args.first)
-          else
-            @options[:update] = true
-          end
-        end
-
-        return interactive if @options[:interactive]
-        return watch_or_update if @options[:watch] || @options[:update]
-        super
-
-        begin
-          input = @options[:input]
-          output = @options[:output]
-
-          @options[:for_engine][:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
-          tree =
-            if input.is_a?(File) && !@options[:check_syntax]
-              ::Sass::Files.tree_for(input.path, @options[:for_engine])
-            else
-              # 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.
-              ::Sass::Engine.new(input.read(), @options[:for_engine]).to_tree
-            end
-
-          input.close() if input.is_a?(File)
-
-          output.write(tree.render)
-          output.close() if output.is_a? File
-        rescue ::Sass::SyntaxError => e
-          raise e if @options[:trace]
-          raise e.sass_backtrace_str("standard input")
-        end
-      end
-
-      private
-
-      def interactive
-        require 'sass'
-        require 'sass/repl'
-        ::Sass::Repl.new(@options).run
-      end
-
-      def watch_or_update
-        require 'sass'
-        require 'sass/plugin'
-        ::Sass::Plugin.options.merge! @options[:for_engine]
-        ::Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
-
-        raise <<MSG if @args.empty?
-What files should I watch? Did you mean something like:
-    sass --watch input.sass:output.css
-    sass --watch input-dir:output-dir
-MSG
-
-        if !colon_path?(@args[0]) && probably_dest_dir?(@args[1])
-          flag = @options[:update] ? "--update" : "--watch"
-          err =
-            if !File.exist?(@args[1])
-              "doesn't exist"
-            elsif @args[1] =~ /\.css$/
-              "is a CSS file"
-            end
-          raise <<MSG if err
-File #{@args[1]} #{err}.
-    Did you mean: sass #{flag} #{@args[0]}:#{@args[1]}
-MSG
-        end
-
-        dirs, files = @args.map {|name| split_colon_path(name)}.
-          partition {|i, _| File.directory? i}
-        files.map! {|from, to| [from, to || from.gsub(/\..*?$/, '.css')]}
-        dirs.map! {|from, to| [from, to || from]}
-        ::Sass::Plugin.options[:template_location] = dirs
-
-        ::Sass::Plugin.on_updating_stylesheet do |_, css|
-          if File.exists? css
-            puts_action :overwrite, :yellow, css
-          else
-            puts_action :create, :green, css
-          end
-        end
-
-        had_error = false
-        ::Sass::Plugin.on_creating_directory {|dirname| puts_action :directory, :green, dirname}
-        ::Sass::Plugin.on_deleting_css {|filename| puts_action :delete, :yellow, filename}
-        ::Sass::Plugin.on_compilation_error do |error, _, _|
-          raise error unless error.is_a?(::Sass::SyntaxError) && !@options[:stop_on_error]
-          had_error = true
-          puts_action :error, :red, "#{error.sass_filename} (Line #{error.sass_line}: #{error.message})"
-        end
-
-        if @options[:update]
-          ::Sass::Plugin.update_stylesheets(files)
-          exit 1 if had_error
-          return
-        end
-
-        puts ">>> Sass is watching for changes. Press Ctrl-C to stop."
-
-        ::Sass::Plugin.on_template_modified {|template| puts ">>> Change detected to: #{template}"}
-        ::Sass::Plugin.on_template_created {|template| puts ">>> New template detected: #{template}"}
-        ::Sass::Plugin.on_template_deleted {|template| puts ">>> Deleted template detected: #{template}"}
-
-        ::Sass::Plugin.watch(files)
-      end
-
-      def colon_path?(path)
-        !split_colon_path(path)[1].nil?
-      end
-
-      def split_colon_path(path)
-        one, two = path.split(':', 2)
-        if one && two && ::Haml::Util.windows? &&
-            one =~ /\A[A-Za-z]\Z/ && two =~ /\A[\/\\]/
-          # If we're on Windows and we were passed a drive letter path,
-          # don't split on that colon.
-          one2, two = two.split(':', 2)
-          one = one + ':' + one2
-        end
-        return one, two
-      end
-
-      # Whether path is likely to be meant as the destination
-      # in a source:dest pair.
-      def probably_dest_dir?(path)
-        return false unless path
-        return false if colon_path?(path)
-        return Dir.glob(File.join(path, "*.s[ca]ss")).empty?
-      end
-    end
-
-    # The `haml` executable.
-    class Haml < HamlSass
-      # @param args [Array<String>] The command-line arguments
-      def initialize(args)
-        super
-        @name = "Haml"
-        @options[:requires] = []
-        @options[:load_paths] = []
-      end
-
-      # Tells optparse how to parse the arguments.
-      #
-      # @param opts [OptionParser]
-      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
@@ -543,6 +242,7 @@ MSG
       # and runs the Haml compiler appropriately.
       def process_result
         super
+        @options[:for_engine][:filename] = @options[:filename]
         input = @options[:input]
         output = @options[:output]
 
@@ -644,6 +344,8 @@ END
         handle_load_error(err)
       end
     end
+<<<<<<< HEAD
+=======
 
     # The `sass-convert` executable.
     class SassConvert < Generic
@@ -839,10 +541,10 @@ END
               Less::Engine.new(input).to_tree.to_sass_tree.send("to_#{@options[:to]}", @options[:for_tree])
             else
               if input.is_a?(File)
-                ::Sass::Files.tree_for(input.path, @options[:for_engine])
+                ::Sass::Engine.for_file(input.path, @options[:for_engine])
               else
-                ::Sass::Engine.new(input.read, @options[:for_engine]).to_tree
-              end.send("to_#{@options[:to]}", @options[:for_tree])
+                ::Sass::Engine.new(input.read, @options[:for_engine])
+              end.to_tree.send("to_#{@options[:to]}", @options[:for_tree])
             end
           end
 
@@ -867,5 +569,6 @@ END
 NOTE
       end
     end
+>>>>>>> master
   end
 end