haml-edge 2.3.240 → 2.3.241

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-2.3.240
+2.3.241

data/Rakefile

@@ -269,6 +269,7 @@ OPTS
       list.exclude('lib/haml/helpers/xss_mods.rb')
       list.exclude('lib/sass/plugin/merb.rb')
       list.exclude('lib/sass/plugin/rails.rb')
+      list.exclude('lib/sass/less.rb')
     end.to_a
     t.options << '--incremental' if Rake.application.top_level_tasks.include?('redoc')
     t.options += FileList.new(scope('yard/*.rb')).to_a.map {|f| ['-e', f]}.flatten

data/VERSION

@@ -1 +1 @@
-2.3.240
+2.3.241

data/lib/haml/exec.rb

@@ -155,6 +155,17 @@ module Haml
         flag = 'wb' if @options[:unix_newlines] && flag == 'w'
         File.open(filename, flag)
       end
+
+      def handle_load_error(err)
+        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!
+  Run "gem install #{dep}" to get it.
+  Use --trace for backtrace.
+MESSAGE
+        exit 1
+      end
     end
 
     # An abstrac class that encapsulates the code
@@ -558,14 +569,7 @@ END
         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 <<MESSAGE
-Required dependency #{dep} not found!
-  Run "gem install #{dep}" to get it.
-  Use --trace for backtrace.
-MESSAGE
-        exit 1
+        handle_load_error(err)
       end
     end
 
@@ -595,14 +599,15 @@ Options:
 END
 
         opts.on('-F', '--from FORMAT',
-          'The format to convert from. Can be css, scss, sass, or sass2.',
+          'The format to convert from. Can be css, scss, sass, less, 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
-          unless [:css, :scss, :sass, :sass2].include?(@options[:from])
+          unless [:css, :scss, :sass, :less, :sass2].include?(@options[:from])
             raise "Unknown format for sass-convert --from: #{name}"
           end
+          try_less_note if @options[:from] == :less
         end
 
         opts.on('-T', '--to FORMAT',
@@ -685,11 +690,11 @@ END
             if @options[:in_place]
               f
             elsif @options[:output]
-              output_name = f.gsub(/\.(c|sa|sc)ss$/, ".#{@options[:to]}")
+              output_name = f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
               output_name[0...@options[:input].size] = @options[:output]
               output_name
             else
-              f.gsub(/\.(c|sa|sc)ss$/, ".#{@options[:to]}")
+              f.gsub(/\.(c|sa|sc|le)ss$/, ".#{@options[:to]}")
             end
 
           unless File.directory?(File.dirname(output))
@@ -715,6 +720,7 @@ END
             case input.path
             when /\.scss$/; :scss
             when /\.sass$/; :sass
+            when /\.less$/; :less
             when /\.css$/; :css
             end
         elsif @options[:in_place]
@@ -743,6 +749,11 @@ END
             if @options[:from] == :css
               require 'sass/css'
               ::Sass::CSS.new(input.read, @options[:for_tree]).render(@options[:to])
+            elsif @options[:from] == :less
+              require 'sass/less'
+              try_less_note
+              input = input.read if input.is_a?(IO) && !input.is_a?(File) # Less is dumb
+              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])
@@ -758,6 +769,19 @@ END
         raise e if @options[:trace]
         file = " of #{e.sass_filename}" if e.sass_filename
         raise "Error on line #{e.sass_line}#{file}: #{e.message}\n  Use --trace for backtrace"
+      rescue LoadError => err
+        handle_load_error(err)
+      end
+
+      @@less_note_printed = false
+      def try_less_note
+        return if @@less_note_printed
+        @@less_note_printed = true
+        warn <<NOTE
+* NOTE: Sass and Less are different languages, and they work differently.
+* I'll do my best to translate, but some features -- especially mixins --
+* should be checked by hand.
+NOTE
       end
     end
   end

data/lib/sass/less.rb

