activefacts 0.8.16 → 0.8.18

data/lib/activefacts/generate/json.rb

@@ -53,12 +53,12 @@ module ActiveFacts
             j = {
               :uuid => uuids[o],
               :name => o.name,
-              :shapes => o.all_object_type_shape.map do |shape|
-                x = { :diagram => uuids[shape.diagram],
+              :shapes => o.all_object_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                x = { :diagram => uuids[shape.orm_diagram],
                   :is_expanded => shape.is_expanded,
                   :uuid => uuid_from_id(shape),
-                  :x => shape.position.x,
-                  :y => shape.position.y
+                  :x => shape.location.x,
+                  :y => shape.location.y
                 }
                 x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
                 x
@@ -98,7 +98,7 @@ module ActiveFacts
         fact_types = @vocabulary.constellation.
           FactType.values.
           reject{|ft|
-            ActiveFacts::Metamodel::ImplicitFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
+            ActiveFacts::Metamodel::LinkFactType === ft || ActiveFacts::Metamodel::TypeInheritance === ft
           }
         puts "  fact_types: [\n#{
           fact_types.sort_by{|f| f.identifying_role_values.inspect}.map do |f|
@@ -144,18 +144,18 @@ module ActiveFacts
             end
 
             # Emit shapes
-            j[:shapes] = f.all_fact_type_shape.map do |shape|
+            j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
               sj = {
-                :diagram => uuids[shape.diagram],
+                :diagram => uuids[shape.orm_diagram],
                 :uuid => uuid_from_id(shape),
-                :x => shape.position.x,
-                :y => shape.position.y
+                :x => shape.location.x,
+                :y => shape.location.y
               }
 
               # Add the role_order, if specified
               if shape.all_role_display.size > 0
                 if shape.all_role_display.size != roles.size
-                  raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.diagram.name} diagram"
+                  raise "Invalid RoleDisplay for #{f.default_reading} in #{shape.orm_diagram.name} diagram"
                 end
                 ro = role_order(
                   uuids,
@@ -167,15 +167,17 @@ module ActiveFacts
 
               # REVISIT: Place the ReadingShape
 
-              # Emit the position of the name, if objectified
+              # Emit the location of the name, if objectified
               if n = shape.objectified_fact_type_name_shape
-                sj[:name_shape] = {:x => n.position.x, :y => n.position.y}
+                sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
               end
               sj
             end
 
             # Emit Internal Presence Constraints
-            f.internal_presence_constraints.each do |ipc|
+            f.internal_presence_constraints.to_a.sort_by{|ipc, z|
+		  [ipc.is_preferred_identifier ? 0 : 1, ipc.is_mandatory ? 0 : 1, ipc.min_frequency || 0, ipc.max_frequency || 1_000]
+		}.each do |ipc|
               uuid = (uuids[ipc] ||= uuid_from_id(ipc))
 
               constraint = {
@@ -207,11 +209,11 @@ module ActiveFacts
               flatten.uniq.each do |ring|
                 (j[:constraints] ||= []) << {
                     :uuid => (uuids[ring] ||= uuid_from_id(ring)),
-                    :shapes => ring.all_constraint_shape.map do |shape|
-                      { :diagram => uuids[shape.diagram],
+                    :shapes => ring.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                      { :diagram => uuids[shape.orm_diagram],
                         :uuid => uuid_from_id(shape),
-                        :x => shape.position.x,
-                        :y => shape.position.y
+                        :x => shape.location.x,
+                        :y => shape.location.y
                       }
                     end,
                     :ringKind => ring.ring_type,
@@ -234,11 +236,11 @@ module ActiveFacts
             j = {
               :uuid => uuid,
               :type => c.class.basename,
-              :shapes => c.all_constraint_shape.map do |shape|
-                { :diagram => uuids[shape.diagram],
+              :shapes => c.all_constraint_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
+                { :diagram => uuids[shape.orm_diagram],
                   :uuid => uuid_from_id(shape),
-                  :x => shape.position.x,
-                  :y => shape.position.y
+                  :x => shape.location.x,
+                  :y => shape.location.y
                 }
               end
             }
@@ -246,7 +248,7 @@ module ActiveFacts
             if (c.enforcement)
               # REVISIT: Deontic constraint
             end
-            if (c.all_context_note.size > 0)
+            if (c.all_context_note_as_relevant_concept.size > 0)
               # REVISIT: Context Notes
             end
 
@@ -332,3 +334,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('json', ActiveFacts::Generate::JSON)

data/lib/activefacts/generate/null.rb

@@ -29,3 +29,4 @@ module ActiveFacts
   end
 end
 
+ActiveFacts::Registry.generator('null', ActiveFacts::Generate::NULL)

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

@@ -0,0 +1,244 @@
+#
+#       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/vocabulary'
+require 'activefacts/persistence'
+#require 'activefacts/generate/helpers/rails'
+require 'activefacts/mapping/rails'
+require 'active_support'
+
+module ActiveFacts
+  module Generate
+    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
+
+	    foreign_key = ""
+	    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}'"
+	      from_column = fk.from_columns
+	      foreign_key = ", :foreign_key => :#{fk.from_columns[0].rails_name}"
+	    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}" +
+	      "\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 Persistence
+    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::Generate::Rails::Models)

data/lib/activefacts/generate/rails/schema.rb

@@ -0,0 +1,185 @@
+#
+#       ActiveFacts Generators.
+#       Generate a Rails-friendly schema.rb from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2012 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts/vocabulary'
+require 'activefacts/persistence'
+require 'activefacts/mapping/rails'
+
+module ActiveFacts
+  module Generate
+    module Rails
+      # Generate a Rails-friendly schema for the vocabulary
+      # Invoke as
+      #   afgen --rails/schema[=options] <file>.cql
+      class SchemaRb
+      private
+	include Persistence
+
+	def initialize(vocabulary, *options)
+	  @vocabulary = vocabulary
+	  @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+	  help if options.include? "help"
+	  @exclude_fks = options.include? "exclude_fks"
+	  @include_comments = options.include? "include_comments"
+	  @closed_world = options.include? "closed_world"
+	end
+
+	def help
+	  @helping = true
+	  warn %Q{Options for --rails/schema:
+	exclude_fks		Don't generate foreign key definitions for use with the foreigner gem
+	include_comments	Generate a comment for each column showing the absorption path
+	closed_world		Set this if your DBMS only allows one null in a unique index (MS SQL)
+}
+	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
+
+	  foreign_keys = []
+
+	  # If we get index names that need to be truncated, add a counter to ensure uniqueness
+	  dup_id = 0
+
+	  puts "#\n# schema.rb auto-generated using ActiveFacts for #{@vocabulary.name} on #{Date.today}\n#\n\n"
+	  puts "ActiveRecord::Schema.define(:version => #{Time.now.strftime('%Y%m%d%H%M%S')}) do"
+
+	  @vocabulary.tables.each do |table|
+	    ar_table_name = table.rails_name
+
+	    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
+
+	    # Detect if this table is a join table.
+	    # Join tables have multi-part primary keys that are made up only of foreign keys
+	    is_join_table = pk.length > 1 and
+	      !pk.detect do |pk_column|
+		!fk_columns.include?(pk_column)
+	      end
+	    warn "Warning: #{table.name} has a multi-part primary key" if pk.length > 1 and !is_join_table
+
+	    needs_rails_id_field = (pk.length > 1) && !is_join_table
+	    move_pk_to_create_table_call = !needs_rails_id_field &&
+		pk.length == 1 &&
+		(to = pk[0].references[-1].to) &&
+		to.supertypes_transitive.detect{|t| t.name == 'Auto Counter'}
+
+	    identity =
+	      if move_pk_to_create_table_call
+		":primary_key => :#{pk[0].rails_name}"
+	      else
+		":id => #{needs_rails_id_field}"
+	      end
+
+	    puts %Q{  create_table "#{ar_table_name}", #{identity}, :force => true do |t|}
+
+	    # 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 do |column|
+		  [ # Emit columns alphabetically, but PK first, then FKs, then others
+		    case
+		    when column == identity_column
+		      0
+		    when fk_columns.include?(column)
+		      1
+		    else
+		      2
+		    end,
+		    column.rails_name
+		  ]
+		end.
+		map do |column|
+	      next [] if move_pk_to_create_table_call and column == pk[0]
+	      name = column.rails_name
+	      type, params, constraints = column.type
+	      length = params[:length]
+	      length &&= length.to_i
+	      scale = params[:scale]
+	      scale &&= scale.to_i
+	      type, length = Persistence::rails_type(type, length)
+
+	      length_name = type == 'decimal' ? 'precision' : 'limit'
+
+	      primary = (!is_join_table && pk.include?(column)) ? ", :primary => true" : ''
+	      comment = column.comment
+	      (@include_comments ? ["    \# #{comment}"] : []) +
+	      [
+		%Q{    t.#{type}\t"#{name}"#{
+		    length ? ", :#{length_name} => #{length}" : ''
+		  }#{
+		    scale ? ", :scale => #{scale}" : ''
+		  }#{
+		    column.is_mandatory ? ', :null => false' : ''
+		  }#{primary}}
+	      ]
+	    end.flatten
+
+	    unless @exclude_fks
+	      table.foreign_keys.each do |fk|
+		from_columns = fk.from_columns.map{|column| column.rails_name}
+		to_columns = fk.to_columns.map{|column| column.rails_name}
+		foreign_keys <<
+		  if (from_columns.length == 1)
+		    "    add_foreign_key :#{fk.from.rails_name}, :#{fk.to.rails_name}, :column => :#{from_columns[0]}, :primary_key => :#{to_columns[0]}, :dependent => :cascade"
+		  else
+		    # This probably isn't going to work without Dr Nic's CPK gem:
+		    "    add_foreign_key :#{fk.to.rails_name}, :#{fk.from.rails_name}, :column => [:#{from_columns.join(':, ')}], :primary_key => [:#{to_columns.join(':, ')}], :dependent => :cascade"
+		  end
+	      end
+	    end
+
+	    indices = table.indices
+	    index_text = []
+	    indices.each do |index|
+	      next if move_pk_to_create_table_call and index.is_primary	  # We've handled this already
+
+	      index_name = index.rails_name
+
+	      unique = !index.columns.detect{|column| !column.is_mandatory} and !@closed_world
+	      index_text << %Q{  add_index "#{ar_table_name}", ["#{index.columns.map{|c| c.rails_name}*'", "'}"], :name => :#{index_name}#{
+		unique ? ", :unique => true" : ''
+	      }}
+	    end
+
+	    puts columns.join("\n")
+	    puts "  end\n\n"
+
+	    puts index_text.join("\n")
+	    puts "\n" unless index_text.empty?
+	  end
+
+	  unless @exclude_fks
+	    puts '  unless ENV["EXCLUDE_FKS"]'
+	    puts foreign_keys.join("\n")
+	    puts '  end'
+	  end
+	  puts "end"
+	end
+
+      end
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('rails/schema', ActiveFacts::Generate::Rails::SchemaRb)