activefacts-generators 1.7.1

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

@@ -0,0 +1,204 @@
+#
+#       ActiveFacts Generators.
+#
+#       Generate metadata in JSON
+#
+# Copyright (c) 2013 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/api'
+require 'activefacts/rmap'
+require 'json'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators #:nodoc:
+    class Metadata #:nodoc:
+      class JSON #:nodoc:
+        def initialize(vocabulary, *options)
+          @vocabulary = vocabulary
+          @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+          options.each{|option| set_option(option) }
+        end
+
+        def set_option(option)
+        end
+
+        def generate(out = $>)
+	  @metadata = {"types" => {}}
+
+          object_types_dump
+
+	  out.puts ::JSON.pretty_generate(@metadata)
+        end
+
+	# Store the metadata for all types into the types section of the @metadata hash
+	def object_types_dump
+	  types = @metadata["types"]
+
+	  # Compute the relational mapping if not already done:
+	  @tables ||= @vocabulary.tables
+
+	  @vocabulary.all_object_type.
+	  sort_by{|c| c.name}.each do |o|
+	    object_type = o.as_json_metadata
+
+	    types[o.name] = object_type if object_type
+	  end
+	end
+
+      end
+    end
+  end
+
+  module Metamodel
+    class ObjectType
+      def as_json_metadata
+	# Using proc avoids polluting the object's namespace with these little methods
+	verbalise_role = proc do |role, plural|
+	  fc = Array.new(role.fact_type.all_role.size, plural ? 'some' : 'one')
+	  reading = role.fact_type.reading_preferably_starting_with_role(role)
+          fc.reverse! unless reading.role_sequence.all_role_ref.to_a[0].role == role
+	  fc[reading.role_sequence.all_role_ref_in_order.to_a.index{|rr| rr.role == role}] = 'this'
+	  reading.expand(fc, false)
+	end
+
+	titlize_words = proc do |phrase|
+	  phrase && phrase.split(/\s+/).map{|w| w.sub(/^[a-z]/) {|i| i.upcase}}*' '
+	end
+
+	role_name = proc do |role|
+	  if role.role_name
+	    role.role_name
+	  else
+	    ref = role.preferred_reference
+	    [ titlize_words.call(ref.leading_adjective), role.object_type.name, titlize_words.call(ref.trailing_adjective)].compact*' '
+	  end
+	end
+
+	return nil if name == '_ImplicitBooleanValueType'
+
+	object_type = {}
+	object_type["is_main"] = is_table
+	object_type["id"] = concept.guid.to_s
+	functions = object_type["functions"] = []
+
+	if is_a?(ActiveFacts::Metamodel::EntityType)
+
+	  # Don't emit a binary objectified fact type that plays no roles (except in implicit fact types:
+	  if fact_type and fact_type.all_role.size == 2 and all_role.size == 2
+	    return nil
+	  end
+
+	  # Export the supertypes
+	  (supertypes_transitive-[self]).sort_by{|t| t.name}.each do |supertype|
+	    functions <<
+	      {
+		"title" => "as #{supertype.name}",
+		"type" => "#{supertype.name}"
+	      }
+	  end
+
+	  # Export the subtypes
+	  (subtypes_transitive-[self]).sort_by{|t| t.name}.each do |subtype|
+	    functions <<
+	      {
+		"title" => "as #{subtype.name}",
+		"type" => "#{subtype.name}"
+	      }
+	  end
+
+	  # If an objectified fact type, export the fact type's roles
+	  if fact_type
+	    fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).each do |role|
+	      functions <<
+		{
+		  "title" => "involving #{role_name.call(role)}",
+		  "type" => "#{role.object_type.name}",
+		  "where" => verbalise_role.call(role, true)  # REVISIT: Need plural setting here!
+		}
+	    end
+	  end
+	end
+
+	# Now export the ordinary roles. Get a sorted list first:
+	roles = all_role.reject do |role|
+	    # supertype and subtype roles get handled separately
+	    role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) ||
+	      role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+	  end.sort_by do |role|
+	    # Where this object type plays two roles in the same fact type,
+	    # we order them by the position of that role in the preferred reading:
+	    [role.fact_type.default_reading, role.fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).index(role)]
+	  end
+
+	# For binary fact types, collect the count of the times the unadorned counterpart role name occurs, so we can adorn it
+	plural_counterpart_counts = roles.inject(Hash.new{0}) do |h, role|
+	  next h unless role.fact_type.all_role.size == 2
+	  uc = role.all_role_ref.detect do |rr|
+	      rs = rr.role_sequence
+	      next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
+	      rs.all_presence_constraint.detect do |pc|
+		  next false unless pc.max_frequency == 1   # It's a uniqueness constraint
+		  true
+		end
+	    end
+	  next h if uc	# Not a plural role
+
+	  counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
+	  h[role_name.call(counterpart_role)] += 1
+	  h
+	end
+
+	roles.each do |role|
+	  type_name = nil
+	  counterpart_name = nil
+
+	  if role.fact_type.entity_type and	      # Role is in an objectified fact type
+	    # For binary objectified fact types, we traverse directly to the other role, not just to the objectification
+	    !(role.fact_type.entity_type.all_role.size == 2 and role.fact_type.all_role.size == 2)
+
+	    type_name = role.fact_type.entity_type.name
+	    counterpart_name = type_name	  # If self plays more than one role in OFT, need to construct a role name
+	    plural = true
+	  elsif role.fact_type.all_role.size == 1
+	    # Handle unary roles
+	    type_name = 'boolean'
+	    counterpart_name = role.fact_type.default_reading
+	    plural = false
+	  else
+	    # Handle binary roles
+	    counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
+	    type_name = counterpart_role.object_type.name
+	    counterpart_name = role_name.call(counterpart_role)
+	    # Figure out whether the counterpart is plural (say "all ..." if so)
+	    uc = role.all_role_ref.detect do |rr|
+		rs = rr.role_sequence
+		next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
+		rs.all_presence_constraint.detect do |pc|
+		    next false unless pc.max_frequency == 1   # It's a uniqueness constraint
+		    true
+		  end
+	      end
+	    plural = !uc
+	    if plural_counterpart_counts[counterpart_name] > 1
+	      counterpart_name += " as " + role_name.call(role)
+	    end
+	  end
+
+	  node = {
+	    "title" => "#{plural ? 'all ' : ''}#{counterpart_name}",
+	    "type" => "#{type_name}",
+	    "where" => verbalise_role.call(role, plural),
+	    "role_id" => role.concept.guid.to_s
+	  }
+	  node["is_list"] = true if plural
+	  functions << node 
+
+	end
+	functions.size > 0 ? object_type : nil
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('metadata/json', ActiveFacts::Generators::Metadata::JSON)

