activefacts 0.7.2 → 0.7.3

data/examples/CQL/Warehousing.cql

@@ -3,18 +3,18 @@ vocabulary Warehousing;
 /*
  * Value Types
  */
-BinID is defined as AutoCounter();
-DispatchID is defined as AutoCounter();
-DispatchItemID is defined as AutoCounter();
-PartyID is defined as AutoCounter();
-ProductID is defined as AutoCounter();
-PurchaseOrderID is defined as AutoCounter();
-Quantity is defined as UnsignedInteger(32);
-ReceiptID is defined as AutoCounter();
-ReceivedItemID is defined as AutoCounter();
-SalesOrderID is defined as AutoCounter();
-TransferRequestID is defined as AutoCounter();
-WarehouseID is defined as AutoCounter();
+BinID is written as AutoCounter();
+DispatchID is written as AutoCounter();
+DispatchItemID is written as AutoCounter();
+PartyID is written as AutoCounter();
+ProductID is written as AutoCounter();
+PurchaseOrderID is written as AutoCounter();
+Quantity is written as UnsignedInteger(32);
+ReceiptID is written as AutoCounter();
+ReceivedItemID is written as AutoCounter();
+SalesOrderID is written as AutoCounter();
+TransferRequestID is written as AutoCounter();
+WarehouseID is written as AutoCounter();
 
 /*
  * Entity Types

data/examples/CQL/WindowInRoomInBldg.cql

@@ -3,10 +3,10 @@ vocabulary WindowInRoomInBldg;
 /*
  * Value Types
  */
