agreement-design-prototype 0.0.3 → 0.0.4

data/src/diagram.rb

@@ -1,67 +1,13 @@
 require 'fileutils'
-require_relative 'doc'
+require_relative 'transform'
+include Transform
 
+class Diagram < Output
 
-class TableElement < Element
-  def initialize file, node
-    super(file)
-    @node = node
-    pput %Q("#{@node}" [label=<<table BORDER="1" CELLBORDER="0" CELLSPACING="0"><TH><TD>#{@node}</TD></TH>)
-    @items = []
+  def initialize dir, name
+    super dir, name, ".dot"
   end
 
-  def item i
-    @items << i
-    self.pput %Q(<TR><TD ALIGN="LEFT">-#{i}</TD></TR>)
-  end
-
-  def finish
-    # self.pput " " << @items.join( ",")
-    self.pput "</table>"
-    self.pput ">];\n"
-  end
-
-
-end
-
-class Graph < Element
-  def initialize file
-    super(file)
-    self.pput "strict digraph {\n"
-  end
-
-  def finish
-    self.pput "}\n"
-  end
-
-end
-
-class SubGraph < Element
-  def initialize file, model
-    super(file)
-    self.pput "subgraph cluster_#{model} {\n"
-    self.pput "node [shape=plaintext margin=0];\n"
-    self.pput "label=#{model};\n"
-  end
-
-  def finish
-    self.pput "}\n"
-  end
-
-end
-
-class Links < Element
-
-  def link el1, el2, label: el, arrowhead: nil, arrowtail: nil
-    ah = arrowhead ? %Q!arrowhead = "#{arrowhead}"! : ""
-    at = arrowtail ? %Q!arrowtail = "#{arrowtail}"! : ""
-    pput %Q!"#{el1}" -> "#{el2}" [label="#{label}" #{ah} #{at} ];\n!
-  end
-
-end
-
-class Diagram < Doc
-
   def dotfile
     File.join(diagram_path, "#{self.name}.dot")
   end
@@ -75,42 +21,56 @@ class Diagram < Doc
     FileUtils.mkpath diagram_path
     FileUtils.mkpath image_path
     File.open(self.dotfile, "w") do |file|
-      graph = Graph.new(file)
-      for model in models
-        subgraph = SubGraph.new(file, modelname(model))
-        for type in model.types.values
-          table = TableElement.new(file, typename(type))
-          for att in type.attributes(false).values
-            table.item att_detail(att)
-          end
-          table.finish
-        end
-        subgraph.finish
-      end
-      for model in models
-        links = Links.new(file)
-        for type in model.types.values
-          for att in type.attributes(false).keys
-            if type.attributes[att][:links]
-              contains = (type.attributes[att][:type] < DataType)
-              links.link typename(type),
-                         typename(type.attributes[att][:links]),
-                         label: %Q!#{contains ? "{contains} " : ""}#{type.attributes[att][:name]}!,
-                         arrowhead: contains ? "none": "open",
-                         arrowtail: contains ? "diamond": "none"
-            end
-          end
-          if type.superclass < DataType
-            links.link typename(type),
-                       typename(type.superclass),
+      # nodes
+      file.print "strict digraph {\n"
+
+      transform_metamodel(
+          {
+              before_model: lambda do |model:|
+                file.print "subgraph cluster_#{model} {\n"
+                file.print "node [shape=plaintext margin=0];\n"
+                file.print "label=#{model};\n"
+              end,
+              after_model: lambda do |model:, before:|
+                file.print "}\n"
+              end,
+              before_type: lambda do |type:, depth:, index:, total:|
+                file.print %Q("#{type.typename}" [label=<<table BORDER="1" CELLBORDER="0" CELLSPACING="0"><TH><TD>#{type.typename}</TD></TH>)
+              end,
+              after_type: lambda do |type:, depth:, before:|
+                file.print "</table>"
+                file.print ">];\n"
+              end,
+              attribute: lambda do |id:, val:, depth:, type:, index:, total:|
+                file.print %Q(<TR><TD ALIGN="LEFT">-#{id}</TD></TR>)
+              end,
+          },
+          *models
+      )
+      #  links
+      transform_metamodel(
+          {
+              before_type: lambda do |type:, depth:, index:, total:|
+                if type.superclass < DataType
+                  link(file, type.typename, type.superclass.typename,
                        label: "extends",
                        arrowhead: "none",
-                       arrowtail:  "normal"
-          end
-        end
-        links.finish
-      end
-      graph.finish
+                       arrowtail: "normal")
+                end
+              end,
+              :attribute => lambda do |id:, val:, depth: 0, type:, index:, total:|
+                if val[:links] || val[:type] < DataType
+                  contains = (val[:type] < DataType)
+                  link(file, type.typename, val[:links] ? val[:links].typename : val[:type].typename,
+                       label: %Q!#{contains ? "{contains} " : ""}#{val[:name]}!,
+                       arrowhead: contains ? "none" : "open",
+                       arrowtail: contains ? "diamond" : "none")
+                end
+              end,
+          },
+          *models
+      )
+      file.print "}\n"
     end
 
     unless system("dot -Tjpg #{self.dotfile} > #{self.jpgfile}")
@@ -136,11 +96,17 @@ class Diagram < Doc
   private
 
   def image_path
-    File.join(self.path, "images")
+    File.join(self.dir, "images")
   end
 
   def diagram_path
-    File.join(self.path, "diagrams")
+    File.join(self.dir, "diagrams")
+  end
+
+  def link file, el1, el2, label: el2, arrowhead: nil, arrowtail: nil
+    ah = arrowhead ? %Q!arrowhead = "#{arrowhead}"! : ""
+    at = arrowtail ? %Q!arrowtail = "#{arrowtail}"! : ""
+    file.print %Q!"#{el1}" -> "#{el2}" [label="#{label}" #{ah} #{at} ];\n!
   end
 
 end

data/src/doc.rb

@@ -1,114 +1,61 @@
-class Element
-  def initialize file
-    @file = file
-  end
-
-  def finish
-    self
-  end
-
-  protected
-
-  def pput(string)
-    @file.print string
-    self
-  end
-
-end
-
-def cond_call(depth, id, value, lam, lambdas)
-  if lambdas[lam]
-    return lambdas[lam].(depth, id, value)
-  end
-  return 0
-end
-
-# each lambda takes the depth, id, value
-# Lambdas are:
-#               :before_type_lambda,
-#               :after_type_lambda,
-#               :before_array_lambda,
-#               :after_array_lambda,
-#               :attribute_lambda
-# which takes a type and returns an object (the id)
-# depth is the number counting from zero, incremented with array elements and nested types.
-# ID is a nested int of the type a for types and a.b for array types,
-# and is the name of the attribute for attributes
-# decl is the type or attribute or array
+require_relative 'transform'
+include Transform
 
-def transform_type depth, id, decl, lambdas
+class Document < Output
 
-  if decl.class <= Array
-    cond_call(depth, id, decl, :before_array_lambda, lambdas)
-    j = 1
-    for aa in decl
-      transform_type(depth , "#{id}.#{j}", aa, lambdas)
-      j = j + 1
-    end
-    cond_call(depth, id, decl, :after_array_lambda, lambdas)
-  elsif decl.class <= DataType
-    cond_call(depth, id, decl, :before_type_lambda, lambdas)
-    for ak in decl.attributes.keys
-      av = decl.attributes[ak]
-      transform_type(depth + 1, ak, av, lambdas)
-    end
-    cond_call(depth, id, decl, :after_type_lambda, lambdas)
-  else
-    cond_call(depth, id, decl, :attribute_lambda, lambdas)
+  def initialize dir, name
+    super File.join( dir, "doc"), name, "md"
   end
-  self
-end
-
-class ClassNameElement < Element
 
-  def write cat
-    pput %Q!\# #{cat.class}: #{cat.name}\n!
-    if (cat.respond_to?(:description))
-      pput %Q! #{cat.description}\n!
+  def document *models
+    file do |file|
+      transform_datamodel(
+          {
+              :before_type => lambda do |type:, depth: 0, index:,total:|
+                file.print %Q!####{'#' * depth} #{type.name} #{type.attributes[:id] || ""} \n!
+              end,
+              :attribute => lambda do |id:, val:, depth: 0, type: nil, index:, total:|
+                file.print %Q!#{"  " * depth} - #{id} #{val}\n!
+              end
+          }, *models)
     end
   end
 
-end
-
-class GroupElement < Element
-
-  def write grpname, level: 2
-    pput %Q! #{'#' * level} #{grpname}\n!
-  end
-
-end
-
-class TypeDeclElement < Element
-
-  def write indent, id, decl
-    transform_type(indent, id, decl,
-                   {
-                       :before_type_lambda => lambda do |indent, id, decl|
-                         pput %Q!####{'#' * indent} #{decl.name} #{decl.attributes[:id] || id} \n!
-                       end,
-                       :attribute_lambda => lambda do |indent, id, decl|
-                         pput %Q!#{"  " * indent} - #{id} #{decl}\n!
-                       end
-                   })
-    self
-  end
-
-end
-
-class MetaTypeElement < Element
-
-  def write type
-    pput "## #{type.typename}"
-    if type.extends
-      pput " extends #{type.extends}"
-    end
-    pput "\n  #{type.description}\n\n"
-    pput "|attribute|type|multiplicity|description|\n"
-    pput "|---------|----|------------|-----------|\n"
-    for a in type.attributes.values
-      pput "|#{a[:name]}|#{a[:type]}|#{self.multiplicity(a)}|#{a[:description]}|\n"
+  def document_metamodel *models
+    file do |file|
+      transform_metamodel(
+          {
+              before_model: lambda do |model:|
+                file.print %Q!\# Data model: #{model}\n!
+              end,
+              before_group: lambda do |group|
+                file.print %Q!\# #{cat.class}: #{cat.name}\n!
+                if (cat.respond_to?(:description))
+                  file.print %Q! #{cat.description}\n!
+                end
+              end,
+              before_type: lambda do |type:, depth:, index:, total:|
+                file.print "## #{type.typename}"
+                if type.extends
+                  file.print " extends #{type.extends}"
+                end
+                file.print "\n  #{type.description}\n\n"
+                file.print "|attribute|type|multiplicity|description|\n"
+                file.print "|---------|----|------------|-----------|\n"
+              end,
+              attribute: lambda do |id:, val:, type:, depth:, index:, total:|
+                file.print "|#{val[:name]}|#{type_and_link(val)}|#{multiplicity(val)}|#{val[:description]}|\n"
+              end,
+              before_codes: lambda do |model:|
+                file.print "# Codes\n"
+              end,
+              code: lambda do |model:, code:|
+                file.print "## #{code[:id]} #{code[:title]}\n"
+                file.print "#{code[:description]}\n"
+                file.print "#{code[:uri]}\n"
+              end
+          }, *models)
     end
-    self
   end
 
   def multiplicity m
@@ -125,57 +72,14 @@ class MetaTypeElement < Element
     end
     return m.to_s
   end
-end
-
-class Doc
-  attr_accessor :path, :name
 
-  def initialize path, name
-    self.path = path
-    self.name = name
-  end
+  private
 
-  def document *models
-    FileUtils.mkpath doc_path
-    File.open(self.docfile, "w") do |file|
-      for model in models
-        dom = ClassNameElement.new(file)
-        dom.write model
-        for typename in model.contents.keys
-          grp = GroupElement.new(file)
-          grp.write typename
-          i = 1
-          for decl in model.contents[typename]
-            TypeDeclElement.new(file).write(0, i, decl).finish
-            i = i + 1
-          end
-          grp.finish
-        end
-        dom.finish
-      end
+  def type_and_link(val)
+    if val[:links]
+      return "#{val[:type]} -> #{val[:links]}"
     end
-  end
-
-  def document_metamodel *models
-    FileUtils.mkpath doc_path
-    File.open(self.docfile, "w") do |file|
-      for model in models
-        dom = GroupElement.new(file)
-        dom.write model.name, level: 1
-        for type in model.types.values
-          MetaTypeElement.new(file).write(type).finish
-        end
-        dom.finish
-      end
-    end
-  end
-
-  def docfile
-    File.join(doc_path, "#{self.name}.md")
-  end
-
-  def doc_path
-    File.join(self.path, "doc")
+    val[:type]
   end
 
 end

data/src/transform.rb

@@ -0,0 +1,144 @@
+module Transform
+
+  class Output
+    public
+
+    attr_accessor :dir, :name, :ext
+
+    def initialize dir, name, ext
+      self.dir = dir
+      self.name = name
+      self.ext = ext
+    end
+
+    def filepath
+      File.join(self.dir, "#{name}.#{ext}")
+    end
+
+    def file(&block)
+      FileUtils.mkpath dir
+      File.open(filepath, "w", &block)
+    end
+  end
+
+
+  def before_model_lambda model: nil
+    return [model: model]
+  end
+
+  def after_model_lambda model: nil, before: nil
+    return [model: model, before: before]
+  end
+
+  def before_codes_lambda model: nil
+    return [model: model]
+  end
+
+  def code_lambda model: nil, code: nil
+    return [model: model, code: code]
+  end
+
+  def before_group_lambda name: nil, depth: 0
+    return [name: name, depth: depth]
+  end
+
+  def after_group_lambda name: nil, before: nil, depth: 0
+    return [name: name, before: before, depth: depth]
+  end
+
+  def before_type_lambda type: nil, depth: 0, index: 0, total: 1
+    return [type: type, depth: depth, index: index, total: total]
+  end
+
+  def after_type_lambda type: nil, before: nil, depth: 0
+    return [type: type, before: before, depth: depth]
+  end
+
+  def before_array_lambda name: nil, decl: nil, depth: 0, total: 1
+    return [name: name, decl: decl, depth: depth, total: total]
+  end
+
+  def after_array_lambda index: 0, decl: nil, depth: 0, before: nil
+    return [index: index, decl: decl, depth: depth, before: before]
+  end
+
+  def attribute_lambda id:, val:, depth: 0, type: nil, index:, total:
+    return [id: id, val: val, depth: depth, type: type, index: index, total: total]
+  end
+
+  # @param models - the models to transform
+  # @lambdas - set of function callbacks to transform
+
+  def transform_datamodel lambdas, *models
+    for model in models
+      dom = cond_call(lambdas, :before_model, *before_model_lambda(model: model))
+      for typename in model.contents.keys
+        grp = cond_call(lambdas, :before_group, *before_group_lambda(name: typename))
+        t = 0
+        # there will be more than one of each type
+        for type in model.contents[typename]
+          transform_type(lambdas, decl: type, name: typename, depth: 0, index: 0, total: 1)
+          t = t + 1
+        end
+        grp = cond_call(lambdas, :after_group, *after_group_lambda(name: typename, before: grp))
+      end
+      cond_call(lambdas, :after_model, *after_model_lambda(model: model, before: dom))
+    end
+  end
+
+  def transform_metamodel lambdas, *models
+    for model in models
+      dom = cond_call(lambdas, :before_model, *before_model_lambda(model: model))
+      for type in model.types.values
+        before = cond_call(lambdas, :before_type, *before_type_lambda(type: type, index:0, total:1))
+        i = 0
+        for ak in type.attributes.keys
+          av = type.attributes[ak]
+          cond_call(lambdas, :attribute, *attribute_lambda(id: ak, val: av, type: type, index: i, total: type.attributes.keys.length))
+          i = i + 1
+        end
+        cond_call(lambdas, :after_type, *after_type_lambda(type: type, before: before))
+      end
+      cond_call(lambdas, :after_model, *after_model_lambda(model: model, before: dom))
+      if model.respond_to? :codes
+        cond_call(lambdas, :before_codes, *before_codes_lambda(model: model))
+        for code in model.codes.values
+          cond_call(lambdas, :code, *code_lambda(model: model, code: code))
+        end
+      end
+    end
+  end
+
+  def cond_call(lambdas, lam, *args)
+    if lambdas[lam]
+      return lambdas[lam].(*args)
+    end
+    return 0
+  end
+
+  def transform_type(lambdas, index:, name:, decl:, depth:, total:)
+
+    if decl.class <= Array
+      arrctx = cond_call(lambdas, :before_array, *before_array_lambda(name: name, decl: decl, depth: depth, total: decl.length))
+      j = 0
+      for aa in decl
+        transform_type(lambdas, index: j, decl: aa, name: name, depth: depth, total: decl.length)
+        j = j + 1
+      end
+      cond_call(lambdas, :after_array, *after_array_lambda(index: index, decl: decl, depth: depth, before: arrctx))
+    elsif decl.class <= DataType
+      before = cond_call(lambdas, :before_type, *before_type_lambda(type: decl, depth: depth, index: index, total: total))
+      i = 0
+      for ak in decl.attributes.keys
+        av = decl.attributes[ak]
+        transform_type(lambdas, name: ak, decl: av, depth: depth + 1, index: i, total: decl.attributes.keys.length)
+        i = i + 1
+      end
+      cond_call(lambdas, :after_type, *after_type_lambda(type: decl, depth: depth, before: before))
+    else
+      cond_call(lambdas, :attribute, *attribute_lambda(id: name, val: decl, index: index, depth: depth, total: total))
+    end
+    self
+  end
+
+end