activefacts 0.7.3 → 0.8.5

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

@@ -62,8 +62,8 @@ module ActiveFacts
         def value_type_dump(o)
           return unless o.supertype    # An imported type
           if o.name == o.supertype.name
-              # In ActiveFacts, parameterising a ValueType will create a new datatype
-              # throw Can't handle parameterized value type of same name as its datatype" if ...
+              # In ActiveFacts, parameterising a ValueType will create a new ValueType
+              # throw Can't handle parameterized value type of same name as its ValueType" if ...
           end
 
           parameters =
@@ -139,13 +139,13 @@ module ActiveFacts
             # Detect standard reference-mode readings:
             forward_reading = reverse_reading = nil
             ft.all_reading.each do |reading|
-              if reading.reading_text =~ /^\{(\d)\} has \{\d\}$/
+              if reading.text =~ /^\{(\d)\} has \{\d\}$/
                 if reading.role_sequence.all_role_ref[$1.to_i].role == entity_role
                   forward_reading = reading
                 else
                   reverse_reading = reading
                 end
-              elsif reading.reading_text =~ /^\{(\d)\} is of \{\d\}$/
+              elsif reading.text =~ /^\{(\d)\} is of \{\d\}$/
                 if reading.role_sequence.all_role_ref[$1.to_i].role == value_role
                   reverse_reading = reading
                 else
@@ -356,7 +356,7 @@ module ActiveFacts
             }
           frequency_constraints = [] unless frequency_constraints.detect{|fc| fc[0] =~ /some/ }
 
-          #$stderr.puts "fact_type roles (#{fact_type.all_role.map{|r| r.concept.name}*","}) default_reading '#{fact_type.preferred_reading.reading_text}' roles (#{fact_type.preferred_reading.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*","}) #{frequency_constraints.inspect}"
+          #$stderr.puts "fact_type roles (#{fact_type.all_role.map{|r| r.concept.name}*","}) default_reading '#{fact_type.preferred_reading.text}' roles (#{fact_type.preferred_reading.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}*","}) #{frequency_constraints.inspect}"
 
           # REVISIT: Make sure that we refer to the constrained players by their common supertype
 

data/lib/activefacts/generate/oo.rb

@@ -98,7 +98,7 @@ module ActiveFacts
         role_name = role_method
         role_name = nil if role_name == role.concept.name.snakecase
 
-        binary_dump(role, other_role_name, other_player, one_to_one, nil, role_name, other_role_method)
+        binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
       end
 
       def preferred_role_name(role, is_for = nil)
@@ -117,7 +117,7 @@ module ActiveFacts
         # Unaries are a hack, with only one role for what is effectively a binary:
         if (role.fact_type.all_role.size == 1)
           return (role.role_name && role.role_name.snakecase) ||
-            reading.reading_text.gsub(/ *\{0\} */,'').gsub(' ','_').downcase
+            reading.text.gsub(/ *\{0\} */,'').gsub(' ','_').downcase
         end
 
         # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.concept.name}, trailing_adjective=#{p.trailing_adjective}"
@@ -161,7 +161,7 @@ module ActiveFacts
             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)
+            binary_dump(role, role_name, role.concept, true, one_to_one, nil, nil, other_role_method)
           }
       end
 

data/lib/activefacts/generate/ordered.rb

@@ -65,7 +65,7 @@ module ActiveFacts
       def value_types_dump
         done_banner = false
         @value_type_dumped = {}
