haml-edge 2.3.186 → 2.3.187

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.186
+2.3.187

data/VERSION

@@ -1 +1 @@
-2.3.186
+2.3.187

data/lib/haml/exec.rb

@@ -105,6 +105,39 @@ module Haml
         @options[:input], @options[:output] = input, output
       end
 
+      # @private
+      COLORS = { :red => 31, :green => 32, :yellow => 33 }
+
+      # Prints a status message about performing the given action,
+      # colored using the given color (via terminal escapes) if possible.
+      #
+      # @param name [#to_s] A short name for the action being performed.
+      #   Shouldn't be longer than 11 characters.
+      # @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)
+        printf color(color, "%11s %s\n"), name, arg
+      end
+
+      # Wraps the given string in terminal escapes
+      # causing it to have the given color.
+      # If terminal esapes aren't supported on this platform,
+      # just returns the string instead.
+      #
+      # @param color [Symbol] The name of the color to use.
+      #   Can be `:red`, `:green`, or `:yellow`.
+      # @param str [String] The string to wrap in the given color.
+      # @return [String] The wrapped string.
+      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"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
+        return "\e[#{COLORS[color]}m#{str}\e[0m"
+      end
+
       private
 
       def open_file(filename, flag = 'r')
@@ -358,23 +391,6 @@ MSG
 
         ::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"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
-        return "\e[#{COLORS[color]}m#{str}\e[0m"
-      end
     end
 
     # The `haml` executable.
@@ -574,12 +590,21 @@ END
           @options[:to] = name.downcase.to_sym
         end
 
+        opts.on('-R', '--recursive',
+          'Convert all the files in a directory. Requires --from and --to.') do
+          @options[:recursive] = true
+        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('--dasherize', 'Convert underscores to dashes') do
+          @options[:dasherize] = true
+        end
+
         opts.on('--old', 'Output the old-style ":prop val" property syntax.',
                          'Only meaningful when generating Sass.') do
           @options[:for_tree][:old] = true
@@ -596,12 +621,63 @@ END
       # and runs the CSS compiler appropriately.
       def process_result
         require 'sass'
-        super
 
+        if @options[:recursive]
+          process_directory
+          return
+        end
+
+        super
         input = @options[:input]
+        raise "Error: '#{input}' is a directory (did you mean to use --recursive?)" if File.directory?(input)
         output = @options[:output]
         output = input if @options[:in_place]
+        process_file(input, output)
+      end
+
+      def process_directory
+        input = @options[:input] = @args.shift
+        output = @options[:output] = @args.shift
+        raise "Error: --from required when using --recursive." unless @options[:from]
+        raise "Error: --to required when using --recursive." unless @options[:to]
+        raise "Error: '#{@options[:input]}' is not a directory" unless File.directory?(@options[:input])
+        if @options[:output] && File.exists?(@options[:output]) && !File.directory?(@options[:output])
+          raise "Error: '#{@options[:output]}' is not a directory"
+        end
+        @options[:output] ||= @options[:input]
+
+        ext = @options[:from]
+        ext = :sass if ext == :sass2
+        Dir.glob("#{@options[:input]}/**/*.#{ext}") do |f|
+          output =
+            if @options[:in_place]
+              f
+            elsif @options[:output]
+              output_name = f.gsub(/\.(c|sa|sc)ss$/, ".#{@options[:to]}")
+              output_name[0...@options[:input].size] = @options[:output]
+              output_name
+            else
+              f.gsub(/\.(c|sa|sc)ss$/, ".#{@options[:to]}")
+            end
+
+          unless File.directory?(File.dirname(output))
+            puts_action :directory, :green, File.dirname(output)
+            FileUtils.mkdir_p(File.dirname(output))
+          end
+          puts_action :convert, :green, f
+          if File.exists?(output)
+            puts_action :overwrite, :yellow, output
+          else
+            puts_action :create, :green, output
+          end
+
+          input = open_file(f)
+          output = @options[:in_place] ? input : open_file(output, "w")
+          process_file(input, output)
+        end
+      end
 
+      def process_file(input, output)
         if input.is_a?(File)
           @options[:from] ||=
             case input.path

data/lib/haml/helpers.rb

@@ -348,7 +348,9 @@ MESSAGE
         haml_buffer.capture_position = position
         block.call(*args)
 
