less_to_sass 0.1.0

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

@@ -0,0 +1,119 @@
+module Less2Sass
+  module Less
+    module Tree
+      # A RuleNode in Less can be a CSS rule, or a
+      # variable definition.
+      #
+      # Examples:
+      #   - color: @var;
+      #   - @var: 50px;
+      #
+      # The Sass equivalent is {::Sass::Tree::VariableNode}
+      # or {::Sass::Tree::RuleNode}.
+      class RuleNode < Node
+        attr_accessor :name
+        attr_accessor :value
+        attr_accessor :important
+        attr_accessor :merge
+        attr_accessor :index
+        attr_accessor :currentFileInfo
+        attr_accessor :inline
+        attr_accessor :variable
+
+        attr_accessor :guarded
+        attr_accessor :global
+
+        # @see VariableNode#sass_name
+        def sass_name
+          @name[1..-1] if @name
+        end
+
+        # Returns whether the node is a variable definition.
+        #
+        # @return [Boolean]
+        def is_variable_definition?
+          @variable
+        end
+
+        # Checks, if the given variable is referenced by the variable's definition
+        #
+        # @param [Less2Sass::Less::Tree:RuleNode] variable the variable
+        # @param [String] variable the variable's name
+        # @return [Boolean]
+        def references?(variable)
+          if variable.is_a?(String)
+            @ref_vars.include?(variable)
+          else
+            @ref_vars.include?(variable.name)
+          end
+        end
+
+        # Converts this node to {::Sass::Tree::VariableNode}, if
+        # it's a variable definition. Otherwise it must be a CSS
+        # property declaration and gets converted to {::Sass::Tree::PropNode}.
+        #
+        # The 3rd param of `::Sass::Tree::PropNode` refers to the CSS
+        # syntax to be outputted. Its value can be:
+        #   - `:new` using `a: b`-style syntax
+        #   - `:old` using `:a b`-style syntax
+        #
+        # For the sake of simplicity, we'll use the new syntax only.
+        # Later could be set in cli arguments as option.
+        #
+        # @note Always put on a new line.
+        # @return [::Sass::Tree::VariableNode, ::Sass::Tree::PropNode]
+        # @see Node#to_sass
+        def to_sass
+          node ||=
+            begin
+              if is_variable_definition?
+                ::Sass::Tree::VariableNode.new(
+                  sass_name, @value.to_sass, @guarded, @global
+                )
+              else
+                # TODO: Don't forget about the `#{}`
+                ::Sass::Tree::PropNode.new(
+                  process_property_name, @value.to_sass, :new
+                )
+              end
+            end
+          node(node, line(:new))
+        end
+
+        private
+
+        # Creates the Sass representation of the property name.
+        #
+        # @return [Array<String, ::Sass::Script::Tree::Node>]
+        def process_property_name
+          return [create_name] unless @name.is_a?(Array)
+          @name.inject([]) do |name, part|
+            name << create_name(part)
+          end
+        end
+
+        # Returns a part of the property name.
+        #
+        # @param [VariableNode, #to_s] name part of the property name
+        # @return [String, ::Sass::Script::Tree::Node] converted
+        #   part of property name
+        def create_name(name = @name)
+          if name.is_a?(VariableNode)
+            create_interpolation(name)
+          else
+            name.to_s
+          end
+        end
+
+        # Creates a Sass interpolation node
+        #
+        # @param [VariableNode] variable_node the variable node to convert
+        # @return [::Sass::Script::Tree::Interpolation] a Sass Interpolation node
+        def create_interpolation(variable_node)
+          var = ::Sass::Script::Tree::Variable.new(variable_node.name[1..-1])
+          node(::Sass::Script::Tree::Interpolation.new(nil, var, nil, false, false), line)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,82 @@
+module Less2Sass
+  module Less
+    module Tree
+      # The Ruleset node is the root node of every Less AST.
+      # It also means a block of selector and its inner rules.
+      #
+      # Its Sass equivalent is a {::Sass::Tree::RootNode}, or
+      # {::Sass::Tree::RuleNode}.
+      class RulesetNode < Node
+        attr_accessor :selectors, :rules, :_lookups,
+                      :root, :firstRoot, :strictImports
+
+        def initialize(options = nil)
+          super
+          @options = options unless options.nil?
+        end
+
+        # @see Node#creates_context?
+        def creates_context?
+          true
+        end
+
+        # Transforms the ruleset node by reordering the child nodes.
+        #
+        #   1. Creates a new environment and puts the child
+        #      nodes into it.
+        #
+        #   2. Further traverses the tree of nodes and transforms them, as well.
+        #
+        #   3. Saves the re-ordered rules and child nodes.
+        #
+        # @param (see Node#transform)
+        # @return [Void]
+        def transform(env = nil)
+          env = Less2Sass::Less::Environment.new(env)
+          env.set_environment(@children)
+          env.build
+          super(env)
+          @rules = env.get_ordered_child_nodes
+          @children = @rules
+        end
+
+        # Converts node to {::Sass::Tree::RootNode} if it's root.
+        # Otherwise it converts to {::Sass::Tree::RuleNode}.
+        #
+        # In case of root node, all the children nodes have to be
+        # converted. Otherwise rule nodes only.
+        #
+        # @note I both cases the node is placed on a new line.
+        # @return [::Sass::Tree::RootNode, ::Sass::Tree::RuleNode]
+        # @see Node#to_sass
+        def to_sass(options = nil)
+          if @root
+            node = node(::Sass::Engine.new('', options).to_tree, line(:new))
+            children = @children
+          else
+            node = node(::Sass::Tree::RuleNode.new(get_full_selector), line(:new))
+            children = @rules.is_a?(Array) ? @rules : [@rules]
+          end
+          children.each { |c| node << c.to_sass }
+          node
+        end
+
+        private
+
+        # Creates a list of selectors.
+        #
+        # @return [Array<String, Sass::Script::Tree::Node>] the list of selectors
+        def get_full_selector
+          raise UnknownError if @selectors.nil?
+          if @selectors.is_a?(Array)
+            # Creates a list of selectors {Array<String, Sass::Script::Tree::node>} separated by a comma
+            # and returns the list without the last, trailing comma
+            @selectors.inject([]) { |rule, selector| rule << [selector.to_sass, ','] }.flatten[0..-2]
+          else
+            [@selectors.to_sass].flatten
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the full selector of a given {RulesetNode}.
+      #
+      # No equivalent node is present in Sass, it's the `rule`
+      # member of {::Sass::Tree::PropNode}, instead.
+      class SelectorNode < Node
+        # @return [Array<Tree::ElementNode>]
+        attr_accessor :elements
+        attr_accessor :extendList
+        attr_accessor :condition
+        # @return [Hash]
+        attr_accessor :currentFileInfo
+        # @return [Boolean]
+        attr_accessor :evaldCondition
+
+        # see Node#to_sass
+        def to_sass
+          raise UnknownError if @elements.nil?
+          return @elements.to_sass unless @elements.is_a?(Array)
+          @elements.inject([]) { |selector, element| selector << element.to_sass }
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,17 @@
+module Less2Sass
+  module Less
+    module Tree
+      class UnitNode < Node
+        attr_accessor :numerator
+        attr_accessor :denominator
+        attr_accessor :backupUnit
+
+        def to_s
+          val = @numerator[0].to_s
+          val += @denominator[0] unless @denominator.nil? || @denominator.empty?
+          val
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the CSS `url` function call.
+      #
+      # The Sass equivalent is {::Sass::Script::Tree::Funcall}.
+      class UrlNode < Node
+        attr_accessor :value
+        attr_accessor :currentFileInfo
+        attr_accessor :index
+        attr_accessor :isEvald
+
+        # @return [::Sass::Script::Tree::Funcall]
+        # @see https://github.com/sass/sass/blob/stable/lib/sass/script/tree/funcall.rb#L42-46
+        # @see Node#to_sass
+        def to_sass
+          node(::Sass::Script::Tree::Funcall.new('url', [@value.to_sass], ::Sass::Util::NormalizedMap.new, nil, nil), line)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+module Less2Sass
+  module Less
+    module Tree
+      # Represents the value of any Less AST node.
+      #
+      # It has no individual representation in Sass,
+      # so it returns its value node's Sass representation,
+      # when {#to_sass} gets called.
+      #
+      # Sass equivalents:
+      #   - {::Sass::Script::Tree::Literal} if part of property declaration
+      #   - {::Sass::Script::Tree::ListLiteral} if part of variable definition
+      #
+      # @see Node
+      class ValueNode < Node
+        # @todo update Sass and check out a lately commit regarding the deprecated SassScript usage in CSS rules
+        # @see https://github.com/sass/sass/commit/b671122234d2d4df088a6c6d4c54b64d6997d255
+
+        # The ValueNode is not the final value of a variable
+        # or a property.
+        #
+        # @return [Node, Array<Node>]
+        attr_accessor :value
+
+        # This node's value is either a single expression,
+        # or an array of those. The array needs to be further
+        # processed.
+        #
+        # @return [::Sass::Script::Tree::Literal, ::Sass::Script::Tree::ListLiteral]
+        # @see Node#to_sass
+        def to_sass
+          if @value.is_a?(Array)
+            # TODO: don't forget about interpolation. What if one of the expressions is a variable?
+            if @parent.is_variable_definition? || contains_variables?
+              elements = @value.inject([]) { |elements, elem| elements << elem.to_sass }
+              node(::Sass::Script::Tree::ListLiteral.new(elements, :comma), line)
+            else
+              value = @value.inject([]) do |value, elem|
+                substring = elem.to_sass
+                # TODO: describe solution for '"Source Code Pro", Monaco, monospace'
+                substring = substring.value.value if substring.is_a?(::Sass::Script::Tree::Literal)
+                value << substring
+              end.join(', ')
+              node(::Sass::Script::Tree::Literal.new(::Sass::Script::Value::String.new(value)), line)
+            end
+          else
+            @value.to_sass
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Less2Sass
+  module Less
+    module Tree
+      # A node representing a variable.
+      # The Sass representation of it is {::Sass::Script::Tree:Variable}
+      class VariableNode < Node
+        # @return [String]
+        attr_accessor :name
+        # @return [Integer]
+        attr_accessor :index
+        # @return [Hash]
+        attr_accessor :currentFileInfo
+
+        # Returns the sass specific name property by
+        # removing the starting @.
+        #
+        # Example:
+        #   node.sass_name => "var1"
+        #
+        # @return [String]
+        def sass_name
+          @name[1..-1] if @name
+        end
+
+        # Checks, whether the variable node is an interpolation
+        #
+        # @return [Boolean]
+        def interpolation?
+          return false unless [ElementNode, RuleNode].include?(@parent.class)
+          return !@parent.is_variable_definition? if @parent.is_a?(RuleNode)
+          true
+        end
+
+        # @see Node#to_sass
+        def to_sass
+          variable = node(::Sass::Script::Tree::Variable.new(sass_name), line)
+          variable = node(::Sass::Script::Tree::Interpolation.new(nil, variable, nil, false, false), line) if interpolation?
+          variable
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/less/tree.rb

