activefacts-generators 1.7.1

data/lib/activefacts/generators/diagrams/json.rb

@@ -0,0 +1,340 @@
+#
+#       ActiveFacts Generators.
+#       Generate json output from a vocabulary, for loading into APRIMO
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'json'
+require 'digest/sha1'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    module Diagrams
+      # Generate json output from a vocabulary, for loading into APRIMO.
+      # Invoke as
+      #   afgen --diagrams/json <file>.cql=diagrams
+      class JSON
+      private
+	def initialize(vocabulary)
+	  @vocabulary = vocabulary
+	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+	end
+
+	def puts(*a)
+	  @out.puts *a
+	end
+
+      public
+	def generate(out = $>)
+	  @out = out
+	  uuids = {}
+
+	  puts "{ model: '#{@vocabulary.name}',\n" +
+	  "diagrams: [\n#{
+	    @vocabulary.all_diagram.sort_by{|o| o.name.gsub(/ /,'')}.map do |d|
+	      j = {:uuid => (uuids[d] ||= uuid_from_id(d)), :name => d.name}
+	      "    #{j.to_json}"
+	    end*",\n"
+	  }\n  ],"
+
+	  object_types = @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}
+	  puts "  object_types: [\n#{
+	    object_types.sort_by{|o|o.identifying_role_values.inspect}.map do |o|
+	      uuids[o] ||= uuid_from_id(o)
+	      ref_mode = nil
+	      if o.is_a?(ActiveFacts::Metamodel::EntityType) and
+		p = o.preferred_identifier and
+		(rrs = p.role_sequence.all_role_ref).size == 1 and
+		(r = rrs.single.role).fact_type != o.fact_type and
+		r.object_type.is_a?(ActiveFacts::Metamodel::ValueType) and
+		!r.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+		ref_mode = "#{r.object_type.name}"
+		ref_mode.sub!(%r{#{o.name} *}, '.')
+	      end
+	      j = {
+		:uuid => uuids[o],
+		:name => o.name,
+		:shapes => o.all_object_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+		  x = { :diagram => uuids[shape.orm_diagram],
+		    :is_expanded => shape.is_expanded,
+		    :uuid => uuid_from_id(shape),
+		    :x => shape.location.x,
+		    :y => shape.location.y
+		  }
+		  x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
+		  x
+		end
+	      }
+	      j[:ref_mode] = ref_mode if ref_mode
+	      j[:independent] = true if o.is_independent
+
+	      if o.is_a?(ActiveFacts::Metamodel::EntityType)
+		# Entity Type may be objectified, and may have supertypes:
+		if o.fact_type
+		  uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
+		  j[:objectifies] = uuid
+		  j[:implicit] = true if o.concept.implication_rule
+		end
+		if o.all_type_inheritance_as_subtype.size > 0
+		  j[:supertypes] = o.
+		    all_type_inheritance_as_subtype.
+		    sort_by{|ti| ti.provides_identification ? 0 : 1}.
+		    map{|ti|
+		      [ uuids[ti.supertype] ||= uuid_from_id(ti.supertype),
+			uuids[ti.supertype_role] = uuid_from_id(ti.supertype_role)
+		      ]
+		    }
+		end
+	      else
+		# ValueType usually has a supertype:
+		if (o.supertype)
+		  j[:supertype] = (uuids[o.supertype] ||= uuid_from_id(o.supertype))
+		end
+	      end
+	      # REVISIT: Place a ValueConstraint and shape
+	      "    #{j.to_json}"
+	    end*",\n"
+	  }\n  ],"
+
+	  fact_types = @vocabulary.constellation.
+	    FactType.values.
+	    reject{|ft|
+	      ActiveFacts::Metamodel::LinkFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
+	    }
+	  puts "  fact_types: [\n#{
+	    fact_types.sort_by{|f| f.identifying_role_values.inspect}.map do |f|
+	      uuids[f] ||= uuid_from_id(f)
+	      j = {:uuid => uuids[f]}
+
+	      if f.entity_type
+		j[:objectified_as] = uuids[f.entity_type]
+	      end
+
+	      # Emit roles
+	      roles = f.all_role.sort_by{|r| r.ordinal }
+	      j[:roles] = roles.map do |role|
+		uuid = (uuids[role] ||= uuid_from_id(role))
+		# REVISIT: Internal Mandatory Constraints
+		# REVISIT: Place a ValueConstraint and shape
+		# REVISIT: Place a RoleName shape
+		{:uuid => uuid, :player => uuids[role.object_type]}
+		# N.B. The object_type shape to which this role is attached is not in the meta-model
+		# Attach to the closest instance on this diagram (if any)
+	      end
+
+	      # Emit readings. Each is a [role_order, text] pair
+	      j[:readings] = f.all_reading.map do |r|
+		role_refs = r.role_sequence.all_role_ref_in_order
+		[
+		  role_order(uuids, role_refs.map{|rr| rr.role}, roles),
+		  r.text.gsub(/\{([0-9])\}/) do |insert|
+		    role_ref = role_refs[$1.to_i]
+		    la = role_ref.leading_adjective
+		    la = nil if la == ''
+		    ta = role_ref.trailing_adjective
+		    ta = nil if ta == ''
+		    (la ? la+'-' : '') +
+		      (la && la.index(' ') ? ' ' : '') +
+		      insert +
+		      (ta && ta.index(' ') ? ' ' : '') +
+		      (ta ? '-'+ta : '')
+		  end
+		]
+	      end.sort_by{|(ro,text)| ro }.map do |(ro,text)|
+		[ ro, text ]
+	      end
+
+	      # Emit shapes
+	      j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+		sj = {
+		  :diagram => uuids[shape.orm_diagram],
+		  :uuid => uuid_from_id(shape),
+		  :x => shape.location.x,
+		  :y => shape.location.y
+		}
+
+		# Add the role_order, if specified
+		if shape.all_role_display.size > 0
+		  if shape.all_role_display.size != roles.size
+		    raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.orm_diagram.name} diagram"
+		  end
+		  ro = role_order(
+		    uuids,
+		    shape.all_role_display.sort_by{|rd| rd.ordinal }.map{|rd| rd.role },
+		    roles
+		  )
+		  sj[:role_order] = ro if ro
+		end
+
+		# REVISIT: Place the ReadingShape
+
+		# Emit the location of the name, if objectified
+		if n = shape.objectified_fact_type_name_shape
+		  sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
+		end
+		sj
+	      end
+
+	      # Emit Internal Presence Constraints
+	      f.internal_presence_constraints.to_a.sort_by{|ipc, z|
+		    [ipc.is_preferred_identifier ? 0 : 1, ipc.is_mandatory ? 0 : 1, ipc.min_frequency || 0, ipc.max_frequency || 1_000]
+		  }.each do |ipc|
+		uuid = (uuids[ipc] ||= uuid_from_id(ipc))
+
+		constraint = {
+		  :uuid => uuid,
+		  :min => ipc.min_frequency,
+		  :max => ipc.max_frequency,
+		  :is_preferred => ipc.is_preferred_identifier,
+		  :mandatory => ipc.is_mandatory
+		}
+
+		# Get the role (or excluded role, for a UC)
+		roles = ipc.role_sequence.all_role_ref_in_order.map{|r| r.role}
+		if roles.size > 1 || (!ipc.is_mandatory && ipc.max_frequency == 1)
+		  # This can be only a uniqueness constraint. Record the missing role, if any
+		  role = (f.all_role.to_a - roles)[0]
+		  constraint[:uniqueExcept] = uuids[role]
+		else
+		  # An internal mandatory or frequency constraint applies to only one role.
+		  # If it's also unique (max == 1), that applies on the counterpart role.
+		  # You can also have a mandatory frequency constraint, but that applies on this role.
+		  constraint[:role] = uuids[roles[0]]
+		end
+		(j[:constraints] ||= []) << constraint
+	      end
+
+	      # Add ring constraints
+	      f.all_role_in_order.
+		map{|r| r.all_ring_constraint.to_a+r.all_ring_constraint_as_other_role.to_a }.
+		flatten.uniq.each do |ring|
+		  (j[:constraints] ||= []) << {
+		      :uuid => (uuids[ring] ||= uuid_from_id(ring)),
+		      :shapes => ring.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+			{ :diagram => uuids[shape.orm_diagram],
+			  :uuid => uuid_from_id(shape),
+			  :x => shape.location.x,
+			  :y => shape.location.y
+			}
+		      end,
+		      :ringKind => ring.ring_type,
+		      :roles => [uuids[ring.role], uuids[ring.other_role]]
+		      # REVISIT: Deontic, enforcement
+		    }
+		end
+
+	      # REVISIT: RotationSetting
+
+	      "    #{j.to_json}"
+	    end*",\n"
+	  }\n  ],"
+
+	  constraints = @vocabulary.constellation.
+	    Constraint.values
+	  puts "  constraints: [\n#{
+	    constraints.sort_by{|c|c.identifying_role_values.inspect}.select{|c| !uuids[c]}.map do |c|
+	      uuid = uuids[c] ||= uuid_from_id(c)
+	      j = {
+		:uuid => uuid,
+		:type => c.class.basename,
+		:shapes => c.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+		  { :diagram => uuids[shape.orm_diagram],
+		    :uuid => uuid_from_id(shape),
+		    :x => shape.location.x,
+		    :y => shape.location.y
+		  }
+		end
+	      }
+
+	      if (c.enforcement)
+		# REVISIT: Deontic constraint
+	      end
+	      if (c.concept.all_context_note_as_relevant_concept.size > 0)
+		# REVISIT: Context Notes
+	      end
+
+	      case c
+	      when ActiveFacts::Metamodel::PresenceConstraint
+		j[:min_frequency] = c.min_frequency
+		j[:max_frequency] = c.max_frequency
+		j[:is_mandatory] = c.is_mandatory
+		j[:is_preferred_identifier] = c.is_preferred_identifier
+		rss = [c.role_sequence.all_role_ref_in_order.map(&:role)]
+
+		# Ignore internal presence constraints on TypeInheritance fact types
+		next nil if !c.role_sequence.all_role_ref.
+		  detect{|rr|
+		    !rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+		  }
+
+	      when ActiveFacts::Metamodel::RingConstraint
+		next nil  # These are emitted with the corresponding fact type
+
+	      when ActiveFacts::Metamodel::SetComparisonConstraint
+		rss = c.
+		  all_set_comparison_roles.sort_by{|scr| scr.ordinal}.
+		  map{|scr| scr.role_sequence.all_role_ref_in_order.map(&:role) }
+		if (ActiveFacts::Metamodel::SetExclusionConstraint === c)
+		  j[:is_mandatory] = c.is_mandatory
+		end
+
+	      when ActiveFacts::Metamodel::SubsetConstraint
+		rss = [c.subset_role_sequence, c.superset_role_sequence].
+		  map{|rs| rs.all_role_ref_in_order.map(&:role) }
+
+	      when ActiveFacts::Metamodel::ValueConstraint
+		next nil  # REVISIT: Should have been handled elsewhere
+		if (c.role)
+		  # Should have been handled as role.role_value_constraint
+		elsif (c.value_type)
+		  # Should have been handled as object_type.value_constraint
+		end
+		j[:allowed_ranges] = c.all_allowed_range.map{|ar|
+		  [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].
+		    map{|b| [b.value.literal, b.value.unit.name, b.is_inclusive] }
+		}
+
+	      else
+		raise "REVISIT: Constraint type not yet dumped to JSON"
+	      end
+
+	      # rss contains the constrained role sequences; map to uuids
+	      j[:role_sequences] = rss.map{|rs|
+		rs.map do |role|
+		  uuids[role]
+		end
+	      }
+
+	      "    #{j.to_json}"
+	    end.compact*",\n"
+	  }\n  ]"
+
+	  puts "}"
+	end
+
+	def role_order(uuids, roles, order)
+	  if (roles.size > 9)
+	    roles.map{|r| uuids[r] }
+	  else
+	    roles.map{|r| order.index(r).to_s }*''
+	  end
+	end
+
+	def uuid_from_id o
+	  irvs = o.identifying_role_values.inspect
+	  d = Digest::SHA1.digest irvs
+	  # $stderr.puts "#{o.class.basename}: #{irvs}"
+	  d[0,4].unpack("H8")[0]+'-'+
+	    d[4,2].unpack("H4")[0]+'-'+
+	    d[6,2].unpack("H4")[0]+'-'+
+	    d[8,2].unpack("H4")[0]+'-'+
+	    d[10,6].unpack("H6")[0]
+	end
+
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('diagrams/json', ActiveFacts::Generators::Diagrams::JSON)