@@ -0,0 +1,363 @@
+#!/usr/bin/env ruby
+
+require 'less'
+
+module Less
+  # This is the class that Treetop defines for parsing Less files.
+  # Since not everything gets parsed into the AST but is instead resolved at parse-time,
+  # we need to override some of it so that it can be converted into Sass.
+  module StyleSheet
+    # Selector mixins that don't have arguments.
+    # This depends only on the syntax at the call site;
+    # if it doesn't use parens, it hits this production,
+    # regardless of whether the mixin being called has arguments or not.
+    module Mixin4
+      def build_with_sass(env)
+        selectors.build(env, :mixin).each do |path|
+          el = path.inject(env.root) do |current, node|
+            current.descend(node.selector, node) or raise MixinNameError, "#{selectors.text_value} in #{env}"
+          end
+          if el.is_a?(Node::Mixin::Def)
+            # Calling a mixin with arguments, which gets compiled to a Sass mixin
+            env << Node::Mixin::Call.new(el, [], env)
+          else
+            # Calling a mixin without arguments, which gets compiled to @extend
+            sel = selector_str(path)
+            base = selector_str(selector_base(path))
+            if base == sel
+              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([sel]))
+            else
+              Haml::Util.haml_warn <<WARNING
+WARNING: Sass doesn't support mixing in selector sequences.
+Replacing "#{sel}" with "@extend #{base}"
+WARNING
+              env << Node::SassNode.new(Sass::Tree::CommentNode.new("// #{sel};", true))
+              env << Node::SassNode.new(Sass::Tree::ExtendNode.new([base]))
+            end
+          end
+        end
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+
+      def selector_base(path)
+        el, i = Haml::Util.enum_with_index(path).to_a.reverse.find {|e, i| e.selector !~ /^:{1,2}$/} ||
+          [path.first, 0]
+        sel = (el.selector =~ /^:{0,2}$/ ? el.selector : "")
+        [Node::Element.new(el.name, sel)] + path[i+1..-1]
+      end
+
+      def selector_str(path)
+        path.map {|e| e.sass_selector_str}.join(' ').gsub(' :', ':')
+      end
+    end
+
+    # Property and variable declarations.
+    # We want to keep track of the line number
+    # so we don't space out the variables too much in the generated Sass.
+    module Declaration3
+      def build_with_sass(env)
+        build_without_sass(env)
+        env.rules.last.src_line = input.line_of(interval.first)
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # Comma-separated selectors.
+    # Less breaks these into completely separate nodes.
+    # Since we don't want this duplication in the Sass,
+    # we modify the production to keep track of the original group
+    # so we can reconstruct it later on.
+    module Selectors2
+      def build_with_sass(env, method)
+        arr = build_without_sass(env, method)
+        return arr if method == :mixin
+        rarr = arr.map {|e| e.top(env)}
+        rarr.each {|e| e.group = rarr}
+        arr
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # Attribute accessors.
+    # Sass just flat-out doesn't support these,
+    # so we print a warning to that effect and compile them to comments.
+    module Accessor1
+      def build(env)
+        Haml::Util.haml_warn <<WARNING
+WARNING: Sass doesn't support attribute accessors.
+Ignoring #{text_value}
+WARNING
+        Node::Anonymous.new("/* #{text_value} */")
+      end
+    end
+
+    # @import statements.
+    # Less handles these during parse-time,
+    # so we want to wrap them up as a node in the tree.
+    # We also include the nodes, though,
+    # since we want to have access to the mixins
+    # so we can tell if they take arguments or not.
+    # The included nodes are hidden so they don't appear in the output.
+    module Import1
+      def build_with_sass(env)
+        line = input.line_of(interval.first)
+        import = Sass::Tree::ImportNode.new(url.value.gsub(/\.less$/, ''))
+        import.line = input.line_of(interval.first)
+        env << Node::SassNode.new(import)
+        old_rules = env.rules.dup
+        build_without_sass env
+        (env.rules - old_rules).each {|r| r.hide_in_sass = true}
+      rescue ImportError => e
+        raise Sass::SyntaxError.new("File to import #{url.text_value} not found or unreadable", :line => line)
+      end
+      alias_method :build_without_sass, :build
+      alias_method :build, :build_with_sass
+    end
+
+    # The IE-specific `alpha(opacity=@var)`.
+    # Less manually resolves the variable here at parse-time.
+    # We want to keep the variable around,
+    # so we compile this to a function.
+    # Less doesn't actually have an `=` operator,
+    # but that's okay since it's just getting compiled to Sass anyway.
+    module Entity::Alpha1
+      def build(env)
+        Node::Function.new("alpha",
+          [Node::Expression.new([
+                Node::Keyword.new("opacity"),
+                Node::Operator.new("="),
+                variable.build])])
+      end
+    end
+  end
+
+  # The Less AST classes for the document,
+  # including both stylesheet-level nodes and expression-level nodes.
+  # The main purpose of overriding these is to add `#to_sass_tree` functions
+  # for converting to Sass.
+  module Node
+    module Entity
+      attr_accessor :hide_in_sass
+      attr_accessor :src_line
+    end
+
+    class Element
+      attr_accessor :group
+
+      def top(env)
+        return self if parent.equal?(env)
+        return parent.top(env)
+      end
+
+      def to_sass_tree
+        if root?
+          root = Sass::Tree::RootNode.new("")
+          rules.each {|r| root << r.to_sass_tree}
+          return root
+        end
+        return if hide_in_sass
+        return if !self.equal?(group.first)
+
+        last_el = nil
+        sel = group.map do |el|
+          comma_sel = []
+          loop do
+            comma_sel << el.sass_selector_str
+            break unless el.rules.size == 1 && el.rules.first.is_a?(Element)
+            el = el.rules.first
+          end
+          last_el = el
+          comma_sel = comma_sel.join(' ').gsub(' :', ':')
+          comma_sel.gsub!(/^:/, '&:') unless parent.root?
+          comma_sel
+        end.join(', ')
+
+        rule = Sass::Tree::RuleNode.new([sel])
+        last_el.rules.each {|r| rule << r.to_sass_tree}
+        return rule
+      end
+
+      def sass_selector_str
+        case @selector
+        when /[+>~]/; "#{@selector} #{@name}"
+        else @selector + @name
+        end
+      end
+    end
+
+    module Mixin
+      class Call
+        def to_sass_tree
+          return if hide_in_sass
+          Sass::Tree::MixinNode.new(@mixin.name.gsub(/^\./, ''), @params.map {|v| v.to_sass_tree})
+        end
+      end
+
+      class Def
+        def to_sass_tree
+          return if hide_in_sass
+          mixin = Sass::Tree::MixinDefNode.new(name, @params.map do |v|
+              v.value.flatten!
+              [Sass::Script::Variable.new(v), v.value.to_sass_tree]
+            end)
+          rules.each {|r| mixin << r.to_sass_tree}
+          mixin
+        end
+      end
+    end
+
+    class SassNode
+      include Entity
+
+      def initialize(node)
+        @node = node
+      end
+
+      def to_sass_tree
+        return if hide_in_sass
+        @node
+      end
+    end
+
+    class Property
+      def to_sass_tree
+        return if hide_in_sass
+        Sass::Tree::PropNode.new([self], @value.to_sass_tree, :new)
+      end
+    end
+
+    class Expression
+      def to_sass_tree
+        if first.is_a?(Array)
+          val = map {|e| _to_sass_tree(e)}.inject(nil) do |e, i|
+            next i unless e
+            Sass::Script::Operation.new(e, i, :comma)
+          end
+        else
+          val = _to_sass_tree(self)
+        end
+        val.options = {}
+        val
+      end
+
+      private
+
+      LESS_TO_SASS_OPERATORS = {"-" => :minus, "+" => :plus, "*" => :times, "/" => :div, "=" => :single_eq}
+      def _to_sass_tree(arr)
+        return Sass::Script::UnaryOperation.new(_to_sass_tree(arr[1..-1]), :minus) if arr[0] == "-"
+        _to_sass_tree2(*_sass_split(arr))
+      end
+
+      def _to_sass_tree2(first, rest)
+        return first if rest.empty?
+        if rest[0].is_a?(Operator)
+          op = LESS_TO_SASS_OPERATORS[rest[0]]
+          if op == :times || op == :div
+            second, rest = _sass_split(rest[1..-1])
+            return _to_sass_tree2(Sass::Script::Operation.new(first, second, op), rest)
+          else
+            return Sass::Script::Operation.new(first, _to_sass_tree(rest[1..-1]), op)
+          end
+        end
+
+        Sass::Script::Operation.new(first, _to_sass_tree(rest), :concat)
+      end
+
+      def _sass_split(arr)
+        return arr[0].to_sass_tree, arr[1..-1] unless arr[0] == "("
+        parens = 1
+        i = arr[1..-1].each_with_index do |e, i|
+          parens += 1 if e == "("
+          parens -= 1 if e == ")"
+          break i if parens == 0
+        end
+
+        return _to_sass_tree(arr[1...i+1]), arr[i+2..-1]
+      end
+    end
+
+    class Color
+      def to_sass_tree
+        Sass::Script::Color.new(:red => r, :green => g, :blue => b, :alpha => a)
+      end
+    end
+
+    class Number
+      def to_sass_tree
+        Sass::Script::Number.new(self, [self.unit])
+      end
+    end
+
+    class Variable
+      def to_sass_tree
+        if @declaration
+          return if hide_in_sass
+          node = Sass::Tree::VariableNode.new(self, @value.to_sass_tree, false)
+          node.line = self.src_line
+          node
+        else
+          Sass::Script::Variable.new(self)
+        end
+      end
+    end
+
+    class Function
+      def to_sass_tree
+        Sass::Script::Funcall.new(self, @args.map {|a| a.to_sass_tree})
+      end
+    end
+
+    class Keyword
+      def to_sass_tree
+        Sass::Script::String.new(self)
+      end
+    end
+
+    class Anonymous
+      def to_sass_tree
+        Sass::Script::String.new(self)
+      end
+    end
+
+    class Quoted
+      def to_sass_tree
+        Sass::Script::String.new(self, true)
+      end
+    end
+
+    class FontFamily
+      def to_sass_tree
+        @family.map {|f| f.to_sass_tree}.inject(nil) do |e, f|
+          next f unless e
+          Sass::Script::Operation.new(e, f, :comma)
+        end
+      end
+    end
+  end
+
+  # The entry point to Less.
+  # By default Less doesn't preserve the filename of the file being parsed,
+  # which is unpleasant for error reporting.
+  # Our monkeypatch keeps it around.
+  class Engine
+    def initialize_with_sass(obj, opts = {})
+      initialize_without_sass(obj, opts)
+      @filename = obj.path if obj.is_a?(File)
+    end
+    alias_method :initialize_without_sass, :initialize
+    alias_method :initialize, :initialize_with_sass
+
+    def parse_with_sass
+      parse_without_sass
+    rescue Sass::SyntaxError => e
+      e.modify_backtrace(:filename => @filename)
+      raise e
+    end
+    alias_method :parse_without_sass, :parse
+    alias_method :parse, :parse_with_sass
+    alias_method :to_tree, :parse
+  end
+end

