less_to_sass 0.1.0

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

@@ -0,0 +1,32 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the elements of a {SelectorNode}.
+      # These elements are usually separated by a
+      # {CombinatorNode}.
+      #
+      # No equivalent in Sass.
+      class ElementNode < Node
+        # @return [Tree::CombinatorNode]
+        attr_accessor :combinator
+        # @return [String]
+        attr_accessor :value
+        # @return [Integer]
+        attr_accessor :index
+        # @return [Hash]
+        attr_accessor :currentFileInfo
+
+        # @see Node#to_sass
+        def to_sass
+          if @value.is_a?(VariableNode)
+            @value.to_sass
+          elsif @value.is_a?(String)
+            @combinator.to_s + @value
+          else
+            raise FeatureConversionError, self
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the expression in the Less AST.
+      #
+      # Sass does not have an Expression node. It is usually
+      # represented as the `expr` member of the {::Sass::Tree::VariableNode},
+      # that represents a variable definition.
+      #
+      # The Sass equivalent is either {::Sass::Script::Value::Base}
+      # wrapped in {::Sass::Script::Tree::Literal} or {::Sass::Tree::Node}.
+      class ExpressionNode < Node
+        attr_accessor :value
+
+        # @return [::Sass::Script::Tree::Literal, ::Sass::Script::Tree::ListLiteral, ::Sass::Tree::Node]
+        # @see Node#to_sass
+        def to_sass
+          if @value.is_a?(Array)
+            # TODO: document solution of: method to_sass is invoked on "to right":String, deal with it
+            if is_multiword_keyword?
+              multiword_keyword_argument
+            elsif should_be_literal?
+              @value.inject([]) { |value, elem| value << elem.to_s }.join(' ')
+            else
+              elements = @value.inject([]) do |value, elem|
+                node = elem.to_sass
+                node = node(::Sass::Script::Tree::Literal.new(node), line) if node.is_a?(::Sass::Script::Value::Base)
+                value << node
+              end
+              node(::Sass::Script::Tree::ListLiteral.new(elements, :space), line)
+            end
+          else
+            value = @value.to_sass
+            return value unless value.is_a?(::Sass::Script::Value::Base)
+            node(::Sass::Script::Tree::Literal.new(value), line)
+          end
+        end
+
+        private
+
+        LITERAL_PROPERTIES = %w(font transition).freeze
+
+        # @todo: should be checked once more
+        def is_multiword_keyword?
+          @value.select { |elem| !elem.is_a?(KeywordNode) }.empty?
+        end
+
+        # Checks, whether the expression contains a {VariableNode}.
+        # Some properties in Less store their values as string literals
+        # instead of list literals.
+        #
+        # @return [Boolean] true if the expression should be converted
+        #                   to {::Sass::Script::Tree::Literal}
+        def should_be_literal?
+          grandparent = @parent.parent
+          return false unless grandparent.is_a?(RuleNode)
+          LITERAL_PROPERTIES.include?(grandparent.name.value) && !contains_variables?
+        end
+
+        # Creates a {::Sass::Script::Tree::ListLiteral} out of
+        # multiple keywords - usually referencing a complex CSS keyword.
+        #
+        # Example (`to right` is an example of multiword keyword):
+        #   `list-style-image: linear-gradient(to right, rgba(255,0,0,0), rgba(255,0,0,1));`
+        #
+        def multiword_keyword_argument
+          keywords = @value.inject([]) { |value, elem| value << elem.to_sass }
+          node(::Sass::Script::Tree::ListLiteral.new(keywords, :space), line)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Less2Sass
+  module Less
+    module Tree
+      class ExtendNode < Node
+        attr_accessor :selector
+        attr_accessor :option
+        attr_accessor :index
+        attr_accessor :object_id
+        attr_accessor :parent_ids
+        attr_accessor :currentFileInfo
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Less2Sass
+  module Less
+    module Tree
+      class ImportNode < Node
+        attr_accessor :options
+        attr_accessor :index
+        attr_accessor :path
+        attr_accessor :features
+        attr_accessor :currentFileInfo
+        attr_accessor :css
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the CSS property names and
+      # a little bit more.
+      #
+      # It can represent the name of a CSS rule,
+      # or it can be a part of a variable definition's
+      # value.
+      #
+      # In the latter case its Sass equivalents are:
+      #   - {::Sass::Script::Value::Bool}
+      #   - {::Sass::Script::Value::Null}
+      class KeywordNode < Node
+        attr_accessor :value
+
+        def to_s
+          @value.to_s
+        end
+
+        def empty?
+          @value.empty?
+        end
+
+        # Returns a SassScript Value node.
+        #
+        # Usually will be called in case of a variable
+        # definition and its parent node would be a
+        # {ExpressionNode}, which would wrap it up into a
+        # {::Sass::Script::Tree::Literal}.
+        #
+        # @raise FeatureConversionError if this node's value is not expected.
+        # @return [::Sass::Script::Value::Base]
+        # @see Node#to_sass
+        def to_sass
+          case @value
+          when 'true' then ::Sass::Script::Value::Bool.new(true)
+          when 'false' then ::Sass::Script::Value::Bool.new(false)
+          when 'null' then ::Sass::Script::Value::Null.new
+          else
+            raise FeatureConversionError, self unless @value.respond_to?(:to_s)
+            string = ::Sass::Script::Value::String.new(@value.to_s)
+            node(::Sass::Script::Tree::Literal.new(string), line)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Less2Sass
+  module Less
+    module Tree
+      class MediaNode < Node
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+        attr_accessor :features
+        attr_accessor :rules
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Less2Sass
+  module Less
+    module Tree
+      class MixinCallNode < Node
+        attr_accessor :selector
+        attr_accessor :arguments
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+        attr_accessor :important
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Less2Sass
+  module Less
+    module Tree
+      class MixinDefinitionNode < Node
+        attr_accessor :name
+        attr_accessor :selectors
+        attr_accessor :params
+        attr_accessor :condition
+        attr_accessor :variadic
+        attr_accessor :arity
+        attr_accessor :rules
+        attr_accessor :_lookups
+        attr_accessor :required
+        attr_accessor :optionalParameters
+        attr_accessor :frames
+
+        # @see Node#creates_environment?
+        def creates_environment?
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,212 @@
+require 'less2sass/less/environment'
+
+module Less2Sass
+  module Less
+    module Tree
+      # The base node class of the Less AST.
+      class Node
+        include Enumerable
+
+        # The parent node of this node.
+        #
+        # @return [Less2Sass::Less::Tree::Node]
+        attr_accessor :parent
+
+        # Whether or not this node has parent node.
+        #
+        # @return [Boolean]
+        attr_reader :has_parent
+
+        # The child nodes of this node.
+        #
+        # @return [Array<Less2Sass::Less::Tree::Node>]
+        attr_accessor :children
+
+        # Whether or not this node has child nodes.
+        #
+        # @return [Boolean]
+        attr_reader :has_children
+
+        # Sets the line number of the node
+        #
+        # @return [Void]
+        attr_writer :line
+
+        # This member gets set if the node's children contain
+        # referenced {VariableNode}s.
+        #
+        # @return [Array<String>] referenced variable names
+        attr_accessor :ref_vars
+
+        # The environment, where the nodes sits lexically.
+        # TODO: Consider to set a reference to the lexical scope (the environment) of the node.
+        # @return [Less2Sass::Less::Environment]
+        # attr_reader :env
+
+        # The current line number the conversion process is at
+        @@lines = 0
+
+        def initialize(parent)
+          @children = []
+          @parent = parent
+          @creates_new_line = false
+        end
+
+        # @private
+        def parent=(parent)
+          @has_parent ||= !parent.nil?
+          @parent = parent
+        end
+
+        # @private
+        def children=(children)
+          @has_children ||= !children.empty?
+          @children = children
+        end
+
+        # @private
+        def ref_vars
+          @ref_vars || get_referenced_variable_names
+        end
+
+        # Tells, whether the node creates a new context
+        # or variable environment.
+        #
+        # @return [Boolean]
+        def creates_context?
+          false
+        end
+
+        # Appends a child to the node.
+        #
+        # @param [Less2Sass::Less::Tree::Node, Array<Less2Sass::Less::Tree::Node>] child
+        #   The child node or nodes
+        def <<(child)
+          return if child.nil?
+          if child.is_a?(Array)
+            child.each { |c| self << c }
+          else
+            @has_children = true
+            child.parent = self
+            @children << child
+          end
+        end
+
+        # Compares this node and another object (only other {Less2Sass::Less::Tree::Node}s will be equal).
+        #
+        # @param [Object] other The object to compare with
+        # @return [Boolean] Whether or not this node and the other object
+        #   are the same
+        def ==(other)
+          self.class == other.class && other.children == children
+        end
+
+        # Iterates through each node in the tree rooted at this node
+        # in a pre-order walk.
+        #
+        # @yield node
+        # @yieldparam node [Less2Sass::Less::Tree::Node] a node in the tree
+        def each
+          yield self
+          children.each { |c| c.each { |n| yield n } }
+        end
+
+        # The base implementation of transform.
+        #
+        # Transforms the tree by its traversal. Each respective node type
+        # should implement the specific transformation and calling `#super`.
+        # The position, where `#super` is called determines the walking order.
+        # The standard should be post-order walk - transforming the child nodes
+        # first and self as last.
+        #
+        # Should be overridden by subclasses adding specific implementation.
+        #
+        # @param [Less2Sass::Less::Environment] env parent environment
+        # @return [Void]
+        def transform(env = nil)
+          #   TODO: Consider to set a reference to the lexical scope (the environment) of the node.
+          #   @env = env
+          @children.each { |c| c.transform(env) }
+        end
+
+        # Returns the line number and sets the class level
+        # current line number based on the passed option.
+        #
+        # @param [Symbol] opt the line number option
+        # @option opt [Symbol] :new tells the method to
+        #   return the next line and increments @@lines
+        # @option opt [Symbol] :current tells the method to
+        #   return the current line the converter is "processing"
+        #
+        # @return [Fixnum] the line number based on the given option
+        def line(opt = :current)
+          case opt
+          when :current
+            @@lines
+          when :new
+            @@lines = @@lines.next
+          else
+            raise StandardError, "Option can't be other than :current or :new"
+          end
+        end
+
+        # Converts this node to the equivalent Sass node
+        #
+        # Should be overwritten by subclasses.
+        # All subclasses should also set the line number
+        # of the resulting Sass node.
+        #
+        # @raise NotImplementedError if called on the base node object
+        #   or subclass method not implemented, yet.
+        def to_sass
+          raise NotImplementedError
+        end
+
+        # Loops through the children nodes and
+        # searches for variable occurrences.
+        #
+        # @return [Array<String>] list of variable names
+        #   contained in the value's expressions
+        # @note Use on {Less2Sass::Less::Tree::RuleNode}s. It's a good practice
+        #   to check first if it's a variable definition.
+        #   See (Less2Sass::Less::Tree::RuleNode#is_variable_definition?)
+        def get_referenced_variable_names
+          if is_a?(VariableNode)
+            [@name]
+          else
+            @children.inject([]) { |vars, c| vars + c.get_referenced_variable_names }
+          end
+        end
+
+        # Checks, whether a variable is referenced in the scope of the node.
+        #
+        # @return [Boolean]
+        def contains_variables?
+          variables = nil
+          each do |child|
+            if child.is_a?(VariableNode)
+              variables = true
+              break
+            end
+          end
+          variables
+        end
+
+        protected
+
+        # Sets up a node with the mandatory options (line, options).
+        #
+        # @param [::Sass::Tree::Node, ::Sass::Script::Tree::Node] node
+        #   the node to be set up
+        # @param [Fixnum] line the line number, where the node sits lexically
+        # @param [Hash] options the options to pass to the node
+        # @return [::Sass::Tree::Node, ::Sass::Script::Tree::Node] the set up node
+        def node(node, line, options = { :style => :nested })
+          node.line = line if line
+          node.options = options if node.class.method_defined?(:options=)
+          node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Node representing the operation with 2 operands.
+      #
+      # Converts to {::Sass::Script::Tree::Operation}.
+      class OperationNode < Node
+        attr_accessor :op
+        attr_accessor :operands
+        attr_accessor :isSpaced
+
+        def to_s
+          @operands[0].to_s + @op + @operands[1].to_s
+        end
+
+        # @see Node#to_sass
+        def to_sass
+          node(::Sass::Script::Tree::Operation.new(@operands[0].to_sass, @operands[1].to_sass, sass_operator), line)
+        end
+
+        # A hash from operator strings to the corresponding token types.
+        #
+        # Copied from Sass' lexer
+        # @see https://github.com/sass/sass/blob/stable/lib/sass/script/lexer.rb#L44-L69
+        OPERATORS = {
+          '+' => :plus,
+          '-' => :minus,
+          '*' => :times,
+          '/' => :div,
+          '%' => :mod,
+          '=' => :single_eq,
+          ':' => :colon,
+          '(' => :lparen,
+          ')' => :rparen,
+          ',' => :comma,
+          'and' => :and,
+          'or' => :or,
+          'not' => :not,
+          '==' => :eq,
+          '!=' => :neq,
+          '>=' => :gte,
+          '<=' => :lte,
+          '>' => :gt,
+          '<' => :lt,
+          '#{' => :begin_interpolation,
+          '}' => :end_interpolation,
+          ';' => :semicolon,
+          '{' => :lcurly,
+          '...' => :splat
+        }.freeze
+
+        # Returns the sass operator symbol, that is used internally.
+        #
+        # @param [String] op the operator to look for
+        # @return [Symbol] the operator symbol
+        def sass_operator(op = @op)
+          raise Less2Sass::OperatorConversionError, op unless OPERATORS[op]
+          OPERATORS[op]
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,64 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents a single or double-quoted string in Less.
+      #
+      # The Sass equivalent is a {::Sass::Script::Value::String}
+      # wrapped in {::Sass::Script::Tree::Literal}.
+      class QuotedNode < Node
+        attr_accessor :escaped
+        attr_accessor :value
+        attr_accessor :quote
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+
+        # Returns the Sass equivalent for a quoted string.
+        #
+        # @return [::Sass::Script::Tree::Literal] simple string literal
+        # @return [::Sass::Script::Tree::StringInterpolation] interpolation node,
+        #   if the string contains interpolations
+        # @see Node#to_sass
+        def to_sass
+          if string_interpolation?
+            interpolation_node(@value)
+          else
+            node(::Sass::Script::Tree::Literal.new(::Sass::Script::Value::String.new(@value, :string)), line)
+          end
+        end
+
+        # Returns the string's raw value without passing the type of quote.
+        #
+        # Sass has its own standards regarding the quotes, it should be in
+        # Sass' competences to choose what type of quote to use.
+        def to_s
+          @value
+        end
+
+        # Checks, whether the quoted string contains an interpolation.
+        #
+        # @return [Boolean]
+        def string_interpolation?(value = @value)
+          !value.index(INTERPOLATION).nil?
+        end
+
+        private
+
+        INTERPOLATION = /(@\{[\w_-]*\})/
+        VARIABLE_NAME = /@\{([\w_-]*)\}/
+
+        # Creates a {::Sass::Script::Tree::StringInterpolation} node.
+        #
+        # @param [String] value the string containing interpolation(s)
+        # @return [::Sass::Script::Tree::StringInterpolation] the interpolation node
+        def interpolation_node(value)
+          parts = value.split(INTERPOLATION, 2) # Must be split maximally into 3 parts
+          parts[2] = '' if parts.length == 2 # Always must have 3 parts
+          before = node(::Sass::Script::Tree::Literal.new(::Sass::Script::Value::String.new(parts[0], :string)), line)
+          mid = node(::Sass::Script::Tree::Variable.new(parts[1].match(VARIABLE_NAME)[1]), line)
+          after = string_interpolation?(parts[2]) ? interpolation_node(parts[2]) : node(::Sass::Script::Tree::Literal.new(::Sass::Script::Value::String.new(parts[2], :string)), line)
+          node(::Sass::Script::Tree::StringInterpolation.new(before, mid, after), line)
+        end
+      end
+    end
+  end
+end