@@ -0,0 +1,34 @@
+require 'less2sass/less/tree/node'
+require 'less2sass/less/tree/alpha_node'
+require 'less2sass/less/tree/anonymous_node'
+require 'less2sass/less/tree/assignment_node'
+require 'less2sass/less/tree/attribute_node'
+require 'less2sass/less/tree/call_node'
+require 'less2sass/less/tree/color_node'
+require 'less2sass/less/tree/combinator_node'
+require 'less2sass/less/tree/comment_node'
+require 'less2sass/less/tree/condition_node'
+require 'less2sass/less/tree/detached_ruleset_node'
+require 'less2sass/less/tree/dimension_node'
+require 'less2sass/less/tree/directive_node'
+require 'less2sass/less/tree/element_node'
+require 'less2sass/less/tree/expression_node'
+require 'less2sass/less/tree/extend_node'
+require 'less2sass/less/tree/import_node'
+require 'less2sass/less/tree/keyword_node'
+require 'less2sass/less/tree/media_node'
+require 'less2sass/less/tree/mixin_call_node'
+require 'less2sass/less/tree/mixin_definition_node'
+require 'less2sass/less/tree/negative_node'
+require 'less2sass/less/tree/operation_node'
+require 'less2sass/less/tree/paren_node'
+require 'less2sass/less/tree/quoted_node'
+require 'less2sass/less/tree/rule_node'
+require 'less2sass/less/tree/ruleset_call_node'
+require 'less2sass/less/tree/ruleset_node'
+require 'less2sass/less/tree/selector_node'
+require 'less2sass/less/tree/unicode_descriptor_node'
+require 'less2sass/less/tree/unit_node'
+require 'less2sass/less/tree/url_node'
+require 'less2sass/less/tree/value_node'
+require 'less2sass/less/tree/variable_node'

