haml 2.2.24 → 3.0.0.beta.1

data/VERSION

@@ -1 +1 @@
-2.2.24
+3.0.0.beta.1

data/VERSION_NAME

@@ -1 +1 @@
-Powerful Penny
+Classy Cassidy

data/bin/css2sass

@@ -3,5 +3,11 @@
 require File.dirname(__FILE__) + '/../lib/haml'
 require 'haml/exec'
 
-opts = Haml::Exec::CSS2Sass.new(ARGV)
+warn <<END
+DEPRECATION WARNING:
+The css2sass tool is deprecated and will be removed in Sass 3.2.
+Use the sass-convert tool instead.
+END
+
+opts = Haml::Exec::SassConvert.new(%w[--from css --to sass] + ARGV)
 opts.parse!

data/bin/sass-convert

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/haml'
+require 'haml/exec'
+
+opts = Haml::Exec::SassConvert.new(ARGV)
+opts.parse!

data/extra/haml-mode.el

@@ -352,7 +352,8 @@ With ARG, do it that many times."
           ;; Move through multiline attrs
           (when (eq (char-before) ?,)
             (save-excursion
-              (while (progn (end-of-line) (and (eq (char-before) ?,) (not (eobp))))
+              (while (progn (end-of-line)
+                            (and (eq (char-before) ?,) (not (eobp))))
                 (forward-line))
 
               (forward-line -1)

data/lib/haml/buffer.rb

@@ -233,30 +233,43 @@ RUBY
 
     # Merges two attribute hashes.
     # This is the same as `to.merge!(from)`,
-    # except that it merges id and class attributes.
+    # except that it merges id, class, and data attributes.
     #
     # ids are concatenated with `"_"`,
     # and classes are concatenated with `" "`.
+    # data hashes are simply merged.
     #
     # Destructively modifies both `to` and `from`.
     #
     # @param to [{String => String}] The attribute hash to merge into
-    # @param from [{String => String}] The attribute hash to merge from
+    # @param from [{String => #to_s}] The attribute hash to merge from
     # @return [{String => String}] `to`, after being merged
     def self.merge_attrs(to, from)
+      from['id'] = Precompiler.filter_and_join(from['id'], '_') if from['id']
       if to['id'] && from['id']
         to['id'] << '_' << from.delete('id').to_s
       elsif to['id'] || from['id']
         from['id'] ||= to['id']
       end
 
+      from['class'] = Precompiler.filter_and_join(from['class'], ' ') if from['class']
       if to['class'] && from['class']
         # Make sure we don't duplicate class names
-        from['class'] = (from['class'].split(' ') | to['class'].split(' ')).sort.join(' ')
+        from['class'] = (from['class'].to_s.split(' ') | to['class'].split(' ')).sort.join(' ')
       elsif to['class'] || from['class']
         from['class'] ||= to['class']
       end
 
+      from_data = from['data'].is_a?(Hash)
+      to_data = to['data'].is_a?(Hash)
+      if from_data && to_data
+        to['data'] = to['data'].merge(from['data'])
+      elsif to_data
+        to = Haml::Util.map_keys(to.delete('data')) {|name| "data-#{name}"}.merge(to)
+      elsif from_data
+        from = Haml::Util.map_keys(from.delete('data')) {|name| "data-#{name}"}.merge(from)
+      end
+
       to.merge!(from)
     end
 
@@ -278,7 +291,12 @@ RUBY
       ref = ref[0]
       # Let's make sure the value isn't nil. If it is, return the default Hash.
       return {} if ref.nil?
-      class_name = underscore(ref.class)
+      class_name =
+        if ref.respond_to?(:haml_object_ref)
+          ref.haml_object_ref
+        else
+          underscore(ref.class)
+        end
       id = "#{class_name}_#{ref.id || 'new'}"
       if prefix
         class_name = "#{ prefix }_#{ class_name}"

data/lib/haml/engine.rb

@@ -99,6 +99,8 @@ module Haml
         @options[:encoding] = @options[:encoding].name
       end
 
+      template = check_encoding(template) {|msg, line| raise Haml::Error.new(msg, line)}
+
       # :eod is a special end-of-document marker
       @template = (template.rstrip).split(/\r\n|\r|\n/) + [:eod, :eod]
       @template_index = 0
@@ -113,7 +115,9 @@ module Haml
 
       precompile
     rescue Haml::Error => e
-      e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}" if @index
+      if @index || e.line
+        e.backtrace.unshift "#{@options[:filename]}:#{(e.line ? e.line + 1 : @index) + @options[:line] - 1}"
+      end
       raise
     end
 

data/lib/haml/exec.rb

@@ -3,7 +3,7 @@ require 'fileutils'
 require 'rbconfig'
 
 module Haml
-  # This module handles the various Haml executables (`haml`, `sass`, `css2sass`, etc).
+  # This module handles the various Haml executables (`haml`, `sass`, `sass-convert`, etc).
   module Exec
     # An abstract class that encapsulates the executable code for all three executables.
     class Generic
@@ -93,17 +93,14 @@ module Haml
       # so they can run their respective programs.
       def process_result
         input, output = @options[:input], @options[:output]
-        input_file, output_file = if input
-                                    [nil, open_file(@args[0], 'w')]
-                                  else
-                                    @options[:filename] = @args[0]
-                                    [open_file(@args[0]), open_file(@args[1], 'w')]
-                                  end
-
-        input  ||= input_file
-        output ||= output_file
-        input  ||= $stdin
-        output ||= $stdout
+        args = @args.dup
+        input ||=
+          begin
+            filename = args.shift
+            @options[:filename] = filename
+            open_file(filename) || $stdin
+          end
+        output ||= open_file(args.shift, 'w') || $stdout
 
         @options[:input], @options[:output] = input, output
       end
@@ -218,10 +215,28 @@ END
       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('-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('-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
@@ -244,19 +259,24 @@ END
       # Processes the options set by the command-line arguments,
       # and runs the Sass compiler appropriately.
       def process_result
-        if @options[:interactive]
-          require 'sass'
-          require 'sass/repl'
-          ::Sass::Repl.new(@options).run
-          return
+        if !@options[:update] && !@options[:watch] &&
+            @args.first && @args.first.include?(':')
+          if @args.size == 1
+            @args = @args.first.split(':', 2)
+          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[: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])
@@ -273,8 +293,87 @@ END
           output.close() if output.is_a? File
         rescue ::Sass::SyntaxError => e
           raise e if @options[:trace]
-          raise "Syntax error on line #{get_line e}: #{e.message}"
+          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]
+
+        if @args[1] && !@args[0].include?(':')
+          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| name.split(':', 2)}.
+          map {|from, to| [from, to || from.gsub(/\..*?$/, '.css')]}.
+          partition {|i, _| File.directory? i}
+        ::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
+
+        ::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)
+          puts_action :error, :red, "#{error.sass_filename} (Line #{error.sass_line}: #{error.message})"
+        end
+
+        if @options[:update]
+          ::Sass::Plugin.update_stylesheets(files)
+          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
+
+      # @private
+      COLORS = { :red => 31, :green => 32, :yellow => 33 }
+
+      def puts_action(name, color, arg)
+        printf color(color, "%11s %s\n"), name, arg
+      end
+
+      def color(color, str)
+        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
+
+        # Almost any real Unix terminal will support color,
+        # so we just filter for Windows terms (which don't set TERM)
+        # and not-real terminals, which aren't ttys.
+        return str if ENV["TERM"].empty? || !STDOUT.tty?
+        return "\e[#{COLORS[color]}m#{str}\e[0m"
       end
     end
 