-Building is defined as SignedInteger(32);
-RoomNumber is defined as SignedInteger(32);
-WallNumber is defined as SignedInteger(32);
-WindowNumber is defined as UnsignedInteger(32);
+Building is written as SignedInteger(32);
+RoomNumber is written as SignedInteger(32);
+WallNumber is written as SignedInteger(32);
+WindowNumber is written as UnsignedInteger(32);
 
 /*
  * Entity Types

data/lib/activefacts/api/concept.rb

@@ -172,7 +172,7 @@ module ActiveFacts
       def define_binary_fact_type(one_to_one, role_name, related, mandatory, related_role_name)
         # puts "#{self}.#{role_name} is to #{related.inspect}, #{mandatory ? :mandatory : :optional}, related role is #{related_role_name}"
 
-        raise "#{self.class.basename} cannot have more than one role named #{role_name}" if roles[role_name]
+        raise "#{name} cannot have more than one role named #{role_name}" if roles[role_name]
         roles[role_name] = role = Role.new(self, related, nil, role_name, mandatory)
 
         # There may be a forward reference here where role_name is a Symbol,
@@ -350,6 +350,7 @@ module ActiveFacts
 
         # resolve the Symbol to a Class now if possible:
         resolved = vocabulary.concept(related) rescue nil
+        #puts "#{related} resolves to #{resolved}"
         related = resolved if resolved
         # puts "related = #{related.inspect}"
 
@@ -399,7 +400,7 @@ module ActiveFacts
         when String     # Arrange for this to happen later
           vocabulary.__delay(concept, args, &block)
         else
-          raise "Delayed binding not possible for #{concept.inspect}"
+          raise "Delayed binding not possible for #{concept.class.name} #{concept.inspect}"
         end
       end
     end

data/lib/activefacts/api/constellation.rb

@@ -79,7 +79,7 @@ module ActiveFacts
 
             # REVISIT: It would be better not to rely on the role name pattern here:
             single_roles, multiple_roles = klass.roles.keys.sort_by(&:to_s).partition{|r| r.to_s !~ /\Aall_/ }
-            single_roles -= klass.identifying_role_names if (klass.respond_to?(:identifying_role_names))
+            single_roles -= klass.identifying_role_names if (klass.is_entity_type)
             # REVISIT: Need to include superclass roles also.
 
             instances = send(concept.to_sym)

data/lib/activefacts/api/entity.rb

@@ -109,6 +109,16 @@ module ActiveFacts
           @identifying_role_names ||= []
         end
 
+        def identifying_roles
+          debug :persistence, "Identifying roles for #{basename}" do
+            @identifying_role_names.map{|name|
+              role = roles[name] || (!superclass.is_entity_type || superclass.roles[name])
+              debug :persistence, "#{name} -> #{role ? "found" : "NOT FOUND"}"
+              role
+            }
+          end
+        end
+
         # Convert the passed arguments into an array of Instance objects that can identify an instance of this Entity type:
         def identifying_role_values(*args)
           #puts "Getting identifying role values #{identifying_role_names.inspect} of #{basename} using #{args.inspect}"
@@ -211,7 +221,7 @@ module ActiveFacts
         # inherited from a superclass.
         def initialise_entity_type(*args) #:nodoc:
           #puts "Initialising entity type #{self} using #{args.inspect}"
-          @identifying_role_names = superclass.identifying_role_names if superclass.respond_to?(:identifying_role_names)
+          @identifying_role_names = superclass.identifying_role_names if superclass.is_entity_type
           # REVISIT: @identifying_role_names here are the symbols passed in, not the Role objects we should use.
           # We'd need late binding to use Role objects...
           @identifying_role_names = args if args.size > 0 || !@identifying_role_names
@@ -235,6 +245,7 @@ module ActiveFacts
 
         # Register ourselves with the parent module, which has become a Vocabulary:
         vocabulary = other.modspace
+        # puts "Entity.included(#{other.inspect})"
         unless vocabulary.respond_to? :concept  # Extend module with Vocabulary if necessary
           vocabulary.send :extend, Vocabulary
         end

data/lib/activefacts/api/instance.rb

@@ -14,7 +14,7 @@ module ActiveFacts
       attr_accessor :constellation
 
       def initialize(args = []) #:nodoc:
-        unless (self.class.respond_to?(:identifying_role_names))
+        unless (self.class.is_entity_type)
         #if (self.class.superclass != Object)
           # puts "constructing #{self.class.superclass} with #{args.inspect}"
           super(*args)

data/lib/activefacts/api/role.rb

@@ -30,7 +30,7 @@ module ActiveFacts
         @name = name
         @mandatory = mandatory
         @unique = unique
-        @is_identifying = @owner.respond_to?(:identifying_role_names) && @owner.identifying_role_names.include?(@name)
+        @is_identifying = @owner.is_entity_type && @owner.identifying_role_names.include?(@name)
       end
 
       # Is this role a unary (created by maybe)? If so, it has no counterpart

data/lib/activefacts/api/standard_types.rb

@@ -43,10 +43,14 @@ class Class
   # Make this Class into a Concept and if necessary its module into a Vocabulary.
   # The parameters are the names (Symbols) of the identifying roles.
   def identified_by *args
-    raise "not an entity type" if respond_to? :value_type  # Don't make a ValueType into an EntityType
+    raise "#{basename} is not an entity type" if respond_to? :value_type  # Don't make a ValueType into an EntityType
     include ActiveFacts::API::Entity
     initialise_entity_type(*args)
   end
+
+  def is_entity_type
+    respond_to?(:identifying_role_names)
+  end
 end
 
 # REVISIT: Fix these NORMA types
@@ -56,10 +60,14 @@ class SignedInteger < Int #:nodoc:
 end
 class SignedSmallInteger < Int #:nodoc:
 end
+class SignedTinyInteger < Int #:nodoc:
+end
 class UnsignedInteger < Int #:nodoc:
 end
 class UnsignedSmallInteger < Int #:nodoc:
 end
+class UnsignedTinyInteger < Int #:nodoc:
+end
 class LargeLengthText < String #:nodoc:
 end
 class FixedLengthText < String #:nodoc:

data/lib/activefacts/api/support.rb

@@ -23,6 +23,10 @@ class String #:nodoc:
   def snakecase
     gsub(/([a-z])([A-Z])/,'\1_\2').downcase
   end
+
+  def camelwords
+    gsub(/([a-z])([A-Z])/,'\1_\2').split(/[_\s]+/)
+  end
 end
 
 class Module #:nodoc:

data/lib/activefacts/api/value.rb

@@ -118,6 +118,7 @@ module ActiveFacts
 
         # Register ourselves with the parent module, which has become a Vocabulary:
         vocabulary = other.modspace
+        # puts "ValueType.included(#{other.inspect})"
         unless vocabulary.respond_to? :concept  # Extend module with Vocabulary if necessary
           vocabulary.send :extend, Vocabulary
         end

data/lib/activefacts/api/vocabulary.rb

@@ -28,7 +28,7 @@ module ActiveFacts
           __bind(camel)
           return c
         end
-        return (const_get(camel) rescue nil)
+        return (const_get("#{name}::#{camel}") rescue nil)
       end
 
       def add_concept(klass)  #:nodoc:
@@ -48,6 +48,7 @@ module ActiveFacts
       # __bind raises an error if the named class doesn't exist yet.
       def __bind(concept_name)  #:nodoc:
         concept = const_get(concept_name)
+        # puts "#{name}.__bind #{concept_name} -> #{concept.name}" if concept
         if (@delayed && @delayed.include?(concept_name))
           # $stderr.puts "#{concept_name} was delayed, binding now"
           d = @delayed[concept_name]
@@ -67,64 +68,6 @@ module ActiveFacts
             }*"\n\t"
       end
 
-=begin
-      # Create or find an instance of klass in constellation using value to identify it
-      def adopt(klass, constellation, value)  #:nodoc:
-        puts "Adopting #{ value.verbalise rescue value.class.to_s+' '+value.inspect} as #{klass} into constellation #{constellation.object_id}"
-
-        path = "unknown"
-        # Create a value instance we can hack if the value isn't already in this constellation
-        if (c = constellation)
-          if value.is_a?(klass)            # Right class?
-            value = value.__getobj__ if RoleProxy === value
-            vc = value.constellation rescue nil
-            if (c == vc)                # Right constellation?
-              # Already right class, in the right constellation
-              path = "right constellation, right class, just use it"
-            else
-              # We need a new object from our constellation, so copy the value.
-              if klass.respond_to?(:identifying_role_names)
-                # Make a new entity having only the identifying roles set.
-                # Someone will complain that this is wrong, and all functional role values should also
-                # be cloned, and I'm listening... but not there yet. Why just those?
-                cloned = c.send(
-                    :"#{klass.basename}",
-                    *klass.identifying_role_names.map{|role| value.send(role) }
-                  )
-                path = "wrong constellation, right class, cloned entity"
-              else
-                # Just copy a value:
-                cloned = c.send(:"#{klass.basename}", *value)
-                path = "wrong constellation, right class, copied value"
-              end
-              value.constellation = c
-            end
-          else
-            # Wrong class, assume it's a valid constructor arg. Get our constellation to find/make it:
-            value = [ value ] unless Array === value
-            value = c.send(:"#{klass.basename}", *value)
-            path = "right constellation but wrong class, constructed from args"
-          end
-        else
-          # This object's not in a constellation
-          if value.is_a?(klass)            # Right class?
-            value = value.__getobj__ if RoleProxy === value
-            if vc = value.constellation rescue nil
-              raise "REVISIT: Assigning to #{self.class.basename}.#{role_name} with constellation=#{c.inspect}: Can't dis-associate object from its constellation #{vc.object_id} yet"
-            end
-            # Right class, no constellation, just use it
-            path = "no constellation, correct class"
-          else
-            # Wrong class, construct one
-            value = klass.send(:new, *value)
-            path = "no constellation, constructed from wrong class"
-          end
-        end
-        # print "#{path}"; puts ", adopted as #{value.verbalise rescue value.inspect}"
-        value
-      end
-=end
-
     end
   end
 end

data/lib/activefacts/cql/DataTypes.treetop

@@ -9,7 +9,7 @@ module ActiveFacts
     grammar DataTypes
       rule data_type
         s name:id
-        ( s '=' s / defined_as )
+        ( s '=' s / written_as )
         base:id s
         '(' s tpl:type_parameter_list? ')' s
         u0:(!restricted u1:unit s)?
@@ -34,6 +34,15 @@ module ActiveFacts
         }
       end
 
+      rule unit_definition
+	numerator:number denominator:(s '/' s number)?
+	baseunits:(unit+ (s '/' s unit+)?) s
+	offset:(('+' / '-') s number)
+	'makes' s ('approximately' s)?
+	singular:id plural:(s '/' s id)?
+	(s '[' s 'ephemeral' s ']')?
+      end
+
       rule type_parameter_list
         head:number s tail:( ',' s number s )*
         {

data/lib/activefacts/cql/Expressions.treetop

@@ -88,7 +88,7 @@ module ActiveFacts
       end
 
       rule variable
-        id0:id o0:( !defined_as s id1:id )?
+        id0:id o0:( !written_as s id1:id )?
         {
           def value
             # Variable names may consist of one or two words (optional adjective and a noun):

data/lib/activefacts/cql/FactTypes.treetop

@@ -8,7 +8,7 @@ module ActiveFacts
   module CQL
     grammar FactTypes
       rule named_fact_type
-        s name:id ( s '=' s / defined_as / s is s where )
+        s name:id ( s '=' s / written_as / s is s where )
         anonymous_fact_type
         {
           def value

data/lib/activefacts/cql/Language/English.treetop

@@ -12,8 +12,8 @@ module ActiveFacts
         'is' s 'a' s ('kind'/'subtype') s 'of' S
       end
 
-      rule defined_as
-        s 'is' s 'defined' S as s
+      rule written_as
+        s 'is' s 'written' S as s
       end
 
       rule identified_by

data/lib/activefacts/generate/absorption.rb

@@ -19,8 +19,6 @@ module ActiveFacts
     # * no_identifier Don't show the identified_by columns for an EntityType
 
     class ABSORPTION
-      include Metamodel
-
       def initialize(vocabulary, *options)  #:nodoc:
         @vocabulary = vocabulary
         @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary

data/lib/activefacts/generate/cql.rb

@@ -14,8 +14,6 @@ module ActiveFacts
     #   afgen --cql <file>.cql
     class CQL < OrderedDumper
     private
-      include Metamodel
-
       def vocabulary_start(vocabulary)
         puts "vocabulary #{vocabulary.name};\n\n"
       end
@@ -46,7 +44,7 @@ module ActiveFacts
 
                   #" restricted to {#{(allowed_values.map{|r| r.inspect}*", ").gsub('"',"'")}}")
 
-        puts "#{o.name} is defined as #{o.supertype.name}#{ parameters }#{
+        puts "#{o.name} is written as #{o.supertype.name}#{ parameters }#{
             o.value_restriction ? " restricted to {#{
               o.value_restriction.all_allowed_range.sort_by{|ar|
                     ((min = ar.value_range.minimum_bound) && min.value) ||
@@ -342,7 +340,7 @@ module ActiveFacts
         end
         #puts "#{c.class.basename} has players #{players.map{|p| p.name}*", "}"
 
-        if (SetEqualityConstraint === c)
+        if c.is_a?(ActiveFacts::Metamodel::SetEqualityConstraint)
           # REVISIT: Need a proper approach to some/that and adjective disambiguation:
           puts \
             scrs.map{|scr|
@@ -436,13 +434,13 @@ module ActiveFacts
 
       def constraint_dump(c)
           case c
-          when PresenceConstraint
+          when ActiveFacts::Metamodel::PresenceConstraint
             dump_presence_constraint(c)
-          when RingConstraint
+          when ActiveFacts::Metamodel::RingConstraint
             dump_ring_constraint(c)
-          when SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
+          when ActiveFacts::Metamodel::SetComparisonConstraint # includes SetExclusionConstraint, SetEqualityConstraint
             dump_set_constraint(c)
-          when SubsetConstraint
+          when ActiveFacts::Metamodel::SubsetConstraint
             dump_subset_constraint(c)
           else
             "#{c.class.basename} #{c.name}: unhandled constraint type"

data/lib/activefacts/generate/cql/html.rb

@@ -72,7 +72,7 @@ module ActiveFacts
             ].compact
           parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : "()"
 
-          puts "#{concept o.name} #{keyword "is defined as"} #{concept o.supertype.name + parameters }#{
+          puts "#{concept o.name} #{keyword "is written as"} #{concept o.supertype.name + parameters }#{
               if (o.value_restriction)
                 keyword("restricted to")+
                 o.value_restriction.all_allowed_range.map{|ar|

data/lib/activefacts/generate/oo.rb

@@ -11,8 +11,6 @@ module ActiveFacts
   module Generate
     # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
     class OO < OrderedDumper  #:nodoc:
-      include Metamodel
-
       def constraints_dump(constraints_used)
         # Stub, not needed.
       end
@@ -29,7 +27,7 @@ module ActiveFacts
             role.fact_type.all_role.size <= 2
           }.
           sort_by{|role|
-            preferred_role_name(role.fact_type.all_role.select{|r2| r2 != role}[0] || role)
+            preferred_role_name(role.fact_type.all_role.select{|r2| r2 != role}[0] || role, o)
           }.each{|role| 
             role_dump(role)
           }
@@ -38,54 +36,63 @@ module ActiveFacts
       def role_dump(role)
         fact_type = role.fact_type
         if fact_type.all_role.size == 1
-          unary_dump(role, preferred_role_name(role))
+          unary_dump(role, preferred_role_name(role)) unless fact_type.entity_type
+          # REVISIT: If the objectified fact type has already been dumped, we'll get nothing.
           return
         elsif fact_type.all_role.size != 2
           return  # ternaries and higher are always objectified
         end
 
         # REVISIT: TypeInheritance
-        if TypeInheritance === fact_type
+        if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
           # debug "Ignoring role #{role} in #{fact_type}, subtype fact type"
           return
         end
 
-        other_role = fact_type.all_role.select{|r| r != role}[0]
-        other_role_name = preferred_role_name(other_role)
-        other_player = other_role.concept
-
         # Find any uniqueness constraint over this role:
         fact_constraints = @presence_constraints_by_fact[fact_type]
         #debug "Considering #{fact_constraints.size} fact constraints over fact role #{role.concept.name}"
-        ucs = fact_constraints.select{|c| PresenceConstraint === c && c.max_frequency == 1 }
+        ucs = fact_constraints.select{|c| c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) && c.max_frequency == 1 }
         # Emit "has_one/one_to_one..." only for functional roles here:
         #debug "Considering #{ucs.size} unique constraints over role #{role.concept.name}"
         unless ucs.find {|c|
-              roles = c.role_sequence.all_role_ref.map(&:role)
-              #debug "Unique constraint over role #{role.concept.name} has roles #{roles.map{|r| describe_fact_type(r.fact_type, r)}*", "}"
-              roles == [role]
+              c.role_sequence.all_role_ref.map(&:role) == [role]
           }
           #debug "No uniqueness constraint found for #{role} in #{fact_type}"
           return
         end
 
-        if ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] } &&
-            !@concept_types_dumped[other_role.concept]
-          #debug "Will dump 1:1 later for #{role} in #{fact_type}"
-          return
-        end
-
-        # It's a one_to_one if there's a uniqueness constraint on the other role:
-        one_to_one = ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] }
-
-        # Find role name:
-        role_method = preferred_role_name(role)
-        as = other_role_name != other_player.name.snakecase ? "_as_#{other_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.name.snakecase and
-          role_method == role.concept.name.snakecase
-          other_role_method += "_as_#{other_role_name}"
+        if fact_type.entity_type
+          # other_role is a phantom played by the entity type that objectifies this fact type.
+          # REVISIT: No rolename can be provided for the phantom role, so _as_XYZ doesn't occur
+          other_player = fact_type.entity_type
+          return unless @concept_types_dumped[other_player]
+
+          other_role_name = other_player.name.snakecase
+          other_role_method = role.concept.name.snakecase
+          one_to_one = true
+        else
+
+          other_role = fact_type.all_role.select{|r| r != role}[0]
+          other_role_name = preferred_role_name(other_role)
+          other_player = other_role.concept
+
+          # It's a one_to_one if there's a uniqueness constraint on the other role:
+          one_to_one = ucs.find {|c| c.role_sequence.all_role_ref.map(&:role) == [other_role] }
+          if one_to_one &&
+              !@concept_types_dumped[other_role.concept]
+            #debug "Will dump 1:1 later for #{role} in #{fact_type}"
+            return
+          end
+
+          # Find role name:
+          role_method = preferred_role_name(role)
+          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.name.snakecase and
+            role_method == role.concept.name.snakecase
+            other_role_method += "_as_#{other_role_name}"
+          end
         end
 
         role_name = role_method
@@ -94,8 +101,13 @@ module ActiveFacts
         binary_dump(role, other_role_name, other_player, one_to_one, nil, role_name, other_role_method)
       end
 
-      def preferred_role_name(role)
-        return "" if TypeInheritance === role.fact_type
+      def preferred_role_name(role, is_for = nil)
+        return "" if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+
+        if is_for && role.fact_type.entity_type == is_for && role.fact_type.all_role.size == 1
+          return role.concept.name.snakecase
+        end
+
         # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
         reading = role.fact_type.preferred_reading
         preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
@@ -129,19 +141,27 @@ module ActiveFacts
       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 ||
-          TypeInheritance === f
+          f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
       end
 
       # An objectified fact type has internal roles that are always "has_one":
-      def fact_roles_dump(fact)
-        fact.all_role.sort_by{|role|
-            preferred_role_name(role)
+      def fact_roles_dump(fact_type)
+        fact_type.all_role.sort_by{|role|
+            preferred_role_name(role, fact_type.entity_type)
           }.each{|role| 
-            role_name = preferred_role_name(role)
+            role_name = preferred_role_name(role, fact_type.entity_type)
+            one_to_one = role.all_role_ref.detect{|rr|
+              rr.role_sequence.all_role_ref.size == 1 &&
+              rr.role_sequence.all_presence_constraint.detect{|pc|
+                pc.max_frequency == 1
+              }
+            }
             as = role_name != role.concept.name.snakecase ? "_as_#{role_name}" : ""
-            raise "Fact #{fact.describe} type is not objectified" unless fact.entity_type
-            other_role_method = "all_"+fact.entity_type.name.snakecase+as
-            binary_dump(role, role_name, role.concept, false, nil, nil, other_role_method)
+            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.name.snakecase +
+              as
+            binary_dump(role, role_name, role.concept, one_to_one, nil, nil, other_role_method)
           }
       end