ontomde-uml2 1.0.4

data/lib/ontomde-uml2/multipleInheritance.rb

@@ -0,0 +1,104 @@
+
+
+
+module Mrdf_Model
+  def umlx_mapMultipleInheritanceToInterface!
+    nl=Set.new
+    umlx_classesWithMultipleInheritance.each {|c|
+      c.umlx_mapMultipleInheritanceToInterface!(nl)
+    }
+
+  end
+  def umlx_classesWithMultipleInheritance(ret=Set.new)
+    uml_Class_all.each {|c|
+      next if c.kind_of?(Muml_Interface) || c.kind_of?(Muml_Enumeration)
+      next if c.uml_generalization.length <2
+      ret << c
+    }
+    return ret
+  end
+end
+
+
+module Muml_Class
+  #nl : no loop
+  def umlx_mapMultipleInheritanceToInterface!(nl)
+    if nl.include?(self)
+      log.error {"umlx_mapMultipleInheritanceToInterface!: multiple call detected for #{self}" }
+      return
+    end
+    nl<< self
+    log.debug { "umlx_mapMultipleInheritanceToInterface! #{self}::#{self.class.name}" }
+    #Create an interface to replace this class
+    #Interface will have the name of the class
+    #Class implements the interface
+    i=umlx_owner_one.umlx_createAndAddInterface("#{self.rdf_uri}_interface",self.uml_name.to_s)
+    self.umlx_createAndAddImplementation(i)
+
+    #Obviously The class name must change to avoid a name clash.
+    self.uml_name="#{self.uml_name}_Implem"
+
+    #process type 3 elements (refer to diagram)
+    #(type 3 are handled as type 1 from the other extremity)
+    #Change classes this class generalize to interface
+    ug_copy=Array.new ; uml_generalization.each {|g| ug_copy<< g }
+    ug_copy.each { |general|
+      t=general.uml_general_one
+      #log.debug { "mi recursing trough generalization from #{self} to #{t}"}
+      i2=t.umlx_mapMultipleInheritanceToInterface!(nl)
+      i.umlx_createAndAddGeneralization(i2)
+    }
+
+
+
+    #process type 2 elements (refer to diagram)
+    #replace this class as attribute with interface i everywhere in model
+    uml_type_inv.each {|m|
+      #log.debug { "Changing attribut #{m} type from #{self} to #{i}" }
+      m.uml_type=i
+    }
+
+    #process type 1 elements (refer to diagram)
+    #replace this class generalization with i interface implementation
+    uml_general_inv.each { |general|
+      general.uml_generalization_inv.each {|cgen|
+        #log.debug { "Changing #{cgen} generalization #{self} to implement #{i}" }
+        #create new implementation
+        cgen.umlx_createAndAddImplementation(i)
+        #remove old generalization
+        cgen.uml_generalization.delete(general)
+      }
+    }
+
+    #process type 4 and 5 elements (refer to diagram)
+    #copy property from this class to interface i
+    uml_ownedAttribute.each { |a|
+      #log.debug { "Copy property #{a} to interface #{i}" }
+      na=i.umlx_createAndAddProperty("#{a.rdf_uri}_interface",a.uml_name.to_s);
+      a.umlx_copyToAttributeProperty(na)
+    }
+
+    #process type 7 elements (refer to diagram)
+    #copy method from this class to interface i
+    uml_ownedOperation.each { |op|
+      #log.debug { "Copy operation #{op} to interface #{i}" }
+      nop=i.umlx_createAndAddOperation("#{op.rdf_uri}_interface",op.uml_name.to_s)
+      #copy parameter
+      op.uml_ownedParameter.each { |p|
+        np=nop.umlx_createAndAddParameter("#{p.rdf_uri}_interface",p.uml_name.to_s)
+        p.umlx_copyToAttributeProperty(np)
+      }
+      #copy return parameter
+      op.uml_returnResult.each { |p|
+        np=nop.umlx_createAndAddReturnParameter("#{p.rdf_uri}_interface",p.uml_name.to_s)
+        p.umlx_copyToAttributeProperty(np)
+      }
+    }
+
+
+    return i
+  end
+
+
+end
+