data/lib/activefacts/generators/help.rb

@@ -0,0 +1,64 @@
+#
+#       ActiveFacts Generators.
+#       Provides help for afgen - from afgen --help
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    # Generate nothing from an ActiveFacts vocabulary. This is useful to check the file can be read ok.
+    # Invoke as
+    #   afgen --null <file>.cql
+    class HELP
+    private
+      def initialize(vocabulary, *options)
+	generators = $:.
+	  map{|path|
+            Dir[path+"/activefacts/generators/**/*.rb"].
+	      reject{|p|
+		p =~ %r{/(transform|helpers)/}
+	      }.
+	      map{|p|
+                p.sub(%r{.*/activefacts/generators/}, '').sub(/\.rb/,'')
+              }
+          }
+	transformers = $:.
+	  map{|path|
+            Dir[path+"/activefacts/generators/transform/**/*.rb"].
+	      map{|p|
+                p.sub(%r{.*/activefacts/generators/}, '').sub(/\.rb/,'')
+	      }
+          }
+
+        puts %Q{
+Usage: afgen [ --transformer[=options] ... ] [ --generator[=options] ... ] file.inp[=options]
+        options are comma-separated lists. Use =help to get more information.
+
+Available generators are:
+        #{generators.flatten.uniq.sort.join("\n\t")
+}
+
+Available transformers are:
+        #{transformers.flatten.uniq.sort.join("\n\t")
+}
+
+inp is the name of a file input handler. Available input handlers are:
+        #{$:.map{|path|
+            Dir[path+"/activefacts/input/**.rb"].map{|p|
+                p.sub(%r{.*/}, '').sub(/\.rb/,'')
+            }
+        }.flatten.uniq.sort.join("\n\t")
+}
+}
+      end
+
+    public
+      def generate(out = $>)
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('help', ActiveFacts::Generators::HELP)

