lib/delorean/engine.rb in delorean_lang-0.1.7 vs lib/delorean/engine.rb in delorean_lang-0.2.0

@@ -3,16 +3,17 @@
 require 'set'
 require 'pp'
 
 module Delorean
   class Engine
-    attr_reader :last_node, :module_name, :version,
-    :line_no, :comp_set, :pm, :m, :imports
+    attr_reader :last_node, :module_name, :line_no,
+    :comp_set, :pm, :m, :imports, :sset
 
-    def initialize(module_name, version=nil)
+    def initialize(module_name, sset=nil)
       # name of current module
-      @module_name, @version = module_name, version
+      @module_name = module_name
+      @sset = sset
       reset
     end
 
     def reset
       @m, @pm = nil, nil
@@ -30,34 +31,34 @@
 
     def curr_line
       @multi_no || @line_no
     end
 
-    def parse_import(sset, name, version)
+    def parse_import(name)
       err(ParseError, "No script set") unless sset
 
       err(ParseError, "Module #{name} importing itself") if
         name == module_name
 
       begin
-        @imports[name] = [sset.import(name, version), version]
+        @imports[name] = sset.get_engine(name)
       rescue => exc
         err(ImportError, exc.to_s)
       end
 
-      @pm.const_set("#{MOD}#{name}", @imports[name][0].pm)
+      @pm.const_set("#{MOD}#{name}", @imports[name].pm)
     end
 
-    def gen_import(name, version)
-      @imports.merge!(@imports[name][0].imports)
+    def gen_import(name)
+      @imports.merge!(@imports[name].imports)
 
-      @m.const_set("#{MOD}#{name}", @imports[name][0].m)
+      @m.const_set("#{MOD}#{name}", @imports[name].m)
     end
 
     def get_import_engine(name)
       err(ParseError, "#{name} not imported") unless @imports[name]
-      @imports[name][0]
+      @imports[name]
     end
 
     def is_node_defined(name)
       @pm.constants.member? name.to_sym
     end
@@ -210,12 +211,12 @@
 
     def parser
       @@parser ||= DeloreanParser.new
     end
 
-    def generate(t, sset=nil)
-      t.check(self, sset)
+    def generate(t)
+      t.check(self)
 
       begin
         # generate ruby code
         gen = t.rewrite(self)
       rescue RuntimeError => exc
@@ -231,11 +232,11 @@
         # bad ruby code generated, shoudn't happen
         err(ParseError, "codegen error: " + exc.message)
       end
     end
 
-    def parse(source, sset=nil)
+    def parse(source)
       raise "can't call parse again without reset" if @pm
 
       # @m module is used at runtime for code evaluation.  @pm module
       # is only used during parsing to check for errors.
       @m, @pm = BaseModule.clone, Module.new
@@ -261,11 +262,11 @@
           multi_line += line
           t = parser.parse(multi_line)
 
           if t
             multi_line, @multi_no = nil, nil
-            generate(t, sset)
+            generate(t)
           end
 
         else
           t = parser.parse(line)
 
@@ -273,11 +274,11 @@
             err(ParseError, "syntax error") unless line =~ /^\s+/
 
             multi_line = line
             @multi_no = @line_no
           else
-            generate(t, sset)
+            generate(t)
           end
         end
       end
 
       # left over multi_line
@@ -293,12 +294,11 @@
       SortedSet[* @node_attrs.keys]
     end
 
     # enumerate qualified list of all attrs
     def enumerate_attrs
-      @node_attrs.keys.inject({}) { |h, node|
+      @node_attrs.keys.each_with_object({}) { |node, h|
         h[node] = enumerate_attrs_by_node(node)
-        h
       }
     end
 
     # enumerate qualified list of attrs by node
     def enumerate_attrs_by_node(node)