ontomde-uml2 1.0.4

data/lib/ontomde-uml2/check.rb

@@ -0,0 +1,28 @@
+
+
+module Mrdf_Model
+  def umlx_checkAbstractAndInheritance()
+    return unless context[:checkForAbstractAndInheritance,false]
+    msg=""
+    uml_Class_all.each { |c|
+      next if c.kind_of?(Muml_Enumeration)
+      next if c.kind_of?(Muml_Interface)
+      next if c.umlx_external?
+      next if c.uml_isAbstract?
+      next if c.uml_general_inv.empty?
+      msg=msg+"\n****  #{c.uml_name}"
+    }
+    return if msg.empty?
+    log.error { %{
+******************* INCORRECT MODEL *******************
+This model contains incorrect constructions.
+
+The following classe(s) has (have) been found guilty
+of being *not* abstract and having inheriting classes.
+Please, check your model and mark these classes abstract
+#{msg}
+******************* INCORRECT MODEL *******************
+      }}
+    #exit(1)
+  end
+end

data/lib/ontomde-uml2/createAndAdd.rb

@@ -0,0 +1,222 @@
+# This file contains several helper to create new UML elements.
+
+
+
+module Muml_Operation
+  def umlx_createAndAddParameter(new_uri,new_name=nil)
+    p=Cuml_Parameter.new(rdf_model,new_uri)
+    uml_ownedParameter_add(p)
+    p.uml_name=new_name unless new_name.nil?
+    p.uml_isUnique=RDF_TRUE
+    p.uml_isOrdered=RDF_FALSE
+    p.uml_direction=Cuml_ParameterDirectionKind::In
+    return p
+  end
+
+  #Create and add a return parameter.
+  #
+  def umlx_createAndAddReturnParameter(new_uri,new_name="return")
+    p=Cuml_Parameter.new(rdf_model,new_uri)
+    uml_ownedParameter_add(p)
+    p.uml_name=new_name
+    p.uml_isUnique=RDF_TRUE
+    p.uml_isOrdered=RDF_FALSE
+    p.uml_direction=Cuml_ParameterDirectionKind::Return
+    return p
+  end
+
+end
+module Muml_Interface
+  def umlx_createAndAddGeneralization(gen)
+    g=Cuml_Generalization.new(rdf_model,nil)
+    g.uml_general=gen
+    g.uml_specific=self
+    self.uml_generalization_add(g)
+    return g
+  end
+end
+module Muml_Class
+  #Creates and add a new UML Class.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddClass(new_uri,new_name=nil)
+    c=Cuml_Class.new(rdf_model,new_uri)
+    #uml_ownedMember_add(c)
+    uml_nestedClassifier_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    c.uml_visibility=::Cuml_VisibilityKind::Public
+    #puts "création classe #{new_name} in #{self.java_qualifiedName}"
+    return c
+  end
+  def umlx_createAndAddGeneralization(gen)
+    g=Cuml_Generalization.new(rdf_model,nil)
+    g.uml_general=gen
+    g.uml_specific=self
+    self.uml_generalization_add(g)
+    return g
+  end
+
+  def umlx_createAndAddImplementation(gen)
+    g=Cuml_Implementation.new(rdf_model,nil)
+    g.uml_supplier=gen
+    g.uml_implementingClassifier=self
+    self.uml_implementation_add(g)
+    return g
+  end
+end
+module Muml_Enumeration
+  def umlx_createAndAddLiteral(lit)
+    lit=lit.to_s
+    o=Cuml_EnumerationLiteral.new(rdf_model,"#{rdf_uri}_#{lit}")
+    o.uml_name=lit
+    self.uml_ownedLiteral_add(o)
+    return o
+  end
+  def umlx_createAndAddImplementation(gen)
+    g=Cuml_Implementation.new(rdf_model,nil)
+    g.uml_supplier=gen
+    g.uml_implementingClassifier=self
+    self.uml_implementation_add(g)
+    return g
+  end
+end
+module Muml_Package
+  #Creates and add a new UML Enumeration.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddEnumeration(new_uri,new_name=nil)
+    c=Cuml_Enumeration.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    c.uml_visibility=::Cuml_VisibilityKind::Public
+    #puts "création classe #{new_name} in #{self.java_qualifiedName}"
+    return c
+  end
+  #Creates and add a new UML Interface.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddInterface(new_uri,new_name=nil)
+    c=Cuml_Interface.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    c.uml_visibility=::Cuml_VisibilityKind::Public
+    #puts "création classe #{new_name} in #{self.java_qualifiedName}"
+    return c
+  end
+  #Creates and add a new UML Class.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddClass(new_uri,new_name=nil)
+    c=Cuml_Class.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    c.uml_visibility=::Cuml_VisibilityKind::Public
+    #puts "création classe #{new_name} in #{self.java_qualifiedName}"
+    return c
+  end
+  #Creates and add a new UML DataType.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddDataType(new_uri,new_name=nil)
+    c=Cuml_DataType.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    #puts "création classe #{new_name} in #{self.java_qualifiedName}"
+    return c
+  end
+
+  #Creates and add a new UML Stereotype.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddStereotype(new_uri,new_name=nil)
+    c=Cuml_Stereotype.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    return c
+  end
+
+  #Creates and add a new UML package.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddPackage(new_uri,new_name=nil)
+    c=Cuml_Package.new(rdf_model,new_uri)
+    uml_ownedMember_add(c)
+    c.umlx_owner=self
+    c.uml_name=new_name unless new_name.nil?
+    #puts "creation package #{new_name} dans #{self} (#{self.class.name})"
+    return c
+  end
+end
+
+module Muml_Classifier
+  #Creates and adds a new UML Operation.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddOperation(new_uri,new_name=nil)
+    m=Cuml_Operation.new(rdf_model,new_uri)
+    self.uml_ownedOperation_add(m)
+    m.uml_name=new_name unless new_name.nil?
+    m.uml_visibility=::Cuml_VisibilityKind::Public
+    return m
+  end
+
+  #Creates and adds a new UML property.
+  #Return the newly created element.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddProperty(new_uri,new_name=nil)
+    #log.debug { %{umlx_createAndAddProperty : name="#{new_name}" uri="#{uri}" owner="#{self}" owner_uri="#{self.rdf_uri}"} }
+    m=Cuml_Property.new(rdf_model,new_uri)
+    self.uml_ownedAttribute_add(m)
+    m.uml_name=new_name unless new_name.nil?
+    m.uml_isUnique=RDF_TRUE
+    m.uml_isOrdered=RDF_FALSE
+    m.uml_visibility=::Cuml_VisibilityKind::Public
+    #m.uml_class=self
+    return m
+  end
+
+  #Creates and adds a new UML Association.
+  #Return the newly created association.
+  #new_uri should be globaly unique.
+  def umlx_createAndAddAssociation(new_uri,otherEnd)
+    c1=self; c2=otherEnd
+    a=Cuml_Association.new(rdf_model,new_uri)
+
+    m1=Cuml_Property.new(rdf_model,"#{new_uri}_e1")
+    m1.uml_type=c2
+    #m1.uml_class=c1
+    c1.uml_ownedAttribute_add(m1)
+
+    m2=Cuml_Property.new(rdf_model,"#{new_uri}_e2")
+    m2.uml_type=c1
+    #m2.uml_class=c1
+    #c2.uml_ownedAttribute_add(m2)
+
+
+
+    [m1,m2].each {  |m|
+      a.uml_memberEnd_add(m)
+      m.uml_association=a
+      m.uml_isUnique=RDF_TRUE
+      m.uml_isOrdered=RDF_FALSE
+      m.uml_visibility=::Cuml_VisibilityKind::Public
+    }
+
+    return [a,m1,m2]
+  end
+end
+
+module Muml_Element
+  #Create a uml_Comment and append it to uml_ownedComment
+  def umlx_createAndAddComment(uri,txtComment)
+    c=Cuml_Comment.new(rdf_model,uri);
+    uml_ownedComment_add(c)
+    c.uml_body=txtComment
+  end
+end