@@ -309,6 +408,11 @@ END
           @options[:for_engine][:escape_html] = true
         end
 
+        opts.on('-q', '--double-quote-attributes',
+                'Set attribute wrapper to double-quotes (default is single).') do
+          @options[:for_engine][:attr_wrapper] = '"'
+        end
+
         opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
           @options[:requires] << file
         end
@@ -368,17 +472,7 @@ END
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
-
         @module_opts = {}
-
-        begin
-          require 'haml/html'
-        rescue LoadError => err
-          dep = err.message.scan(/^no such file to load -- (.*)/)[0]
-          raise err if @options[:trace] || dep.nil? || dep.empty?
-          $stderr.puts "Required dependency #{dep} not found!\n  Use --trace for backtrace."
-          exit 1
-        end
       end
 
       # Tells optparse how to parse the arguments.
@@ -393,12 +487,20 @@ Description: Transforms an HTML file into corresponding Haml code.
 Options:
 END
 
-        opts.on('-r', '--rhtml', 'Parse RHTML tags.') do
-          @module_opts[:rhtml] = true
+        opts.on('-e', '--erb', 'Parse ERb tags.') do
+          @module_opts[:erb] = true
+        end
+
+        opts.on('--no-erb', "Don't parse ERb tags.") do
+          @options[:no_erb] = true
+        end
+
+        opts.on('-r', '--rhtml', 'Deprecated; same as --erb.') do
+          @module_opts[:erb] = true
         end
 
-        opts.on('--no-rhtml', "Don't parse RHTML tags.") do
-          @options[:no_rhtml] = true
+        opts.on('--no-rhtml', "Deprecated; same as --no-erb.") do
+          @options[:no_erb] = true
         end
 
         opts.on('-x', '--xhtml', 'Parse the input using the more strict XHTML parser.') do
@@ -413,25 +515,33 @@ END
       def process_result
         super
 
+        require 'haml/html'
+
         input = @options[:input]
         output = @options[:output]
 
-        @module_opts[:rhtml] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
-        @module_opts[:rhtml] &&= @options[:no_rhtml] != false
+        @module_opts[:erb] ||= input.respond_to?(:path) && input.path =~ /\.(rhtml|erb)$/
+        @module_opts[:erb] &&= @options[:no_erb] != false
 
         output.write(::Haml::HTML.new(input, @module_opts).render)
