maroon 0.7.1 → 0.8.0

data/generated/Tokens.rb

@@ -1,6 +1,11 @@
 class Tokens
   def self.define_token(name)
-    class_eval("@@#{name} = Tokens.new :#{name};def Tokens.#{name};@@#{name};end")
+    class_eval %{
+      @#{name} = Tokens.new :#{name};
+      def Tokens.#{name}
+        @#{name}
+      end
+    }
   end
 
   def to_s
@@ -21,4 +26,61 @@ class Tokens
   define_token :indexer
   define_token :block
   define_token :block_with_bind
-end
+  define_token :initializer
+  define_token :const
+end
+
+class DependencyGraphModel
+
+  def initialize(dependencies)
+    @dependencies = dependencies
+  end
+
+  def to_hash
+    @dependecies
+  end
+
+  def to_s
+    print_dependencies @dependencies,0
+  end
+
+  def to_dot
+    res = ''
+    dependencies = denormalize @dependencies
+    dependencies.each{|d| res << d.reverse.join('->') << '
+'}
+    'digraph g{
+    ' + res + '}'
+  end
+
+  private
+  def print_dependencies(dependencies,indent)
+    res = ''
+    dependencies.each do |key,value|
+        res << key.to_s
+        if value.instance_of? Hash
+          res << '->' << (print_dependencies value,indent != nil ? indent+4 : nil)
+        elsif
+          res << ':' << value.to_s + '
+          '
+          indent.times {res << ' '} unless indent == nil
+        end
+        res << '
+  '
+      end
+    res
+  end
+
+  def denormalize(dependencies)
+    res = []
+    dependencies.each do |key,value|
+      if value.instance_of? Hash
+        res = denormalize value
+        res.each{|a| a << key}
+      else
+        res << [key]
+      end
+    end
+    res
+  end
+end

data/generated/build.rb

@@ -9,6 +9,4 @@ require_relative './interpretation_context'
 require_relative './AbstractSyntaxTree'
 require_relative './AstRewritter'
 require_relative './Transformer'
-
-
-
+require_relative './DependencyGraph'

data/generated/maroon/kernel.rb

@@ -0,0 +1,7 @@
+require_relative '../Context'
+
+unless Kernel::methods.detect { |m| m== :context }
+  def context(*args, &b)
+    Context.define *args, &b
+  end
+end

data/lib/AbstractSyntaxTree.rb

