RubyGems - activefacts - Versions diffs - 0.8.6 → 0.8.8 - Mend

activefacts 0.8.6 → 0.8.8

Files changed (118) hide show

data/Manifest.txt +33 -2
data/README.rdoc +30 -36
data/Rakefile +16 -20
data/bin/afgen +17 -11
data/bin/cql +313 -36
data/download.html +43 -19
data/examples/CQL/Address.cql +15 -15
data/examples/CQL/Blog.cql +8 -8
data/examples/CQL/CompanyDirectorEmployee.cql +6 -5
data/examples/CQL/Death.cql +3 -3
data/examples/CQL/Diplomacy.cql +48 -0
data/examples/CQL/Genealogy.cql +41 -41
data/examples/CQL/Insurance.cql +311 -0
data/examples/CQL/JoinEquality.cql +35 -0
data/examples/CQL/Marriage.cql +1 -1
data/examples/CQL/Metamodel.cql +290 -185
data/examples/CQL/MetamodelNext.cql +420 -0
data/examples/CQL/Monogamy.cql +24 -0
data/examples/CQL/MonthInSeason.cql +27 -0
data/examples/CQL/Moon.cql +23 -0
data/examples/CQL/MultiInheritance.cql +4 -4
data/examples/CQL/NonRoleId.cql +14 -0
data/examples/CQL/OddIdentifier.cql +18 -0
data/examples/CQL/OilSupply.cql +24 -24
data/examples/CQL/OneToOnes.cql +17 -0
data/examples/CQL/Orienteering.cql +55 -55
data/examples/CQL/OrienteeringER.cql +58 -0
data/examples/CQL/PersonPlaysGame.cql +2 -2
data/examples/CQL/RedundantDependency.cql +34 -0
data/examples/CQL/SchoolActivities.cql +5 -5
data/examples/CQL/SeparateSubtype.cql +28 -0
data/examples/CQL/ServiceDirector.cql +283 -0
data/examples/CQL/SimplestUnary.cql +2 -2
data/examples/CQL/SubtypePI.cql +11 -11
data/examples/CQL/Supervision.cql +38 -0
data/examples/CQL/Tests.Test5.Load.cql +38 -0
data/examples/CQL/WaiterTips.cql +33 -0
data/examples/CQL/Warehousing.cql +55 -53
data/examples/CQL/WindowInRoomInBldg.cql +9 -9
data/examples/CQL/unit.cql +433 -544
data/examples/index.html +314 -170
data/examples/intro.html +6 -176
data/examples/local.css +8 -4
data/index.html +40 -25
data/lib/activefacts/api/concept.rb +2 -2
data/lib/activefacts/api/constellation.rb +4 -4
data/lib/activefacts/api/instance.rb +2 -2
data/lib/activefacts/api/instance_index.rb +4 -0
data/lib/activefacts/api/numeric.rb +3 -1
data/lib/activefacts/api/role.rb +1 -1
data/lib/activefacts/api/standard_types.rb +23 -16
data/lib/activefacts/api/support.rb +3 -1
data/lib/activefacts/api/vocabulary.rb +4 -0
data/lib/activefacts/cql/CQLParser.treetop +87 -39
data/lib/activefacts/cql/Concepts.treetop +95 -69
data/lib/activefacts/cql/Context.treetop +11 -2
data/lib/activefacts/cql/Expressions.treetop +23 -59
data/lib/activefacts/cql/FactTypes.treetop +141 -95
data/lib/activefacts/cql/Language/English.treetop +33 -21
data/lib/activefacts/cql/LexicalRules.treetop +6 -1
data/lib/activefacts/cql/Terms.treetop +75 -26
data/lib/activefacts/cql/ValueTypes.treetop +52 -54
data/lib/activefacts/cql/compiler.rb +46 -1691
data/lib/activefacts/cql/compiler/constraint.rb +602 -0
data/lib/activefacts/cql/compiler/entity_type.rb +425 -0
data/lib/activefacts/cql/compiler/fact.rb +300 -0
data/lib/activefacts/cql/compiler/fact_type.rb +230 -0
data/lib/activefacts/cql/compiler/reading.rb +832 -0
data/lib/activefacts/cql/compiler/shared.rb +109 -0
data/lib/activefacts/cql/compiler/value_type.rb +104 -0
data/lib/activefacts/cql/parser.rb +132 -81
data/lib/activefacts/generate/cql.rb +397 -274
data/lib/activefacts/generate/oo.rb +13 -12
data/lib/activefacts/generate/ordered.rb +107 -117
data/lib/activefacts/generate/ruby.rb +34 -38
data/lib/activefacts/generate/sql/mysql.rb +62 -45
data/lib/activefacts/generate/sql/server.rb +59 -42
data/lib/activefacts/input/cql.rb +6 -3
data/lib/activefacts/input/orm.rb +991 -557
data/lib/activefacts/persistence/columns.rb +16 -12
data/lib/activefacts/persistence/foreignkey.rb +7 -4
data/lib/activefacts/persistence/index.rb +3 -4
data/lib/activefacts/persistence/reference.rb +5 -2
data/lib/activefacts/support.rb +20 -14
data/lib/activefacts/version.rb +1 -1
data/lib/activefacts/vocabulary.rb +1 -0
data/lib/activefacts/vocabulary/extensions.rb +328 -44
data/lib/activefacts/vocabulary/metamodel.rb +145 -20
data/lib/activefacts/vocabulary/verbaliser.rb +621 -0
data/spec/absorption_spec.rb +4 -4
data/spec/api/value_type.rb +1 -1
data/spec/cql/context_spec.rb +45 -22
data/spec/cql/deontic_spec.rb +88 -0
data/spec/cql/matching_spec.rb +517 -0
data/spec/cql/samples_spec.rb +88 -31
data/spec/cql/unit_spec.rb +58 -37
data/spec/cql_cql_spec.rb +12 -7
data/spec/cql_mysql_spec.rb +3 -7
data/spec/cql_parse_spec.rb +0 -4
data/spec/cql_ruby_spec.rb +1 -4
data/spec/cql_sql_spec.rb +5 -18
data/spec/cql_symbol_tables_spec.rb +3 -0
data/spec/cqldump_spec.rb +0 -2
data/spec/helpers/array_matcher.rb +35 -0
data/spec/helpers/ctrl_c_support.rb +52 -0
data/spec/helpers/diff_matcher.rb +38 -0
data/spec/helpers/file_matcher.rb +5 -3
data/spec/helpers/string_matcher.rb +39 -0
data/spec/helpers/test_parser.rb +13 -0
data/spec/norma_cql_spec.rb +13 -5
data/spec/norma_ruby_spec.rb +11 -3
data/spec/{absorption_ruby_spec.rb → norma_ruby_sql_spec.rb} +37 -32
data/spec/norma_sql_spec.rb +11 -5
data/spec/norma_tables_spec.rb +33 -29
data/spec/spec_helper.rb +4 -1
data/status.html +92 -23
metadata +102 -36
data/lib/activefacts/generate/cql/html.rb +0 -403

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