data/lib/activefacts/generators/null.rb

@@ -0,0 +1,32 @@
+#
+#       ActiveFacts Generators.
+#       Generate *no* output for ActiveFacts vocabularies; i.e. just a stub
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/rmap'
+
+module ActiveFacts
+  module Generators
+    # Generate nothing from an ActiveFacts vocabulary. This is useful to check the file can be read ok.
+    # Invoke as
+    #   afgen --null <file>.cql
+    class NULL
+    private
+      def initialize(vocabulary, *options)
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+        @tables = options.include? "tables"
+        @columns = options.include? "columns"
+        @indices = options.include? "indices"
+      end
+
+    public
+      def generate(out = $>)
+        @vocabulary.tables if @tables || @columns || @indices
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('null', ActiveFacts::Generators::NULL)

data/lib/activefacts/generators/rails/models.rb

@@ -0,0 +1,247 @@
+#
+#       ActiveFacts Generators.
+#       Generate models for Rails from an ActiveFacts vocabulary.
+#
+#       Models should normally be generated into "app/models/auto",
+#       then extend(ed) into your real models.
+#
+# Copyright (c) 2013 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/metamodel'
+require 'activefacts/rmap'
+#require 'activefacts/generators/helpers/rails'
+require 'activefacts/generators/traits/rails'
+require 'active_support'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    module Rails
+      # Generate Rails models for the vocabulary
+      # Invoke as
+      #   afgen --rails/schema[=options] <file>.cql
+      class Models
+
+	HEADER = "# Auto-generated from CQL, edits will be lost"
+
+      private
+
+	def initialize(vocabulary, *options)
+	  @vocabulary = vocabulary
+	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+	  help if options.include? "help"
+	  options.delete_if { |option| @output = $1 if option =~ /^output=(.*)/ }
+	  @concern = nil
+	  options.delete_if { |option| @concern = $1 if option =~ /^concern=(.*)/ }
+	  @validations = true
+	  options.delete_if { |option| @validations = eval($1) if option =~ /^validation=(.*)/ }
+	end
+
+	def help
+	  @helping = true
+	  warn %Q{Options for --rails/schema:
+	output=dir		Overwrite model files into this output directory
+	concern=name		Namespace for the concerns
+	validation=false	Disable generation of validations
+}
+	end
+
+	def warn *a
+	  $stderr.puts *a
+	end
+
+	def puts s
+	  @out.puts s
+	end
+
+      public
+	def generate(out = $>)      #:nodoc:
+	  return if @helping
+	  @out = out
+	  list_extant_files if @output
+
+	  # Populate all foreignkeys first:
+	  @vocabulary.tables.each { |table| table.foreign_keys }
+	  ok = true
+	  @vocabulary.tables.each do |table|
+	    ok &= generate_table(table)
+	  end
+	  $stderr.puts "\# #{@vocabulary.name} generated with errors" unless ok
+	  delete_old_generated_files if @output
+	  ok
+	end
+
+	def list_extant_files
+	  @preexisting_files = Dir[@output+'/*.rb']
+	end
+
+	def delete_old_generated_files
+	  remaining = []
+	  cleaned = 0
+	  @preexisting_files.each do |pathname|
+	    if generated_file_exists(pathname) == true
+	      File.unlink(pathname) 
+	      cleaned += 1
+	    else
+	      remaining << pathname
+	    end
+	  end
+	  $stderr.puts "Cleaned up #{cleaned} old generated files" if @preexisting_files.size > 0
+	  $stderr.puts "Remaining non-generated files:\n\t#{remaining*"\n\t"}" if remaining.size > 0
+	end
+
+	def generated_file_exists pathname
+	  File.open(pathname, 'r') do |existing|
+	    first_lines = existing.read(1024)	  # Make it possible to pass over a magic charset comment
+	    if first_lines.length == 0 or first_lines =~ %r{^#{HEADER}}
+	      return true
+	    end
+	  end
+	  return false	  # File exists, but is not generated
+	rescue Errno::ENOENT
+	  return nil	  # File does not exist
+	end
+
+	def create_if_ok filename
+	  # Create a file in the output directory, being careful not to overwrite carelessly
+	  if @output
+	    pathname = (@output+'/'+filename).gsub(%r{//+}, '/')
+	    @preexisting_files.reject!{|f| f == pathname }    # Don't clean up this file
+	    if generated_file_exists(pathname) == false
+	      $stderr.puts "not overwriting non-generated file #{pathname}"
+	      @individual_file = nil
+	      return
+	    end
+	    @individual_file = @out = File.open(pathname, 'w')
+	    puts "#{HEADER}"
+	  end
+	  true
+	end
+
+	def to_associations table
+	  # belongs_to Associations
+	  table.foreign_keys.map do |fk|
+	    association_name = fk.rails_from_association_name
+
+	    if association_name != fk.to.rails_singular_name
+	      # A different class_name is implied, emit an explicit one:
+	      class_name = ", :class_name => '#{fk.to.rails_class_name}'"
+	    end
+	    foreign_key = ", :foreign_key => :#{fk.from_columns[0].rails_name}"
+	    if foreign_key == fk.to.rails_singular_name+'_id'
+	      # See lib/active_record/reflection.rb, method #derive_foreign_key
+	      foreign_key = ''
+	    end
+
+	    %Q{
+    \# #{fk.verbalised_path}
+    belongs_to :#{association_name}#{class_name}#{foreign_key}}
+	  end
+	end
+
+	def from_associations table
+	  # has_one/has_many Associations
+	  table.foreign_keys_to.sort_by{|fk| fk.describe}.map do |fk|
+	    # Get the jump reference
+
+	    if fk.from_columns.size > 1
+	      raise "Can't emit Rails associations for multi-part foreign key with #{fk.references.inspect}. Did you mean to use --transform/surrogate"
+	    end
+
+	    association_type, association_name = *fk.rails_to_association
+
+	    ref = fk.jump_reference
+	    [
+	      "\n    \# #{fk.verbalised_path(true)}" +
+	      "\n" +
+		%Q{    #{association_type} :#{association_name}} +
+		%Q{, :class_name => '#{fk.from.rails_class_name}'} +
+		%Q{, :foreign_key => :#{fk.from_columns[0].rails_name}} +
+		%Q{, :dependent => :destroy}
+	    ] +
+	      # If ref.from is a join table, we can emit a has_many :through for each other key
+	      # REVISIT Could alternately do this for all belongs_to's in ref.from
+	      if ref.from.identifier_columns.length > 1
+		ref.from.identifier_columns.map do |ic|
+		  next nil if ic.references[0] == ref or	# Skip the back-reference
+		    ic.references[0].is_unary		# or use rails_plural_name(ic.references[0].to_names) ?
+		  # This far association name needs to be augmented for its role name
+		  far_association_name = ic.references[0].to.rails_name
+		  %Q{    has_many :#{far_association_name}, :through => :#{association_name}} # \# via #{ic.name}}
+		end
+	      else
+		[]
+	      end
+	  end.flatten.compact
+	end
+
+	def column_constraints table
+	  return [] unless @validations
+	  ccs =
+	    table.columns.map do |column|
+	      name = column.rails_name
+	      column.is_mandatory &&
+		!column.is_auto_assigned && !column.is_auto_timestamp ? [
+		"    validates :#{name}, :presence => true"
+	      ] : []
+	    end.flatten
+	  ccs.unshift("") unless ccs.empty?
+	  ccs
+	end
+
+	def model_body table
+	  %Q{module #{table.rails_class_name}
+  extend ActiveSupport::Concern
+  included do} +
+	    (table.identifier_columns.length == 1 ? %Q{
+    self.primary_key = '#{table.identifier_columns[0].rails_name}'
+} : ''
+	    ) +
+
+	    (
+	      to_associations(table) +
+	      from_associations(table) +
+	      column_constraints(table)
+	    ) * "\n" +
+	    %Q{
+  end
+end
+}
+	end
+
+	def generate_table table
+	  old_out = @out
+	  filename = table.rails_singular_name+'.rb'
+
+	  return unless create_if_ok filename
+
+	  puts "\n"
+	  puts "module #{@concern}" if @concern
+	  puts model_body(table).gsub(/^./, @concern ? '  \0' : '\0')
+	  puts 'end' if @concern
+
+	  true	  # We succeeded
+	ensure
+	  @out = old_out
+	  @individual_file.close if @individual_file
+	end
+
+      end
+    end
+  end
+
+  module RMap
+    class Column
+      def is_auto_timestamp
+	case name('_')
+	when /\A(created|updated)_(at|on)\Z/i
+	  true
+	else
+	  false
+	end
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('rails/models', ActiveFacts::Generators::Rails::Models)