riml 0.2.0 → 0.2.1

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 by Luke Gruber
+Copyright (c) 2012-2013 by Luke Gruber
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -4,12 +4,19 @@ require 'rake/testtask'
 task :default => :test
 task :test => [:output_test_count]
 
-desc 'Run all *_tests and *_specs (default)'
+desc 'Run all tests (default)'
 Rake::TestTask.new(:test) do |t|
   TEST_LIST = FileList['test/**/*_test.rb'].to_a
   t.test_files = TEST_LIST
 end
 
+desc 'recreate lib/parser.rb from lib/grammar.y using racc'
+task :parser do
+  Dir.chdir(File.expand_path("../lib", __FILE__)) do
+    sh 'racc -o parser.rb grammar.y'
+  end
+end
+
 task :output_test_count do
   puts "#{TEST_LIST.size} test files to run."
 end

data/bin/riml

@@ -99,6 +99,9 @@ module Riml
         elsif options.repl
           require 'repl'
           Riml::Repl.new(options.vi_readline).run
+        else
+          ARGV << '--help'
+          start
         end
       end
     end

data/lib/ast_rewriter.rb

@@ -13,20 +13,25 @@ module Riml
       @ast = ast
       @classes = classes || ClassMap.new
       @rewritten_include_files = {}
+      # keeps track of which files included which, to prevent infinite loops
+      @included_file_refs = {}
     end
 
-    def rewrite(file = nil)
-      if rewritten_ast = rewritten_include_files[file]
-        return rewritten_ast
+    def rewrite(from_file = nil)
+      if from_file
+        if rewritten_ast = rewritten_include_files[from_file]
+          return rewritten_ast
+        end
+        rewrite_included_files!(from_file)
       end
-      rewrite_included_files!
       establish_parents(ast)
       rewriters = [
         StrictEqualsComparisonOperator.new(ast, classes),
         VarEqualsComparisonOperator.new(ast, classes),
         ClassDefinitionToFunctions.new(ast, classes),
         ObjectInstantiationToCall.new(ast, classes),
-        CallToExplicitCall.new(ast, classes)
+        CallToExplicitCall.new(ast, classes),
+        DefaultParamToIfNode.new(ast, classes)
       ]
       rewriters.each do |rewriter|
         rewriter.rewrite_on_match
@@ -53,14 +58,30 @@ module Riml
       replace node if match?(node)
     end
 
-    def rewrite_included_files!
+    # We need to rewrite the included files before anything else. This is in
+    # order to keep track of any classes defined in the included files (and
+    # files included in those, etc...). We keep a cache of rewritten asts
+    # because the 'riml_include'd files are parsed more than once. They're
+    # parsed first before anything else, plus whenever the compiler visits a
+    # 'compile_include' node in order to compile it on the spot.
+    def rewrite_included_files!(from_file)
       old_ast = ast
       ast.children.each do |node|
         next unless RimlCommandNode === node && node.name == 'riml_include'
         node.each_existing_file! do |file|
+          if from_file && @included_file_refs[file] == from_file
+            msg = "#{from_file.inspect} can't include #{file.inspect}, as " \
+                  " #{file.inspect} already included #{from_file.inspect}"
+            raise IncludeFileLoop, msg
+          elsif from_file == file
+            raise UserArgumentError, "#{file.inspect} can't include itself"
+          end
+          @included_file_refs[from_file] = file
           full_path = File.join(Riml.source_path, file)
           riml_src = File.read(full_path)
-          rewritten_ast = Parser.new.parse(riml_src, self)
+          # recursively parse included files with this ast_rewriter in order
+          # to pick up any classes that are defined there
+          rewritten_ast = Parser.new.parse(riml_src, self, file)
           rewritten_include_files[file] = rewritten_ast
         end
       end
@@ -297,5 +318,50 @@ module Riml
       end
     end
 