data/lib/ontomde-uml2/nt_old_to_nt_new.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+(
+echo "("
+echo "echo \"#!ontomdx\""
+
+echo "cat  uml2.rdfs.nt.org | sed '"
+(
+cat uml2.rdfs.nt.org | grep 'rdf-syntax-ns#Property' | sed 's/^<\([^<>]*\)> <\([^<>]*\)>.*/URI=\1/g' | uniq
+#cat uml2.rdfs.nt.org | sed 's/^<\([^<>]*\)> <\([^<>]*\)>.*/URI=\2/g' | uniq
+#cat uml2.rdfs.nt.org | sed 's/^<\([^<>]*\)> <\([^<>]*\)> <\([^<>]*\)>.*/URI=\3/g'
+) \
+	| grep URI \
+	| sort | uniq \
+	| sed 's/.*#\(.*\)_\(.*\)/s\/\\(http:\\\/\\\/uml\\\/2#\\)\1_\2\/\\1\2\/g/g' \
+
+echo "' \\" 
+# removes duplicate declaration (became homonyms)
+echo ") | sort | uniq \\"
+echo " > uml2.rdfs.nt_tmp"
+
+) > nt_old_to_nt_new_tmp.sh
+
+./nt_old_to_nt_new_tmp.sh
+mv uml2.rdfs.nt_tmp uml2.rdfs.nt
+#cat  uml2.rdfs.nt.org  | sort | uniq > tmp2
+#diff   uml2.rdfs.nt.org   uml2.rdfs.nt
+
+rm -f uml2.rdfs.nt.rb	

data/lib/ontomde-uml2/owner.rb

@@ -0,0 +1,61 @@
+
+module Muml_Package
+  def umlx_owner_one
+    #return uml_ownedMember_inv_one0
+    ext_isReferencedBy.each { |res|
+      return res if res.respond_to?(:uml_ownedMember) && res.uml_ownedMember.include?(self)
+    }
+    return nil
+  end
+  def umlx_owner=(p)
+    old=umlx_owner_one
+    old.uml_ownedMember.delete(self) unless old.nil?
+    p.uml_ownedMember_add(self)
+    ext_isReferencedBy_add(p)
+  end
+end
+
+module Muml_Classifier
+  def umlx_owner_one
+    #return uml_ownedMember_inv_one0
+    ext_isReferencedBy.each { |res|
+      return res if res.respond_to?(:uml_ownedMember) && res.uml_ownedMember.include?(self)
+    }
+    return nil
+  end
+  def umlx_owner=(p)
+    old=umlx_owner_one
+    old.uml_ownedMember.delete(self) unless old.nil?
+    p.uml_ownedMember_add(self)
+    ext_isReferencedBy_add(p)
+  end
+end
+
+module Muml_Operation
+  #returns element owner if found, nil otherwise
+  def umlx_owner_one
+    ext_isReferencedBy.each { |res|
+      next unless res.kind_of?(Muml_Classifier)
+      next if res.kind_of?(Muml_Association)
+      next unless res.uml_ownedOperation.include?(self)
+      return res
+    }
+    log.error("umlx_owner_one not found for #{self.class} #{self}")
+    return nil
+  end
+end
+
+module Muml_Property
+  #returns element owner if found, nil otherwise
+  def umlx_owner_one(donotlog=false)
+    ext_isReferencedBy.each { |res|
+      next unless res.kind_of?(Muml_Classifier)
+      next if res.kind_of?(Muml_Association)
+      next unless res.uml_ownedAttribute.include?(self)
+      return res
+    }
+    log.error("umlx_owner_one not found for #{self.class} #{self}") unless donotlog
+    return nil
+  end
+end
+

data/lib/ontomde-uml2/salvageErrors.rb