-        captured = haml_buffer.buffer.slice!(position..-1).split(/^/)
+        captured = haml_buffer.buffer.slice!(position..-1)
+        return captured if haml_buffer.options[:ugly]
+        captured = captured.split(/^/)
 
         min_tabs = nil
         captured.each do |line|

data/lib/sass/engine.rb

@@ -415,7 +415,7 @@ WARNING
         if eq.strip[0] == SCRIPT_CHAR
           expr.context = :equals
           Script.equals_warning("properties", name,
-            Sass::Tree::PropNode.val_to_sass(expr), false,
+            Sass::Tree::PropNode.val_to_sass(expr, @options), false,
             @line, line.offset + 1, @options[:filename])
         end
       end

data/lib/sass/script/bool.rb

@@ -10,7 +10,7 @@ module Sass::Script
     alias_method :to_bool, :value
 
     # @return [String] "true" or "false"
-    def to_s
+    def to_s(opts = {})
       @value.to_s
     end
     alias_method :to_sass, :to_s

data/lib/sass/script/color.rb

@@ -375,7 +375,7 @@ END
     # but if the color has a name that's used instead.
     #
     # @return [String] The string representation
-    def to_s
+    def to_s(opts = {})
       return rgba_str if alpha?
       return smallest if options[:style] == :compressed
       return HTML4_COLORS_REVERSE[rgb] if HTML4_COLORS_REVERSE[rgb]

data/lib/sass/script/funcall.rb

@@ -31,8 +31,8 @@ module Sass
       end
 
       # @see Node#to_sass
-      def to_sass
-        "#{name}(#{args.map {|a| a.to_sass}.join(', ')})"
+      def to_sass(opts = {})
+        "#{dasherize(name, opts)}(#{args.map {|a| a.to_sass(opts)}.join(', ')})"
       end
 
       # Returns the arguments to the function.

data/lib/sass/script/interpolation.rb

@@ -9,16 +9,16 @@ module Sass::Script
     end
 
     def inspect
-      "(interpolation #{@before.inspect} #{@mid.inspect} #{after.inspect})"
+      "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
     end
 
-    def to_sass
+    def to_sass(opts = {})
       res = ""
-      res << @before.to_sass if @before
+      res << @before.to_sass(opts) if @before
       res << ' ' if @before && @whitespace_before
-      res << '#{' << @mid.to_sass << '}'
+      res << '#{' << @mid.to_sass(opts) << '}'
       res << ' ' if @after && @whitespace_after
-      res << @after.to_sass if @after
+      res << @after.to_sass(opts) if @after
       res
     end
 

data/lib/sass/script/literal.rb

@@ -218,7 +218,7 @@ MSG
     # as it would be output to the CSS document.
     #
     # @return [String]
-    def to_s
+    def to_s(opts = {})
       raise Sass::SyntaxError.new("[BUG] All subclasses of Sass::Literal must implement #to_s.")
     end
     alias_method :to_sass, :to_s

data/lib/sass/script/node.rb

@@ -74,12 +74,21 @@ module Sass::Script
     # Returns the text of this SassScript expression.
     #
     # @return [String]
-    def to_sass
+    def to_sass(opts = {})
       raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #to_sass.")
     end
 
     protected
 
+    # Converts underscores to dashes if the :dasherize option is set.
+    def dasherize(s, opts)
+      if opts[:dasherize]
+        s.gsub(/_/,'-')
+      else
+        s
+      end
+    end
+
     # Evaluates this node.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript

data/lib/sass/script/number.rb

@@ -238,7 +238,7 @@ module Sass::Script
     # as long as there is only one unit.
     #
     # @return [String] The representation
-    def inspect
+    def inspect(opts = {})
       value =
         if self.value.is_a?(Float) && (self.value.infinite? || self.value.nan?)
           self.value

data/lib/sass/script/operation.rb

@@ -33,10 +33,10 @@ module Sass::Script
     end
 
     # @see Node#to_sass
-    def to_sass
+    def to_sass(opts = {})
       pred = Sass::Script::Parser.precedence_of(@operator)
-      o1 = operand_to_sass pred, @operand1
-      o2 = operand_to_sass pred, @operand2
+      o1 = operand_to_sass pred, @operand1, opts
+      o2 = operand_to_sass pred, @operand2, opts
       sep =
         case @operator
         when :comma; ", "
