riml 0.3.3 → 0.3.4

data/lib/{class_map.rb → riml/class_map.rb}

@@ -1,4 +1,5 @@
 require File.expand_path("../errors", __FILE__)
+require File.expand_path("../imported_class", __FILE__)
 
 module Riml
   # Map of {"ClassName" => ClassDefinitionNode}
@@ -6,13 +7,26 @@ module Riml
   #
   # Ex : class_map.superclass("g:SomeClass") => "g:SomeClassBase"
   class ClassMap
+    attr_reader :globbed_imports
+
     def initialize
       @map = {}
+      # list of ImportedClass objects that are #globbed?
+      @globbed_imports = []
     end
 
     def [](key)
       ensure_key_is_string!(key)
-      @map[key] or raise ClassNotFound, "class #{key.inspect} not found."
+      klass = @map[key]
+      return klass if klass
+      if key[0..1] == 'g:'
+        globbed_imports.each do |imported_class|
+          if imported_class.match?(key)
+            return @map[key] = ImportedClass.new(key)
+          end
+        end
+      end
+      raise ClassNotFound, "class #{key.inspect} not found."
     end
 
     def []=(key, val)
@@ -39,7 +53,16 @@ module Riml
       @map.keys
     end
 
+    def safe_fetch(key)
+      @map[key]
+    end
+
+    def has_global_import?
+      @globbed_imports.any? { |import| import.global_import? }
+    end
+
     protected
+
     def ensure_key_is_string!(key)
       unless key.is_a?(String)
         raise ArgumentError, "key must be name of class (String)"

data/lib/{compiler.rb → riml/compiler.rb}

@@ -596,7 +596,7 @@ module Riml
       end
     end
 
-    class RimlCommandNodeVisitor < CallNodeVisitor
+    class RimlFileCommandNodeVisitor < CallNodeVisitor
       def compile(node)
         if node.name == 'riml_source'
           node.name = 'source'
@@ -610,8 +610,7 @@ module Riml
             raise IncludeNotTopLevel, error_msg
           end
           node.each_existing_file! do |basename, full_path|
-            riml_src = File.read(full_path)
-            output = current_compiler(node).compile_include(riml_src, basename)
+            output = current_compiler(node).compile_include(basename, full_path)
             node.compiled_output << output if output
           end
           return node.compiled_output
@@ -781,13 +780,14 @@ module Riml
       @included_files_compiled ||= []
     end
 
-    def compile_include(source, filename)
-      return if included_files_compiled.include?(filename)
-      Riml.include_cache.fetch(filename) do
-        root_node = parser.parse(source, parser.ast_rewriter, filename, true)
+    def compile_include(file_basepath, file_fullpath)
+      return if included_files_compiled.include?(file_basepath)
+      Riml.include_cache.fetch(file_basepath) do
+        source = File.read(file_fullpath)
+        root_node = parser.parse(source, parser.ast_rewriter, file_basepath, true)
+        included_files_compiled << file_basepath
         output = compile(root_node)
-        included_files_compiled << filename
-        (Riml::INCLUDE_COMMENT_FMT % filename) + output
+        (Riml::INCLUDE_COMMENT_FMT % file_basepath) + output
       end
     end
 

data/lib/{constants.rb → riml/constants.rb}

@@ -20,8 +20,10 @@ module Riml
       %w(& @ $)
     BUILTIN_COMMANDS  =
       %w(echo echon echomsg echoerr echohl execute exec sleep throw)
-    RIML_COMMANDS =
+    RIML_FILE_COMMANDS =
       %w(riml_source riml_include)
+    RIML_CLASS_COMMANDS = %w(riml_import)
+    RIML_COMMANDS = RIML_FILE_COMMANDS + RIML_CLASS_COMMANDS
     VIML_COMMANDS =
       %w(source source! command! command silent silent!)
 

data/lib/{environment.rb → riml/environment.rb}