@@ -0,0 +1,71 @@
+
+
+
+
+module Mrdf_Model
+  # Tries to fix a broken UML model.
+  # This feature is not meant for serious work
+  # and should only be used for quick demonstration.
+  def umlx_tryToSalvageErrors!
+    return unless context[:salvage,false]
+    log.error { <<END
+
+************ salvage mode is on ***************
+Salvage mode should only be used for quick
+demonstration purposes and never for  any serious
+work.
+************ salvage mode is on ***************
+END
+    }
+    each { |k,v|
+      # fix untyped property
+      if v.kind_of?(Muml_Property)
+        v.uml_type=v.umlx_owner_one.umlx_dataType_string if v.uml_type.empty?
+        # id is generated if persistence is enabled
+        v.uml_name="business Id" if context[:db] && v.uml_name.to_s=="id"
+      end
+
+      #fix blank or missing names
+      if v.kind_of?(Muml_NamedElement)
+        v.uml_name="missing_name_in_model_"+v.rdf_uri if v.uml_name.empty? || v.uml_name.to_s==""
+      end
+    }
+    each { |k,v|
+
+      #fix visibility (force to public)
+      if v.respond_to?(:uml_visibility)
+        v.uml_visibility=::Cuml_VisibilityKind::Public
+      end
+
+
+      # ejb service should not be abstract
+      if v.kind_of?(Muml_Class) && v.umlx_hasStereotype?("Service")
+        v.uml_isAbstract="false"
+      end
+
+      #no duplicate attribute (in one single class)
+      if v.kind_of?(Muml_Class)
+        names=Set.new
+        i=1
+        v.uml_ownedAttribute.each { |a|
+          n=a.uml_name.to_s
+          if a.respond_to?(:java_Name)
+            #in case java is loaded
+            n=a.java_Name.to_s
+          end
+
+          if names.include?(n)
+            i=i+1
+            a.uml_name="#{v.uml_name}_duplicate_#{i}"
+          else
+            names.add(n)
+          end
+        }
+
+      end
+    }
+
+
+  end
+end
+

data/lib/ontomde-uml2/select.rb

@@ -0,0 +1,85 @@
+# utility methods to select parts of a model
+#
+module Mrdf_Model
+  #search and returns every uml model
+  def uml_Model_all
+    return @typeIndex[Muml_Model]
+    ret=Array.new
+    each { |k,m|
+      next unless m.kind_of?(Muml_Model)
+      ret << m
+    }
+    return ret
+  end
+  def uml_Class_all(ret=Set.new)
+    #return @typeIndex[Muml_Class]
+    uml_Model_all.each { |m|
+      m.uml_Class_all(ret)
+    }
+    return ret
+  end
+end
+
+module Muml_Model
+  #search and returns evry uml class contained in the current model.
+  #NOTE: inner classes are not included
+  def uml_Class_all(ret=Set.new)
+    uml_ownedMember.each { |n|
+      if n.kind_of?(Muml_Enumeration)||n.kind_of?(Muml_Interface) || (n.kind_of?(Muml_Class) && n.umlx_isReallyAClass?)
+        ret << n
+      elsif n.kind_of?(Muml_Package) && !n.kind_of?(Muml_Profile)
+        n.uml_Class_all(ret)
+      else
+        #log.debug { "uml_Class_all ignored #{n.class.name} #{n}" }
+      end
+    }
+    return ret
+  end
+  #search and returns evry uml class contained in the current model.
+  #NOTE: inner classes are not included
+  def uml_UseCase_all(ret=Array.new)
+    uml_ownedMember.each { |n|
+      if n.kind_of?(Muml_UseCase)
+        ret << n
+      elsif n.kind_of?(Muml_Package) && !n.kind_of?(Muml_Profile)
+        n.uml_UseCase_all(ret)
+      else
+        #log.debug { "ignored #{n}" }
+      end
+    }
+    return ret
+  end
+end
+module Muml_Package
+  #search and returns evry uml class contained in the current package.
+  #NOTE: inner classes are not included
+  def uml_Class_all(ret=Array.new)
+    uml_ownedMember.each { |n|
+      if n.kind_of?(Muml_Enumeration)||n.kind_of?(Muml_Interface) || (n.kind_of?(Muml_Class) && n.umlx_isReallyAClass?)
+        ret << n
+      elsif n.kind_of?(Muml_Package)  && !n.kind_of?(Muml_Profile)
+        n.uml_Class_all(ret)
+      else
+        #log.debug { "ignored #{n}" }
+      end
+    }
+    return ret
+  end
+  #search and returns evry uml class contained in the current package.
+  #NOTE: inner classes are not included
+  def uml_UseCase_all(ret=Array.new)
+    uml_ownedMember.each { |n|
+      if n.kind_of?(Muml_UseCase)
+        ret << n
+        next
+      end
+      if n.kind_of?(Muml_Package)  && !n.kind_of?(Muml_Profile)
+        n.uml_UseCase_all(ret)
+        next
+      end
+      #log.debug { "ignored #{n}" }
+    }
+    return ret
+  end
+
+end