+    class DefaultParamToIfNode < AST_Rewriter
+      def match?(node)
+        DefaultParamNode === node
+      end
+
+      def replace(node)
+        def_node = node.parent
+        param_idx = def_node.parameters.index(node)
+        first_default_param = def_node.parameters.detect(&DefNode::DEFAULT_PARAMS)
+        first_default_param_idx = def_node.parameters.index(first_default_param)
+
+        last_default_param = def_node.parameters.reverse.detect(&DefNode::DEFAULT_PARAMS)
+        insert_idx = param_idx - first_default_param_idx
+
+        while param = def_node.parameters[param_idx += 1]
+          unless param == def_node.splat || DefaultParamNode === param
+            raise UserArgumentError, "can't have regular parameter after default parameter in function #{def_node.name.inspect}"
+          end
+        end
+
+        if_expression = construct_if_expression(node)
+
+        if last_default_param == node
+          def_node.parameters.delete_if(&DefNode::DEFAULT_PARAMS)
+          def_node.parameters << SPLAT_LITERAL unless def_node.splat
+        end
+        def_node.expressions.insert(insert_idx, if_expression)
+        reestablish_parents(def_node)
+      end
+
+      def construct_if_expression(node)
+        get_splat_node = CallNode.new(nil, 'get', [ GetVariableNode.new('a:', '000'), NumberNode.new(0), StringNode.new('rimldefault', :s) ])
+        condition_node = BinaryOperatorNode.new('!=#', [ get_splat_node, StringNode.new('rimldefault', :s) ])
+        remove_from_splat_node = CallNode.new(nil, 'remove', [ GetVariableNode.new('a:', '000'), NumberNode.new(0) ])
+        IfNode.new(condition_node,
+          Nodes.new([
+            AssignNode.new('=', GetVariableNode.new(nil, node.parameter), remove_from_splat_node),
+          ElseNode.new(Nodes.new([
+            AssignNode.new('=', GetVariableNode.new(nil, node.parameter), node.expression)
+          ]))
+          ])
+        )
+      end
+    end
+
   end
 end

data/lib/compiler.rb

@@ -185,6 +185,19 @@ module Riml
     ContinueNodeVisitor = LiteralNodeVisitor
     BreakNodeVisitor = LiteralNodeVisitor
 
+    class StringLiteralConcatNodeVisitor < Visitor
+      def compile(nodes)
+        nodes.each_with_index do |node, i|
+          visitor = visitor_for_node(node)
+          node.parent_node = nodes
+          next_node = nodes.nodes[i+1]
+          node.accept(visitor)
+          nodes.compiled_output << ' ' if next_node
+        end
+        nodes.compiled_output
+      end
+    end
+
     class ListUnpackNodeVisitor < ListNodeVisitor
       def compile(node)
         node.compiled_output = super.reverse.sub(',', ';').reverse
@@ -219,7 +232,9 @@ module Riml
       def set_modifier(node)
         # Ex: n:myVariable = "override riml default scoping" compiles into:
         #       myVariable = "override riml default scoping"
-        node.scope_modifier = "" if node.scope_modifier == "n:"
+        if node.scope_modifier == "n:"
+          node.scope_modifier = ""
+        end
         return node.scope_modifier if node.scope_modifier
         node.scope_modifier = scope_modifier_for_node(node)
       end
@@ -495,6 +510,11 @@ module Riml
             root_node(node).current_compiler.compile_queue << file
           end
         elsif node.name == 'riml_include'
+          # riml_include has to be top-level
+          unless node.parent == root_node(node)
+            error_msg = %Q(riml_include error, has to be called at top-level)
+            raise IncludeNotTopLevel, error_msg
+          end
           node.each_existing_file! do |file|
             full_path = File.join(Riml.source_path, file)
             riml_src = File.read(full_path)
@@ -510,8 +530,10 @@ module Riml
       end
 
       def root_node(node)
-        node = node.parent until node.parent.nil?
-        node
+        @root_node ||= begin
+          node = node.parent until node.parent.nil?
+          node
+        end
       end
     end
 
@@ -618,6 +640,20 @@ module Riml
       end
     end
 
+    class GetVariableByScopeAndDictNameNodeVisitor < Visitor
+      def compile(node)
+        node.scope_modifier.parent = node
+        node.scope_modifier.accept(visitor_for_node(node.scope_modifier))
+        node.keys.each do |key|
+          key.parent = node
+          node.compiled_output << '['
+          key.accept(visitor_for_node(key))
+          node.compiled_output << ']'
+        end
+        node.compiled_output
+      end
+    end
+
     class ClassDefinitionNodeVisitor < Visitor
       def compile(node)
         node.expressions.parent_node = node
@@ -645,10 +681,13 @@ module Riml
       @compile_queue ||= []
     end
 
-    def compile_include(source, from_file = nil)
+    def sourced_files_compiled
+      @sourced_files_compiled ||= []
+    end
+
+    def compile_include(source, from_file)
       root_node = parser.parse(source, parser.ast_rewriter, from_file)
       output = compile(root_node)
-      return output unless from_file
       (Riml::INCLUDE_COMMENT_FMT % from_file) + output
     end
 

data/lib/constants.rb

@@ -30,7 +30,24 @@ module Riml
     COMPARISON_OPERATORS = IGNORECASE_CAPABLE_OPERATORS.map do |o|
       [o + '#', o + '?', o]
     end.flatten