+      rescue ::Haml::Error => e
+        raise "#{e.is_a?(::Haml::SyntaxError) ? "Syntax error" : "Error"} on line " +
+          "#{get_line e}: #{e.message}"
+      rescue LoadError => err
+        dep = err.message.scan(/^no such file to load -- (.*)/)[0]
+        raise err if @options[:trace] || dep.nil? || dep.empty?
+        $stderr.puts "Required dependency #{dep} not found!\n  Use --trace for backtrace."
+        exit 1
       end
     end
 
-    # The `css2sass` executable.
-    class CSS2Sass < Generic
+    # The `sass-convert` executable.
+    class SassConvert < Generic
       # @param args [Array<String>] The command-line arguments
       def initialize(args)
         super
-
-        @module_opts = {}
-
-        require 'sass/css'
+        @options[:for_tree] = {}
+        @options[:for_engine] = {}
       end
 
       # Tells optparse how to parse the arguments.
@@ -439,18 +549,45 @@ END
       # @param opts [OptionParser]
       def set_opts(opts)
         opts.banner = <<END
-Usage: css2sass [options] [INPUT] [OUTPUT]
+Usage: sass-convert [options] [INPUT] [OUTPUT]
 
-Description: Transforms a CSS file into corresponding Sass code.
+Description:
+  Converts between CSS, Sass, and SCSS files.
+  E.g. converts from SCSS to Sass,
+  or converts from CSS to SCSS (adding appropriate nesting).
 
 Options:
 END
 
-        opts.on('--old', 'Output the old-style ":prop val" property syntax') do
-          @module_opts[:old] = true
+        opts.on('-F', '--from FORMAT',
+          'The format to convert from. Can be css, scss, sass, or sass2.',
+          'sass2 is the same as sass, but updates more old syntax to new.',
+          'By default, this is inferred from the input filename.',
+          'If there is none, defaults to css.') do |name|
+          @options[:from] = name.downcase.to_sym
+        end
+
+        opts.on('-T', '--to FORMAT',
+          'The format to convert to. Can be scss or sass.',
+          'By default, this is inferred from the output filename.',
+          'If there is none, defaults to sass.') do |name|
+          @options[:to] = name.downcase.to_sym
+        end
+
+        opts.on('-i', '--in-place',
+          'Convert a file to its own syntax.',
+          'This can be used to update some deprecated syntax.') do
+          @options[:in_place] = true
         end
 
-        opts.on_tail('-a', '--alternate', 'Ignored') {}
+        opts.on('--old', 'Output the old-style ":prop val" property syntax.',
+                         'Only meaningful when generating Sass.') do
+          @options[:for_tree][:old] = true
+        end
+
+        opts.on('-C', '--no-cache', "Don't cache to sassc files.") do
+          @options[:for_engine][:cache] = false
+        end
 
         super
       end
@@ -458,12 +595,60 @@ END
       # Processes the options set by the command-line arguments,
       # and runs the CSS compiler appropriately.
       def process_result
+        require 'sass'
         super
 
         input = @options[:input]
         output = @options[:output]
+        output = input if @options[:in_place]
+
+        if input.is_a?(File)
+          @options[:from] ||=
+            case input.path
+            when /\.scss$/; :scss
+            when /\.sass$/; :sass
+            when /\.css$/; :css
+            end
+        elsif @options[:in_place]
+          raise "Error: the --in-place option requires a filename."
+        end
+
+        if output.is_a?(File)
+          @options[:to] ||=
+            case output.path
+            when /\.scss$/; :scss
+            when /\.sass$/; :sass
+            end
+        end
+
+        if @options[:from] == :sass2
+          @options[:from] = :sass
+          @options[:for_engine][:sass2] = true
+        end
+
+        @options[:from] ||= :css
+        @options[:to] ||= :sass
+        @options[:for_engine][:syntax] = @options[:from]
+
+        out =
+          ::Haml::Util.silence_haml_warnings do
+            if @options[:from] == :css
+              require 'sass/css'
+              ::Sass::CSS.new(input.read, @options[:for_tree]).render(@options[:to])
+            else
+              if input.is_a?(File)
+                ::Sass::Files.tree_for(input.path, @options[:for_engine])
+              else
+                ::Sass::Engine.new(input.read, @options[:for_engine]).to_tree
+              end.send("to_#{@options[:to]}", @options[:for_tree])
+            end
+          end
 
-        output.write(::Sass::CSS.new(input, @module_opts).render)
+        output = File.open(input.path, 'w') if @options[:in_place]
+        output.write(out)
+      rescue ::Sass::SyntaxError => e
+        raise e if @options[:trace]
+        raise "Syntax error on line #{get_line e}: #{e.message}\n  Use --trace for backtrace"
       end
     end
   end