@@ -82,10 +82,10 @@ module Sass::Script
 
     private
 
-    def operand_to_sass(pred, op)
+    def operand_to_sass(pred, op, opts = {})
       return "(#{op.to_sass})" if op.is_a?(Operation) &&
         Sass::Script::Parser.precedence_of(op.operator) < pred
-      op.to_sass
+      op.to_sass(opts)
     end
   end
 end

data/lib/sass/script/string.rb

@@ -35,23 +35,30 @@ module Sass::Script
     end
 
     # @see Node#to_s
-    def to_s
-      to_sass
+    def to_s(opts = {})
+      to_sass(opts)
     end
 
-    # @param type [Symbol] The type of string to render this as.
-    #   `:string`s have double quotes, `:identifier`s do not.
+    # @param opts [{Symbol => Object}]
+    #   `opts[:type]` -- The type of string to render this as.
+    #     `:string`s have double quotes, `:identifier`s do not.
+    #     Defaults to `:identifier`.
     # @see Node#to_sass
-    def to_sass(type = self.type)
+    def to_sass(opts = {})
+      type = opts[:type] || self.type
       if type == :identifier
         if context == :equals && Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
           return "unquote(#{Sass::Script::String.new(self.value, :string).to_sass})"
+        elsif context == :equals && self.value.size == 0
+          return %q{""}
         end
         return self.value
       end
 
       # Replace single backslashes with double. Really.
       value = self.value.gsub("\\", "\\\\\\\\")