@@ -0,0 +1,120 @@
+class AbstractSyntaxTree
+      def initialize(ast,interpretation_context) rebind(ImmutableQueue.empty.push(ast), interpretation_context) end
+ def type() case
+when (nil == production) then
+  nil
+when self_production_is_block_with_bind? then
+  Tokens.block_with_bind
+when self_production_is_block? then
+  Tokens.block
+when (production.instance_of?(Fixnum) or production.instance_of?(Symbol)) then
+  Tokens.terminal
+when self_production_is_rolemethod_call? then
+  Tokens.rolemethod_call
+when self_production_is_role? then
+  Tokens.role
+when self_production_is_indexer? then
+  Tokens.indexer
+when self_production_is_const? then
+  Tokens.const
+when self_production_is_initializer? then
+  Tokens.initializer
+when self_production_is_call? then
+  Tokens.call
+else
+  Tokens.other
+end end
+ def [](i) @production[i] end
+ def []=(i,v) @production[i] = v end
+ def length() @production.length end
+ def last() @production.last end
+ def first() @production.first end
+ def data() return @data if @data
+@data = case
+when self_production_is_call? then
+  @production[2]
+else
+  @production
+end
+ end
+ def each_production() yield(self)
+if production.instance_of?((Sexp or production.instance_of?(Array))) then
+  @queue = @queue.push_array(production)
+end
+while @queue.!=(ImmutableQueue.empty) do
+  rebind(@queue, @interpretation_context)
+  yield(self)
+  if production.instance_of?((Sexp or production.instance_of?(Array))) then
+    @queue = @queue.push_array(production)
+  end
+end
+ end
+     private
+def rebind(queue,ctx) @data = nil
+@production, @queue = queue.pop
+@interpretation_context = ctx
+ end
+def self_production_is_role?() case
+when (self_production_is_call? and interpretation_context.roles.has_key?(production[2])) then
+  @data = [production[2]]
+  return true
+when (((production == :self) or ((self_production_is_indexer? and ((production[1] == nil) or (production[1] == :self))) or (production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :self))))) and @interpretation_context.defining_role) then
+  @data = @interpretation_context.defining_role
+  return true
+else
+  false
+end end
+   def self_production_is_indexer?() self_production_is_call? and ((production[2] == :[]) or (production[2] == :[]=)) end
+   def self_production_is_call?() production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :call)) end
+   def self_production_is_block?() production and ((production.instance_of?(Sexp) or production.instance_of?(Array)) and (production[0] == :iter)) end
+   def self_production_is_block_with_bind?() if self_production_is_block? then
+  body = @production.last
+  if body and exp = body[1] then
+    bind = AbstractSyntaxTree.new(exp, @interpretation_context)
+    if (bind.type == Tokens.call) and (bind.data == :bind) then
+      aliases = {}
+      list = exp.last[(1..-1)]
+      (list.length / 2).times do |i|
+        local = list[(i * 2)].last
+        role_name = list[((i * 2) + 1)].last
+        raise("Local in bind should be a symbol") unless local.instance_of?(Symbol)
+        unless role_name.instance_of?(Symbol) then
+          raise("Role name in bind should be a symbol")
+        end
+        aliases[local] = role_name
+      end
+      @data = aliases
+      true
+    end
+  end
+end end
+   def self_production_is_const?() if production.instance_of?(Sexp) and ((production.length == 2) and ((production[0] == :const) and production[1].instance_of?(Symbol))) then
+  @data = [production[1]]
+  true
+else
+  false
+end end
+   def self_production_is_initializer?() if self_production_is_call? then
+  if (AbstractSyntaxTree.new(production[1], @interpretation_context).type == Tokens.const) then
+    return true if (production[2] == :new)
+  end
+end
+false
+ end
+   def self_production_is_rolemethod_call?() can_be = self_production_is_call?
+if can_be then
+  instance = AbstractSyntaxTree.new(production[1], @interpretation_context)
+  can_be = (instance.type == Tokens.role)
+  if can_be then
+    instance_data = instance.data[0]
+    role = @interpretation_context.roles[instance_data]
+    data = production[2]
+    can_be = role.has_key?(data)
+    @data = [data, instance_data]
+  end
+end
+can_be
+ end
+attr_reader :interpretation_context, :queue, :production
+
+           end

data/lib/AstRewritter.rb

@@ -1,65 +1,60 @@
 class AstRewritter