@@ -1,403 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate HTML-highlighted CQL from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-# The text generated here is pre-formatted, and it spans haing the following styles:
-# keyword: ORM2 standard colour is #00C (blue)
-# concept: ORM2 standard concept is #808 (purple)
-# copula: ORM2 standard concept is #060 (green)
-#
-require 'activefacts/vocabulary'
-require 'activefacts/api'
-require 'activefacts/generate/ordered'
-require 'activefacts/generate/cql'
-module ActiveFacts
-  module Generate
-    class CQL
-      # Generate CQL with HTML syntax-highlighting for an ActiveFacts vocabulary.
-      # Invoke as
-      #   afgen --cql/html <file>.cql
-      class HTML < CQL
-      private
-        def initialize(vocabulary, *options)
-          super
-        end
-        def puts s
-          super(s.gsub(/[,;]/) do |p| keyword p; end)
-        end
-        def keyword(str)
-          "<span class='keyword'>#{str}</span>"
-        end
-        def concept(str)
-          "<span class='concept'>#{str}</span>"
-        end
-        def copula(str)
-          "<span class='copula'>#{str}</span>"
-        end
-        def vocabulary_start(vocabulary)
-          puts %q{<head>
-            <link rel="stylesheet" href="css/orm2.css" type="text/css"/>
-            </head>
-            <pre class="copula">}
-          puts "#{keyword "vocabulary"} #{concept(vocabulary.name)};\n\n"
-        end
-        def vocabulary_end
-          puts %q{</pre>}
-        end
-        def value_type_banner
-          puts "/*\n * Value Types\n */"
-        end
-        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 ValueType
-              # throw Can't handle parameterized value type of same name as its ValueType" if ...
-          end
-          parameters =
-            [ o.length != 0 || o.scale != 0 ? o.length : nil,
-              o.scale != 0 ? o.scale : nil
-            ].compact
-          parameters = parameters.length > 0 ? "("+parameters.join(",")+")" : "()"
-          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|
-                    # REVISIT: Need to display as string or numeric according to type here...
-                    min = ar.value_range.minimum_bound
-                    max = ar.value_range.maximum_bound
-                    range = (min ? min.value : "") +
-                      (min.value != (max&&max.value) ? (".." + (max ? max.value : "")) : "")
-                    keyword range
-                  }*", "
-              else
-                ""
-              end
-            };"
-        end
-        def append_ring_to_reading(reading, ring)
-          reading << keyword(" [#{(ring.ring_type.scan(/[A-Z][a-z]*/)*", ").downcase}]")
-        end
-        def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
-          identifying_role_names = identifying_roles.map{|role|
-              preferred_role_ref = preferred_readings[role.fact_type].role_sequence.all_role_ref.detect{|reading_rr|
-                  reading_rr.role == role
-                }
-              role_words = []
-              # REVISIT: Consider whether NOT to use the adjective if it's a prefix of the role_name
-              role_name = role.role_name
-              role_name = nil if role_name == ""
-              # debug "concept.name=#{preferred_role_ref.role.concept.name}, role_name=#{role_name.inspect}, preferred_role_name=#{preferred_role_ref.role.role_name.inspect}"
-              if (role.fact_type.all_role.size == 1)
-                # REVISIT: Guard against unary reading containing the illegal words "and" and "where".
-                role.fact_type.default_reading    # Need whole reading for a unary.
-              elsif (role_name)
-                role_name
-              else
-                role_words << preferred_role_ref.leading_adjective if preferred_role_ref.leading_adjective != ""
-                role_words << preferred_role_ref.role.concept.name
-                role_words << preferred_role_ref.trailing_adjective if preferred_role_ref.trailing_adjective != ""
-                role_words.compact*"-"
-              end
-            }
-          # REVISIT: Consider emitting extra fact types here, instead of in entity_type_dump?
-          # Just beware that readings having the same players will be considered to be of the same fact type, even if they're not.
-          # Detect standard reference-mode scenarios
-          ft = identifying_facts[0]
-          fact_constraints = nil
-          if identifying_facts.size == 1 and
-            entity_role = ft.all_role[n = (ft.all_role[0].concept == entity_type ? 0 : 1)] and
-            value_role = ft.all_role[1-n] and
-            value_name = value_role.concept.name and
-            residual = value_name.gsub(%r{#{entity_role.concept.name}},'') and
-            residual != '' and
-            residual != value_name
-            # The EntityType is identified by its association with a single ValueType
-            # whose name is an extension (the residual) of the EntityType's name.
-            # Detect standard reference-mode readings:
-            forward_reading = reverse_reading = nil
-            ft.all_reading.each do |reading|
-              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.text =~ /^\{(\d)\} is of \{\d\}$/
-                if reading.role_sequence.all_role_ref[$1.to_i].role == value_role
-                  reverse_reading = reading
-                else
-                  forward_reading = reading
-                end
-              end
-            end
-            debug :mode, "------------------- Didn't find standard forward reading" unless forward_reading
-            debug :mode, "------------------- Didn't find standard reverse reading" unless reverse_reading
-            # If we didn't find at least one of the standard readings, don't use a refmode:
-            if (forward_reading || reverse_reading)
-              # Elide the constraints that would have been emitted on those readings.
-              # If there is a UC that's not in the standard form for a reference mode,
-              # we have to emit the standard reading anyhow.
-              fact_constraints = @presence_constraints_by_fact[ft]
-              fact_constraints.each do |pc|
-                if (pc.role_sequence.all_role_ref.size == 1 and pc.max_frequency == 1)
-                  # It's a uniqueness constraint, and will be regenerated
-                  @constraints_used[pc] = true
-                end
-              end
-              @fact_types_dumped[ft] = true
-              # Figure out whether any non-standard readings exist:
-              other_readings = ft.all_reading - [forward_reading] - [reverse_reading]
-              debug :mode, "--- other_readings.size now = #{other_readings.size}" if other_readings.size > 0
-              fact_text = other_readings.map do |reading|
-                expanded_reading(reading, fact_constraints, true)
-              end*",\n\t"
-              return keyword(" identified by its ") +
-                concept(residual) +
-                (fact_text != "" ? keyword(" where\n\t") + fact_text : "")
-            end
-          end
-          identifying_facts.each{|f| @fact_types_dumped[f] = true }
-          @identifying_fact_text =
-              identifying_facts.map{|f|
-                  fact_readings_with_constraints(f, fact_constraints)
-              }.flatten*",\n\t"
-          keyword(" identified by ") +
-            identifying_role_names.map{|n| concept n} * keyword(" and ") +
-            keyword(" where\n\t") +
-            @identifying_fact_text
-        end
-        def show_frequency role, constraint
-          # REVISIT: Need to also colorize the adjectives here:
-          [ constraint ? keyword(constraint.frequency) : nil, concept(role.concept.name) ]
-        end
-        def entity_type_banner
-          puts(keyword("/*\n * Entity Types\n */"))
-        end
-        def fact_readings(fact_type)
-          constrained_fact_readings = fact_readings_with_constraints(fact_type)
-          constrained_fact_readings*",\n\t"
-        end
-        def subtype_dump(o, supertypes, pi)
-          print "#{concept o.name} #{keyword "is a kind of"} #{ o.supertypes.map(&:name).map{|n| concept n}*keyword(", ") }"
-          if pi
-            print identified_by(o, pi)
-          end
-          # If there's a preferred_identifier for this subtype, identifying readings were emitted
-          if o.fact_type
-            print(
-              (pi ? "," : keyword(" where")) +
-              "\n\t" +
-              fact_readings(o.fact_type)
-            )
-          end
-          puts ";\n"
-        end
-        def non_subtype_dump(o, pi)
-          print "#{concept(o.name)} #{keyword "is"}" +
-            identified_by(o, pi)
-          print(keyword(" where\n\t") + fact_readings(o.fact_type)) if o.fact_type
-          puts ";\n"
-        end
-        def fact_type_dump(fact_type, name)
-          @identifying_fact_text = nil
-          if (o = fact_type.entity_type)
-            print "#{concept o.name} #{keyword "is"}"
-            if !o.all_type_inheritance_as_subtype.empty?
-              print(keyword(" a kind of ") + o.supertypes.map(&:name).map{|n| concept n}*", ")
-            end
-            # Alternate identification of objectified fact type?
-            primary_supertype = o.supertypes[0]
-            pi = fact_type.entity_type.preferred_identifier
-            if pi && primary_supertype && primary_supertype.preferred_identifier != pi
-              print identified_by(o, pi)
-              print ";\n"
-            end
-          end
-          unless @identifying_fact_text
-            print(keyword(" where\n\t")) if o
-            puts(fact_readings(fact_type)+";")
-          end
-        end
-        def fact_type_banner
-          puts keyword("/*\n * Fact Types\n */")
-        end
-        def constraint_banner
-          puts keyword("/*\n * Constraints:\n */")
-        end
-        def dump_presence_constraint(c)
-          roles = c.role_sequence.all_role_ref.map{|rr| rr.role }
-          # REVISIT: If only one role is covered and it's mandatory >=1 constraint, use SOME/THAT form:
-          # each Bug SOME Tester logged THAT Bug;
-          players = c.role_sequence.all_role_ref.map{|rr| rr.role.concept.name}.uniq
-          fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
-          puts \
-            "#{keyword "each #{players.size > 1 ? "combination " : ""}"}"+
-            "#{players.map{|n| concept n}*", "} "+
-            "#{keyword "occurs #{c.frequency} time in"}\n\t"+
-            "#{fact_types.map{|ft| ft.default_reading([], nil)}*",\n\t"}" +
-              ";"
-        end
-        def dump_set_constraint(c)
-          # REVISIT exclusion: every <player-list> must<?> either reading1, reading2, ...
-          # Each constraint involves two or more occurrences of one or more players.
-          # For each player, a subtype may be involved in the occurrences.
-          # Find the common supertype of each player.
-          scrs = c.all_set_comparison_roles
-          player_count = scrs[0].role_sequence.all_role_ref.size
-          role_seq_count = scrs.size
-          #raise "Can't verbalise constraint over many players and facts" if player_count > 1 and role_seq_count > 1
-          players_differ = []   # Record which players are also played by subclasses
-          players = (0...player_count).map do |pi|
-            # Find the common supertype of the players of the pi'th role in each sequence
-            concepts = scrs.map{|r| r.role_sequence.all_role_ref[pi].role.concept }
-            player, players_differ[pi] = common_supertype(concepts)
-            raise "Role sequences of #{c.class.basename} must have concepts matching #{c.name} in position #{pi}" unless player
-            player
-          end
-          #puts "#{c.class.basename} has players #{players.map{|p| p.name}*", "}"
-          if (SetEqualityConstraint === c)
-            # REVISIT: Need a proper approach to some/that and adjective disambiguation:
-            puts \
-              scrs.map{|scr|
-                scr.role_sequence.all_role_ref.map{|rr|
-                  rr.role.fact_type.default_reading([], nil)
-                }*keyword(" and ")
-              } * keyword("\n\tif and only if\n\t") + ";"
-            return
-          end
-          mode = c.is_mandatory ? "exactly one" : "at most one"
-          puts "#{keyword "for each"} #{players.map{|p| concept p.name}*", "} #{keyword(mode + " of these holds")}:\n\t" +
-            (scrs.map do |scr|
-              constrained_roles = scr.role_sequence.all_role_ref.map{|rr| rr.role }
-              fact_types = constrained_roles.map{|r| r.fact_type }.uniq
-              fact_types.map do |fact_type|
-                # REVISIT: future: Use "THAT" and "SOME" only when:
-                # - the role player occurs twice in the reading, or
-                # - is a subclass of the constrained concept, or
-                reading = fact_type.preferred_reading
-                expand_constrained(reading, constrained_roles, players, players_differ)
-              end * keyword(" and ")
-            end*",\n\t"
-            )+';'
-        end
-        # Expand this reading using (in)definite articles where needed
-        # Handle any roles in constrained_roles specially.
-        def expand_constrained(reading, constrained_roles, players, players_differ)
-          frequency_constraints = reading.role_sequence.all_role_ref.map {|role_ref|
-              i = constrained_roles.index(role_ref.role)
-              if !i
-                v = [ "some", role_ref.role.concept.name]
-              elsif players_differ[i]
-                v = [ "that", players[i].name ]   # Make sure to use the superclass name
-              else
-                if reading.fact_type.all_role.select{|r| r.concept == role_ref.role.concept }.size > 1
-                  v = [ "that", role_ref.role.concept.name ]
-                else
-                  v = [ "some", role_ref.role.concept.name ]
-                end
-              end
-              v[0] = keyword(v[0])
-              v[1] = concept(v[1])
-              v
-            }
-          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.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
-          reading.expand(frequency_constraints, nil)
-        end
-        def dump_subset_constraint(c)
-          # If the role players are identical and not duplicated, we can simply say "reading1 only if reading2"
-          subset_roles = c.subset_role_sequence.all_role_ref.map{|rr| rr.role}
-          superset_roles = c.superset_role_sequence.all_role_ref.map{|rr| rr.role}
-          subset_players = subset_roles.map(&:concept)
-          superset_players = superset_roles.map(&:concept)
-          subset_fact_types = c.subset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }.uniq
-          superset_fact_types = c.superset_role_sequence.all_role_ref.map{|rr| rr.role.fact_type }.uniq
-          # We need to ensure that if the player of any constrained role also exists
-          # as the player of a role that's not a constrained role, there are different
-          # adjectives or other qualifiers qualifier applied to distinguish that role.
-          fact_type_roles = (subset_fact_types+superset_fact_types).map{|ft| ft.all_role }.flatten
-          non_constrained_roles = fact_type_roles - subset_roles - superset_roles
-          if (r = non_constrained_roles.detect{|r| (subset_roles+superset_roles).include?(r) })
-            # REVISIT: Find a way to deal with this problem, should it arise.
-            # It would help, but not entirely fix it, to use SOME/THAT to identify the constrained roles.
-            # See ServiceDirector's DataStore<->Client fact types for example
-            # Use SOME on the subset, THAT on the superset.
-            raise "Critical ambiguity, #{r.concept.name} occurs both constrained and unconstrained in #{c.name}"
-          end
-          puts \
-            "#{subset_fact_types.map{|ft| ft.default_reading([], nil)}*" and "}" +
-            "\n\t#{keyword "only if"} " +
-            "#{superset_fact_types.map{|ft| ft.default_reading([], nil)}*" and "}" +
-            ";"
-        end
-      end
-      end
-    end
-  end
-end