-    # :h function-list
+
+    SPLAT_LITERAL = '...'
+
+    # :help registers
+    REGISTERS = [
+      '"',
+      (0..9).to_a.map(&:to_s),
+      '-',
+      ('a'..'z').to_a.map(&:to_s),
+      ('A'..'Z').to_a.map(&:to_s),
+      ':', '.', '%', '#',
+      '=',
+      '*', '+', '~',
+      '_',
+      '/'
+    ].flatten
+
+    # :help function-list
     BUILTIN_FUNCTIONS =
     %w(
 abs

data/lib/errors.rb

@@ -6,6 +6,10 @@ module Riml
   CompileError = Class.new(RimlError)
 
   FileNotFound = Class.new(RimlError)
+  IncludeFileLoop = Class.new(RimlError)
+  IncludeNotTopLevel = Class.new(RimlError)
+  # bad user arguments to Riml functions
+  UserArgumentError = Class.new(RimlError)
 
   ClassNotFound = Class.new(RimlError)
   ClassRedefinitionError = Class.new(RimlError)

data/lib/grammar.y

@@ -122,6 +122,8 @@ rule
   String:
     STRING_S                              { result = StringNode.new(val[0], :s) }
   | STRING_D                              { result = StringNode.new(val[0], :d) }
+  | String STRING_S                       { result = StringLiteralConcatNode.new(val[0], StringNode.new(val[1], :s)) }
+  | String STRING_D                       { result = StringLiteralConcatNode.new(val[0], StringNode.new(val[1], :d)) }
   ;
 
   Regexp:
@@ -318,6 +320,7 @@ rule
   VariableRetrieval:
     Scope IDENTIFIER                           { result = GetVariableNode.new(val[0], val[1]) }
   | SPECIAL_VAR_PREFIX IDENTIFIER              { result = GetSpecialVariableNode.new(val[0], val[1]) }
+  | ScopeModifierLiteral ListOrDictGetWithBrackets { result = GetVariableByScopeAndDictNameNode.new(val[0], val[1]) }
   ;
 
   AllVariableRetrieval:
@@ -374,7 +377,13 @@ rule
   ParamList:
     /* nothing */                         { result = [] }
   | IDENTIFIER                            { result = val }
+  | DefaultParam                          { result = val }
   | ParamList ',' IDENTIFIER              { result = val[0] << val[2] }
+  | ParamList ',' DefaultParam            { result = val[0] << val[2] }
+  ;
+
+  DefaultParam:
+    IDENTIFIER '=' ValueExpression        { result = DefaultParamNode.new(val[0], val[2]) }
   ;
 
   Return:
@@ -419,6 +428,7 @@ rule
   For:
     FOR IDENTIFIER IN ValueExpression Block END     { result = ForNode.new(val[1], val[3], val[4]) }
   | FOR List IN ValueExpression Block END           { result = ForNode.new(val[1], val[3], val[4]) }
+  | FOR ListUnpack IN ValueExpression Block END     { result = ForNode.new(val[1], val[3], val[4]) }
   ;
 
   Try:

data/lib/lexer.rb

@@ -88,8 +88,17 @@ module Riml
         @token_buf << [:SCOPE_MODIFIER_LITERAL, scope_modifier_literal]
       elsif special_var_prefix = chunk[/\A(&(\w:)?(?!&)|\$|@)/]
         @token_buf << [:SPECIAL_VAR_PREFIX, special_var_prefix.strip]
-        @expecting_identifier = true
         @i += special_var_prefix.size
+        if special_var_prefix == '@'
+          new_chunk = get_new_chunk
+          next_char = new_chunk[0]
+          if REGISTERS.include?(next_char)
+            @token_buf << [:IDENTIFIER, next_char]
+            @i += 1
+          end
+        else
+          @expecting_identifier = true
+        end
       elsif function_method = chunk[/\A(function)\(/, 1]
         @token_buf << [:IDENTIFIER, function_method]
         @i += function_method.size
@@ -153,7 +162,7 @@ module Riml
         @token_buf << [:NUMBER, hex]
         @i += hex.size
       # integer or float (decimal)
-      elsif decimal = chunk[/\A[0-9]+(\.[0-9]+)?/]
+      elsif decimal = chunk[/\A[0-9]+(\.[0-9]+([eE][+-]?[0-9]+)?)?/]
         @token_buf << [:NUMBER, decimal]
         @i += decimal.size
       elsif interpolation = chunk[INTERPOLATION_REGEX]

data/lib/nodes.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../constants', __FILE__)
+require File.expand_path('../errors', __FILE__)
 require 'set'
 
 module Visitable
@@ -29,9 +30,8 @@ module Visitable
       super
     end
   end
-  def respond_to_missing?(method, include_private = false)
-    return true if method =~ DESCENDANT_OF_REGEX
-    super
+  def respond_to?(method, include_private = false)
+    super || method =~ DESCENDANT_OF_REGEX
   end
 end
 
@@ -127,9 +127,8 @@ class Nodes < Struct.new(:nodes)
     end
   end
 
-  def respond_to_missing?(method, include_private = false)
-    return true if nodes.respond_to?(method)
-    super
+  def respond_to?(method, include_private = false)
+    super || nodes.respond_to?(method, include_private)
   end
 
   def children
@@ -155,6 +154,20 @@ class StringNode < Struct.new(:value, :type) # type: :d or :s for double- or sin
   include Visitable
 end
 
+class StringLiteralConcatNode < Struct.new(:string_nodes)
+  include Visitable
+  include Walkable
+
+  def initialize(*string_nodes)
+    super(string_nodes)
+  end
+  alias nodes string_nodes
+
+  def children
+    string_nodes
+  end
+end
+
 class RegexpNode < LiteralNode; end
 
 class ListNode < LiteralNode
@@ -306,6 +319,14 @@ end
 #   call s:Method(argument1, argument2)
 class ExplicitCallNode < CallNode; end
 class RimlCommandNode  < CallNode
+
+  def initialize(*)
+    super
+    if arguments.empty? || !arguments.all? { |arg| arg.is_a?(StringNode) }
+      raise Riml::UserArgumentError, "#{name.inspect} error: must pass string (name of file)"
+    end
+  end
+
   def each_existing_file!
     files = []
     arguments.map(&:value).each do |file|
@@ -316,8 +337,15 @@ class RimlCommandNode  < CallNode
           "source path (#{Riml.source_path.inspect})"
       end
     end
+    return unless block_given?
     # all files exist
-    files.each {|f| yield f} if block_given?
+    files.each do |f|
+      begin
+        yield f
+      rescue Riml::IncludeFileLoop
+        arguments.delete_if { |arg| arg.value == f }
+      end
+    end
   end
 end
 
@@ -477,28 +505,30 @@ class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keyword,
   def initialize(*args)
     super
     # max number of arguments in viml
-    if parameters.size > 20
-      raise ArgumentError, "can't have more than 20 parameters for #{full_name}"
+    if parameters.reject(&DEFAULT_PARAMS).size > 20
+      raise Riml::UserArgumentError, "can't have more than 20 parameters for #{full_name}"
     end
   end
 
-  SPLAT = lambda {|arg| arg == '...' || arg[0] == "*"}
+  SPLAT = lambda {|arg| arg == Riml::Constants::SPLAT_LITERAL || arg[0] == "*"}
+  DEFAULT_PARAMS = lambda {|p| DefaultParamNode === p}
 
   # ["arg1", "arg2"}
   def argument_variable_names
-    @argument_variable_names ||= parameters.reject(&SPLAT)
+    parameters.reject(&SPLAT)
   end
 
   # returns the splat argument or nil
   def splat
-    @splat ||= begin
-      parameters.select(&SPLAT).first
-    end
+    parameters.detect(&SPLAT)
   end
 
   def keyword
-    return super unless name.include?(".")
-    "dict"
+    if name.include?('.')
+      'dict'
+    else
+      super
+    end
   end
 
   def autoload?
@@ -516,8 +546,13 @@ class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keyword,
     end
   end
 
+  def default_param_nodes
+    parameters.select(&DEFAULT_PARAMS)
+  end
+
   def children
-     [expressions]
+    children = [expressions]
+    children.concat(default_param_nodes)
   end
 
   def method_missing(method, *args, &blk)
@@ -529,6 +564,15 @@ class DefNode < Struct.new(:bang, :scope_modifier, :name, :parameters, :keyword,
   end
 end
 
+class DefaultParamNode < Struct.new(:parameter, :expression)
+  include Visitable
+  include Walkable
+
+  def children
+    [parameter, expression]
+  end
+end
+
 class ScopeNode
   attr_writer :for_node_variable_names, :argument_variable_names
   attr_accessor :function
@@ -721,6 +765,15 @@ class ListOrDictGetNode < Struct.new(:list_or_dict, :keys)
   end
 end
 
+class GetVariableByScopeAndDictNameNode < Struct.new(:scope_modifier, :keys)
+  include Visitable
+  include Walkable
+
+  def children
+    [scope_modifier] + keys
+  end
+end
+
 class TryNode < Struct.new(:try_block, :catch_nodes, :finally_block)
   include Visitable
   include Indentable
@@ -750,7 +803,14 @@ class ClassDefinitionNode < Struct.new(:name, :superclass_name, :expressions)
 
   def constructor
     expressions.detect do |n|
-      DefNode === n && (n.name == 'initialize' || n.name.match(/Constructor\Z/))
+      next(false) unless DefNode === n && (n.name == 'initialize' || n.name.match(/Constructor\Z/))
+      if n.instance_of?(DefMethodNode)
+        Riml.warn("class #{name.inspect} has an initialize function declared with 'defm'. Please use 'def'.")
+        new_node = n.to_def_node
+        new_node.keyword = nil
+        n.replace_with(new_node)
+      end
+      true
     end
   end
   alias constructor? constructor