data/lib/ontomde-uml2/depencies.rb

@@ -0,0 +1,30 @@
+#Helper methods to compute class depencies
+#This feature is used primarily for imports (in ActionScript generator)
+
+module Muml_Classifier
+  #returns every class this elements depends on
+  def umlx_computeDirectDepencies(ret=Set.new)
+    (uml_ownedAttribute+uml_ownedOperation).each { |a|
+      a.umlx_computeDirectDepencies(ret)
+    }
+    return ret
+  end
+end
+
+module Muml_Operation
+  #returns every class this elements depends on
+  def umlx_computeDirectDepencies(ret=Set.new)
+    (uml_returnResult+uml_ownedParameter).each { |a|
+      a.umlx_computeDirectDepencies(ret)
+    }
+    return ret
+  end
+end
+
+module Muml_TypedElement
+  #returns every class this elements depends on
+  def umlx_computeDirectDepencies(ret=Set.new)
+    ret.add(uml_type_one)
+    return ret
+  end
+end

data/lib/ontomde-uml2/dotDiagram.rb

@@ -0,0 +1,115 @@
+
+DOT_NODE_COLOR_SECONDARY="color=lightblue2, style=filled"
+DOT_NODE_COLOR_PRIMARY="color=darkolivegreen1, style=filled"
+
+module Mrdf_Model
+  def umlx_generateCompositonDotDiagram
+    return unless context[:generateCompositionDiagram,false]
+    mtk_writeSession("#{context[:javaDir]}/composition.dot") {
+      umlx_composition_dotDiagram
+    }
+  end
+  def umlx_composition_dotDiagram
+    write <<END
+digraph {
+rankdir=LR
+Node[shape=box,fontsize=10,color=darkolivegreen1]
+END
+    uml_Class_all.each { |c|
+      next if c.kind_of?(Muml_Enumeration)
+      style=""
+      ster=""
+      if c.uml_isAbstract?
+        style=",color=pink"
+      elsif c.kind_of?(Muml_Interface)
+        style=",color=khaki"
+        ster="<<interface>>\\n"
+      elsif ! (c.uml_general_inv.empty?)
+        # incorrect class
+        # not abstract with inheriting class
+        style=",color=red,style=filled"
+      else
+        style=",color=red,style=filled"
+        style=",style=filled"
+      end
+      write(%{#{c.dotId} [label="#{ster}#{c.uml_name}" #{style}]\n})
+      #Implements
+      if c.kind_of?(Muml_Class)
+        c.uml_implementation.each { |g|
+          o=g.uml_supplier_one
+          write( %{#{c.dotId} -> #{o.dotId} [arrowtail=none,arrowhead=onormal,style=dotted]\n} )
+        }
+      end
+      c.uml_generalization.each { |g|
+        o=g.uml_general_one
+        write( %{#{c.dotId} -> #{o.dotId} [arrowtail=none,arrowhead=onormal,color=indianred3]\n} )
+
+      }
+
+    }
+
+    #Composition
+    each  { |k,p|
+      next unless p.kind_of?(Muml_Association)
+      ce=nil #composante
+      ci=nil  #composite
+      p.uml_memberEnd.each {|a|
+        if a.uml_aggregation_one.isComposite?
+          ci=a
+        else
+          ce=a
+        end
+      }
+      next if ci.nil? || ce.nil?
+      next if ci.uml_type_one.kind_of?(Muml_Stereotype)
+      next if ce.uml_type_one.kind_of?(Muml_Stereotype)
+
+      write( %{#{ce.uml_type_one.dotId} -> #{ci.uml_type_one.dotId} [arrowhead="none" arrowtail="diamond"]\n} )
+    }
+
+
+    write("}\n")
+
+  end
+end
+
+module Muml_Class
+  # generates a standard class diagram for this class in the dot language.
+  # Note:
+  #   1 level of Generalization is included.
+  #   Attributes are included
+  def umlx_classDiagram_dotFile
+    write("digraph {\n")
+    #write("rankdir=LR;\n");
+    write("node [shape=box,#{DOT_NODE_COLOR_SECONDARY}];\n")
+
+    write(%{#{dotId} [label="#{uml_name}",#{DOT_NODE_COLOR_PRIMARY}]\n})
+
+    uml_generalization.each { |g|
+      g.umlx_classDiagram_dotFragment
+    }
+    uml_ownedAttribute.each { |oa|
+      oa.umlx_classDiagram_dotFragment
+    }
+    write("}\n")
+  end
+end
+module Muml_Generalization
+  # Generate dot graphical instruction for this element.
+  def umlx_classDiagram_dotFragment
+    c=uml_general_one
+    o=uml_specific_one
+    write(%{#{c.dotId} [label="#{c.uml_name}"]\n})
+    write(%{#{c.dotId}->#{o.dotId} [arrowhead=none,arrowtail=onormal,minlen=2]\n})
+  end
+end
+module Muml_Property
+  # Generate dot graphical instruction for this element.
+  def umlx_classDiagram_dotFragment
+    return if umlx_isAttribute?
+    o=uml_class_one
+    c=uml_type_one
+    write(%{#{c.dotId} [label="#{c.uml_name}"]\n})
+    write(%{#{o.dotId}->#{c.dotId} [arrowtail=none,arrowhead=vee,minlen=2,label="#{uml_name}"]\n})
+  end
+end

data/lib/ontomde-uml2/enumerated.rb

@@ -0,0 +1,36 @@
+# Enumerated type helpers.
+#
+# Detects UML enumerated types and provides helper methods and constants.
+#
+# EXAMPLE:
+#  constant: Cuml_visibilityKind::Public
+#  method:   Cuml_visibilityKind isPublic?
+#
+# NOTE: UML Enumerated type are declared in this file.
+module Mumlx_EnumeratedValue
+  # Internal use
+  def initialize(model,uri)
+    super(model,uri)
+    a=uri.split("_",3)
+    v=a[2].capitalize
+    @@z=self
+    cmd="class ::#{self.class}< ::Crdfs_Class\n  public\n  #{v}=@@z\n  def is#{v}?\n    return self==#{v}\n  end\n end"
+    eval(cmd)
+    @@z=nil
+  end
+end
+
+# UML2 enumerated type declaration
+class Cuml_VisibilityKind  < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_ParameterDirectionKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_AggregationKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_CallConcurrencyKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_MessageKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_MessageSort < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_ExpansionKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_InteractionOperator < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_TransitionKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_PseudostateKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_ParameterEffectKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_ObjectNodeOrderingKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end
+class Cuml_ConnectorKind < ::Crdfs_Class ; include Mumlx_EnumeratedValue ; end

data/lib/ontomde-uml2/extension.rb

@@ -0,0 +1,5 @@
+module Muml_Enumeration
+  #UML does not support implementation for enums
+  #Because Java does, this feature is added
+  rdf_safe_attr_reader_many :uml_implementation
+end

data/lib/ontomde-uml2/helper.rb

@@ -0,0 +1,14 @@
+module Muml_Classifier
+  #returns every type assignable to this classifier
+  #(this includes self and any class deriving from it)
+  def umlx_ownedAndInheritedOperation(ret=Set.new)
+    uml_ownedOperation.each {|biz|
+      ret << biz
+    }
+    uml_generalization.each { |g|
+      next if g.kind_of?(Muml_Interface)
+      g.uml_general_one.umlx_ownedAndInheritedOperation(ret)
+    }
+    return ret
+  end
+end