riml 0.3.1 → 0.3.2

data/Gemfile.lock

@@ -3,12 +3,13 @@ GEM
   specs:
     minitest (2.5.1)
     racc (1.4.9)
-    rake (10.0.4)
+    rake (10.1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  bundler (~> 1.3)
   minitest (~> 2.5.1)
   racc
-  rake
+  rake (~> 10.1.0)

data/Rakefile

@@ -1,5 +1,7 @@
 require File.expand_path('../lib/environment', __FILE__)
 require 'rake/testtask'
+require 'bundler/setup'
+require 'bundler/gem_tasks'
 
 task :default => :test
 task :test => [:parser]

data/bin/riml

@@ -20,7 +20,8 @@ module Riml
       options.check_syntax_files = []
       options.repl = false
       options.vi_readline = false
-      options.output_dir = nil
+      options.readable = DEFAULT_COMPILE_OPTIONS[:readable]
+      options.output_dir = DEFAULT_COMPILE_FILES_OPTIONS[:output_dir]
 
       OptionParser.new do |opts|
         opts.banner = "Usage: riml [options] [file1][,file2]..."
@@ -59,6 +60,10 @@ module Riml
           options.output_dir = dir
         end
 
+        opts.on("-d", "--condensed", "Compiled VimL contains no extraneous newlines") do
+          options.readable = false
+        end
+
         opts.on("-i", "--interactive", "Start an interactive riml session (REPL).") do
           options.repl = true
         end
@@ -101,11 +106,16 @@ module Riml
     class << self
       def start
         options = Options.parse(ARGV)
-
+        compile_options = {
+          :readable => options.readable
+        }
+        compile_files_options = compile_options.merge(
+          :output_dir => options.output_dir
+        )
         if options.stdio
-          puts Riml.compile($stdin.read)
+          puts Riml.compile($stdin.read, compile_options)
         elsif options.compile_files.any?
-          Riml.compile_files(*options.compile_files, :output_dir => options.output_dir)
+          Riml.compile_files(*options.compile_files, compile_files_options)
         elsif options.check_syntax_files.any?
           files = options.check_syntax_files
           Riml.check_syntax_files(*files)
@@ -114,7 +124,7 @@ module Riml
           puts "ok (#{size} file#{'s' if size > 1})"
         elsif options.repl
           require 'repl'
-          Riml::Repl.new(options.vi_readline).run
+          Riml::Repl.new(options.vi_readline, compile_options).run
         else
           ARGV.replace ['--help']
           start

data/lib/backtrace_filter.rb

@@ -0,0 +1,14 @@
+module Riml
+  class BacktraceFilter
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    def filter!
+      error.backtrace.clear
+    end
+
+  end
+end

data/lib/compiler.rb

@@ -3,7 +3,22 @@ require File.expand_path('../nodes', __FILE__)
 # visits AST nodes and translates them into VimL
 module Riml
   class Compiler
-    attr_accessor :parser, :output_dir
+    attr_accessor :parser
+    attr_writer :options
+
+    # compiler options
+
+    def options
+      @options ||= {}
+    end
+
+    def output_dir
+      options[:output_dir]
+    end
+
+    def readable
+      options.has_key?(:readable) and options[:readable]
+    end
 
     # Base abstract visitor
     class Visitor
@@ -19,6 +34,8 @@ module Riml
         propagate_up_tree(node, output)
       end
 
+      protected
+
       def propagate_up_tree(node, output)
         node.parent_node.compiled_output << output.to_s unless @propagate_up_tree == false || node.parent_node.nil?
       end
@@ -26,6 +43,17 @@ module Riml
       def visitor_for_node(node, params={})
         Compiler.const_get("#{node.class.name.split('::').last}Visitor").new(params)
       end
+
+      def root_node(node)
+        @root_node ||= begin
+          node = node.parent until node.parent.nil?
+          node
+        end
+      end
+
+      def current_compiler(node)
+        root_node(node).current_compiler
+      end
     end
 
     class IfNodeVisitor < Visitor
@@ -452,6 +480,11 @@ module Riml
           end
         end
         node.compiled_output = declaration << body << "endfunction\n"
+        if current_compiler(node).readable
+          node.compiled_output << "\n"
+        else
+          node.compiled_output
+        end
       end
 
       private
@@ -565,7 +598,7 @@ module Riml
         if node.name == 'riml_source'
           node.name = 'source'
           node.each_existing_file! do |basename, full_path|
-            root_node(node).current_compiler.compile_queue << full_path
+            current_compiler(node).compile_queue << full_path
           end
         elsif node.name == 'riml_include'
           # riml_include has to be top-level
@@ -575,7 +608,7 @@ module Riml
           end
           node.each_existing_file! do |basename, full_path|
             riml_src = File.read(full_path)
-            node.compiled_output << root_node(node).current_compiler.compile_include(riml_src, basename)
+            node.compiled_output << current_compiler(node).compile_include(riml_src, basename)
           end
           return node.compiled_output
         end
@@ -585,13 +618,6 @@ module Riml
         node.compiled_output.sub!('.riml', '.vim')
         node.compiled_output
       end
-
-      def root_node(node)
-        @root_node ||= begin
-          node = node.parent until node.parent.nil?
-          node
-        end
-      end
     end
 
     class ForNodeVisitor < Visitor

data/lib/nodes.rb

@@ -45,15 +45,19 @@ module Riml
     alias walk each
 
     def previous
-      idx = index
-      return unless idx
-      parent.children.fetch(idx - 1)
+      idx = index_by_member
+      if idx && parent.members[idx - 1]
+        attr = parent.members[idx - 1]
+        return send(attr)
+      else
+        idx = index_by_children
+        return unless idx
+        parent.children.fetch(idx - 1)
+      end
     end
 
     def child_previous_to(node)
-      idx = children.find_index(node)
-      return unless idx
-      children.fetch(idx - 1)
+      node.previous
     end
 
     def insert_before(node, new_node)
@@ -63,15 +67,19 @@ module Riml
     end
 
     def next
-      idx = index
-      return unless idx
-      parent.children.fetch(idx + 1)
+      idx = index_by_member
+      if idx && parent.members[idx + 1]
+        attr = parent.members[idx + 1]
+        return parent.send(attr)
+      else
+        idx = index_by_children
+        return unless idx
+        parent.children.fetch(idx + 1)
+      end
     end
 
     def child_after(node)
-      idx = children.find_index(node)
-      return unless idx
-      children.fetch(idx + 1)
+      node.next
     end
 
     def insert_after(node, new_node)
@@ -80,21 +88,44 @@ module Riml
       children.insert(idx + 1, new_node)
     end
 
-    def index
+    def index_by_member
+      attrs = parent.members
+      attrs.each_with_index do |attr, i|
+        if parent.send(attr) == self
+          return i
+        end
+      end
+      nil
+    end
+
+    def index_by_children
       parent.children.find_index(self)
     end
 
     def remove
-      idx = index
-      parent.children.slice!(idx) if idx
+      idx = index_by_member
+      if idx
+        attr = parent.members[idx]
+        parent.send("#{attr}=", nil)
+      else
+        idx = index_by_children
+        parent.children.slice!(idx) if idx
+      end
     end
 
     def replace_with(new_node)
-      idx = index
-      return unless idx
-      parent.children.insert(idx, new_node)
-      parent.children.slice!(idx + 1)
-      new_node
+      idx = index_by_member
+      if idx
+        attr = parent.members[idx]
+        new_node.parent = parent
+        parent.send("#{attr}=", new_node)
+      else
+        idx = index_by_children
+        return unless idx
+        new_node.parent = parent
+        parent.children.insert(idx, new_node)
+        parent.children.slice!(idx + 1)
+      end
     end
   end
 
@@ -539,9 +570,13 @@ module Riml
     end
 
     def children
-      return [] unless interpolated?
-      return value if nested?
-      [value]
+      if !interpolated?
+        []
+      elsif nested?
+        value
+      else
+        [value]
+      end
     end
   end
 
@@ -740,7 +775,7 @@ module Riml
   end
   class WhileNode < ControlStructure; end
 
-  class UnlessNode < ControlStructure
+  class UnlessNode < IfNode
     def initialize(*)
       super
       wrap_condition_in_parens!

data/lib/repl.rb

@@ -9,7 +9,7 @@ require_relative 'riml'
 module Riml
   class Repl
     attr_reader :line
-    attr_reader :parser, :compiler
+    attr_reader :parser, :compiler, :compiler_options
     private :parser, :compiler
 
     COMPILE_ON = %w(compile c)
@@ -22,9 +22,10 @@ clear previous class definitions: #{RELOAD_ON.join(', ')}
 exit repl:                        #{EXIT_ON.join(', ')}
 msg
 
-    def initialize(vi_readline = false)
+    def initialize(vi_readline = false, compile_options = {})
       @indent_amount = 0
       @line = nil
+      @compiler_options = DEFAULT_COMPILE_OPTIONS.merge(compile_options)
       prepare_new_context
       Readline.vi_editing_mode if vi_readline
       trap(:INT) { reset!; puts }
@@ -55,6 +56,7 @@ msg
 
     def prepare_new_context
       @compiler = Compiler.new
+      @compiler.options = compiler_options
       @parser = Parser.new
     end
     alias reload! prepare_new_context
@@ -76,7 +78,7 @@ msg
     end
 
     def compile_unit!
-      viml = Riml.compile(current_compilation_unit.join("\n"), parser, compiler).chomp
+      viml = Riml.do_compile(current_compilation_unit.join("\n"), parser, compiler).chomp
       puts viml, "\n"
     rescue => e
       print_error(e)

data/lib/riml.rb

@@ -7,8 +7,15 @@ require 'lexer'
 require 'parser'
 require 'compiler'
 require 'warning_buffer'
+require 'backtrace_filter'
 
 module Riml
+
+  DEFAULT_COMPILE_OPTIONS = { :readable => true }
+  DEFAULT_COMPILE_FILES_OPTIONS = DEFAULT_COMPILE_OPTIONS.merge(
+    :output_dir => nil
+  )
+
   # lex code (String) into tokens (Array)
   def self.lex(code)
     Lexer.new(code).tokenize
@@ -23,10 +30,17 @@ module Riml
     Parser.new.parse(input, ast_rewriter, filename)
   end
 
+  def self.compile(input, options = {})
+    parser = Parser.new
+    compiler = Compiler.new
+    compiler.options = DEFAULT_COMPILE_OPTIONS.merge(options)
+    do_compile(input, parser, compiler)
+  end
+
   # compile AST (Nodes), tokens (Array), code (String) or object that returns
   # String from :read to output code (String). Writes file(s) if `input` is a
   # File.
-  def self.compile(input, parser = Parser.new, compiler = Compiler.new)
+  def self.do_compile(input, parser = Parser.new, compiler = Compiler.new)
     if input.is_a?(Nodes)
       nodes = input
     elsif input.is_a?(String) || input.is_a?(Array)
@@ -59,16 +73,15 @@ module Riml
     process_compile_queue!(compiler)
   end
 
-  # expects `filenames` (String) arguments, to be readable files. Optional options (Hash) as
-  # last argument.
+  # expects `filenames` (String) arguments, to be readable files.
+  # Optional options (Hash) as last argument.
   def self.compile_files(*filenames)
     parser, compiler = Parser.new, Compiler.new
 
     if filenames.last.is_a?(Hash)
-      opts = filenames.pop
-      if dir = opts[:output_dir]
-        compiler.output_dir = dir
-      end
+      compiler.options = DEFAULT_COMPILE_FILES_OPTIONS.merge(filenames.pop)
+    else
+      compiler.options = DEFAULT_COMPILE_FILES_OPTIONS.dup
     end
 
     if filenames.size > 1
@@ -78,22 +91,26 @@ module Riml
           _parser, _compiler = parser, compiler
         else
           _parser, _compiler = Parser.new, Compiler.new
-          _compiler.output_dir = compiler.output_dir
+          _compiler.options = compiler.options
         end
         threads << Thread.new do
           f = File.open(fname)
-          compile(f, _parser, _compiler)
+          # `do_compile` will close file handle
+          do_compile(f, _parser, _compiler)
         end
       end
       threads.each {|t| t.join}
     elsif filenames.size == 1
       fname = filenames.first
       f = File.open(fname)
-      # `compile` will close file handle
-      compile(f, parser, compiler)
+      # `do_compile` will close file handle
+      do_compile(f, parser, compiler)
     else
       raise ArgumentError, "need filenames to compile"
     end
+  rescue Riml::ParseError => pe
+    BacktraceFilter.new(pe).filter!
+    raise
   ensure
     flush_warnings
   end
@@ -183,7 +200,7 @@ module Riml
     while full_path = compiler.compile_queue.shift
       unless compiler.sourced_files_compiled.include?(full_path)
         compiler.sourced_files_compiled << full_path
-        compile(File.open(full_path), compiler.parser, compiler)
+        do_compile(File.open(full_path), compiler.parser, compiler)
       end
     end
   end
@@ -210,6 +227,9 @@ module Riml
     basename_without_riml_ext = File.basename(fname).sub(/\.riml\Z/i, '')
     FileUtils.mkdir_p(output_dir) unless File.directory?(output_dir)
     full_path = File.join(output_dir, "#{basename_without_riml_ext}.vim")
+    if output[-2..-1] == "\n\n"
+      output.chomp!
+    end
     File.open(full_path, 'w') do |f|
       f.write FILE_HEADER + output
     end

data/version.rb

@@ -1,4 +1,4 @@
 module Riml
-  # last changed: Sept. 14, 2013
-  VERSION = [0,3,1]
+  # last changed: Sept. 22, 2013
+  VERSION = [0,3,2]
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riml
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-14 00:00:00.000000000 Z
+date: 2013-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: racc
@@ -64,6 +64,7 @@ files:
 - lib/included.vim
 - lib/constants.rb
 - lib/parser.output
+- lib/backtrace_filter.rb
 - lib/lexer.rb
 - lib/grammar.y
 - lib/compiler.rb