data/lib/ontomde-uml2/shortcut.rb

@@ -0,0 +1,27 @@
+#Handle shortcuts (from a namespace to a model)
+
+module Mrdf_Model
+  #Transform a set of UML models with links into a
+  #single model with uml ownedMember.
+  def umlx_processShortcuts!
+    each_value {  |s|
+      next unless s.respond_to?(:umlx_shortcut)
+      next if s.umlx_shortcut.nil?
+
+      s.umlx_shortcut.each {|p|
+        #remove link with package
+        p.uml_ownedMember_inv.each { |m|
+          m.uml_ownedMember.delete(p)
+        }
+
+        #replace shortcut with ownership
+        s.uml_ownedMember_add(p)
+      }
+
+
+
+
+    }
+
+  end
+end

data/lib/ontomde-uml2/uml2.rb

@@ -0,0 +1,236 @@
+require 'singleton'
+
+class Crdf_Model
+  # Loads UML2 metamodel.
+  def loadUml2
+    loadMetaModelFromFile("#{File.dirname(__FILE__)}/uml2.rdfs.nt");
+    addTypeIndex(Muml_Class)
+    addTypeIndex(Muml_Model)
+  end
+end
+
+module Muml_Classifier
+  # Returns in a Set any class this class inherit froms, both directly and indirectly (trough other classes)
+  #parameter is used internaly for recursion and should not be used.
+  def umlx_classifier_generalization_indirect(s=Set.new)
+    self.uml_generalization.each { |gene|
+      gene.uml_general.each{ |c|
+        recurse=!s.include?(c) # anti boucle infinie sur modele KO
+        s.add(c)
+        c.umlx_classifier_generalization_indirect(s) if recurse
+      }
+    }
+    return s
+  end
+end
+
+module Muml_Namespace
+  # Returns containing package.
+  # NOTE: Returns null if containing package is a Model.
+  def umlx_package
+    #TODO: utiliser relation inverse when available
+    p=umlx_owner_one
+    return nil if p.kind_of?(Cuml_Model)
+    return p
+  end
+
+  # Internal use.
+  #
+  # Kept for possible future use.
+  def _computePackage_notUsed
+    rdf_model.each { |a,x|
+      if(x.class==Cuml_Class)
+        x.uml_nestedClassifier {
+          return x if e==self
+        }
+      end
+      if(x.class==Cuml_Package)
+        x.uml_ownedMember.each { |e|
+          return x if e==self
+        }
+      end
+    }
+    return nil
+  end
+end
+module Muml_Namespace
+  #Returns the chain of namespace owning this element including this element
+  def umlx_hierarchy
+    p=umlx_package
+    if(p==nil) # || p.kind_of?(Muml_Model))
+      r=Array.new()
+    else
+      r=p.umlx_hierarchy
+    end
+    r.push(self) if !self.kind_of?(Muml_Model)
+    return r
+  end
+
+  #Returns the chain of namespace owning this element *NOT* including this element
+  def umlx_sub_hierarchy
+    p=umlx_package
+    if(p==nil)
+      r=Array.new()
+    else
+      r=p.umlx_hierarchy
+    end
+    return r
+  end
+end
+
+module ::Muml_NamedElement
+  #Internal use
+  #
+  #Used by web server
+  def to_s
+    s=uml_name.to_s
+    return s if s.length>0
+    super
+  end
+end
+module ::Muml_Generalization
+  #Internal use
+  #
+  #Used by web server
+  def to_s
+    return "->#{uml_general.to_s}"
+  end
+end
+module ::Muml_Implementation
+  #Internal use
+  #
+  #Used by web server
+  def to_s
+    return "->#{uml_realizingClassifier.to_s}"
+  end
+end
+
+module ::Muml_Association
+  #Internal use
+  #
+  #Used by web server
+  def to_s
+    return  "#{uml_ownedEnd}->#{uml_memberEnd}"
+  end
+end
+module ::Muml_LiteralUnlimitedNatural
+  def to_s
+    return uml_value.to_s if uml_value.to_s.length>0
+    super
+  end
+  def umlx_to_i
+    return 0 if to_s.nil?
+    return to_s.to_i;
+  end
+
+end
+module ::Muml_LiteralInteger
+  def to_s
+    return uml_value.to_s if uml_value.to_s.length>0
+    super
+  end
+  def umlx_to_i
+    return 0 if to_s.nil?
+    return to_s.to_i;
+  end
+end
+
+module ::Muml_Property
+  #Returns the other end of the association this property is linked to.
+  #NOTES:
+  #   Returns nil if this class is not part of an association
+  #   Returns nil if other en is not navigable.
+  def umlx_otherEnd
+    self.uml_association.each { |ass|
+      ass.uml_memberEnd.each { |p|
+        return p if p!=self
+      }
+    }
+    return nil
+  end
+end
+
+module ::Muml_Class
+  # returns ownedAttribute including non navigable ones.
+  def umlx_ownedAttribute
+    ret=Array.new
+    ext_isReferencedBy.each { |res|
+      next if !res.kind_of?(Cuml_Property)
+      ##log.debug "referencedBy : #{res.class.name}"
+      next if res.uml_type_one!=self
+      ret << res
+    }
+    return ret
+  end
+
+  # returns true if this class is a direct composante member end of a composition.
+  # NOTE:
+  #   This method returns direct relations only.
+  #   cf: umlx_isComposanteRec? for recursive
+  def umlx_isComposante?
+    #(self.umlx_ownedAttribute-self.uml_ownedAttribute).each { |a|
+    (self.umlx_ownedAttribute).each { |a|
+      next if self.uml_ownedAttribute.include?(a)
+      #next if !p.kind_of?(Cuml_Property)
+      #log.debug "#{self.uml_name} --> #{a.umlx_otherEnd.class.name}"
+      #[a, a.umlx_otherEnd].each { |p|
+      [a].each { |p|
+
+        return true if (!p.nil?) && (!p.uml_aggregation_one0.nil?)&& (p.uml_aggregation_one.isComposite?)
+      }}
+    return false
+  end
+
+  # returns true if this class is this class or one of its inheriting class is a direct composante member end of a composition.
+  # cf: umlx_isComposante? for non recursive behavior.
+  def umlx_isComposanteRec?
+    return true if umlx_isComposante?
+    self.umlx_classifier_generalization_indirect.each {|c|
+      return true if c.umlx_isComposanteRec?
+    }
+    return false
+  end
+
+  # returns true if this class carries directly a composition
+  # cf umlx_carryCompositionRec? for recursive behavior.
+  def umlx_carryComposition?
+    (self.uml_ownedAttribute+self.umlx_ownedAttribute).each { |a|
+      #next if !p.kind_of?(Cuml_Property)
+      #log.debug "#{self.uml_name} --> #{a.umlx_otherEnd.class.name}"
+      [a, a.umlx_otherEnd].each { |p|
+
+        return true if (!p.nil?) && (!p.uml_aggregation_one0.nil?)&& (p.uml_aggregation_one.isComposite?)
+      }}
+    return false
+  end
+  #
+  # returns true if this class or one of its inherited classes carries directly a composition
+  # cf umlx_carryComposition? for non recursive behavior.
+  def umlx_carryCompositionRec?
+    return true if umlx_carryComposition?
+    self.umlx_classifier_generalization_indirect.each {|c|
+      return true if c.umlx_carryCompositionRec?
+    }
+    return false
+  end
+end
+
+module Muml_Operation
+  #retrieve operation return parameter if any (nil otherwise)
+  def umlx_returnResult_one0
+    fp=nil
+    uml_returnResult.each { |p|
+      #pour RSM (non conformite de l'export)
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    uml_ownedParameter.each { |p|
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    return fp
+  end
+end
+
+
+#end # ProfileCoreUML