riml 0.3.5 → 0.3.6

data/README.md

@@ -1,10 +1,10 @@
 [![Build Status](https://secure.travis-ci.org/luke-gru/riml.png?branch=master)](https://travis-ci.org/luke-gru/riml)
 
-Riml, a relaxed Vimscript
+Riml, a relaxed Vim script
 ====================================
 
-Riml is a subset of Vimscript with some added features, and it compiles to
-plain Vimscript. Some of the added features include classes, string interpolation,
+Riml is a subset of Vim script with some added features, and it compiles to
+plain Vim script. Some of the added features include classes, string interpolation,
 heredocs, default case-sensitive string comparison, default parameters
 in functions, and other things programmers tend to take for granted.
 To see how Riml is compiled to VimL, just take a look at this README. The left
@@ -70,7 +70,7 @@ Notice in the last line of Riml there's string interpolation. This works
 in double-quoted strings and heredocs, which we'll encounter later.
 
 In Riml, you can choose to end any block with 'end', or with whatever you used
-to do in Vimscript ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
+to do in Vim script ('endif', 'endfunction', etc...). Also, 'if' and 'unless' can
 now be used as statement modifiers:
 
     callcount = 0 unless callcount?
@@ -260,9 +260,9 @@ global, this is not a problem. Simply:
     end
 
 If you look at the last line of Riml in the previous example, you'll see that
-it doesn't use Vimscript's builtin 'call' function for calling the 'translate'
+it doesn't use Vim script's builtin 'call' function for calling the 'translate'
 method on the translation object. Riml can figure out when 'call' is necessary,
-and will add it to the compiled Vimscript.
+and will add it to the compiled Vim script.
 
 ###Using 'super'
 

data/bin/riml

@@ -8,36 +8,38 @@ module Riml
   require 'riml'
 
   require 'optparse'
+  require 'ostruct'
 
   class Options
-    def self.parse(argv)
+    def self.parse(argv = ARGV)
       argv << '--help' if argv.size.zero?
 
       # defaults
-      options = {}
-      options[:compile_files] = []
-      options[:check_syntax_files] = []
-      options[:repl] = false
-      options[:vi_readline] = false
-      options[:allow_undefined_global_classes] = DEFAULT_PARSE_OPTIONS[:allow_undefined_global_classes]
-      options[:readable] = DEFAULT_COMPILE_OPTIONS[:readable]
-      options[:output_dir] = DEFAULT_COMPILE_FILES_OPTIONS[:output_dir]
-
-      OptionParser.new do |opts|
+      options = OpenStruct.new
+      options.compile_files = []
+      options.check_syntax_files = []
+      options.repl = false
+      options.vi_readline = false
+      options.allow_undefined_global_classes = DEFAULT_PARSE_OPTIONS[:allow_undefined_global_classes]
+      options.include_reordering = DEFAULT_PARSE_OPTIONS[:include_reordering]
+      options.readable = DEFAULT_COMPILE_OPTIONS[:readable]
+      options.output_dir = DEFAULT_COMPILE_FILES_OPTIONS[:output_dir]
+
+      opts_parser = OptionParser.new do |opts|
         opts.banner = "Usage: riml [options] [file1][,file2]..."
         opts.separator ""
         opts.separator "Specific options:"
 
         opts.on("-c", "--compile FILES", Array, "Compiles riml file(s) to VimL.") do |filenames|
-          append_filenames_to_list_if_valid(options[:compile_files], *filenames)
+          append_filenames_to_list_if_valid(options.compile_files, *filenames)
         end
 
         opts.on("-s", "--stdio", "Takes riml from stdin and outputs VimL to stdout.") do
-          options[:stdio] = true
+          options.stdio = true
         end
 
         opts.on("-k", "--check FILES", Array, "Checks syntax of file(s). Because Riml is (mostly) compatible with VimL, this can also be used to check VimL syntax.") do |filenames|
-          append_filenames_to_list_if_valid(options[:check_syntax_files], *filenames)
+          append_filenames_to_list_if_valid(options.check_syntax_files, *filenames)
         end
 
         opts.on("-S", "--source-path PATH", "Colon-separated path riml uses to find files for `riml_source`. Defaults to pwd.") do |path|
@@ -57,23 +59,27 @@ module Riml
         end
 
         opts.on("-a", "--allow-undef-global-classes", "Continue compilation when encountering undefined global class(es).") do
-          options[:allow_undefined_global_classes] = true
+          options.allow_undefined_global_classes = true
+        end
+
+        opts.on("-n", "--no-include-reordering", "Turns off default feature of reordering `riml_include`s based on class dependencies.") do
+          options.include_reordering = false
         end
 
         opts.on("-o", "--output-dir DIR", "Output all .vim files in specified directory.") do |dir|
-          options[:output_dir] = dir
+          options.output_dir = dir
         end
 
         opts.on("-d", "--condensed", "Omit readability improvements such as blank lines.") do
-          options[:readable] = false
+          options.readable = false
         end
 
         opts.on("-i", "--interactive", "Start an interactive riml session (REPL).") do
-          options[:repl] = true
+          options.repl = true
         end
 
         opts.on("--vi", "Use vi readline settings during interactive session.") do
-          options[:vi_readline] = options[:repl] =  true
+          options.vi_readline = options.repl =  true
         end
 
         opts.on_tail("-v", "--version", "Show riml version.") do
@@ -85,8 +91,13 @@ module Riml
           puts opts
           exit
         end
-      end.parse!(argv)
+      end
 
+      begin
+        opts_parser.parse!(argv)
+      rescue OptionParser::ParseError => e
+        abort e.message
+      end
       options
     end
 
@@ -110,34 +121,38 @@ module Riml
   class Runner
     class << self
       def start
-        options = Options.parse(ARGV)
+        options = Options.parse
         compile_options = {
-          :readable => options[:readable],
-          :allow_undefined_global_classes => options[:allow_undefined_global_classes]
+          :readable => options.readable,
+          :allow_undefined_global_classes => options.allow_undefined_global_classes,
+          :include_reordering => options.include_reordering
         }
         compile_files_options = compile_options.merge(
-          :output_dir => options[:output_dir]
+          :output_dir => options.output_dir
         )
-        if options[:stdio]
+        if options.stdio
           puts Riml.compile($stdin.read, compile_options)
-        elsif options[:compile_files].any?
+        elsif options.compile_files.any?
           FileRollback.trap(:INT, :QUIT, :KILL) { print("\n"); exit 1 }
-          Riml.compile_files(*options[:compile_files], compile_files_options)
-        elsif options[:check_syntax_files].any?
-          files = options[:check_syntax_files].uniq
+          Riml.compile_files(*options.compile_files, compile_files_options)
+        elsif options.check_syntax_files.any?
+          files = options.check_syntax_files.uniq
           Riml.check_syntax_files(*files)
           size = files.size
           # "ok (1 file)" OR "ok (2 files)"
           puts "ok (#{size} file#{'s' if size > 1})"
-        elsif options[:repl]
+        elsif options.repl
           require 'riml/repl'
-          Riml::Repl.new(options[:vi_readline], compile_options).run
+          Riml::Repl.new(options.vi_readline, compile_options).run
         else
-          ARGV.replace ['--help']
-          start
+          abort "Invalid arguments. See valid arguments with 'riml --help'"
         end
       end
     end
   end
-  Runner.start
+  begin
+    Runner.start
+  rescue RimlError => e
+    abort e.message
+  end
 end

data/lib/riml.rb

@@ -10,6 +10,7 @@ require 'riml/warning_buffer'
 require 'riml/include_cache'
 require 'riml/path_cache'
 require 'riml/rewritten_ast_cache'
+require 'riml/backtrace_filter'
 require 'riml/file_rollback'
 
 module Riml
@@ -18,7 +19,10 @@ module Riml
   DEFAULT_COMPILE_FILES_OPTIONS = DEFAULT_COMPILE_OPTIONS.merge(
     :output_dir => nil
   )
-  DEFAULT_PARSE_OPTIONS = { :allow_undefined_global_classes => false }
+  DEFAULT_PARSE_OPTIONS = {
+    :allow_undefined_global_classes => false,
+    :include_reordering => true
+  }
 
   EXTRACT_PARSE_OPTIONS   = lambda { |k,_| DEFAULT_PARSE_OPTIONS.keys.include?(k.to_sym) }
   EXTRACT_COMPILE_OPTIONS = lambda { |k,_| DEFAULT_COMPILE_OPTIONS.keys.include?(k.to_sym) }

data/lib/riml/ast_rewriter.rb

@@ -1,6 +1,7 @@
 require File.expand_path("../constants", __FILE__)
 require File.expand_path("../imported_class", __FILE__)
 require File.expand_path("../class_map", __FILE__)
+require File.expand_path("../class_dependency_graph", __FILE__)
 require File.expand_path("../walker", __FILE__)
 
 module Riml
@@ -10,7 +11,7 @@ module Riml
     attr_accessor :ast, :options
     attr_reader :classes, :rewritten_included_and_sourced_files
 
-    def initialize(ast = nil, classes = nil)
+    def initialize(ast = nil, classes = nil, class_dependency_graph = nil)
       @ast = ast
       @classes = classes || ClassMap.new
       # AST_Rewriter shares options with Parser. Parser set AST_Rewriter's
@@ -23,6 +24,9 @@ module Riml
       # ex: { nil => ["main.riml"], "main.riml" => ["lib1.riml", "lib2.riml"],
       # "lib1.riml" => [], "lib2.riml" => [] }
       @included_and_sourced_file_refs = Hash.new { |h, k| h[k] = [] }
+      @class_dependency_graph = class_dependency_graph || ClassDependencyGraph.new
+      @class_dependency_graph.classes = @classes
+      @resolving_class_dependencies = nil
     end
 
     def rewrite(filename = nil, included = false)
@@ -30,12 +34,17 @@ module Riml
         rewrite_included_and_sourced_files!(filename)
         return rewritten_ast
       end
+      establish_parents(ast)
       if @options && @options[:allow_undefined_global_classes] && !@classes.has_global_import?
         @classes.globbed_imports.unshift(ImportedClass.new('*'))
+      else
+        class_imports = RegisterImportedClasses.new(ast, classes)
+        class_imports.rewrite_on_match
+      end
+      if resolve_class_dependencies?
+        resolve_class_dependencies!(filename)
+        return if @resolving_class_dependencies == true
       end
-      establish_parents(ast)
-      class_imports = RegisterImportedClasses.new(ast, classes)
-      class_imports.rewrite_on_match
       class_registry = RegisterDefinedClasses.new(ast, classes)
       class_registry.rewrite_on_match
       rewrite_included_and_sourced_files!(filename)
@@ -58,6 +67,114 @@ module Riml
       ast
     end
 
+    def resolve_class_dependencies?
+      @resolving_class_dependencies = false if @options[:include_reordering] != true
+      @resolving_class_dependencies != false
+    end
+
+    def resolve_class_dependencies!(filename)
+      if @resolving_class_dependencies.nil?
+        start_resolving = @resolving_class_dependencies = true
+        @included_ASTs_by_include_file = {}
+      end
+      old_ast = ast
+      RegisterClassDependencies.new(ast, classes, @class_dependency_graph, filename).rewrite_on_match
+      ast.children.grep(RimlFileCommandNode).each do |node|
+        next unless node.name == 'riml_include'
+        node.each_existing_file! do |file, fullpath|
+          if filename && @included_and_sourced_file_refs[file].include?(filename)
+            msg = "#{filename.inspect} can't include #{file.inspect}, as " \
+                  " #{file.inspect} already included #{filename.inspect}"
+            raise IncludeFileLoop, msg
+          elsif filename == file
+            raise UserArgumentError, "#{file.inspect} can't include itself"
+          end
+          @included_and_sourced_file_refs[filename] << file
+          riml_src = File.read(fullpath)
+          Parser.new.tap { |p| p.options = @options }.parse(riml_src, self, file, true)
+          @included_ASTs_by_include_file[file] = Parser.ast_cache[file]
+        end
+      end
+    ensure
+      self.ast = old_ast
+      if start_resolving == true
+        @resolving_class_dependencies = false
+        @included_and_sourced_file_refs.clear
+        reorder_includes_based_on_class_dependencies!
+      end
+    end
+
+    def reorder_includes_based_on_class_dependencies!
+      global_included_filename_order = @class_dependency_graph.filename_order
+      asts = [ast]
+      while (ast = asts.shift)
+        include_nodes =
+          ast.children.grep(RimlFileCommandNode).select do |n|
+            n.name == 'riml_include'
+          end
+        included_filenames = include_nodes.map { |n| n.arguments.map(&:value) }.flatten
+        new_order_filenames = global_included_filename_order & included_filenames
+        add_to_head = included_filenames - new_order_filenames
+        new_order_filenames = add_to_head + new_order_filenames
+        include_nodes.each do |node|
+          node.arguments.each do |arg|
+            if (included_file_ast = @included_ASTs_by_include_file[arg.value])
+              asts << included_file_ast
+            end
+            if new_order_filenames.first
+              arg.value = new_order_filenames.shift
+            else
+              # for now, just to be cautious
+              raise "Internal error in AST rewriting process. Please report bug!"
+            end
+          end
+        end
+      end
+    end
+
+    class RegisterClassDependencies < AST_Rewriter
+      def initialize(ast, classes, class_dependency_graph, filename)
+        super(ast, classes, class_dependency_graph)
+        @filename = filename
+      end
+
+      def match?(node)
+        ClassDefinitionNode === node || ObjectInstantiationNode === node
+      end
+
+      def replace(node)
+        if ClassDefinitionNode === node
+          @class_dependency_graph.class_defined(
+            @filename, class_node_full_name(node),
+            class_name_full_name(node.superclass_name)
+          )
+        else
+          @class_dependency_graph.class_encountered(
+            @filename,
+            class_node_full_name(node.call_node)
+          )
+        end
+      end
+
+      private
+
+      def class_node_full_name(node)
+        (
+         node.scope_modifier ||
+         ClassDefinitionNode::DEFAULT_SCOPE_MODIFIER
+        ) + node.name
+      end
+
+      def class_name_full_name(class_name)
+        return nil if class_name.nil?
+        if class_name[1] == ':'
+          class_name
+        else
+          ClassDefinitionNode::DEFAULT_SCOPE_MODIFIER + class_name
+        end
+      end
+    end
+
     def establish_parents(node)
       Walker.walk_node(node, method(:do_establish_parents))
     end

data/lib/riml/backtrace_filter.rb

@@ -1,13 +1,32 @@
+require File.expand_path('../environment', __FILE__)
+
 module Riml
   class BacktraceFilter
+    include Riml::Environment
+
+    RIML_INTERNAL_FILE_REGEX = /#{ROOTDIR}/
+
     attr_reader :error
 
     def initialize(error)
       @error = error
     end
 
-    def filter!
-      error.backtrace.clear
+    def filter!(first_i = 0, last_i = -1)
+      if first_i < 0
+        raise ArgumentError, "first argument must be >= 0"
+      end
+      if last_i > 0 && first_i > last_i
+        raise ArgumentError, "first index must come before (or be equal to) last index"
+      end
+
+      unless $DEBUG
+        add_to_head = @error.backtrace[0...first_i] || []
+        add_to_tail = @error.backtrace[last_i...-1] || []
+        backtrace = @error.backtrace[first_i..last_i] || []
+        backtrace.delete_if { |loc| RIML_INTERNAL_FILE_REGEX =~ loc }
+        @error.set_backtrace(add_to_head + backtrace + add_to_tail)
+      end
     end
 
   end

data/lib/riml/class_dependency_graph.rb

@@ -0,0 +1,88 @@
+# topological sorting module from stdlib
+# uses Tarjan's algorithm for strongly connected components
+require 'tsort'
+
+module Riml
+  # Used for reordering `riml_include`s based on class dependencies.
+  class ClassDependencyGraph
+    include TSort
+
+    attr_reader :definition_graph, :encountered_graph
+    # for checking imported classes
+    attr_accessor :classes
+
+    # definition_graph:  { "faster_car.riml" => { "s:FasterCar" => "s:Car" }, "car.riml" => { "s:Car" => nil } }
+    # encountered_graph: { "faster_car.riml" => ["s:FasterCar", "s:Car"], "car.riml" => ["s:Car"] }
+    def initialize(definition_graph = {}, encountered_graph = {})
+      @definition_graph = definition_graph
+      @encountered_graph = encountered_graph
+      @filename_graph = nil
+    end
+
+    def class_defined(filename, class_name, superclass_name)
+      @definition_graph[filename] ||= {}
+      @definition_graph[filename][class_name] = superclass_name
+      class_encountered(filename, class_name)
+      class_encountered(filename, superclass_name) if superclass_name
+    end
+
+    def class_encountered(filename, class_name)
+      @encountered_graph[filename] ||= []
+      unless @encountered_graph[filename].include?(class_name)
+        @encountered_graph[filename] << class_name
+      end
+    end
+
+    # order in which filenames need to be included based off internal
+    # `@definition_graph` and `@encountered_graph`
+    # @return Array filenames
+    def tsort
+      prepare_filename_graph! if @filename_graph.nil?
+      super
+    end
+
+    alias filename_order tsort
+
+    # Computes `@filename_graph` from `@encountered_graph` and `@definition_graph`.
+    # This graph is used by `tsort` to sort the filenames for inclusion.
+    def prepare_filename_graph!
+      @filename_graph = {}
+      @encountered_graph.each do |filename, encountered_classes|
+        # must be imported class or undefined class
+        if @definition_graph[filename].nil?
+          encountered_classes.each do |enc|
+            # raises Riml::ClassNotFound if not found
+            @classes[enc]
+          end
+          next
+        end
+        defined_in_filename = @definition_graph[filename].keys
+        dependent_by_superclass = @definition_graph[filename].values.compact - defined_in_filename
+        dependent_by_use = encountered_classes - (defined_in_filename + dependent_by_superclass)
+        dependents = dependent_by_superclass + dependent_by_use
+        dependents.each do |dep|
+          dependent_definition_fname = @definition_graph.detect { |fname, hash| hash.has_key?(dep) }.first rescue nil
+          if dependent_definition_fname
+            @filename_graph[filename] ||= []
+            unless @filename_graph[filename].include?(dependent_definition_fname)
+              @filename_graph[filename] << dependent_definition_fname
+            end
+          end
+        end
+      end
+    end
+
+    def tsort_each_node(&block)
+      @filename_graph.each_key(&block)
+    end
+
+    def tsort_each_child(node, &block)
+      if @filename_graph[node]
+        @filename_graph[node].each(&block)
+      else
+        []
+      end
+    end
+
+  end
+end