@@ -1,6 +1,6 @@
 module Riml
   module Environment
-    ROOTDIR = File.expand_path('../../', __FILE__)
+    ROOTDIR = File.expand_path('../../..', __FILE__)
     require File.join(ROOTDIR, 'version')
 
     LIBDIR = File.join(ROOTDIR, 'lib')

data/lib/{errors.rb → riml/errors.rb}

@@ -1,5 +1,7 @@
 module Riml
-  RimlError = Class.new(StandardError)
+  RimlError = Class.new(StandardError) do
+    attr_accessor :node
+  end
 
   SyntaxError  = Class.new(RimlError)
   ParseError   = Class.new(RimlError)

data/lib/{grammar.y → riml/grammar.y}

@@ -4,8 +4,9 @@ token IF ELSE ELSEIF THEN UNLESS END
 token WHILE UNTIL BREAK CONTINUE
 token TRY CATCH FINALLY
 token FOR IN
-token DEF DEF_BANG SPLAT CALL BUILTIN_COMMAND # such as echo "hi"
-token CLASS NEW DEFM DEFM_BANG SUPER RIML_COMMAND
+token DEF DEF_BANG SPLAT_PARAM SPLAT_ARG CALL BUILTIN_COMMAND # such as echo "hi"
+token CLASS NEW DEFM DEFM_BANG SUPER
+token RIML_FILE_COMMAND RIML_CLASS_COMMAND
 token RETURN
 token NEWLINE
 token NUMBER
@@ -64,7 +65,8 @@ rule
   | ClassDefinition                       { result = val[0] }
   | LoopKeyword                           { result = val[0] }
   | EndScript                             { result = val[0] }
-  | RimlCommand                           { result = val[0] }
+  | RimlFileCommand                       { result = val[0] }
+  | RimlClassCommand                      { result = val[0] }
   | MultiAssign                           { result = val[0] }
   | If                                    { result = val[0] }
   | Unless                                { result = val[0] }
@@ -233,9 +235,20 @@ rule
   | Scope DefCallIdentifier                       { result = make_node(val) { |v| Riml::CallNode.new(v[0], v[1], []) } }
   ;
 
-  RimlCommand:
-    RIML_COMMAND '(' ArgList ')'                  { result = make_node(val) { |v| Riml::RimlCommandNode.new(nil, v[0], v[2]) } }
-  | RIML_COMMAND ArgList                          { result = make_node(val) { |v| Riml::RimlCommandNode.new(nil, v[0], v[1]) } }
+  RimlFileCommand:
+    RIML_FILE_COMMAND '(' ArgList ')'             { result = make_node(val) { |v| Riml::RimlFileCommandNode.new(nil, v[0], v[2]) } }
+  | RIML_FILE_COMMAND ArgList                     { result = make_node(val) { |v| Riml::RimlFileCommandNode.new(nil, v[0], v[1]) } }
+  ;
+
+  RimlClassCommand:
+    RIML_CLASS_COMMAND '(' ClassArgList ')'       { result = make_node(val) { |v| Riml::RimlClassCommandNode.new(nil, v[0], v[2]) } }
+  | RIML_CLASS_COMMAND ClassArgList               { result = make_node(val) { |v| Riml::RimlClassCommandNode.new(nil, v[0], v[1]) } }
+  ;
+
+  ClassArgList:
+    Scope IDENTIFIER                              { result = ["#{val[0]}#{val[1]}"] }
+  | String                                        { result = val }
+  | ClassArgList ',' Scope IDENTIFIER             { result = val[0].concat ["#{val[2]}#{val[3]}"] }
   ;
 
   ExplicitCall:
@@ -259,6 +272,18 @@ rule
   | ArgListWithoutNothing                 { result = val[0] }
   ;
 
