less_to_sass 0.1.0

data/lib/less2sass/less/environment.rb

@@ -0,0 +1,212 @@
+module Less2Sass
+  module Less
+    # The lexical environment for Less.
+    # Keeps track of variable and mixin definitions.
+    # The environment differentiates between simple
+    # and constructed(dynamic) variable definitions.
+    #
+    # A new environment is created for each level of Less nesting.
+    # This allows variables to be lexically scoped.
+    # Each environment refers to the environment in the upper scope,
+    # unless it is the global environment, thus having access to
+    # variables defined in enclosing scopes. New variables are defined
+    # locally.
+    class Environment
+      # The enclosing environment, or nil if it's the
+      # global environment.
+      #
+      # @return [Less2Sass::Less::Environment]
+      attr_reader :parent
+
+      # Ordered list of static variable definitions.
+      # Examples:
+      #   - @var: 50px;
+      #
+      # @return [Array<Less2Sass::Less::Tree::RuleNode>]
+      attr_reader :static_var_def_rules
+
+      # Ordered list of constructed variable definitions.
+      # Examples:
+      #   - @var: @var2;
+      #   - @var1: @var2 + 10px;
+      #
+      # @return [Array<Less2Sass::Less::Tree::RuleNode>]
+      attr_reader :dynamic_var_def_rules
+
+      # A list of mixin calls.
+      #
+      # @return [Array<Less2Sass::Less::Tree::RuleNode>]
+      attr_reader :mixin_call_rules
+
+      # @param parent (see :parent)
+      def initialize(parent = nil)
+        @parent = parent
+        @variables_to_reorder = {}
+        @static_var_def_rules = {}
+        @dynamic_var_def_rules = []
+        @rules = []
+        @rest = []
+        @mixin_call_rules = []
+      end
+
+      # Places an array of nodes into this environment.
+      #
+      # @param [Array<Less2Sass::Less::Tree::Node>] objs
+      #   child nodes of a context creator node
+      # @see #put
+      def set_environment(objs)
+        objs.each { |obj| set(obj) }
+      end
+
+      # Builds the `dynamic_var_def_rules` ordered array.
+      #
+      # Processes lazy loaded variables by importing their definition
+      # if they are overridden of this environment's scope. Furthermore,
+      # it reorders the variable definitions.
+      # The only rule is, that the referenced variables should be
+      # placed before their first referral. If no variable definition
+      # references the the current iteration's variable, it shall be
+      # put at the end of the array, since it could reference any of the
+      # previously defined variables.
+      #
+      # @note does not detect recursive variable definitions
+      # @return [void]
+      # @todo implement detection in future releases
+      def build
+        process_lazy_loading
+        to_reorder = @variables_to_reorder.values
+        unless to_reorder.empty?
+          @dynamic_var_def_rules << to_reorder.shift
+          to_reorder.each do |var|
+            @dynamic_var_def_rules.each_with_index do |o_var, index|
+              if o_var.references?(var.name)
+                @dynamic_var_def_rules.insert(index, var)
+                break
+              end
+              @dynamic_var_def_rules.insert(index + 1, var) if @dynamic_var_def_rules.last.eql?(o_var)
+            end
+          end
+        end
+      end
+
+      # Reorders the child nodes of another node, that creates an
+      # environment, resp. an execution context.
+      #
+      # The order should be:
+      #
+      #   1. Simple/static variables
+      #   These do not reference any other variable(s) in their definition.
+      #
+      #   2. Complex/dynamic variables
+      #   These can reference either the static variables in the same context,
+      #   other variables from the outer environment, or each other without any
+      #   cross-reference, also known as recursive reference.
+      #
+      #   TODO: maybe directives should be also sorted out and put before the mixin calls
+      #   3. Other nodes (directives, rules, rule sets, etc.)
+      #
+      #   4. Rules (selector + declarations)
+      #   The Sass rules (Less rule sets) create a new environment and could redefine
+      #   the variables' used after their declaration.
+      #
+      #   5. Mixin calls
+      #   These mixins can reference the rule sets created one step above.
+      #
+      # @return [Array<Less2Sass::Less::Tree::Node>] the reordered list of nodes
+      def get_ordered_child_nodes
+        @static_var_def_rules.values + @dynamic_var_def_rules + @rest + @rules + @mixin_call_rules
+      end
+
+      def variable_defined?(name)
+        @static_var_def_rules[name] || @variables_to_reorder[name]
+      end
+
+      def find_variable_definition_if_dynamic(name)
+        variable = @variables_to_reorder[name]
+        return variable if variable
+        @parent ? @parent.find_variable_definition_if_dynamic(name) : nil
+      end
+
+      private
+
+      # Puts the nodes of this environment's scope into
+      # the appropriate container.
+      #
+      # Sorts out the variable definitions and mixin calls
+      # from the rest. The variable definitions are saved
+      # into hashes under their names as keys. If a variable
+      # is defined multiple times, only the last definition
+      # will be kept.
+      #
+      # @param [Less2Sass::Less::Tree::Node] obj
+      #   the rule to be placed into the environment
+      # @return [void]
+      def set(obj)
+        if obj.is_a?(Less2Sass::Less::Tree::RulesetNode)
+          @rules << obj
+        elsif obj.is_a?(Less2Sass::Less::Tree::RuleNode)
+          if obj.is_variable_definition?
+            referenced_vars = obj.get_referenced_variable_names
+            if referenced_vars.empty?
+              @static_var_def_rules[obj.name] = obj
+            else
+              obj.ref_vars = referenced_vars
+              @variables_to_reorder[obj.name] = obj
+            end
+          else
+            @rest << obj
+          end
+        elsif obj.is_a?(Less2Sass::Less::Tree::MixinCallNode)
+          @mixin_call_rules << obj
+        elsif obj.is_a?(Less2Sass::Less::Tree::SelectorNode)
+          return # ignore selectors
+        else
+          @rest << obj
+        end
+      end
+
+      # Processes lazy loaded variables by importing their definition
+      # if they are overridden of this environment's scope.
+      #
+      # Imports all those variable definitions, whose
+      # members are overridden by the variable definitions
+      # of the current scope.
+      #
+      # @return [Void]
+      def process_lazy_loading
+        rules_to_check = @dynamic_var_def_rules + @rules + @rest + @mixin_call_rules
+        rules_to_check.each do |rule|
+          rules_to_check += [rule.selectors].flatten if rule.is_a?(Less2Sass::Less::Tree::RulesetNode)
+          rule.ref_vars.each do |variable|
+            import_definitions_of(variable)
+          end unless rule.creates_context?
+        end
+      end
+
+      # Imports the appropriate variable definitions
+      # into the current scope.
+      #
+      # Those definitions will be imported, that contain a
+      # reference to a variable, that is redefined in
+      # the current scope. If such a variable is not redefined,
+      # its definition is looked for such a variable.
+      # The process continues recursively just like the process
+      # of lazy loading.
+      #
+      # @param [String] name the variable's name
+      # @return [Void]
+      def import_definitions_of(name)
+        if @parent
+          definition = @parent.find_variable_definition_if_dynamic(name)
+          definition.ref_vars.each do |var|
+            if variable_defined?(var)
+              @variables_to_reorder[definition.name] = definition unless @variables_to_reorder[definition.name]
+            else
+              import_definitions_of(var)
+            end
+          end if definition
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/parser.rb