data/test/sass/less_conversion_test.rb

@@ -0,0 +1,625 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+
+begin
+require 'sass/less'
+
+class LessConversionTest < Test::Unit::TestCase
+  def test_variable_declarations
+    assert_renders <<SCSS, <<LESS
+$var1: 2px 3px;
+$var2: $var1 + 7px;
+
+$var3: fizz;
+
+foo {
+  prop: $var1 $var2 $var3; }
+SCSS
+@var1: 2px 3px;
+@var2: @var1 + 7px;
+
+@var3: fizz;
+
+foo {prop: @var1 @var2 @var3}
+LESS
+  end
+
+  def test_nested_variable_declarations
+    assert_renders <<SCSS, <<LESS
+.foo {
+  $var: 2px;
+  prop: $var; }
+SCSS
+.foo {
+  @var: 2px;
+  prop: @var; }
+LESS
+  end
+
+  def test_import
+    path = File.dirname(__FILE__) + "/templates/importee.less"
+    resolved_path = File.dirname(__FILE__) + "/templates/importee"
+    assert_renders <<SCSS, <<LESS
+@import "#{resolved_path}";
+@import "#{resolved_path}";
+
+@import "#{resolved_path}";
+@import "#{resolved_path}";
+@import "#{resolved_path}";
+SCSS
+@import url(#{path});
+@import url("#{path}");
+
+@import url('#{path}');
+@import '#{path}';
+@import "#{path}";
+LESS
+  end
+
+  def test_mixins_found_through_import
+    path = File.dirname(__FILE__) + "/templates/importee.less"
+    resolved_path = File.dirname(__FILE__) + "/templates/importee"
+    assert_renders <<SCSS, <<LESS
+@import "#{resolved_path}";
+
+.baz {
+  @extend .foo;
+  @include bar; }
+SCSS
+@import "#{path}";
+
+.baz {.foo; .bar;}
+LESS
+  end
+
+  # Selectors
+
+  def test_element_selector
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: b; }
+SCSS
+foo {a: b}
+LESS
+  end
+
+  def test_class_selector
+    assert_renders <<SCSS, <<LESS
+.foo {
+  a: b; }
+SCSS
+.foo {a: b}
+LESS
+  end
+
+  def test_id_selector
+    assert_renders <<SCSS, <<LESS
+#foo {
+  a: b; }
+SCSS
+#foo {a: b}
+LESS
+  end
+
+  def test_pseudoclass_selector
+    assert_renders <<SCSS, <<LESS
+:foo {
+  a: b; }
+SCSS
+:foo {a: b}
+LESS
+  end
+
+  def test_pseudoelement_selector
+    assert_renders <<SCSS, <<LESS
+::foo {
+  a: b; }
+SCSS
+::foo {a: b}
+LESS
+  end
+
+  def test_comma_selector
+    assert_renders <<SCSS, <<LESS
+foo, .bar .baz, :bang {
+  a: b; }
+SCSS
+foo, .bar .baz, :bang {a: b}
+LESS
+  end
+
+  def test_nested_comma_selector
+    assert_renders <<SCSS, <<LESS
+foo bar, .baz {
+  .bang, &:bip bap {
+    a: b; } }
+SCSS
+foo bar, .baz {
+  .bang, :bip bap {a: b} }
+LESS
+  end
+
+  def test_simple_selector_sequence
+    assert_renders <<SCSS, <<LESS
+a.foo#bar[attr=val] {
+  a: b; }
+SCSS
+a.foo#bar[attr=val] {a: b}
+LESS
+  end
+
+  def test_descendant_selector
+    assert_renders <<SCSS, <<LESS
+.foo .bar {
+  a: b; }
+SCSS
+.foo .bar {a: b}
+LESS
+  end
+
+  def test_child_selector
+    assert_renders <<SCSS, <<LESS
+.foo > .bar {
+  a: b; }
+SCSS
+.foo > .bar {a: b}
+LESS
+  end
+
+  def test_adjacent_selector
+    assert_renders <<SCSS, <<LESS
+.foo + .bar {
+  a: b; }
+SCSS
+.foo + .bar {a: b}
+LESS
+  end
+
+  def test_pseudoclass_in_sequence
+    assert_renders <<SCSS, <<LESS
+.foo:bar {
+  a: b; }
+SCSS
+.foo:bar {a: b}
+LESS
+  end
+
+  def test_pseudoelement_in_sequence
+    assert_renders <<SCSS, <<LESS
+.foo::bar {
+  a: b; }
+SCSS
+.foo::bar {a: b}
+LESS
+  end
+
+  # Properties
+
+  def test_space_separated_props
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: foo bar baz; }
+SCSS
+foo {a: foo bar baz}
+LESS
+  end
+
+  def test_comma_separated_props
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: foo, bar, baz; }
+SCSS
+foo {a: foo, bar, baz}
+LESS
+  end
+
+  def test_numbers
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: 1 2.3 -8 5px 3%; }
+SCSS
+foo {a: 1 2.3 -8 5px 3%}
+LESS
+  end
+
+  def test_colors
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: red #abcdef blue; }
+SCSS
+foo {a: #f00 #abcdef blue}
+LESS
+  end
+
+  def test_strings
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: "foo @var bar" "baz bang" "quote'quote" 'quote"quote'; }
+SCSS
+foo {a: "foo @var bar" 'baz bang' "quote'quote" 'quote"quote'}
+LESS
+  end
+
+  def test_slash
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: small/8px 7em/8px;
+  b: 8/4;
+  c: (8 / 4); }
+SCSS
+foo {
+  a: small/8px 7em/8px;
+  b: 8/4;
+  c: 8 / 4; }
+LESS
+  end
+
+  def test_url
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: url("http://foobar.com/fizzle.html?foo=bar&bar=baz");
+  b: url("http://foobar.com/fizzle.html?foo=bar&bar=baz");
+  c: url("http://foobar.com/fizzle.html?foo=bar&bar=baz"); }
+SCSS
+foo {
+  a: url(http://foobar.com/fizzle.html?foo=bar&bar=baz);
+  b: url("http://foobar.com/fizzle.html?foo=bar&bar=baz");
+  c: url('http://foobar.com/fizzle.html?foo=bar&bar=baz'); }
+LESS
+  end
+
+  def test_functions
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: baz(12px) rgba(80, 70 120, 0.76);
+  b: faz(1px + 3px) bang($var, #aaaaaa * 3); }
+SCSS
+foo {
+  a: baz(12px) rgba(80, 70 120, 0.76);
+  b: faz(1px + 3px) bang(@var, #aaa * 3); }
+LESS
+  end
+
+  def test_alpha_function
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: alpha(opacity=2px);
+  b: alpha(opacity = $var); }
+SCSS
+foo {
+  a: alpha(opacity=2px);
+  b: alpha(opacity=@var); }
+LESS
+  end
+
+  def test_variables
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: $var1 $var-foo; }
+SCSS
+foo {a: @var1 @var-foo}
+LESS
+  end
+
+  def test_operators
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: 1px + 2px;
+  b: #bbaa88 - #aa1122;
+  c: 5 * 3;
+  d: (8 / 4); }
+SCSS
+foo {
+  a: 1px + 2px;
+  b: #ba8 - #a12;
+  c: 5 * 3;
+  d: 8 / 4; }
+LESS
+  end
+
+  def test_operator_precedence
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: 1 + 2 * 3 + 4;
+  b: 1 * 2 + 3 * 4;
+  c: 1 - 2 + 2 - 4;
+  d: 1 + 2 - 3 + 4;
+  e: 1 / 2 - 3 / 4;
+  f: 1 - 2 / 3 - 4;
+  g: 1 / 2 * 3 / 4; }
+SCSS
+foo {
+  a: 1 + 2 * 3 + 4;
+  b: 1 * 2 + 3 * 4;
+  c: 1 - 2 + 2 - 4;
+  d: 1 + 2 - 3 + 4;
+  e: 1 / 2 - 3 / 4;
+  f: 1 - 2 / 3 - 4;
+  g: 1 / 2 * 3 / 4; }
+LESS
+  end
+
+  def test_operators_with_parens
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: 1px + 2px * 3;
+  b: (1px - 2px) / 3; }
+SCSS
+foo {
+  a: 1px + (2px * 3);
+  b: (1px - (2px)) / 3; }
+LESS
+  end
+
+  def test_unary_minus
+    assert_renders <<SCSS, <<LESS
+foo {
+  a: 1px + -3px; }
+SCSS
+foo {a: 1px + (- 3px)}
+LESS
+  end
+
+  # Nested Rules
+
+  def test_single_nested_rule
+    assert_renders <<SCSS, <<LESS
+foo bar {
+  a: b; }
+SCSS
+foo {bar {a: b}}
+LESS
+  end
+
+  def test_single_nested_rule_with_props
+    assert_renders <<SCSS, <<LESS
+foo {
+  bar {
+    a: b; }
+  c: d;
+  e: f; }
+SCSS
+foo {
+  bar {a: b}
+  c: d;
+  e: f; }
+LESS
+  end
+
+  def test_two_nested_rules
+    assert_renders <<SCSS, <<LESS
+foo {
+  bar {
+    a: b; }
+  baz {
+    c: d; } }
+SCSS
+foo {
+  bar {a: b}
+  baz {c: d} }
+LESS
+  end
+
+  def test_two_nested_rules_with_props
+    assert_renders <<SCSS, <<LESS
+foo {
+  bar {
+    a: b; }
+  baz {
+    c: d; }
+  e: f;
+  g: h; }
+SCSS
+foo {
+  bar {a: b}
+  baz {c: d}
+  e: f;
+  g: h; }
+LESS
+  end
+
+  def test_nested_rules_with_combinators
+    assert_renders <<SCSS, <<LESS
+foo {
+  > bar {
+    a: b; }
+  + baz {
+    c: d; } }
+SCSS
+foo {
+  > bar {a: b}
+  + baz {c: d} }
+LESS
+  end
+
+  def test_nested_pseudo_rules
+    assert_renders <<SCSS, <<LESS
+foo {
+  &:bar {
+    a: b; }
+  &::baz {
+    c: d; } }
+SCSS
+foo {
+  :bar {a: b}
+  ::baz {c: d} }
+LESS
+  end
+
+  # Mixins
+
+  def test_class_inheritance
+    assert_renders <<SCSS, <<LESS
+.foo {
+  a: b; }
+
+.bar {
+  @extend .foo; }
+SCSS
+.foo {a: b}
+.bar {.foo;}
+LESS
+  end
+
+  def test_multiple_class_inheritance
+    assert_renders <<SCSS, <<LESS
+.foo {
+  a: b; }
+
+.bar {
+  c: d; }
+
+.baz {
+  @extend .foo;
+  @extend .bar; }
+SCSS
+.foo {a: b}
+.bar {c: d}
+.baz {.foo, .bar;}
+LESS
+  end
+
+  def test_pseudoclass_inheritance
+    assert_renders <<SCSS, <<LESS
+:foo {
+  a: b; }
+
+:bar {
+  @extend :foo; }
+SCSS
+:foo {a: b}
+:bar {:foo;}
+LESS
+  end
+
+  def test_multiple_pseudoclass_inheritance
+    assert_renders <<SCSS, <<LESS
+:foo:bar {
+  a: b; }
+
+:baz {
+  @extend :foo:bar; }
+SCSS
+:foo:bar {a: b}
+:baz {:foo:bar;}
+LESS
+  end
+
+  def test_abstract_mixin
+    assert_renders <<SCSS, <<LESS
+@mixin foo {
+  a: b; }
+
+.bar {
+  @include foo; }
+SCSS
+.foo() {a: b}
+.bar {.foo;}
+LESS
+  end
+
+  def test_mixin_with_args
+    assert_renders <<SCSS, <<LESS
+@mixin foo($a: 2px, $b: red) {
+  a: $a; }
+
+.bar {
+  @include foo; }
+SCSS
+.foo(@a: 2px, @b: #f00) {a: @a}
+.bar {.foo;}
+LESS
+
+    assert_renders <<SCSS, <<LESS
+@mixin foo($a: 2px + 3px, $b: red) {
+  a: $a; }
+
+.bar {
+  @include foo(5px); }
+SCSS
+.foo(@a: 2px + 3px, @b: #f00) {a: @a}
+.bar {.foo(5px);}
+LESS
+  end
+
+  ## Disallowed Mixins
+
+  def test_nested_mixin
+    assert_warning(<<WARN) {assert_renders <<SCSS, <<LESS}
+WARNING: Sass doesn't support mixing in selector sequences.
+Replacing ".foo .bar" with "@extend .bar"
+WARN
+.foo .bar {
+  a: b; }
+
+.bar {
+  // .foo .bar;
+  @extend .bar; }
+SCSS
+.foo .bar {a: b}
+.bar {.foo .bar;}
+LESS
+  end
+
+  def test_child_selector_mixin
+    assert_warning(<<WARN) {assert_renders <<SCSS, <<LESS}
+WARNING: Sass doesn't support mixing in selector sequences.
+Replacing "> .bar" with "@extend .bar"
+WARN
+.foo > .bar {
+  a: b; }
+
+.bar {
+  // > .bar;
+  @extend .bar; }
+SCSS
+.foo > .bar {a: b}
+.bar {> .bar;}
+LESS
+  end
+
+  # Accessors
+
+  def test_property_accessor
+    assert_warning(<<WARN) {assert_renders <<SCSS, <<LESS}
+WARNING: Sass doesn't support attribute accessors.
+Ignoring .magic-box['content']
+WARN
+.magic-box {
+  content: "gold"; }
+
+.foo {
+  content: /* .magic-box['content'] */; }
+SCSS
+.magic-box {content: "gold"}
+.foo {content: .magic-box['content']}
+LESS
+  end
+
+  def test_variable_accessor
+    assert_warning(<<WARN) {assert_renders <<SCSS, <<LESS}
+WARNING: Sass doesn't support attribute accessors.
+Ignoring .magic-box[@content]
+WARN
+.magic-box {
+  $content: "gold";
+  content: $content; }
+
+.foo {
+  content: /* .magic-box[@content] */; }
+SCSS
+.magic-box {@content: "gold"; content: @content}
+.foo {content: .magic-box[@content]}
+LESS
+  end
+
+  private
+
+  def assert_renders(scss, less)
+    assert_equal(scss, Less::Engine.new(less).to_tree.to_sass_tree.to_scss)
+  end
+end
+
+rescue LoadError => e
+puts "\nCouldn't require less, skipping some tests."
+end

data/test/sass/templates/importee.less

@@ -0,0 +1,2 @@
+.foo    {a: b}
+.bar () {c: d}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 2.3.240
+  version: 2.3.241
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -69,9 +69,9 @@ files:
 - lib/haml/template.rb
 - lib/haml/shared.rb
 - lib/haml/util.rb
+- lib/haml/template/options.rb
 - lib/haml/template/patch.rb
 - lib/haml/template/plugin.rb
-- lib/haml/template/options.rb
 - lib/haml/version.rb
 - lib/haml/html/erb.rb
 - lib/haml/root.rb
@@ -137,6 +137,7 @@ files:
 - lib/sass/selector/sequence.rb
 - lib/sass/selector/simple.rb
 - lib/sass/selector/simple_sequence.rb
+- lib/sass/less.rb
 - vendor/fssm/LICENSE
 - vendor/fssm/README.markdown
 - vendor/fssm/Rakefile
@@ -312,10 +313,12 @@ files:
 - test/sass/templates/scss_importee.scss
 - test/sass/templates/warn.sass
 - test/sass/templates/warn_imported.sass
+- test/sass/templates/importee.less
 - test/sass/scss/css_test.rb
 - test/sass/scss/rx_test.rb
 - test/sass/scss/scss_test.rb
 - test/sass/scss/test_helper.rb
+- test/sass/less_conversion_test.rb
 - test/test_helper.rb
 - extra/haml-mode.el
 - extra/sass-mode.el
@@ -386,3 +389,4 @@ test_files:
 - test/sass/scss/css_test.rb
 - test/sass/scss/rx_test.rb
 - test/sass/scss/scss_test.rb
+- test/sass/less_conversion_test.rb