-  def initialize(ast, interpretation_context)
-    @ast = Production.new(ast, interpretation_context)
-    @roles = interpretation_context.roles
-  end
-
-  def rewrite!()
-    ast.each do |production|
-      case production.type
-        when Tokens.rolemethod_call then
-          data = production.data
-          production[2] = ((("self_" + data[1].to_s) + "_") + data[0].to_s).to_sym
-          production[1] = nil
-        when Tokens.block_with_bind then
-          block = production.last
-          block.delete_at(1)
-          production.data.each do |local, aliased_role|
-            must_b_sym = "aliased_role must be a Symbol".to_sym
-            local_must_b_sym = "local must be a Symbol".to_sym
-            raise(must_b_sym) unless aliased_role.instance_of?(Symbol)
-            raise(local_must_b_sym) unless local.instance_of?(Symbol)
-            unless @roles.has_key?(aliased_role) then
-              role_names = []
-              @interpretation_context.each { |k, v| (role_names << k.to_s) }
-              raise(((aliased_role.to_s + " is not a role. Available roles are ") + role_names.join(",")))
-            end
-            aliased_field = ("@" + aliased_role.to_s).to_sym
-            temp_symbol = ("temp____" + aliased_role.to_s).to_sym
-            assignment = Sexp.new
-            assignment[0] = :iasgn
-            assignment[1] = aliased_field
-            load_arg = Sexp.new
-            load_arg[0] = :lvar
-            load_arg[1] = local
-            assignment[2] = load_arg
-            block.insert(1, assignment)
-            assignment = Sexp.new
-            assignment[0] = :lasgn
-            assignment[1] = temp_symbol
-            load_field = Sexp.new
-            load_field[0] = :ivar
-            load_field[1] = aliased_field
-            assignment[2] = load_field
-            block.insert(1, assignment)
-            assignment = Sexp.new
-            assignment[0] = :iasgn
-            assignment[1] = aliased_field
-            load_temp = Sexp.new
-            load_temp[0] = :lvar
-            load_temp[1] = temp_symbol
-            assignment[2] = load_temp
-            block[block.length] = assignment
-          end
-        else
-          # do nothing
+      def initialize(ast,interpretation_context) @ast = AbstractSyntaxTree.new(ast, interpretation_context)
+@roles = interpretation_context.roles
+ end
+ def rewrite!() ast.each_production do |production|
+  case production.type
+  when Tokens.rolemethod_call then
+    data = production.data
+    production[2] = ((("self_" + data[1].to_s) + "_") + data[0].to_s).to_sym
+    production[1] = nil
+  when Tokens.block_with_bind then
+    block = production.last
+    block.delete_at(1)
+    production.data.each do |local, aliased_role|
+      must_b_sym = "aliased_role must be a Symbol".to_sym
+      local_must_b_sym = "local must be a Symbol".to_sym
+      raise(must_b_sym) unless aliased_role.instance_of?(Symbol)
+      raise(local_must_b_sym) unless local.instance_of?(Symbol)
+      unless @roles.has_key?(aliased_role) then
+        role_names = []
+        @interpretation_context.each { |k, v| (role_names << k.to_s) }
+        raise(((aliased_role.to_s + " is not a role. Available roles are ") + role_names.join(",")))
       end
+      aliased_field = ("@" + aliased_role.to_s).to_sym
+      temp_symbol = ("temp____" + aliased_role.to_s).to_sym
+      assignment = Sexp.new
+      assignment[0] = :iasgn
+      assignment[1] = aliased_field
+      load_arg = Sexp.new
+      load_arg[0] = :lvar
+      load_arg[1] = local
+      assignment[2] = load_arg
+      block.insert(1, assignment)
+      assignment = Sexp.new
+      assignment[0] = :lasgn
+      assignment[1] = temp_symbol
+      load_field = Sexp.new
+      load_field[0] = :ivar
+      load_field[1] = aliased_field
+      assignment[2] = load_field
+      block.insert(1, assignment)
+      assignment = Sexp.new
+      assignment[0] = :iasgn
+      assignment[1] = aliased_field
+      load_temp = Sexp.new
+      load_temp[0] = :lvar
+      load_temp[1] = temp_symbol
+      assignment[2] = load_temp
+      block[block.length] = assignment
     end
+  else
+    # do nothing
   end
-
-  private
+end end
+     private
 
 
-  attr_reader :ast
+attr_reader :ast
 
-end
+           end

data/lib/Context.rb

@@ -1,133 +1,111 @@
 class Context