@@ -0,0 +1,131 @@
+require 'less2sass/less/tree'
+require 'json'
+
+module Less2Sass
+  module Less
+    # The parser for Less.
+    # It parses a Less project into a tree of {Less2Sass::Less::Tree::Node}s.
+    # The project is meant as one or more files.
+    class Parser
+      # @param [File, IO] input The source project to parse.
+      def initialize(input)
+        @input = input
+        @options = input == $stdin ? "-stdin \"#{Util.read_stdin_as_multiline_arg}\"" : File.expand_path(input)
+      end
+
+      # Checks, whether the Less project can be compiled.
+      #
+      # @return [void]
+      # @raise [Less2Sass::LessCompilationError] if the project can't be compiled.
+      def check_syntax
+        response = `lessc --lint #{File.expand_path(@input)} 2>&1 >/dev/null`
+        raise LessCompilationError, response unless response.empty?
+      end
+
+      # Parses a Less project.
+      #
+      # @return [Less2Sass::Less::Tree::Node] The root node of the project tree
+      # @raise [Less2Sass::LessSyntaxError] if there's a syntax error in the document
+      # @raise [Less2Sass::LessImportNotFoundError] if any of the imports can't be found
+      def parse
+        string_ast = `node #{Util.scope(PARSER)} #{@options}`
+        json_ast = JSON.parse(string_ast)
+        if json_ast['class'] == 'error'
+          raise LessImportNotFoundError, json_ast if json_ast['type'] == 'File'
+          raise LessSyntaxError, json_ast if json_ast['type'] == 'Parse'
+        end
+        build_tree(json_ast)
+      end
+
+      # Converts the parsed Less project from JSON object
+      # to a {Less2Sass::Less::Tree::Node} representation.
+      #
+      # Note, that this method recursively calls itself.
+      #
+      # @param [Hash] json the JSON object representing the Less AST
+      # @param [Less2Sass::Less::Tree::Node] parent the respective parent node
+      #   of the currently processed node.
+      # @return [Less2Sass::Less::Tree::Node] The root node of the project tree
+      # @raise [Less2Sass::LessASTParserError] if something unexpected happens.
+      def build_tree(json, parent = nil)
+        node = create_node(json['class'], parent)
+
+        json.each do |k, v|
+          key = instance_var_sym(k)
+
+          if v.is_a?(Hash)
+            # Is the hash a node, or a simple value?
+            if node?(v)
+              # The node should be referenced under the original key, as well as
+              # in the child nodes, so it's easier to handle conversion
+              # and still be able to traverse the full tree. Since these would be
+              # the same objects, the changes made during the transformation
+              # process would be reflected at both places.
+              subnode = build_tree(v, node)
+              node.instance_variable_set(key, subnode)
+              node << subnode
+            else
+              node.instance_variable_set(key, v)
+            end
+          elsif v.is_a?(Array)
+            if node?(v[0])
+              # It's an array of nodes
+              subnodes = []
+              v.each do |item|
+                # Something is very wrong if the item is not another node
+                raise LessASTParserError, item.class.to_s unless node?(item)
+                subnode = build_tree(item, node)
+                subnodes << subnode
+                node << subnode
+              end
+              value = subnodes.length == 1 ? subnodes[0] : subnodes
+              node.instance_variable_set(key, value)
+            else
+              # It's a simple array containing other values than nodes
+              node.instance_variable_set(key, v)
+            end
+          else
+            # Simple key-value pair
+            next if k == 'class'
+            node.instance_variable_set(key, v)
+          end
+        end
+
+        node
+      end
+
+      private
+
+      PARSER = 'lib/less2sass/js/less_parser.js'.freeze
+
+      # Creates the node in a Ruby object-like representation.
+      #
+      # @param [String] class_name the classname of the node to be created
+      # @param [Less2Sass::Less::Tree::Node] parent the parent node of the one
+      #   currently being created
+      # @return [Less2Sass::Less::Tree::Node] an AST node
+      def create_node(class_name, parent)
+        Tree.const_get(class_name.to_s + 'Node')
+            .new(parent)
+      end
+
+      # Creates a symbol as reference to a member object,
+      # so it can be set dynamically.
+      #
+      # @param [String] key the string representation
+      #   of an object's member
+      # @return [Symbol] the symbolic reference to an object's member
+      def instance_var_sym(key)
+        "@#{key}".to_sym
+      end
+
+      def node?(json)
+        json.is_a?(Hash) && json.key?('class')
+      end
+
+      def hash_value?(hash)
+        !hash.key?('class')
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/alpha_node.rb