data/lib/activefacts/generators/helpers/inject.rb

@@ -0,0 +1,16 @@
+require 'activefacts/metamodel'
+
+module ActiveFacts
+  module TraitInjector
+    def self.included other
+      overlap = Metamodel.constants & other.constants
+      overlap.each do |const|
+	mix_into = Metamodel.const_get(const)
+	mix_in = other.const_get(const)
+	mix_into.instance_exec {
+	  include(mix_in)
+	}
+      end
+    end
+  end
+end

data/lib/activefacts/generators/helpers/oo.rb

@@ -0,0 +1,162 @@
+#
+#       ActiveFacts Generators.
+#       Base class for generators of class libraries in any object-oriented language that supports the ActiveFacts API.
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/generators/helpers/ordered'
+require 'activefacts/generators/traits/oo'
+
+module ActiveFacts
+  module Generators
+
+    module Helpers
+      # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
+      class OO < OrderedDumper  #:nodoc:
+        def constraints_dump
+          # Stub, not needed.
+        end
+
+        def value_type_banner
+        end
+
+        def value_type_end
+        end
+
+        def entity_type_dump(o)
+          o.ordered_dumped!
+          pi = o.preferred_identifier
+
+          supers = o.supertypes
+          if (supers.size > 0)
+            # Ignore identification by a supertype:
+            pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) }
+            subtype_dump(o, supers, pi)
+          else
+            non_subtype_dump(o, pi)
+          end
+          pi.ordered_dumped! if pi
+        end
+
+        # Dump the roles for an object type (excluding the roles of a fact type which is objectified)
+        def roles_dump(o)
+          o.all_role.
+            select{|role|
+              role.fact_type.all_role.size <= 2 &&
+                !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+            }.
+            sort_by{|role|
+	      other_role = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
+              other_role.preferred_role_name(o) + ':' + role.preferred_role_name(other_role.object_type)
+            }.each{|role| 
+              role_dump(role)
+            }
+        end
+
+        def role_dump(role)
+          fact_type = role.fact_type
+          if fact_type.all_role.size == 1
+            unary_dump(role, role.preferred_role_name)
+            return
+	  end
+          return if role.fact_type.entity_type
+
+          if fact_type.all_role.size != 2
+            # Shouldn't come here, except perhaps for an invalid model
+            return  # ternaries and higher are always objectified
+          end
+
+          # REVISIT: TypeInheritance
+          if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+            # trace "Ignoring role #{role} in #{fact_type}, subtype fact type"
+            # REVISIT: What about secondary subtypes?
+            # REVISIT: What about dumping the relational mapping when using separate tables?
+            return
+          end
+
+          return unless role.is_functional
+
+          other_role = fact_type.all_role.select{|r| r != role}[0]
+          other_role_name = other_role.preferred_role_name
+          other_player = other_role.object_type
+
+          # It's a one_to_one if there's a uniqueness constraint on the other role:
+          one_to_one = other_role.is_functional
+          return if one_to_one &&
+              !other_role.object_type.ordered_dumped
+
+          # Find role name:
+          role_method = role.preferred_role_name
+          other_role_method = one_to_one ? role_method : "all_"+role_method
+          # puts "---"+role.role_name if role.role_name
+          if other_role_name != other_player.oo_default_role_name and
+	      role_method == role.object_type.oo_default_role_name
+	    # debugger
+            other_role_method += "_as_#{other_role_name}"
+          end
+
+          role_name = role_method
+          role_name = nil if role_name == role.object_type.oo_default_role_name
+
+b = role.ruby_role_definition
+puts b
+
+          # binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
+        end
+
+        def skip_fact_type(f)
+          # REVISIT: There might be constraints we have to merge into the nested entity or subtype.  These will come up as un-handled constraints.
+          !f.entity_type ||
+            f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+        end
+
+        # An objectified fact type has internal roles that are always "has_one":
+        def fact_roles_dump(fact_type)
+          fact_type.all_role.sort_by{|role|
+              role.preferred_role_name(fact_type.entity_type)
+            }.each{|role| 
+              role_name = role.preferred_role_name(fact_type.entity_type)
+              one_to_one = role.is_unique
+              as = role_name != role.object_type.oo_default_role_name ? "_as_#{role_name}" : ""
+#	      debugger if as != ''
+              raise "Fact #{fact_type.describe} type is not objectified" unless fact_type.entity_type
+              other_role_method = (one_to_one ? "" : "all_") + 
+                fact_type.entity_type.oo_default_role_name +
+                as
+              binary_dump(role, role_name, role.object_type, true, one_to_one, nil, nil, other_role_method)
+            }
+        end
+
+        def entity_type_banner
+        end
+
+        def entity_type_group_end
+        end
+
+        def append_ring_to_reading(reading, ring)
+          # REVISIT: trace "Should override append_ring_to_reading"
+        end
+
+        def fact_type_banner
+        end
+
+        def fact_type_end
+        end
+
+        def constraint_banner
+          # trace "Should override constraint_banner"
+        end
+
+        def constraint_end
+          # trace "Should override constraint_end"
+        end
+
+        def constraint_dump(c)
+          # trace "Should override constraint_dump"
+        end
+
+      end
+    end
+  end
+end