+  ArgListWithSplat:
+    /* nothing */                         { result = [] }
+  | ArgListWithoutNothingWithSplat        { result = val[0] }
+  ;
+
+  ArgListWithoutNothingWithSplat:
+    Expression                                        { result = val }
+  | SPLAT_ARG                                         { result = [ make_node(val) { |v| Riml::SplatNode.new(v[0]) } ] }
+  | ArgListWithoutNothingWithSplat "," Expression     { result = val[0] << val[2] }
+  | ArgListWithoutNothingWithSplat "," SPLAT_ARG      { result = val[0] << make_node(val) { |v| Riml::SplatNode.new(v[2]) } }
+  ;
+
   ArgListWithoutNothing:
     Expression                               { result = val }
   | ArgListWithoutNothing "," Expression     { result = val[0] << val[2] }
@@ -381,10 +406,10 @@ rule
   # Method definition
   # [SID, scope_modifier, name, parameters, keyword, expressions]
   Def:
-    FunctionType SIDAndScope DefCallIdentifier DefKeywords Block END                               { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [], v[3], v[4]) } }
-  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ')' DefKeywords Block END             { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4], v[6], v[7]) } }
-  | FunctionType SIDAndScope DefCallIdentifier '(' SPLAT     ')' DefKeywords Block END             { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [v[4]], v[6], v[7]) } }
-  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ',' SPLAT ')' DefKeywords Block END   { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4] << v[6], v[8], v[9]) } }
+    FunctionType SIDAndScope DefCallIdentifier DefKeywords Block END                                     { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [], v[3], v[4]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ')' DefKeywords Block END                   { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4], v[6], v[7]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' SPLAT_PARAM     ')' DefKeywords Block END             { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], [v[4]], v[6], v[7]) } }
+  | FunctionType SIDAndScope DefCallIdentifier '(' ParamList ',' SPLAT_PARAM ')' DefKeywords Block END   { result = make_node(val) { |v| Riml.const_get(val[0]).new('!', v[1][0], v[1][1], v[2], v[4] << v[6], v[8], v[9]) } }
   ;
 
   FunctionType:
@@ -517,8 +542,8 @@ rule
   ;
 
   Super:
-    SUPER '(' ArgList ')'     { result = make_node(val) { |v| Riml::SuperNode.new(v[2], true) } }
-  | SUPER                     { result = make_node(val) { |_| Riml::SuperNode.new([], false) } }
+    SUPER '(' ArgListWithSplat ')'     { result = make_node(val) { |v| Riml::SuperNode.new(v[2], true) } }
+  | SUPER                              { result = make_node(val) { |_| Riml::SuperNode.new([], false) } }
   ;
 
   ExLiteral:
@@ -535,6 +560,12 @@ end
   # This code will be put as-is in the parser class
 
   attr_accessor :ast_rewriter
+  attr_writer :options
+
+  # The Parser and AST_Rewriter share this same hash of options
+  def options
+    @options ||= {}
+  end
 
   # parses tokens or code into output nodes
   def parse(object, ast_rewriter = Riml::AST_Rewriter.new, filename = nil, included = false)
@@ -560,6 +591,7 @@ end
     @ast_rewriter ||= ast_rewriter
     return ast unless @ast_rewriter
     @ast_rewriter.ast = ast
+    @ast_rewriter.options ||= options
     @ast_rewriter.rewrite(filename, included)
   end
 