@@ -0,0 +1,9 @@
+module Less2Sass
+  module Less
+    module Tree
+      class AlphaNode < Node
+        attr_accessor :value
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/anonymous_node.rb

@@ -0,0 +1,43 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents a CSS literal in Less.
+      #
+      # Its Sass equivalent is {::Sass::Script::Value::Base}
+      # wrapped in {::Sass::Script::Tree::Literal}.
+      class AnonymousNode < Node
+        attr_accessor :value
+        attr_accessor :index
+        attr_accessor :mapLines
+        attr_accessor :currentFileInfo
+        attr_accessor :rulesetLike
+
+        # Converts to a {::Sass::Script::Tree::Literal} that
+        # encapsulates a {::Sass::Script::Value::Base}.
+        #
+        # @note Never seen a different equivalent than String
+        #   or a Number but can't be sure.
+        # @raise FeatureConversionError if `@value` not a String
+        #   or a Numeric.
+        # @return [::Sass::Script::Tree::Literal]
+        # @see Node#to_sass
+        def to_sass
+          subnode ||=
+            begin
+              if @value.is_a?(String)
+                # Always an :identifier - the default value of the 2nd param
+                ::Sass::Script::Value::String.new(@value)
+              elsif @value.is_a?(Numeric)
+                # Anonymous nodes do not have a numerator nor a denominator
+                ::Sass::Script::Value::Number.new(@value)
+              else
+                raise FeatureConversionError, self
+              end
+            end
+          return subnode if subnode.is_a?(::Sass::Script::Tree::Literal)
+          node(::Sass::Script::Tree::Literal.new(subnode), line)
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/assignment_node.rb