-  def self.define(*args, &block)
-    name, base_class, default_interaction = *args
-    if default_interaction and (not base_class.instance_of?(Class)) then
-      base_class = eval(base_class.to_s)
-    end
-    if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
-      base_class, default_interaction = default_interaction, base_class
-    end
-    @@with_contracts ||= nil
-    @@generate_file_path ||= nil
-    ctx = self.send(:create_context_factory, name, base_class, default_interaction, block)
-    transformer = Transformer.new(name, ctx.roles, ctx.interactions, ctx.private_interactions, base_class, default_interaction)
-    return transformer.transform(@@generate_file_path, @@with_contracts)
-  end
-
-  def self.generate_files_in(*args, &b)
-    @@generate_file_path = args[0]
-  end
-
-  def roles()
-    @roles
-  end
-
-  def interactions()
-    @interactions
-  end
-
-  def private_interactions()
-    @private_interactions
-  end
-
-  private
-  def get_definitions(b)
-    sexp = b.to_sexp
-    unless is_definition?(sexp[3]) then
-      sexp = sexp[3]
-      sexp = sexp.select { |exp| is_definition?(exp) } if sexp
-      sexp ||= []
-    end
-    sexp.select { |exp| is_definition?(exp) }
-  end
-
-  def self.create_context_factory(name, base_class, default_interaction, block)
-    ctx = Context.new(name, base_class, default_interaction)
-    ctx.instance_eval do
-      sexp = block.to_sexp
-      temp_block = sexp[3]
-      i = 0
-      while (i < temp_block.length) do
-        exp = temp_block[i]
-        unless temp_block[(i - 2)] and ((temp_block[(i - 2)][0] == :call) and (temp_block[(i - 1)] and (temp_block[(i - 1)][0] == :args))) then
-          if ((exp[0] == :defn) or (exp[0] == :defs)) then
-            add_method(exp)
-            temp_block.delete_at(i)
-            i = (i - 1)
-          else
-            if (exp[0] == :call) and ((exp[1] == nil) and (exp[2] == :private)) then
-              @private = true
-            end
-          end
+      def self.define(*args,&block) name, base_class, default_interaction = *args
+if default_interaction and (not base_class.instance_of?(Class)) then
+  base_class = eval(base_class.to_s)
+end
+if base_class and ((not default_interaction) and (not base_class.instance_of?(Class))) then
+  base_class, default_interaction = default_interaction, base_class
+end
+@with_contracts ||= nil
+ctx = self.send(:create_context_factory, name, base_class, default_interaction, block)
+if self.generate_dependency_graph then
+  dependencies = {}
+  ctx.dependencies = DependencyGraphModel.new(DependencyGraph.new(name, ctx.roles, ctx.interactions, dependencies).create!)
+end
+transformer = Transformer.new(name, ctx.roles, ctx.interactions, ctx.private_interactions, base_class, default_interaction)
+ctx.generated_class = transformer.transform(generate_files_in, @with_contracts)
+ctx
+ end
+ def self.generate_files_in() @generate_files_in end
+ def self.generate_files_in=(folder) @generate_files_in = folder end
+ def self.generate_code=(value) @generate_code = value end
+ def self.generate_dependency_graph=(value) @generate_dependency_graph = value end
+ def self.generate_code() (@generate_code or ((not generate_dependency_graph) or generate_files_in)) end
+ def self.generate_dependency_graph() @generate_dependency_graph end
+ def dependencies() @dependencies end
+ def generated_class() @generated_class end
+ def dependencies=(value) @dependencies = value end
+ def generated_class=(value) @generated_class = value end
+ def roles() @roles end
+ def interactions() @interactions end
+ def private_interactions() @private_interactions end
+     private
+def get_definitions(b) sexp = b.to_sexp
+unless is_definition?(sexp[3]) then
+  sexp = sexp[3]
+  sexp = sexp.select { |exp| is_definition?(exp) } if sexp
+  sexp ||= []
+end
+sexp.select { |exp| is_definition?(exp) }
+ end
+ def self.create_context_factory(name,base_class,default_interaction,block) ctx = Context.new(name, base_class, default_interaction)
+ctx.instance_eval do
+  sexp = block.to_sexp
+  temp_block = sexp[3]
+  i = 0
+  while (i < temp_block.length) do
+    exp = temp_block[i]
+    unless temp_block[(i - 2)] and ((temp_block[(i - 2)][0] == :call) and (temp_block[(i - 1)] and (temp_block[(i - 1)][0] == :args))) then
+      if ((exp[0] == :defn) or (exp[0] == :defs)) then
+        add_method(exp)
+        temp_block.delete_at(i)
+        i = (i - 1)
+      else
+        if (exp[0] == :call) and ((exp[1] == nil) and (exp[2] == :private)) then
+          @private = true
         end