-        @vocabulary.all_feature.sort_by{|o| o.name}.each{|o|
+        @vocabulary.all_concept.sort_by{|o| o.name}.each{|o|
             next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
 
             value_type_banner unless done_banner
@@ -90,11 +90,11 @@ module ActiveFacts
       # if possible (it's not always, there may be loops!)
       def entity_types_dump
         # Build hash tables of precursors and followers to use:
-        precursors, followers = *build_entity_dependencies
+        @precursors, @followers = *build_entity_dependencies
 
         done_banner = false
-        sorted = @vocabulary.all_feature.select{|o|
-          o.is_a?(ActiveFacts::Metamodel::EntityType) and !o.fact_type
+        sorted = @vocabulary.all_concept.select{|o|
+          o.is_a?(ActiveFacts::Metamodel::EntityType) # and !o.fact_type
         }.sort_by{|o| o.name}
         panic = nil
         while true do
@@ -105,7 +105,7 @@ module ActiveFacts
 
               # Can we do this yet?
               if (o != panic and                  # We don't *have* to do it (panic mode)
-                  (p = precursors[o]) and         # There might be...
+                  (p = @precursors[o]) and         # There might be...
                   p.size > 0)                     # precursors - still blocked
                 skipped_this_pass += 1
                 next
@@ -115,14 +115,19 @@ module ActiveFacts
               done_banner = true
 
               # We're going to emit o - remove it from precursors of others:
-              (followers[o]||[]).each{|f|
-                  precursors[f] -= [o]
+              (@followers[o]||[]).each{|f|
+                  @precursors[f] -= [o]
                 }
               count_this_pass += 1
               panic = nil
 
-              entity_type_dump(o)
-              released_fact_types_dump(o)
+              if (o.fact_type)
+                fact_type_dump_with_dependents(o.fact_type)
+                released_fact_types_dump(o)
+              else
+                entity_type_dump(o)
+                released_fact_types_dump(o)
+              end
 
               entity_type_group_end
             }
@@ -136,7 +141,7 @@ module ActiveFacts
                   ":\n\t" + bad.map{|o|
                     o.name +
                     ": " +
-                    precursors[o].map{|p| p.name}.uniq.inspect
+                    @precursors[o].map{|p| p.name}.uniq.inspect
                   } * "\n\t" + "\n"
               else
                 # Find the object that has the most followers and no fwd-ref'd supertypes:
@@ -144,7 +149,7 @@ module ActiveFacts
                 panic = sorted.
                   select{|o| !@concept_types_dumped[o] }.
                   sort_by{|o|
-                      f = followers[o] || []; 
+                      f = @followers[o] || []; 
                       o.supertypes.detect{|s| !@concept_types_dumped[s] } ? 0 : -f.size
                     }[0]
                 # debug "Panic mode, selected #{panic.name} next"
@@ -179,7 +184,7 @@ module ActiveFacts
         role_refs = pi.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
 
         # We need to get the adjectives for the roles from the identifying fact's preferred readings:
-        identifying_facts = role_refs.map{|rr| rr.role.fact_type }.uniq
+        identifying_facts = ([o.fact_type]+role_refs.map{|rr| rr.role.fact_type }).compact.uniq
         preferred_readings = identifying_facts.inject({}){|reading_hash, fact_type|
             pr = fact_type.preferred_reading
             reading_hash[fact_type] = pr
@@ -211,12 +216,13 @@ module ActiveFacts
       def expanded_reading(reading, fact_constraints, define_role_names)
         # Find all role numbers in order of occurrence in this reading:
         role_refs = reading.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
-        role_numbers = reading.reading_text.scan(/\{(\d)\}/).flatten.map{|m| Integer(m) }
+        role_numbers = reading.text.scan(/\{(\d)\}/).flatten.map{|m| Integer(m) }
         roles = role_numbers.map{|m| role_refs[m].role }
-        # debug "Considering #{reading.reading_text} having #{role_numbers.inspect}"
+        # debug "Considering #{reading.text} having #{role_numbers.inspect}"
 
         # Find the constraints that constrain frequency over each role we can verbalise:
         frequency_constraints = []
+        value_restrictions = []
         roles.each do |role|
           # Find a mandatory constraint that's *not* unique; this will need an extra reading
           role_is_first_in = reading.fact_type.all_reading.detect{|r|
@@ -225,6 +231,15 @@ module ActiveFacts
                 }[0].role
             }
 
+          if vr = role.role_value_restriction
+            if @constraints_used[vr]
+              vr = nil
+            else
+              @constraints_used[vr] = true
+              vr = vr.describe
+            end
+          end
+          value_restrictions << vr
           if (role == roles.last)   # First role of the reading?
             # REVISIT: With a ternary, doing this on other than the last role can be ambiguous,
             # in case both the 2nd and 3rd roles have frequencies. Think some more!
@@ -245,7 +260,7 @@ module ActiveFacts
           end
         end
 
-        expanded = reading.expand(frequency_constraints, define_role_names)
+        expanded = reading.expand(frequency_constraints, define_role_names, value_restrictions)
 
         if (ft_rings = @ring_constraints_by_fact[reading.fact_type]) &&
            (ring = ft_rings.detect{|rc| !@constraints_used[rc]})
@@ -279,8 +294,8 @@ module ActiveFacts
       # This returns an array of two hash tables each keyed by an EntityType.
       # The values of each hash entry are the precursors and followers (respectively) of that entity.
       def build_entity_dependencies
-        @vocabulary.all_feature.inject([{},{}]) { |a, o|
-            if o.is_a?(ActiveFacts::Metamodel::EntityType) && !o.fact_type
+        @vocabulary.all_concept.inject([{},{}]) { |a, o|
+            if o.is_a?(ActiveFacts::Metamodel::EntityType)
               precursor = a[0]
               follower = a[1]
               blocked = false
@@ -289,12 +304,21 @@ module ActiveFacts
                 pi.role_sequence.all_role_ref.each{|rr|
                     role = rr.role
                     player = role.concept
+                    # REVISIT: If we decide to emit value types on demand, need to remove this:
                     next unless player.is_a?(ActiveFacts::Metamodel::EntityType)
                     # player is a precursor of o
                     (precursor[o] ||= []) << player if (player != o)
                     (follower[player] ||= []) << o if (player != o)
                   }
               end
+              if o.fact_type
+                o.fact_type.all_role.each do |role|
+                  next unless role.concept.is_a?(ActiveFacts::Metamodel::EntityType)
+                  (precursor[o] ||= []) << role.concept
+                  (follower[role.concept] ||= []) << o
+                end
+              end
+
               # Supertypes are precursors too:
               subtyping = o.all_type_inheritance_as_supertype
               next a if subtyping.size == 0
@@ -304,6 +328,12 @@ module ActiveFacts
                   (precursor[s] ||= []) << o
                   (follower[o] ||= []) << s
                 }
+#            REVISIT: Need to use this to order ValueTypes after their supertypes
+#            else
+#              o.all_value_type_as_supertype.each { |s|
+#                (precursor[s] ||= []) << o
+#                (follower[o] ||= []) << s
+#              }
             end
             a
           }
@@ -317,7 +347,9 @@ module ActiveFacts
           roles.map(&:fact_type).uniq.select{|fact_type|
               # The fact type hasn't already been dumped but all its role players have
               !@fact_types_dumped[fact_type] &&
-                !fact_type.all_role.detect{|r| !@concept_types_dumped[r.concept] }
+                !fact_type.all_role.detect{|r| !@concept_types_dumped[r.concept] } &&
+                !fact_type.entity_type
+#                !(fact_type.entity_type && (p = @precursors[fact_type.entity_type]) && p.size > 0)
             }.sort_by{|fact_type|
               fact_type_key(fact_type)
             }.each{|fact_type|
@@ -380,7 +412,7 @@ module ActiveFacts
               all_role_ref.
               sort_by{|role_ref| role_ref.ordinal}.
               map{|role_ref| [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" } +
-              [pr.reading_text]
+              [pr.text]
           else
             fact_type.all_role.map{|role| role.concept.name }
           end

data/lib/activefacts/generate/ruby.rb

@@ -52,8 +52,8 @@ module ActiveFacts
 
         return if !o.supertype && !is_special_supertype
         if o.supertype && o.name == o.supertype.name
-          # In ActiveFacts, parameterising a ValueType will create a new datatype
-          # throw Can't handle parameterized value type of same name as its datatype" if ...
+          # In ActiveFacts, parameterising a ValueType will create a new ValueType
+          # throw Can't handle parameterized value type of same name as its ValueType" if ...
         end
 
         length = (l = o.length) && l > 0 ? ":length => #{l}" : nil
@@ -76,7 +76,7 @@ module ActiveFacts
         if @sql and o.is_table
           puts "    table"
         end
-        puts "    \# REVISIT: #{o.name} has restricted values\n" if o.value_restriction
+        puts "    restrict #{o.value_restriction.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" if o.value_restriction
         puts "    \# REVISIT: #{o.name} is in units of #{o.unit.name}\n" if o.unit
         roles_dump(o)
         puts "  end\n\n"
@@ -147,26 +147,28 @@ module ActiveFacts
         puts "    maybe :"+role_name
       end
 
-      def binary_dump(role, role_name, role_player, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
+      def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
         # Find whether we need the name of the other role player, and whether it's defined yet:
         if role_name.camelcase(true) == role_player.name.sub(/^[a-z]/) {|i| i.upcase}
           # Don't use Class name if implied by rolename
           role_reference = nil
         else
-          role_reference = concept_reference(role_player)
+          role_reference = ":class => "+concept_reference(role_player)
         end
-        other_role_name = ":"+other_role_name if other_role_name
+        other_role_name = ":counterpart => :"+other_role_name if other_role_name
 
         line = "    #{one_to_one ? "one_to_one" : "has_one" } " +
                 [ ":"+role_name,
                   role_reference,
+                  mandatory ? ":mandatory => true" : nil,
                   readings,
-                  other_role_name
+                  other_role_name,
+                  (vr = role.role_value_restriction) ? ":restrict => #{vr}" : nil
                 ].compact*", "+"  "
         line += " "*(48-line.length) if line.length < 48
         line += "\# See #{role_player.name}.#{other_method_name}" if other_method_name
         puts line
-        puts "    \# REVISIT: #{other_role_name} has restricted values\n" if role.role_value_restriction
+        #puts "    \# REVISIT: #{other_role_name} has values restricted to #{role.role_value_restriction}\n" if role.role_value_restriction
       end
 
       def concept_reference concept

data/lib/activefacts/generate/sql/mysql.rb

@@ -15,7 +15,7 @@ module ActiveFacts
       #   afgen --sql/mysql[=options] <file>.cql
       # Options are comma or space separated:
       # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
-      # * norma Translate datatypes from NORMA to SQL Server
+      # * norma Translate valuetypes from NORMA to SQL Server
       class MYSQL
       private
         include Persistence
@@ -227,24 +227,28 @@ module ActiveFacts
         end
 
       private
+        def sql_value(value)
+          value.is_a_string ? sql_string(value.literal) : value.literal
+        end
+
+        def sql_string(str)
+          "'" + str.gsub(/'/,"''") + "'"
+        end
+
         def check_clause(column_name, restrictions)
           return "" if restrictions.empty?
           # REVISIT: Merge all restrictions (later; now just use the first)
           " CHECK(" +
-            restrictions[0].all_allowed_range.sort_by do |ar|
-              # Put the allowed ranges into a defined order:
-              ((min = ar.value_range.minimum_bound) && min.value) ||
-                ((max = ar.value_range.maximum_bound) && max.value)
-            end.map do |ar|
+            restrictions[0].all_allowed_range_sorted.map do |ar|
               vr = ar.value_range
               min = vr.minimum_bound
               max = vr.maximum_bound
-              if (min && max && max.value == min.value)
-                "#{column_name} = #{min.value}"
+              if (min && max && max.value.literal == min.value.literal)
+                "#{column_name} = #{sql_value(min.value)}"
               else
                 inequalities = [
-                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{min.value}",
-                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{max.value}"
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{sql_value(min.value)}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{sql_value(max.value)}"
                 ].compact
                 inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
               end

data/lib/activefacts/generate/sql/server.rb

@@ -15,7 +15,7 @@ module ActiveFacts
       #   afgen --sql/server[=options] <file>.cql
       # Options are comma or space separated:
       # * delay_fks Leave all foreign keys until the end, not just those that contain forward-references
-      # * norma Translate datatypes from NORMA to SQL Server
+      # * norma Translate valuetypes from NORMA to SQL Server
       class SERVER
       private
         include Persistence
@@ -49,6 +49,7 @@ module ActiveFacts
           @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
           @delay_fks = options.include? "delay_fks"
           @norma = options.include? "norma"
+          @underscore = options.include?("underscore") ? "_" : ""
         end
 
         def puts s
@@ -102,7 +103,7 @@ module ActiveFacts
             when "PictureRawData"; "image"
             when "VariableLengthRawData"; "varbinary"
             when "BIT"; "bit"
-            else raise "SQL type unknown for NORMA type #{type}"
+            else type # raise "SQL type unknown for NORMA type #{type}"
             end
           [sql_type, length]
         end
@@ -116,7 +117,7 @@ module ActiveFacts
           delayed_foreign_keys = []
 
           @vocabulary.tables.each do |table|
-            puts "CREATE TABLE #{escape table.name} ("
+            puts "CREATE TABLE #{escape table.name(@underscore)} ("
 
             pk = table.identifier_columns
             identity_column = pk[0] if pk.size == 1 && pk[0].is_auto_assigned
@@ -128,8 +129,8 @@ module ActiveFacts
 
             # We sort the columns here, not in the persistence layer, because it affects
             # the ordering of columns in an index :-(.
-            columns = table.columns.sort_by { |column| column.name(nil) }.map do |column|
-              name = escape column.name("")
+            columns = table.columns.sort_by { |column| column.name(@underscore) }.map do |column|
+              name = escape column.name(@underscore)
               padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
               type, params, restrictions = column.type
               restrictions = [] if (fk_columns.include?(column))  # Don't enforce VT restrictions on FK columns
@@ -153,22 +154,22 @@ module ActiveFacts
             end.flatten
 
             pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
-                pk.map{|column| escape column.name("")}*", " +
+                pk.map{|column| escape column.name(@underscore)}*", " +
                 ")"
 
             inline_fks = []
             table.foreign_keys.each do |fk|
               fk_text = "FOREIGN KEY (" +
-                fk.from_columns.map{|column| column.name}*", " +
-                ") REFERENCES #{escape fk.to.name} (" +
-                fk.to_columns.map{|column| column.name}*", " +
+                fk.from_columns.map{|column| column.name(@underscore)}*", " +
+                ") REFERENCES #{escape fk.to.name(@underscore)} (" +
+                fk.to_columns.map{|column| column.name(@underscore)}*", " +
                 ")"
               if !@delay_fks and              # We don't want to delay all Fks
                 (tables_emitted[fk.to] or     # The target table has been emitted
                 fk.to == table && !fk.to_columns.detect{|column| !column.is_mandatory})   # The reference columns already have the required indexes
                 inline_fks << fk_text
               else
-                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name}\n\tADD " + fk_text)
+                delayed_foreign_keys << ("ALTER TABLE #{escape fk.from.name(@underscore)}\n\tADD " + fk_text)
               end
             end
 
@@ -177,8 +178,8 @@ module ActiveFacts
             delayed_indices = []
             indices.each do |index|
               next if index.over == table && index.is_primary   # Already did the primary keys
-              abbreviated_column_names = index.abbreviated_column_names*""
-              column_names = index.column_names
+              abbreviated_column_names = index.abbreviated_column_names(@underscore)*""
+              column_names = index.column_names(@underscore)
               column_name_list = column_names.map{|n| escape(n)}*", "
               if index.columns.all?{|column| column.is_mandatory}
                 inline_indices << "UNIQUE(#{column_name_list})"
@@ -186,17 +187,17 @@ module ActiveFacts
                 view_name = escape "#{index.view_name}_#{abbreviated_column_names}"
                 delayed_indices <<
 %Q{CREATE VIEW dbo.#{view_name} (#{column_name_list}) WITH SCHEMABINDING AS
-\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name}
+\tSELECT #{column_name_list} FROM dbo.#{escape index.on.name(@underscore)}
 \tWHERE\t#{
   index.columns.
     select{|column| !column.is_mandatory }.
     map{|column|
-      escape(column.name) + " IS NOT NULL"
+      escape(column.name(@underscore)) + " IS NOT NULL"
     }*"\n\t  AND\t"
 }
 GO
 
-CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.columns.map{|column| column.name}*", "})
+CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.columns.map{|column| column.name(@underscore)}*", "})
 }
               end
             end
@@ -216,24 +217,28 @@ CREATE UNIQUE CLUSTERED INDEX #{escape index.name} ON dbo.#{view_name}(#{index.c
         end
 
       private
+        def sql_value(value)
+          value.is_a_string ? sql_string(value.literal) : value.literal
+        end
+
+        def sql_string(str)
+          "'" + str.gsub(/'/,"''") + "'"
+        end
+
         def check_clause(column_name, restrictions)
           return "" if restrictions.empty?
           # REVISIT: Merge all restrictions (later; now just use the first)
           " CHECK(" +
-            restrictions[0].all_allowed_range.sort_by do |ar|
-              # Put the allowed ranges into a defined order:
-              ((min = ar.value_range.minimum_bound) && min.value) ||
-                ((max = ar.value_range.maximum_bound) && max.value)
-            end.map do |ar|
+            restrictions[0].all_allowed_range_sorted.map do |ar|
               vr = ar.value_range
               min = vr.minimum_bound
               max = vr.maximum_bound
-              if (min && max && max.value == min.value)
-                "#{column_name} = #{min.value}"
+              if (min && max && max.value.literal == min.value.literal)
+                "#{column_name} = #{sql_value(min.value)}"
               else
                 inequalities = [
-                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{min.value}",
-                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{max.value}"
+                  min && "#{column_name} >#{min.is_inclusive ? "=" : ""} #{sql_value(min.value)}",
+                  max && "#{column_name} <#{max.is_inclusive ? "=" : ""} #{sql_value(max.value)}"
                 ].compact
                 inequalities.size > 1 ? "(" + inequalities*" AND " + ")" : inequalities[0]
               end