data/lib/riml/imported_class.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../nodes', __FILE__)
+
+module Riml
+  class ImportedClass
+
+    ANCHOR_BEGIN = '\A'
+    ANCHOR_END = '\Z'
+
+    attr_reader :name
+    def initialize(name)
+      @name = rm_modifier(name)
+    end
+
+    def imported?
+      true
+    end
+
+    # an ImportedClass is #globbed? if its name contains 1 or more '*'
+    # characters.
+    def globbed?
+      not @name.index('*').nil?
+    end
+
+    # returns MatchData or `nil`
+    def match?(class_name)
+      match_regexp.match(rm_modifier(class_name))
+    end
+
+    # returns Regexp
+    def match_regexp
+      @match_regexp ||= begin
+        normalized_glob = @name.gsub(/\*/, '.*?')
+        Regexp.new(ANCHOR_BEGIN + normalized_glob + ANCHOR_END)
+      end
+    end
+
+    def global_import?
+      @name == '*'
+    end
+
+    def scope_modifier
+      'g:'
+    end
+
+    # stubbed out constructor function
+    def constructor
+      @contructor ||= begin
+        DefNode.new('!', nil, scope_modifier, constructor_name, ['...'], [], Nodes.new([]))
+      end
+    end
+
+    def constructor_name
+      "#{name}Constructor"
+    end
+
+    def constructor_obj_name
+      @name[0].downcase + @name[1..-1] + "Obj"
+    end
+
+    private
+
+    def rm_modifier(class_name)
+      class_name.sub(/g:/, '')
+    end
+
+  end
+end

data/lib/{include_cache.rb → riml/include_cache.rb}

@@ -9,8 +9,8 @@ module Riml
     end
 
     # `fetch` can be called recursively in the `yield`ed block, so must
-    # make sure not to try to lock a Mutex if it's already locked, as this
-    # would result in a deadlock.
+    # make sure not to try to lock the Mutex if it's already locked by the
+    # current thread, as this would result in an error.
     def fetch(included_filename)
       if source = @cache[included_filename]
         return source
@@ -32,6 +32,7 @@ module Riml
       end
     end
 
+    # Not used internally but might be useful as an API
     def [](included_filename)
       @m.synchronize { @cache[included_filename] }
     end

data/lib/{lexer.rb → riml/lexer.rb}