@@ -0,0 +1,10 @@
+module Less2Sass
+  module Less
+    module Tree
+      class AssignmentNode < Node
+        attr_accessor :key
+        attr_accessor :value
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/attribute_node.rb

@@ -0,0 +1,11 @@
+module Less2Sass
+  module Less
+    module Tree
+      class AttributeNode < Node
+        attr_accessor :key
+        attr_accessor :op
+        attr_accessor :value
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/call_node.rb

@@ -0,0 +1,65 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents a function call node. It can be either
+      # a CSS or a Less built-in function.
+      #
+      # Its Sass equivalent is {::Sass::Script::Tree::Funcall}.
+      class CallNode < Node
+        attr_accessor :name
+        attr_accessor :args
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+
+        # TODO: Map Less built-in functions to Sass built-in functions, null if there is no equivalent
+
+        MISC_FUNCTIONS = %w(color image-size image-width image-height
+                            convert data-uri default unit get-unit svg-gradient).freeze
+
+        STRING_FUNCTIONS = %w(escape e % replace).freeze
+
+        LIST_FUNCTIONS = %w(length extract).freeze
+
+        MATH_FUNCTIONS = %w(ceil floor percentage round sqrt abs sin
+                            asin cos acos tan atan pi pow mod min max).freeze
+
+        TYPE_FUNCTIONS = %w(isnumber isstring iscolor iskeyword isurl
+                            ispixel isem ispercentage isunit isruleset).freeze
+
+        COLOR_DEFINITION_FUNCTIONS = %w(rgb rgba argb hsl hsla hsv hsva).freeze
+
+        COLOR_CHANNEL_FUNCTIONS = %w(hue saturation lightness hsvhue hsvsaturation
+                                     hsvvalue red green blue alpha luma luminance).freeze
+
+        COLOR_OPERATION_FUNCTIONS = %w(saturate desaturate lighten darken fadein
+                                       fadeout fade spin mix tint shade greyscale contrast).freeze
+
+        COLOR_BLENDING_FUNCTIONS = %w(multiply screen overlay softlight hardlight
+                                      difference exclusion average negation).freeze
+
+        # @todo built-in functions should be converted by the mapping
+        #   if there is no equivalent, a custom conversion should be implemented.
+        #   If the {Hash} does not contain the function, most probably, it's a
+        #   CSS built-in function and it should be copied as it is.
+        #
+        # @note In its current version it could output unrecognizable functions
+        #   by the Sass compiler and/or interpreter.
+        # @return [::Sass::Script::Tree::Funcall]
+        # @see Node#to_sass
+        def to_sass
+          node(::Sass::Script::Tree::Funcall.new(@name, get_args, ::Sass::Util::NormalizedMap.new, nil, nil), line)
+        end
+
+        private
+
+        def get_args
+          if @args.is_a?(Array)
+            @args.inject([]) { |args, arg| args << arg.to_sass }.flatten
+          else
+            [@args.to_sass]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/color_node.rb

@@ -0,0 +1,27 @@
+module Less2Sass
+  module Less
+    module Tree
+      # CSS color representation.
+      #
+      # Usually appears at variable definitions.
+      # Example:
+      #   - `@color: #fff;` rule contains ColorNode
+      #   - `color: #fff;` property declaration does
+      #     not contain ColorNode
+      #
+      # The Sass equivalent is {::Sass::Script::Value::Color}.
+      class ColorNode < Node
+        attr_accessor :rgb
+        attr_accessor :alpha
+        attr_accessor :value
+
+        # @return [::Sass::Script::Value::Color]
+        # @see Node#to_sass
+        def to_sass
+          color = node(::Sass::Script::Value::Color.new(@rgb, @value), nil)
+          node(::Sass::Script::Tree::Literal.new(color), line)
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/combinator_node.rb

@@ -0,0 +1,18 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the separator between some nodes.
+      # No equivalent in Sass.
+      class CombinatorNode < Node
+        # @return [String]
+        attr_accessor :value
+        # @return [Boolean]
+        attr_accessor :emptyOrWhitespace
+
+        def to_s
+          @value
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/comment_node.rb

