activefacts 1.6.0 → 1.7.1

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

@@ -1,273 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate SQL for SQL Server from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    module SQL #:nodoc:
-      # Generate SQL for SQL Server for an ActiveFacts vocabulary.
-      # Invoke as
-      #   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
-      class SERVER
-      private
-        include Persistence
-        ColumnNameMax = 40
-
-        RESERVED_WORDS = %w{
-          ADD ALL ALTER AND ANY AS ASC AUTHORIZATION BACKUP BEGIN BETWEEN
-          BREAK BROWSE BULK BY CASCADE CASE CHECK CHECKPOINT CLOSE CLUSTERED
-          COALESCE COLLATE COLUMN COMMIT COMPUTE CONSTRAINT CONTAINS CONTAINSTABLE
-          CONTINUE CONVERT CREATE CROSS CURRENT CURRENT_DATE CURRENT_TIME
-          CURRENT_TIMESTAMP CURRENT_USER CURSOR DATABASE DBCC DEALLOCATE
-          DECLARE DEFAULT DELETE DENY DESC DISK DISTINCT DISTRIBUTED DOUBLE
-          DROP DUMMY DUMP ELSE END ERRLVL ESCAPE EXCEPT EXEC EXECUTE EXISTS
-          EXIT FETCH FILE FILLFACTOR FOR FOREIGN FREETEXT FREETEXTTABLE FROM
-          FULL FUNCTION GOTO GRANT GROUP HAVING HOLDLOCK IDENTITY IDENTITYCOL
-          IDENTITY_INSERT IF IN INDEX INNER INSERT INTERSECT INTO IS JOIN KEY
-          KILL LEFT LIKE LINENO LOAD NATIONAL NOCHECK NONCLUSTERED NOT NULL
-          NULLIF OF OFF OFFSETS ON OPEN OPENDATASOURCE OPENQUERY OPENROWSET
-          OPENXML OPTION OR ORDER OUTER OVER PERCENT PLAN PRECISION PRIMARY
-          PRINT PROC PROCEDURE PUBLIC RAISERROR READ READTEXT RECONFIGURE
-          REFERENCES REPLICATION RESTORE RESTRICT RETURN REVOKE RIGHT ROLLBACK
-          ROWCOUNT ROWGUIDCOL RULE SAVE SCHEMA SELECT SESSION_USER SET SETUSER
-          SHUTDOWN SOME STATISTICS SYSTEM_USER TABLE TEXTSIZE THEN TO TOP
-          TRAN TRANSACTION TRIGGER TRUNCATE TSEQUAL UNION UNIQUE UPDATE
-          UPDATETEXT USE USER VALUES VARYING VIEW WAITFOR WHEN WHERE WHILE
-          WITH WRITETEXT
-        }.inject({}){ |h,w| h[w] = true; h }
-
-        def initialize(vocabulary, *options)
-          @vocabulary = vocabulary
-          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-          @delay_fks = options.include? "delay_fks"
-          @underscore = options.include?("underscore") ? "_" : ""
-        end
-
-        def puts s
-          @out.puts s
-        end
-
-        def go s
-          puts s
-          puts "GO\n\n"
-        end
-
-        def escape s
-          # Escape SQL keywords and non-identifiers
-          s = s[0...120]
-          if s =~ /[^A-Za-z0-9_]/ || RESERVED_WORDS[s.upcase]
-            "[#{s}]"
-          else
-            s
-          end
-        end
-
-        # Return SQL type and (modified?) length for the passed base type
-        def normalise_type(type, length)
-          sql_type = case type
-            when /^Auto ?Counter$/
-              'int'
-
-            when /^Unsigned ?Integer$/,
-              /^Signed ?Integer$/,
-              /^Unsigned ?Small ?Integer$/,
-              /^Signed ?Small ?Integer$/,
-              /^Unsigned ?Tiny ?Integer$/
-              s = case
-                when length <= 8
-                  'tinyint'
-                when length <= 16
-                  'smallint'
-                when length <= 32
-                  'int'
-                else
-                  'bigint'
-                end
-              length = nil
-              s
-
-            when /^Decimal$/
-              'decimal'
-
-            when /^Fixed ?Length ?Text$/, /^Char$/
-              'char'
-            when /^Variable ?Length ?Text$/, /^String$/
-              'varchar'
-            when /^Large ?Length ?Text$/, /^Text$/
-              'text'
-
-            when /^Date ?And ?Time$/, /^Date ?Time$/
-              'datetime'
-            when /^Date$/
-              'datetime' # SQLSVR 2K5: 'date'
-            when /^Time$/
-              'datetime' # SQLSVR 2K5: 'time'
-            when /^Auto ?Time ?Stamp$/
-              'timestamp'
-
-            when /^Guid$/
-              'uniqueidentifier'
-            when /^Money$/
-              'decimal'
-            when /^Picture ?Raw ?Data$/, /^Image$/
-              'image'
-            when /^Variable ?Length ?Raw ?Data$/, /^Blob$/
-              'varbinary'
-            when /^BIT$/
-              'bit'
-            else type # raise "SQL type unknown for standard type #{type}"
-            end
-          [sql_type, length]
-        end
-
-      public
-        def generate(out = $>)      #:nodoc:
-          @out = out
-          #go "CREATE SCHEMA #{@vocabulary.name}"
-
-          tables_emitted = {}
-          delayed_foreign_keys = []
-
-          @vocabulary.tables.each do |table|
-            puts "CREATE TABLE #{escape table.name.gsub(' ',@underscore)} ("
-
-            pk = table.identifier_columns
-            identity_column = pk[0] if pk[0].is_auto_assigned
-
-            fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-            fk_columns = table.columns.select do |column|
-              column.references[0].is_simple_reference
-            end
-
-            # 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(@underscore) }.map do |column|
-              name = escape column.name(@underscore)
-              padding = " "*(name.size >= ColumnNameMax ? 1 : ColumnNameMax-name.size)
-              type, params, constraints = column.type
-              constraints = [] if (fk_columns.include?(column))  # Don't enforce VT constraints on FK columns
-              length = params[:length]
-              length &&= length.to_i
-              scale = params[:scale]
-              scale &&= scale.to_i
-              type, length = normalise_type(type, length)
-              sql_type = "#{type}#{
-                if !length
-                  ""
-                else
-                  "(" + length.to_s + (scale ? ", #{scale}" : "") + ")"
-                end
-                }"
-	      # Emit IDENTITY for auto-assigned columns, unless it's assigned at assert:
-              identity = column == identity_column && column.references[-1].to.transaction_phase != 'assert' ? " IDENTITY" : ""
-              null = (column.is_mandatory ? "NOT " : "") + "NULL"
-              check = check_clause(name, constraints)
-              comment = column.comment
-              [ "-- #{comment}", "#{name}#{padding}#{sql_type}#{identity} #{null}#{check}" ]
-            end.flatten
-
-            pk_def = (pk.detect{|column| !column.is_mandatory} ? "UNIQUE(" : "PRIMARY KEY(") +
-                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(@underscore)}*", " +
-                ") REFERENCES #{escape fk.to.name.gsub(' ',@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.gsub(' ',@underscore)}\n\tADD " + fk_text)
-              end
-            end
-
-            indices = table.indices
-            inline_indices = []
-            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(@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})"
-              else
-                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.gsub(' ',@underscore)}
-\tWHERE\t#{
-  index.columns.
-    select{|column| !column.is_mandatory }.
-    map{|column|
-      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(@underscore)}*", "})
-}
-              end
-            end
-
-            tables_emitted[table] = true
-
-            puts("\t" + (columns + [pk_def] + inline_indices + inline_fks)*",\n\t")
-            go ")"
-            delayed_indices.each {|index_text|
-              go index_text
-            }
-          end
-
-          delayed_foreign_keys.each do |fk|
-            go fk
-          end
-        end
-
-      private
-        def sql_value(value)
-          value.is_literal_string ? sql_string(value.literal) : value.literal
-        end
-
-        def sql_string(str)
-          "'" + str.gsub(/'/,"''") + "'"
-        end
-
-        def check_clause(column_name, constraints)
-          return "" if constraints.empty?
-          # REVISIT: Merge all constraints (later; now just use the first)
-          " CHECK(" +
-            constraints[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.literal == min.value.literal)
-                "#{column_name} = #{sql_value(min.value)}"
-              else
-                inequalities = [
-                  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
-            end*" OR " +
-          ")"
-        end
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('sql/server', ActiveFacts::Generate::SQL::SERVER)

data/lib/activefacts/generate/stats.rb

@@ -1,69 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate metamodel statistics fora compiled vocabulary
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --text <file>.cql
-    class Statistics
-    private
-      def initialize(vocabulary)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-      end
-
-    public
-      def generate(out = $>)
-	constellation = @vocabulary.constellation
-	object_types = constellation.ObjectType.values
-	fact_types = constellation.FactType.values
-
-	# All metamodel object types:
-	object_count = 0
-	populated_object_type_count = 0
-	fact_types_processed = {}
-	fact_count = 0
-	role_played_count = 0
-	constellation.vocabulary.object_type.map do |object_type_name, object_type|
-	  objects = constellation.send(object_type_name)
-	  next unless objects.size > 0
-	  puts "\t#{object_type_name}: #{objects.size} instances (which play #{object_type.all_role.size} roles)"
-	  populated_object_type_count += 1
-	  object_count += objects.size
-
-	  #puts "#{object_type_name} has #{object_type.all_role.size} roles"
-	  object_type.all_role.each do |name, role|
-	    next unless role.unique
-	    next if fact_types_processed[role.fact_type]
-	    next if role.fact_type.is_a?(ActiveFacts::API::TypeInheritanceFactType)
-	    role_population_count =
-	      objects.values.inject(0) do |count, object|
-		count += 1 if object.send(role.name) != nil
-		count
-	      end
-	    puts "\t\t#{object_type_name}.#{role.name} has #{role_population_count} instances" if role_population_count > 0
-	    fact_count += role_population_count
-	    role_played_count += role_population_count*role.fact_type.all_role.size
-
-	    fact_types_processed[role.fact_type] = true
-	  end
-
-	end
-	puts "#{@vocabulary.name} has"
-	puts "\t#{object_types.size} object types"
-	puts "\t#{fact_types.size} fact types"
-	puts "\tcompiles to #{object_count} objects in total, of #{populated_object_type_count} metamodel types"
-	puts "\tcompiles to #{fact_count} facts in total, of #{fact_types_processed.size} metamodel fact types"
-	puts "\tcompiles to #{role_played_count} role instances in total"
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('records', ActiveFacts::Generate::Statistics)

data/lib/activefacts/generate/text.rb

@@ -1,27 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate text output (verbalise the meta-vocabulary) for ActiveFacts vocabularies.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module Generate
-    # Generate a text verbalisation of the metamodel constellation created for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --text <file>.cql
-    class TEXT
-    private
-      def initialize(vocabulary)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-      end
-
-    public
-      def generate(out = $>)
-        out.puts @vocabulary.constellation.verbalise
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('text', ActiveFacts::Generate::TEXT)

data/lib/activefacts/generate/topics.rb

@@ -1,265 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate metamodel topic hierarchy (topologically sorted) for a compiled vocabulary
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/dependency_analyser'
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # Generate a topic hierarchy of the metamodel constellation created for an ActiveFacts vocabulary.
-    # Invoke as
-    #   afgen --topics <file>.cql
-    class Topics
-    private
-      def initialize(vocabulary)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-      end
-
-    public
-      def generate(out = $>)
-	@constellation = @vocabulary.constellation
-
-	@concepts = @constellation.Concept.values.select do |c|
-	  !c.embodied_as.is_a?(ActiveFacts::Metamodel::Role) &&
-	  !c.implication_rule
-	end
-
-	@concept_deps = ActiveFacts::DependencyAnalyser.new(@concepts) {|c| c.precursors }
-
-	# list_concepts(@concept_deps)
-	# list_precursors(@concept_deps)
-	# list_followers(@concept_deps)
-	# list_chasers(@concept_deps)
-	# list_ranks(@concept_deps)
-
-#	@constellation.Topic.values.each do |topic|
-#	  puts "#{topic.topic_name} depends on #{topic.precursors.map(&:topic_name)*', '}"
-#	end
-
-	# analyse_topic_sequence
-
-	list_groups_by_rank @concept_deps
-
-      end
-
-      def list_concepts concept_deps
-	puts "Concepts are"
-	concept_deps.each do |concept|
-	  puts "\t#{concept.describe}"
-	end
-	puts
-      end
-
-      def list_precursors(concept_deps)
-	puts "Precursors are"
-	concept_deps.each do |concept|
-	  next unless (p = concept_deps.precursors(concept)).size > 0
-	  puts "#{concept.describe}:"
-	  p.each do |precursor|
-	    puts "\t#{precursor.describe}"
-	  end
-	end
-      end
-
-      def list_followers(concept_deps)
-	puts "Followers are:"
-	concept_deps.each do |concept|
-	  next unless (f = concept_deps.followers(concept)).size > 0
-	  puts "#{concept.describe}:"
-	  f.each do |follower|
-	    puts "\t#{follower.describe}"
-	  end
-	end
-      end
-
-      def list_chasers(concept_deps)
-	puts "Chasers are:"
-	concept_deps.each do |concept|
-	  next unless (f = concept_deps.chasers(concept)).size > 0
-	  puts "#{concept.describe}:"
-	  f.each do |follower|
-	    puts "\t#{follower.describe}"
-	  end
-	end
-      end
-
-      def list_ranks(concept_deps)
-	puts "Ranks are:"
-	page_rank = concept_deps.page_rank
-	page_rank.keys.sort_by{|k| -page_rank[k]}.each do |concept|
-	  puts("%8.4f\t%s" % [page_rank[concept], concept.describe])
-	end
-      end
-
-      def analyse_topic_sequence
-	if @constellation.Topic.size == 1
-	  @topics = @constellation.Topic.values.first
-	else
-	  puts "=== Analysing existing topics ==="
-	  @topic_analyser = ActiveFacts::DependencyAnalyser.new(@constellation.Topic.values) do |topic|
-	    topic.precursors
-	  end
-
-	  @topics = []
-	  failed_topics = @topic_analyser.tsort { |topic|
-	    @topics << topic
-	    puts "#{topic.topic_name} including #{topic.all_concept.size} concepts"
-	  }
-	  if failed_topics
-	    puts "Topological sort of topics is impossible"
-
-	    # REVISIT: The strategy here should be to look at the structure of the dependency loop
-	    # involving the highest-rank topic. Choose the loop member that has fewest dependencies
-	    # involving individual concepts, and dump that (it will need to flip topic to dump
-	    # those dependencies). That should break the loop in a minimal way, so we can continue.
-
-	    failed_topics.each do |topic, precursor_topics|
-	      puts "#{topic.topic_name} depends on:"
-	      precursor_topics.each do |precursor_topic|
-		puts "\t#{precursor_topic.topic_name} because of:"
-
-		blocking_concept =
-		  precursor_topic.all_concept.select{|concept| 
-		    concept.precursors.detect{|cp|
-		      cp.topic == precursor_topic
-		    }
-		  }
-
-		  blocking_concept.each do |concept|
-		    puts "\t\t#{concept.describe} (depends on #{concept.precursors.map(&:topic).uniq.map(&:topic_name).sort.inspect})"
-		  end
-	      end
-	    end
-	    return
-	  end
-	end
-      end
-
-      def list_groups_by_rank concept_deps
-	puts "=== Concepts listed in Ranking Order with chasers ==="
-	# List the highest-ranked items that have no un-listed precursors.
-	# After each listed item, list the chasers *transitively* before
-	# choosing the next highest ranked item.
-	@listed = {}
-
-	start = Time.now
-	@page_rank = concept_deps.page_rank    # Get the page_rank
-	# puts "done in #{Time.now-start}"
-
-	@ranked = @page_rank.keys.sort_by{|k| -@page_rank[k]} # Sort decreasing
-	@topic = nil
-	until @listed.size >= @ranked.size
-	  vt = nil  # Capture the first listable ValueType, which we'll choose if we must
-	  chosen = @ranked.detect do |concept|
-	    next if @listed[concept]
-
-	    unlisted_precursors = 
-	      concept_deps.precursors_transitive(concept).
-	      reject do |precursor|
-		is_value_type_concept(precursor) or
-		  precursor == concept or
-		  @listed[precursor] or
-		  is_value_type_concept(precursor)
-	      end
-	    next if unlisted_precursors.size > 0	  # Still has precursors
-	    vt ||= concept
-	    next if is_value_type_concept(concept)
-	    concept
-	  end
-	  chosen ||= vt	  # Choose a value type if there's no other
-
-	  @cluster = []
-
-	  descend concept_deps, chosen
-
-	  cluster_ranks = @cluster.sort_by{|c| -@page_rank[c]}
-	  head = cluster_ranks.detect{|c| c.object_type} || cluster_ranks.first
-	  puts "/*\n * #{head.object_type ? head.object_type.name : head.describe}\n */"
-	  @cluster.each do |concept|
-	    puts '*'*10+" TOPIC #{@topic = concept.topic.topic_name}" if @topic != concept.topic.topic_name
-	    puts concept.describe
-	  end
-	  puts	  # Put a line between sections
-	end
-      end
-
-      # Descend the concept, also the items that are necessarily dumped with concept, so we don't select them again
-      def descend(concept_deps, concept, tab = '')
-	@causation ||= []
-	@cluster ||= []
-	return if @listed[concept] || @causation.include?(concept)  # Recursion prevention
-	begin
-	  @causation << concept	# Reversed by the "ensure" below.
-
-	  concept_deps.precursors(concept).each do |precursor|
-	    descend(concept_deps, precursor, tab) unless @listed[precursor] || precursor == concept
-	  end
-
-	  #puts tab+concept.describe
-	  @listed[concept] = true
-	  @cluster << concept
-
-	  body = concept.embodied_as
-	  case body
-	  when ActiveFacts::Metamodel::FactType
-	    body.internal_presence_constraints.each do |pc|
-	      # puts "Listing #{pc.concept.describe} as internal_presence_constraint of #{concept.describe}"
-	      descend(concept_deps, pc.concept, tab+"\t")
-	    end
-	    if body.entity_type
-	      # puts "Listing #{body.entity_type.concept.describe} as objectification of #{concept.describe}"
-	      descend(concept_deps, body.entity_type.concept, tab+"\t")
-	    end
-	    body.all_role.each do |role|
-	      role.all_ring_constraint.each do |rc|
-		# puts "Listing #{rc.concept.describe} as ring_constraint of #{concept.describe}"
-		descend(concept_deps, rc.concept, tab+"\t")
-	      end
-	    end
-	  when ActiveFacts::Metamodel::EntityType
-	    body.preferred_identifier.role_sequence.all_role_ref.each do |rr|
-	      # puts "Listing #{rr.role.fact_type.concept.describe} as existential fact of #{concept.describe}"
-	      descend(concept_deps, rr.role.fact_type.concept, tab+"\t")
-	    end
-	    descend(concept_deps, body.preferred_identifier.concept, tab+"\t")
-	  when ActiveFacts::Metamodel::ValueType
-	    if body.value_constraint
-	      # puts "Listing #{body.value_constraint.concept.describe} as value constraint of #{concept.describe}"
-	      descend(concept_deps, body.value_constraint.concept, tab+"\t")
-	    end
-	  end
-
-	  # Follow up with unlisted chasers (that have no remaining precursors) in order of decreasing importance:
-	  chasers =
-	    concept_deps.followers(concept).reject do |follower|
-	      @listed[follower] or
-		is_value_type_concept(follower) or
-		concept_deps.precursors(follower).detect{|p| !@listed[p] && !is_value_type_concept(p) } or
-		# Exclude subtypes of entity types from the followers:
-		concept.object_type && concept.object_type.is_a?(ActiveFacts::Metamodel::EntityType) && concept.object_type.subtypes.include?(follower.object_type)
-	    end.
-	    sort_by{|nc| -@page_rank[nc]}
-
-	  chasers.each do |chaser|
-	    # puts "**** Listing #{chaser.describe} as chaser of #{concept.describe}"
-	    descend(concept_deps, chaser, tab)
-	  end
-
-	ensure
-	  @causation.pop
-	end
-      end
-
-      def is_value_type_concept concept
-	o = concept.object_type and o.is_a?(ActiveFacts::Metamodel::ValueType)
-      end
-
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('topics', ActiveFacts::Generate::Topics)