data/lib/less2sass/less.rb

@@ -0,0 +1,2 @@
+require 'less2sass/less/tree'
+require 'less2sass/less/ast_handler'

data/lib/less2sass/sass/ast_handler.rb

@@ -0,0 +1,57 @@
+module Less2Sass
+  module Sass
+    # Wrapped Sass AST
+    class ASTHandler
+      # Creates an empty Sass AST.
+      #
+      # @param [::Sass::Tree::Node] tree the Sass AST
+      def initialize(tree)
+        @tree = tree
+      end
+
+      # Appends child notes to the empty Sass AST.
+      #
+      # Note, that this should be called only once.
+      #
+      # @param [::Sass::Tree::Node] child the rest
+      #   of the converted Less AST
+      def <<(child)
+        # TODO: check if child.is_a?(::Sass::Tree::Node) and raise some error, if not
+        @tree << child
+        self
+      end
+
+      def to_css
+        @tree.render
+      end
+
+      # Outputs the transformed and converted AST
+      # in the form of Sass code.
+      #
+      # @todo method cannot handle import nodes, yet - single files only
+      #
+      # @param [String, IO] destination the base directory
+      #   or an IO Stream where the converted projects
+      #   should be outputted.
+      def code_gen(destination = nil)
+        code = @tree.to_scss
+        return code unless destination
+        if destination.is_a?(String)
+          open_file(destination, 'w') { |file| file.write(code) }
+        else
+          destination.write(code)
+        end
+      end
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        return File.open(filename, flag) unless block_given?
+        yield File.open(filename, flag)
+      end
+
+      def to_yaml
+        @tree.to_yaml
+      end
+    end
+  end
+end

