less_to_sass 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 73f59ec66f3b140eb5e446edf2b163b6b4050bee
+  data.tar.gz: 3a3080ed5b728f6bd80007fb9a998e992b6fe95d
+SHA512:
+  metadata.gz: aad48dc3288693a590fd535a05286dd3732222c1d8688cacbe1f4e770095314c57e2b9aaac7e3a17836f7865a772e83c589814b7f8cd87468695ebf4feefd6a9
+  data.tar.gz: 940d33cfed16ba2b475e68b00fd5b993a9c26ed9d0832d992efa2ba6d3e6335bd63b62918bb9a5b133aae31eede77a82af62db5b4f975b51726dec41baf609c0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Attila Večerek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# less2sass
+
+LESS and SASS are two dynamic style sheet languages with some minor differences in syntax and huge differences in their semantics. The goal of this project is to create a converter application between these formats.
+
+There are some converters available on the Internet, but all of them are working on the search and replace principle and can not produce 100% correct conversion. Less2sass is an AST-based converter, which heavily uses the Less.js and Sass engines in order to correctly parse Less code and generate Sass or SCSS stylesheets, respectively.
+
+## Installing
+
+1. Install *Node.js* v6, if possible, according to the [official instructions](https://nodejs.org/en/download/package-manager/).
+   - On Debian (Ubunu/Mint) set an alias in ~/.bashrc file for nodejs.
+
+      ```
+      alias node='nodejs'
+      ```
+2. Set the ```NODE_PATH``` environment variable to store the install location of nodejs in your bash profile. Usually, it is the folder /usr/lib/node_modules.
+   
+   ```
+   export NODE_PATH=/usr/lib/node_modules:$NODE_PATH
+   ```
+3. Install *Less.js* using the Node.js package manager.
+
+   ```
+   $ sudo npm install -g less@2.7.1
+   ```
+4. You can check, if Less.js has been installed successfully by entering the interactive node shell and trying to require it.    The require should return the path to the module's index file. Usually ```/usr/lib/node_modules/less/index.js```.
+
+   ```
+   $ node
+   > require.resolve('less')
+   ```
+5. Install Less2Sass. Note that the name of the gem is less_to_sass, since the alternative with the number was already taken.
+
+   ```ruby
+   $ gem install less_to_sass
+   ```
+
+## Usage
+```
+$ less2sass <INPUT> [OUTPUT] [options]
+```
+Even though the name of the gem is less_to_sass, the executable is used according to the repo's name.
+
+## Development
+
+1. Install Bundler.
+
+   ```ruby
+   $ gem install bundler
+   ```
+2. Clone git repo and enter it.
+
+   ```
+   $ git clone https://github.com/vecerek/less2sass
+   $ cd less2sass
+   ```
+3. Install development dependencies using bundler.
+
+   ```
+   $ bundle install
+   ```
+4. Run the tests and enjoy the development!
+
+   ```
+   $ bundle exec rspec spec/compare_spec.rb
+   ```
+
+## Language differences
+
+There is an entire [wiki page] (https://github.com/vecerek/less2sass/wiki/Language-Differences), that deals with the language differences. It will be continuously updated as new releases of Less and Sass will be published.
+The current version of the document describes the differences between Less v2.7.1 and Sass v3.4.21

data/bin/less2sass

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# A command line Less to Sass converter
+
+begin
+  # require works with RubyMine, not with terminal
+  require_relative '../lib/less2sass'
+rescue LoadError
+  require 'less2sass'
+end
+
+opts = Less2Sass::Exec::Conversion.new(ARGV, :less2sass)
+opts.parse!

data/bin/sass2less

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# A command line Less to Sass converter
+
+begin
+  # require works with RubyMine, not with terminal
+  require_relative '../lib/less2sass'
+rescue LoadError
+  require 'less2sass'
+end
+
+opts = Less2Sass::Exec::Conversion.new(ARGV, :sass2less)
+opts.parse!

data/lib/less2sass/constants.rb

@@ -0,0 +1,5 @@
+module Less2Sass
+  # The root directory of the Less2Sass source tree.
+  ROOT_DIR = File.expand_path(File.join(__FILE__, '../../..'))
+  VERSION = '0.1.0'.freeze
+end

data/lib/less2sass/error.rb

@@ -0,0 +1,100 @@
+module Less2Sass
+  class Less2SassError < StandardError; end
+
+  class ArgumentUnspecifiedError < ArgumentError
+    def initialize(arg)
+      @arg = arg
+    end
+
+    def message
+      "Argument Error: #{@arg} can't be left unspecified. Choose sass or scss."
+    end
+  end
+
+  class InvalidArgumentError < ArgumentError
+    def initialize(arg, val)
+      @arg = arg
+      @val = val
+    end
+
+    def message
+      "#{@val} is not a valid value for #{arg}"
+    end
+  end
+
+  class JSLessParserError < Less2SassError
+    def initialize(err)
+      @err = err
+    end
+
+    def message
+      "\n#{yield} #{@err['filename']}: #{@err['message']} on line #{@err['line']}, index #{@err['index']}. " +
+        (@err['callLine'].nil? ? '' : "Called from line #{@err['callLine']}")
+    end
+  end
+
+  class LessSyntaxError < JSLessParserError
+    def message
+      super { 'Syntax error found in' }
+    end
+  end
+
+  class LessImportNotFoundError < JSLessParserError
+    def message
+      super { 'The specified import file has not been found in' }
+    end
+  end
+
+  class LessASTParserError < Less2SassError
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def message
+      "Unexpected class type #{@klass} during Less' AST JSON parsing."
+    end
+  end
+
+  class LessCompilationError < Less2SassError
+    def message
+      "\n" + super
+    end
+  end
+
+  # Abstract error class for Less2Sass conversion errors
+  class ConversionError < Less2SassError
+    def initialize
+      raise NotImplementedError
+    end
+
+    def message
+      'Unsupported '
+    end
+  end
+
+  class OperatorConversionError < ConversionError
+    def initialize(operator)
+      @op = operator
+    end
+
+    def message
+      super + "operator #{@op}"
+    end
+  end
+
+  class FeatureConversionError < ConversionError
+    def initialize(obj)
+      @klass = obj.class
+    end
+
+    def message
+      super + "feature when converting #{@klass}"
+    end
+  end
+
+  class UnknownError < Less2SassError
+    def message
+      "Something unexpected just happened.\n" + super
+    end
+  end
+end

data/lib/less2sass/exec/base.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+
+module Less2Sass
+  module Exec
+    # The abstract base class for Less2Sass executables.
+    class Base
+      # @param args [Array<String>] command-line arguments
+      def initialize(args)
+        @args = args
+        @options = {}
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      # Calls `Kernel#exit` at the end, so it never returns.
+      #
+      # @see #parse
+      def parse!
+        begin
+          parse
+        rescue Exception => e
+          raise e if @options[:trace] || e.is_a?(SystemExit)
+          $stderr.puts "#{e.class}: " + e.message.to_s
+          exit 1
+        end
+        exit 0
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      def parse
+        # @opts = OptionParser.new(&method(:set_opts))
+        OptionParser.new do |opts|
+          set_opts(opts)
+        end.parse!(@args)
+
+        process_args
+
+        @options
+      end
+
+      protected
+
+      # Tells optparse how to parse the arguments
+      # available for all executables.
+      #
+      # The method is being overridden by subclasses
+      # to add their own options.
+      #
+      # @param opts [OptionParser]
+      def set_opts(_opts = nil)
+        raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
+      end
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        File.open(filename, flag)
+      end
+
+      # Processes the options set by the command-line arguments -
+      # `@options[:input]` and `@options[:output]` are being set
+      # to appropriate IO streams.
+      #
+      # This method is being overridden by subclasses
+      # to run their respective programs.
+      def process_args
+        input = @options[:input]
+        output = @options[:output]
+        args = @args.dup
+        input ||=
+          begin
+            filename = args.shift
+            @options[:input_filename] = filename
+            open_file(filename) || $stdin
+          end
+        @options[:output_filename] = args.shift
+        output ||= @options[:output_filename] || $stdout
+        @options[:input] = input
+        @options[:output] = output
+
+        run
+      end
+    end
+  end
+end

data/lib/less2sass/exec/conversion.rb

@@ -0,0 +1,102 @@
+require 'less2sass/less'
+require 'yaml'
+
+module Less2Sass
+  module Exec
+    # TODO: rethink the concept, rather use 2 classes - Less2Sass and SassToLess instead of one (Conversion)
+    class Conversion < Base
+      attr_reader :conversion
+
+      def initialize(args, conversion)
+        super(args)
+        @options[:target_syntax] = :scss
+        @conversion = conversion
+      end
+
+      # Tells optparse how to parse the arguments.
+      #
+      # @param opts [OptionParser]
+      def set_opts(opts)
+        opts.banner = <<END
+Usage: #{conversion} [options] [INPUT] [OUTPUT]
+
+Description:
+#{get_banner_desc}
+END
+
+        common_options(opts)
+        input_and_output(opts)
+        miscellaneous(opts)
+      end
+
+      private
+
+      def get_banner_desc
+        'Converts ' + (conversion == :less2sass ?
+            'Less project to Sass' : 'Sass project to Less')
+      end
+
+      def common_options(opts)
+        opts.on('-?', '-h', '--help', 'Show this help message.') do
+          puts opts
+          exit
+        end
+
+        opts.on('-v', '--version', 'Print the Sass version.') do
+          puts("Less2Sass #{Less2Sass.version[:string]}")
+          exit
+        end
+      end
+
+      def input_and_output(opts)
+        opts.separator ''
+        opts.separator 'Input and Output:'
+
+        if conversion == :less2sass
+          opts.on(:OPTIONAL, '--target-syntax SYNTAX',
+                  'Which Sass syntax should the Less project be converted to.',
+                  '  - scss (default):  Use the CSS-superset SCSS syntax.',
+                  '  - sass:            Use the indented Sass syntax.'
+                 ) do |syntax|
+            if syntax.nil?
+              raise ArgumentUnspecifiedError, '--target-syntax'
+            elsif syntax && !%w(scss sass).include?(syntax)
+              raise InvalidArgumentError, '--target-syntax', syntax
+            end
+            @options[:target_syntax] = (syntax || :scss).to_sym
+          end
+        end
+
+        opts.on('-s', '--stdin', :NONE,
+                'Read input from standard input instead of an input file.',
+                'This is the default if no input file is specified.') do
+          @options[:input] = $stdin
+        end
+      end
+
+      def miscellaneous(opts)
+        opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error.') do
+          @options[:trace] = true
+        end
+
+        opts.on('-q', '--quiet', 'Silence warnings and status messages during conversion.') do
+          @options[:for_engine][:quiet] = true
+        end
+      end
+
+      # Runs the appropriate conversion (parse, transform, code gen)
+      def run
+        if conversion == :less2sass
+          sass = Less2Sass::Less::ASTHandler.new(@options[:input], @options[:target_syntax])
+                                            .transform_tree
+                                            .to_sass
+
+          sass.code_gen(@options[:output])
+        elsif conversion == :sass2less
+          # TODO: Implement Sass to Less conversion
+          # Raise some error but this line should never be reached
+        end
+      end
+    end
+  end
+end

data/lib/less2sass/exec.rb

@@ -0,0 +1,2 @@
+require 'less2sass/exec/base'
+require 'less2sass/exec/conversion'

data/lib/less2sass/js/less_parser.js

@@ -0,0 +1,48 @@
+/**
+ * @author Attila Večerek <xvecer17@stud.fit.vutbr.cz>
+ */
+var less = require('less')
+    , fs = require('fs')
+    , path = require('path');
+
+Less = {
+    parse: function(src, isStdin) {
+        // Parses a Less file and outputs its AST
+
+        var visit = function(o) {
+            // Attaches the node type to the necessary objects
+            for (var p in o) {
+                if (typeof o[p] == 'object') visit(o[p]);
+            }
+            if (o != null && o != "") {
+                if ("type" in o) o["class"] = o.type;
+            }
+        };
+
+        var code = src;
+        var options = {};
+
+        if (!isStdin) {
+            code = fs.readFileSync(src, 'utf8').toString();
+            options = {
+                filename: path.resolve(src)
+            }
+        }
+
+        return less.parse(code, options, function(e, tree) {
+            if (!e) {
+                visit(tree);
+                console.log(JSON.stringify(tree, null, 2));
+            } else {
+                e.class = "error"
+                console.log(JSON.stringify(e));
+            }
+        });
+    }
+};
+
+if (process.argv[2] === "-stdin") {
+    Less.parse(process.argv[3], process.argv[2]);
+} else {
+    Less.parse(process.argv[2]);
+}

data/lib/less2sass/less/ast_handler.rb

@@ -0,0 +1,33 @@
+require 'less2sass/less/parser'
+
+module Less2Sass
+  module Less
+    # Handler of the Less AST.
+    class ASTHandler
+      # @param [File, IO] input the root file of the Less project
+      # @param [Symbol] target_syntax the specified Sass syntax
+      #   for the conversion.
+      def initialize(input, target_syntax)
+        @target_syntax = target_syntax
+        parser = Parser.new(input)
+        # TODO: check syntax only if specified in the command-line options
+        # parser.check_syntax unless input == $stdin
+        @tree = parser.parse
+      end
+
+      # Transforms the Less AST, so it can be converted to
+      # an equivalent Sass AST representation.
+      def transform_tree
+        @tree.transform
+        self
+      end
+
+      # Converts the transformed Less AST to Sass AST.
+      #
+      # @return [Less2Sass::Sass::ASTHandler] a wrapped Sass AST
+      def to_sass
+        Less2Sass::Sass::ASTHandler.new(@tree.to_sass(:syntax => @target_syntax))
+      end
+    end
+  end
+end