+      return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}
+      return "'#{value.gsub("'", "\\'")}'" if opts[:quote] == %q{'}
       return "\"#{value}\"" unless value.include?('"')
       return "'#{value}'" unless value.include?("'")
       "\"#{value.gsub('"', "\\\"")}\"" #'

data/lib/sass/script/unary_operation.rb

@@ -19,12 +19,12 @@ module Sass::Script
     end
 
     # @see Node#to_sass
-    def to_sass
-      operand = @operand.to_sass
+    def to_sass(opts = {})
+      operand = @operand.to_sass(opts)
       if @operand.is_a?(Operation) ||
           (@operator == :minus &&
            (operand =~ Sass::SCSS::RX::IDENT) == 0)
-        operand = "(#{@operand.to_sass})"
+        operand = "(#{@operand.to_sass(opts)})"
       end
       op = Lexer::OPERATORS_REVERSE[@operator]
       op + (op =~ /[a-z]/ ? " " : "") + operand

data/lib/sass/script/variable.rb

@@ -14,9 +14,9 @@ module Sass
       end
 
       # @return [String] A string representation of the variable
-      def inspect
+      def inspect(opts = {})
         return "!important" if name == "important"
-        "$#{name}"
+        "$#{dasherize(name, opts)}"
       end
       alias_method :to_sass, :inspect
 

data/lib/sass/scss/css_parser.rb

@@ -9,6 +9,7 @@ module Sass
       def parent_selector; nil; end
       def interpolation; nil; end
       def interp_string; tok(STRING); end
+      def interp_ident(ident = IDENT); tok(ident); end
       def expected_property_separator; '":"'; end
       def use_css_import?; true; end
 

data/lib/sass/scss/parser.rb

@@ -366,12 +366,12 @@ module Sass
 
       def simple_selector_sequence
         # This allows for stuff like http://www.w3.org/TR/css3-animations/#keyframes-
-        return expr unless e = element_name || tok(HASH) || class_expr ||
+        return expr unless e = element_name || id_selector || class_selector ||
           attrib || negation || pseudo || parent_selector || interpolation
         res = [e]
 
         # The tok(/\*/) allows the "E*" hack
-        while v = element_name || tok(HASH) || class_expr ||
+        while v = element_name || id_selector || class_selector ||
             attrib || negation || pseudo || tok(/\*/) || interpolation
           res << v
         end
@@ -382,9 +382,16 @@ module Sass
         tok(/&/)
       end
 
-      def class_expr
+      def class_selector
         return unless tok(/\./)
-        '.' + tok!(IDENT)
+        @expected = "class name"
+        ['.', expr!(:interp_ident)]
+      end
+
+      def id_selector
+        return unless tok(/#(?!\{)/)
+        @expected = "id name"
+        ['#', expr!(:interp_name)]
       end
 
       def element_name
@@ -398,7 +405,7 @@ module Sass
 
       def attrib
         return unless tok(/\[/)
-        res = ['[', str{ss}, str{attrib_name!}, str{ss}]
+        res = ['[', str{ss}, attrib_name!, str{ss}]
 
         if m = tok(/=/) ||
             tok(INCLUDES) ||
@@ -413,31 +420,29 @@ module Sass
       end
 
       def attrib_name!
-        if tok(IDENT)
-          # E, E|E, or E|
-          # The last is allowed so that E|="foo" will work
-          tok(IDENT) if tok(/\|/)
-        elsif tok(/\*/)
-          # *|E
-          tok!(/\|/)
-          tok! IDENT
+        if name_or_ns = interp_ident
+          # E, E|E
+          if tok(/\|(?!=)/)
+            ns = name_or_ns
+            name = interp_ident
+          else
+            name = name_or_ns
+          end
         else
-          # |E or E
-          tok(/\|/)
-          tok! IDENT
+          # *|E or |E
+          ns = tok(/\*/) || ""
+          tok!(/\|/)
+          name = expr!(:interp_ident)
         end
+        return [ns, ("|" if ns), name]
       end
 
       def pseudo
         return unless s = tok(/::?/)
-
         @expected = "pseudoclass or pseudoelement"
-        [s, functional_pseudo || tok!(IDENT)]
-      end
-
-      def functional_pseudo
-        return unless fn = tok(FUNCTION)
-        [fn, str{ss}, expr!(:pseudo_expr), tok!(/\)/)]
+        res = [s, expr!(:interp_ident)]
+        return res unless tok(/\(/)
+        res << '(' << str{ss} << expr!(:pseudo_expr) << tok!(/\)/)
       end
 
       def pseudo_expr
@@ -455,7 +460,7 @@ module Sass
         return unless tok(NOT)
         res = [":not(", str{ss}]
         @expected = "selector"
-        res << (element_name || tok(HASH) || class_expr || attrib || expr!(:pseudo))
+        res << (element_name || id_selector || class_selector || attrib || expr!(:pseudo))
         res << tok!(/\)/)
       end
 
@@ -553,7 +558,7 @@ MESSAGE
       end
 
       def interpolation
-        return unless tok(/#\{/)
+        return unless tok(INTERP_START)
         sass_script(:parse_interpolated)
       end
 
@@ -571,6 +576,19 @@ MESSAGE
         res
       end
 
+      def interp_ident(ident = IDENT)
+        return unless val = tok(ident) || interpolation
+        res = [val]
+        while val = tok(ident) || interpolation
+          res << val
+        end
+        res
+      end
+
+      def interp_name
+        interp_ident NAME
+      end
+
       def str
         @strs.push ""
         yield
@@ -608,6 +626,8 @@ MESSAGE
         :media_query => "media query (e.g. print, screen, print and screen)",
         :media_expr => "media expression (e.g. (min-device-width: 800px)))",
         :pseudo_expr => "expression (e.g. fr, 2n+1)",
+        :interp_ident => "identifier",
+        :interp_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
       }
 

data/lib/sass/scss/rx.rb

@@ -107,6 +107,7 @@ module Sass
 
       # Custom
       HEXCOLOR = /\#[0-9a-fA-F]{3}(?:[0-9a-fA-F]{3})?/
+      INTERP_START = /#\{/
     end
   end
 end

data/lib/sass/tree/for_node.rb

@@ -22,7 +22,7 @@ module Sass::Tree
 
     def to_src(tabs, opts, fmt)
       to = @exclusive ? "to" : "through"
-      "#{'  ' * tabs}@for $#{@var} from #{@from.to_sass} #{to} #{@to.to_sass}" +
+      "#{'  ' * tabs}@for $#{dasherize(@var, opts)} from #{@from.to_sass(opts)} #{to} #{@to.to_sass(opts)}" +
         children_to_src(tabs, opts, fmt)
     end
 

data/lib/sass/tree/if_node.rb

@@ -44,7 +44,7 @@ module Sass::Tree
         else; "else"
         end
       str = "#{'  ' * tabs}@#{name}"
-      str << " #{@expr.to_sass}" if @expr
+      str << " #{@expr.to_sass(opts)}" if @expr
       str << children_to_src(tabs, opts, fmt)
       str << @else.send(:to_src, tabs, opts, fmt, true) if @else
       str

data/lib/sass/tree/mixin_def_node.rb

@@ -23,14 +23,14 @@ module Sass
           else
             '(' + @args.map do |v, d|
               if d
-                "#{v.to_sass}: #{d.to_sass}"
+                "#{v.to_sass(opts)}: #{d.to_sass(opts)}"
               else
-                v.to_sass
+                v.to_sass(opts)
               end
             end.join(", ") + ')'
           end
               
-        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{@name}#{args}" +
+        "#{'  ' * tabs}#{fmt == :sass ? '=' : '@mixin '}#{dasherize(@name, opts)}#{args}" +
           children_to_src(tabs, opts, fmt)
       end
 

data/lib/sass/tree/mixin_node.rb

@@ -29,8 +29,8 @@ module Sass::Tree
     protected
 
     def to_src(tabs, opts, fmt)
-      args = '(' + @args.map {|a| a.to_sass}.join(", ") + ')' unless @args.empty?
-      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{@name}#{args}#{semi fmt}\n"
+      args = '(' + @args.map {|a| a.to_sass(opts)}.join(", ") + ')' unless @args.empty?
+      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{args}#{semi fmt}\n"
     end
 
     # @see Node#_cssize

data/lib/sass/tree/node.rb

@@ -366,6 +366,14 @@ module Sass
           (fmt == :sass ? "\n" : " }\n")
       end
 
+      def dasherize(s, opts)
+        if opts[:dasherize]
+          s.gsub(/_/,'-')
+        else
+          s
+        end
+      end
+
       # Returns a semicolon if this is SCSS, or an empty string if this is Sass.
       #
       # @param fmt [Symbol] `:sass` or `:scss`

data/lib/sass/tree/prop_node.rb

@@ -79,13 +79,13 @@ module Sass::Tree
     protected
 
     def to_src(tabs, opts, fmt)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass}}"}.join