-        i = (i + 1)
       end
-      ctx.instance_eval(&block)
-    end
-    ctx
-  end
-
-  def self.with_contracts(*args)
-    return @@with_contracts if (args.length == 0)
-    value = args[0]
-    if @@with_contracts and (not value) then
-      raise("make up your mind! disabling contracts during execution will result in undefined behavior")
-    end
-    @@with_contracts = value
-  end
-
-  def is_definition?(exp)
-    exp and ((exp[0] == :defn) or (exp[0] == :defs))
-  end
-
-  def role(*args, &b)
-    role_name = args[0]
-    @defining_role = role_name
-    @roles = {} unless @roles
-    @roles[role_name] = Hash.new
-    if block_given? then
-      definitions = get_definitions(b)
-      definitions.each { |exp| add_method(exp) }
-    end
-  end
-
-  def get_methods(*args, &b)
-    name = args[0]
-    sources = (@defining_role ? (@roles[@defining_role]) : (@interactions))[name]
-    if @defining_role and (not sources) then
-      @roles[@defining_role][name] = []
-    else
-      @private_interactions[name] = true if @private
-      @interactions[name] = []
     end
+    i = (i + 1)
   end
+  ctx.instance_eval(&block)
+end
+ctx
+ end
+ def self.with_contracts(*args) return @with_contracts if (args.length == 0)
+value = args[0]
+if @with_contracts and (not value) then
+  raise("make up your mind! disabling contracts during execution will result in undefined behavior")
+end
+@with_contracts = value
+ end
+ def is_definition?(exp) exp and ((exp[0] == :defn) or (exp[0] == :defs)) end
+ def role(*args,&b) role_name = args[0]
+@defining_role = role_name
+@roles = {} unless @roles
+@roles[role_name] = Hash.new
+if block_given? then
+  definitions = get_definitions(b)
+  definitions.each { |exp| add_method(exp) }
+end
+ end
+ def get_methods(*args,&b) name = args[0]
+sources = (@defining_role ? (@roles[@defining_role]) : (@interactions))[name]
+if @defining_role and (not sources) then
+  @roles[@defining_role][name] = []
+else
+  @private_interactions[name] = true if @private
+  @interactions[name] = []
+end
+ end
+ def add_method(definition) name = if definition[1].instance_of?(Symbol) then
+  definition[1]
+else
+  ((definition[1].select { |e| e.instance_of?(Symbol) }.map { |e| e.to_s }.join(".") + ".") + definition[2].to_s).to_sym
+end
+sources = get_methods(name)
+(sources << definition)
+ end
+ def private() @private = true end
+ def initialize(name,base_class,default_interaction) @roles = {}
+@interactions = {}
+@private_interactions = {}
+@role_alias = {}
+@name = name
+@base_class = base_class
+@default_interaction = default_interaction
+ end
 
-  def add_method(definition)
-    name = if definition[1].instance_of?(Symbol) then
-             definition[1]
-           else
-             ((definition[1].select { |e| e.instance_of?(Symbol) }.map { |e| e.to_s }.join(".") + ".") + definition[2].to_s).to_sym
-           end
-    sources = get_methods(name)
-    (sources << definition)
-  end
-
-  def private()
-    @private = true
-  end
-
-  def initialize(name, base_class, default_interaction)
-    @roles = {}
-    @interactions = {}
-    @private_interactions = {}
-    @role_alias = {}
-    @name = name
-    @base_class = base_class
-    @default_interaction = default_interaction
-  end
-
-  attr_reader :name
-  attr_reader :base_class
-  attr_reader :default_interaction
+attr_reader :name, :base_class, :default_interaction
 
-end
+           end