@@ -0,0 +1,58 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents either a single-line or a block comment
+      # Unfortunately, there is no way to find out, whether
+      # the comment has been put on a new line or it just
+      # continues on the same line as a rule, for instance.
+      #
+      # Examples:
+      #   color: #fff; //line comment
+      #   or
+      #   color: #fff;
+      #   //line comment
+      #
+      # The AST will be absolutely identical in both cases.
+      # So let's come up with a convention:
+      #   - line comments will be put on the same line as
+      #     the previous node
+      #   - block comments will be put on new lines
+      class CommentNode < Node
+        attr_accessor :value
+        attr_accessor :isLineComment
+        attr_accessor :currentFileInfo
+
+        def to_sass
+          line = line(@isLineComment ? :current : :new)
+          node(::Sass::Tree::CommentNode.new([@value], type), line)
+        end
+
+        private
+
+        # Specifies the type of the comment.
+        #
+        # There are 3 types of comments in Sass:
+        #   - :normal (output to CSS except in :compressed mode)
+        #   - :silent (never output to CSS)
+        #   - :loud (output to CSS even in :compressed mode)
+        #
+        # To evaluate the type correctly, the original implementation
+        # needs to be used.
+        # @see https://github.com/sass/sass/blob/63586f1e51c0aec47a7afcc8cd17aa03f32f0a29/lib/sass/engine.rb#L764-765
+        #
+        # @return [Symbol] the type of Sass comment
+        def type
+          silent = @value[1] == ::Sass::Engine::SASS_COMMENT_CHAR
+          loud = !silent && @value[2] == ::Sass::Engine::SASS_LOUD_COMMENT_CHAR
+          if silent
+            :silent
+          elsif loud
+            :loud
+          else
+            :normal
+          end
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/condition_node.rb

@@ -0,0 +1,13 @@
+module Less2Sass
+  module Less
+    module Tree
+      class ConditionNode < Node
+        attr_accessor :op
+        attr_accessor :lvalue
+        attr_accessor :rvalue
+        attr_accessor :index
+        attr_accessor :negate
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/detached_ruleset_node.rb

@@ -0,0 +1,10 @@
+module Less2Sass
+  module Less
+    module Tree
+      class DetachedRulesetNode < Node
+        attr_accessor :ruleset
+        attr_accessor :frames
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/dimension_node.rb

@@ -0,0 +1,26 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Representation of a number and a unit.
+      # The Sass equivalent is the {::Sass::Script::Value::Number}
+      # or {::Sass::Script::Tree::Literal} if the dimension is a part
+      # of an {ExpressionNode}'s {OperationNode}.
+      class DimensionNode < Node
+        attr_accessor :value
+        attr_accessor :unit
+
+        # @see Node#to_sass
+        def to_sass
+          numerator = @unit.is_a?(UnitNode) ? @unit.numerator : @unit['numerator']
+          denominator = @unit.is_a?(UnitNode) ? @unit.denominator : @unit['denominator']
+          dimension = ::Sass::Script::Value::Number.new(@value, numerator, denominator)
+          node(::Sass::Script::Tree::Literal.new(dimension), line)
+        end
+
+        def to_s
+          @value.to_s + @unit.to_s
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree/directive_node.rb

@@ -0,0 +1,40 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents a static CSS directive.
+      #
+      # Examples:
+      #   - @charset
+      #   - @namespace
+      #   - @keyframes
+      #   - @counter-style
+      #   - @document
+      #   - @supports
+      #
+      # The Sass equivalent is {::Sass::Tree::DirectiveNode}.
+      # @note Sits on a new line.
+      # @see Node
+      class DirectiveNode < Node
+        attr_accessor :name
+        attr_accessor :value
+        attr_accessor :rules
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+        attr_accessor :debugInfo
+        attr_accessor :isRooted
+
+        # @return [::Sass::Tree::DirectiveNode]
+        # @see Node#to_sass
+        def to_sass
+          node = node(::Sass::Tree::DirectiveNode.new(value), line(:new))
+          @rules.rules.each { |c| node << c.to_sass } # Not all children should be passed
+          node
+        end
+
+        def value
+          @value.empty? ? [@name] : [@name + ' ', @value.to_s]
+        end
+      end
+    end
+  end
+end