+      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
       old = opts[:old] && fmt == :sass
       initial = old ? ':' : ''
       mid = old ? '' : ':'
-      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value)}"
+      res = "#{'  ' * tabs}#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}"
       return res + "#{semi fmt}\n" if children.empty?
-      res.rstrip + children_to_src(tabs, opts, fmt)
+      res.rstrip + children_to_src(tabs, opts, fmt).rstrip + semi(fmt) + "\n"
     end
 
     # Computes the CSS for the property.
@@ -175,42 +175,43 @@ module Sass::Tree
 
     class << self
       # @private
-      def val_to_sass(value)
-        return value.to_sass unless value.context == :equals
-        val_to_sass_comma(value).to_sass
+      def val_to_sass(value, opts)
+        return value.to_sass(opts) unless value.context == :equals
+        val_to_sass_comma(value, opts).to_sass(opts)
       end
 
       private
 
-      def val_to_sass_comma(node)
+      def val_to_sass_comma(node, opts)
         return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_concat(node) unless node.operator == :comma
+        return val_to_sass_concat(node, opts) unless node.operator == :comma
 
         Sass::Script::Operation.new(
-          val_to_sass_concat(node.operand1),
-          val_to_sass_comma(node.operand2),
+          val_to_sass_concat(node.operand1, opts),
+          val_to_sass_comma(node.operand2, opts),
           node.operator)
       end
 
-      def val_to_sass_concat(node)
+      def val_to_sass_concat(node, opts)
         return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_div(node) unless node.operator == :concat
+        return val_to_sass_div(node, opts) unless node.operator == :concat
 
         Sass::Script::Operation.new(
-          val_to_sass_div(node.operand1),
-          val_to_sass_concat(node.operand2),
+          val_to_sass_div(node.operand1, opts),
+          val_to_sass_concat(node.operand2, opts),
           node.operator)
       end
 
-      def val_to_sass_div(node)
+      def val_to_sass_div(node, opts)
         unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
             node.operand1.is_a?(Sass::Script::Number) &&
             node.operand2.is_a?(Sass::Script::Number)
           return node
         end
 
-        Sass::Script::String.new("(#{node.to_sass})")
+        Sass::Script::String.new("(#{node.to_sass(opts)})")
       end
+
     end
   end
 end