data/lib/less2sass/sass/parser.rb

@@ -0,0 +1,20 @@
+module Less2Sass
+  module Sass
+    class Parser
+      def initialize(input)
+        @input = input
+      end
+
+      def parse
+        sass_file_content = File.read(@input)
+        sass_file_path = File.expand_path(@input)
+        tree = ::Sass::Engine.new(
+          sass_file_content,
+          :syntax => :scss, :filename => sass_file_path
+        ).to_tree
+        ::Sass::Tree::Visitors::CheckNesting.visit(tree)
+        ::Sass::Tree::Visitors::Perform.visit(tree)
+      end
+    end
+  end
+end

data/lib/less2sass/sass.rb

@@ -0,0 +1,2 @@
+require 'less2sass/sass/ast_handler'
+require 'sass'

data/lib/less2sass/util.rb

@@ -0,0 +1,36 @@
+module Less2Sass
+  module Util
+    extend self
+
+    # Returns a file's path relative to the Less2Sass root directory.
+    #
+    # @param file [String] The filename relative to the Less2Sass root
+    # @return [String] The filename relative to the the working directory
+    def scope(file)
+      File.join(Less2Sass::ROOT_DIR, file)
+    end
+
+    # Formats a multiline console input, so it can be passed as an argument
+    # to a console application.
+    #
+    # @return [String] properly formatted multiline argument
+    def read_stdin_as_multiline_arg
+      str = ''
+      puts 'Write your code below, so it can be converted for you.'
+      while line = gets
+        line["\n"] = "\\\n"
+        str << line
+      end
+      str
+    end
+
+    # Formats class names properly.
+    #
+    # @return [String] formatted class name
+    # @example formats dashed class name
+    #   "anonymous_node".classify #=> "AnonymousNode"
+    def classify(str)
+      str.split('_').collect!(&:capitalize).join
+    end
+  end
+end

data/lib/less2sass.rb

@@ -0,0 +1,9 @@
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
+
+require 'less2sass/constants'
+require 'less2sass/error'
+require 'less2sass/exec'
+require 'less2sass/util'
+require 'less2sass/sass'
+require 'less2sass/less'