@@ -141,8 +141,10 @@ module Riml
 
         elsif BUILTIN_COMMANDS.include?(identifier) && !chunk[/\A#{Regexp.escape(identifier)}\(/]
           @token_buf << [:BUILTIN_COMMAND, identifier]
-        elsif RIML_COMMANDS.include? identifier
-          @token_buf << [:RIML_COMMAND, identifier]
+        elsif RIML_FILE_COMMANDS.include? identifier
+          @token_buf << [:RIML_FILE_COMMAND, identifier]
+        elsif RIML_CLASS_COMMANDS.include? identifier
+          @token_buf << [:RIML_CLASS_COMMAND, identifier]
         elsif VIML_COMMANDS.include?(identifier) && (prev_token.nil? || prev_token[0] == :NEWLINE)
           @i += identifier.size
           new_chunk = get_new_chunk
@@ -159,12 +161,12 @@ module Riml
 
         parse_dict_vals!
 
-        if @in_function_declaration
-          @in_function_declaration = false unless DEFINE_KEYWORDS.include?(identifier) && @token_buf.size == 1
-        end
-      elsif splat = chunk[/\A(\.{3}|\*[a-zA-Z_]\w*)/]
-        @token_buf << [:SPLAT, splat]
-        @i += splat.size
+      elsif @in_function_declaration && (splat_param = chunk[/\A(\.{3}|\*[a-zA-Z_]\w*)/])
+        @token_buf << [:SPLAT_PARAM, splat_param]
+        @i += splat_param.size
+      elsif !@in_function_declaration && (splat_arg = chunk[/\A\*([bwtglsavn]:)?([a-zA-Z_]\w*|\d+)/])
+        @token_buf << [:SPLAT_ARG, splat_arg]
+        @i += splat_arg.size
       # integer (octal)
       elsif octal = chunk[/\A0[0-7]+/]
         @token_buf << [:NUMBER, octal]
@@ -204,6 +206,9 @@ module Riml
         elsif @dedent_pending
           @dedent_pending = false
         end
+        if @in_function_declaration
+          @in_function_declaration = false
+        end
 
         @i += newlines.size
         @lineno += newlines.size

data/lib/{nodes.rb → riml/nodes.rb}

@@ -284,6 +284,12 @@ module Riml
     end
   end
 
+  # right now just used in splats in a calling context with super,
+  # such as `super(*args)` or `super(*a:000)`
+  class SplatNode < LiteralNode
+    include Walkable
+  end
+
   class SIDNode < LiteralNode
     def initialize(ident = 'SID')
       Riml.warn("expected #{ident} to be SID") unless ident == 'SID'
@@ -396,8 +402,12 @@ module Riml
   #   call s:Method(argument1, argument2)
   class ExplicitCallNode < CallNode; end
 
-  # riml_include and riml_source
-  class RimlCommandNode  < CallNode
+  # riml_include, riml_source, riml_import
+  class RimlCommandNode < CallNode
+  end
+
+  # riml_include, riml_source
+  class RimlFileCommandNode < RimlCommandNode
 
     def initialize(*)
       super
@@ -410,22 +420,16 @@ module Riml
     # Riml.source_path or Riml.include_path
     def each_existing_file!
       files = {}
+      path_dirs
       file_variants.each do |(fname_given, fname_ext_added)|
-        fname = nil
-        if base_path = paths.detect do |path|
-             full_given = File.join(path, fname_given)
-             full_ext_added = File.join(path, fname_ext_added)
-             fname = if File.exists?(full_given)
-               fname_given
-             elsif File.exists?(full_ext_added)
-               add_ext_to_filename(fname_given)
-               fname_ext_added
-             end
-           end
-          files[fname] = File.join(base_path, fname)
+        if (full_path = Riml.path_cache.file(path_dirs, fname_given))
+          files[fname_given] = full_path
+        elsif (full_path = Riml.path_cache.file(path_dirs, fname_ext_added))
+          add_ext_to_filename(fname_given)
+          files[fname_ext_added] = full_path
         else
           raise Riml::FileNotFound, "#{fname_given.inspect} could not be found in " \
-            "Riml.#{name.sub('riml_', '')}_path (#{paths.join(':').inspect})"
+            "Riml.#{name.sub('riml_', '')}_path (#{path_dirs.join(':').inspect})"
         end
       end
       return files unless block_given?
@@ -439,7 +443,9 @@ module Riml
       end
     end
 
-    def paths
+    private
+
+    def path_dirs
       if name == 'riml_include'
         Riml.include_path
       else
@@ -447,8 +453,6 @@ module Riml
       end
     end
 
-    private
-
     def file_variants
       arguments.map { |arg| file_variants_for_arg(arg) }
     end
@@ -464,6 +468,34 @@ module Riml
     end
   end
 
+  class RimlClassCommandNode < RimlCommandNode
+    def initialize(*args)
+      super
+      string_node_arguments.each do |arg|
+        class_name = arg.value
+        # if '*' isn't a char in `class_name`, raise error
+        if class_name.index('*').nil?
+          msg = "* must be a character in class name '#{class_name}' if riml_import " \
+          "is given a string. Try\n`riml_import` #{class_name}` instead."
+          error = UserArgumentError.new(msg)
+          error.node = self
+          raise error
+        end
+      end
+    end
+
+    def class_names_without_modifiers
+      arguments.map do |full_name|
+        full_name = full_name.value if full_name.respond_to?(:value)
+        full_name.sub(/\A\w:/, '')
+      end
+    end
+
+    def string_node_arguments
+      arguments.select { |arg| StringNode === arg }
+    end
+  end
+
   class OperatorNode < Struct.new(:operator, :operands)
     include Visitable
     include Walkable
@@ -639,6 +671,7 @@ module Riml
     include Walkable
 
     attr_accessor :private_function
+    alias private_function? private_function
 
     def initialize(*args)
       super
@@ -991,6 +1024,12 @@ module Riml
       not superclass_name.nil?
     end
 
+    # This if for the AST_Rewriter, checking if a class is an `ImportedClass`
+    # or not without resorting to type checking.
+    def imported?
+      false
+    end
+
     def full_name
       scope_modifier + name
     end