activefacts 1.6.0 → 1.7.1

data/lib/activefacts/generate/json.rb

@@ -1,337 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate json output from a vocabulary, for loading into APRIMO
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'json'
-require 'digest/sha1'
-
-module ActiveFacts
-  module Generate
-    # Generate json output from a vocabulary, for loading into APRIMO.
-    # Invoke as
-    #   afgen --json <file>.cql=diagrams
-    class JSON
-    private
-      def initialize(vocabulary)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-      end
-
-      def puts(*a)
-        @out.puts *a
-      end
-
-    public
-      def generate(out = $>)
-        @out = out
-        uuids = {}
-
-        puts "{ model: '#{@vocabulary.name}',\n" +
-        "diagrams: [\n#{
-          @vocabulary.all_diagram.sort_by{|o| o.name.gsub(/ /,'')}.map do |d|
-            j = {:uuid => (uuids[d] ||= uuid_from_id(d)), :name => d.name}
-            "    #{j.to_json}"
-          end*",\n"
-        }\n  ],"
-
-        object_types = @vocabulary.all_object_type.sort_by{|o| o.name.gsub(/ /,'')}
-        puts "  object_types: [\n#{
-          object_types.sort_by{|o|o.identifying_role_values.inspect}.map do |o|
-            uuids[o] ||= uuid_from_id(o)
-            ref_mode = nil
-            if o.is_a?(ActiveFacts::Metamodel::EntityType) and
-              p = o.preferred_identifier and
-              (rrs = p.role_sequence.all_role_ref).size == 1 and
-              (r = rrs.single.role).fact_type != o.fact_type and
-              r.object_type.is_a?(ActiveFacts::Metamodel::ValueType) and
-              !r.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-              ref_mode = "#{r.object_type.name}"
-              ref_mode.sub!(%r{#{o.name} *}, '.')
-            end
-            j = {
-              :uuid => uuids[o],
-              :name => o.name,
-              :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.location.x,
-                  :y => shape.location.y
-                }
-                x[:is_expanded] = true if ref_mode && shape.is_expanded  # Don't show the reference mode
-                x
-              end
-            }
-            j[:ref_mode] = ref_mode if ref_mode
-            j[:independent] = true if o.is_independent
-
-            if o.is_a?(ActiveFacts::Metamodel::EntityType)
-              # Entity Type may be objectified, and may have supertypes:
-              if o.fact_type
-                uuid = (uuids[o.fact_type] ||= uuid_from_id(o.fact_type))
-                j[:objectifies] = uuid
-                j[:implicit] = true if o.concept.implication_rule
-              end
-              if o.all_type_inheritance_as_subtype.size > 0
-                j[:supertypes] = o.
-                  all_type_inheritance_as_subtype.
-                  sort_by{|ti| ti.provides_identification ? 0 : 1}.
-                  map{|ti|
-                    [ uuids[ti.supertype] ||= uuid_from_id(ti.supertype),
-                      uuids[ti.supertype_role] = uuid_from_id(ti.supertype_role)
-                    ]
-                  }
-              end
-            else
-              # ValueType usually has a supertype:
-              if (o.supertype)
-                j[:supertype] = (uuids[o.supertype] ||= uuid_from_id(o.supertype))
-              end
-            end
-            # REVISIT: Place a ValueConstraint and shape
-            "    #{j.to_json}"
-          end*",\n"
-        }\n  ],"
-
-        fact_types = @vocabulary.constellation.
-          FactType.values.
-          reject{|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|
-            uuids[f] ||= uuid_from_id(f)
-            j = {:uuid => uuids[f]}
-
-            if f.entity_type
-              j[:objectified_as] = uuids[f.entity_type]
-            end
-
-            # Emit roles
-            roles = f.all_role.sort_by{|r| r.ordinal }
-            j[:roles] = roles.map do |role|
-              uuid = (uuids[role] ||= uuid_from_id(role))
-              # REVISIT: Internal Mandatory Constraints
-              # REVISIT: Place a ValueConstraint and shape
-              # REVISIT: Place a RoleName shape
-              {:uuid => uuid, :player => uuids[role.object_type]}
-              # N.B. The object_type shape to which this role is attached is not in the meta-model
-              # Attach to the closest instance on this diagram (if any)
-            end
-
-            # Emit readings. Each is a [role_order, text] pair
-            j[:readings] = f.all_reading.map do |r|
-              role_refs = r.role_sequence.all_role_ref_in_order
-              [
-                role_order(uuids, role_refs.map{|rr| rr.role}, roles),
-                r.text.gsub(/\{([0-9])\}/) do |insert|
-                  role_ref = role_refs[$1.to_i]
-                  la = role_ref.leading_adjective
-                  la = nil if la == ''
-                  ta = role_ref.trailing_adjective
-                  ta = nil if ta == ''
-                  (la ? la+'-' : '') +
-                    (la && la.index(' ') ? ' ' : '') +
-                    insert +
-                    (ta && ta.index(' ') ? ' ' : '') +
-                    (ta ? '-'+ta : '')
-                end
-              ]
-            end.sort_by{|(ro,text)| ro }.map do |(ro,text)|
-              [ ro, text ]
-            end
-
-            # Emit shapes
-            j[:shapes] = f.all_fact_type_shape.sort_by{|s| [s.location.x, s.location.y]}.map do |shape|
-              sj = {
-                :diagram => uuids[shape.orm_diagram],
-                :uuid => uuid_from_id(shape),
-                :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.orm_diagram.name} diagram"
-                end
-                ro = role_order(
-                  uuids,
-                  shape.all_role_display.sort_by{|rd| rd.ordinal }.map{|rd| rd.role },
-                  roles
-                )
-                sj[:role_order] = ro if ro
-              end
-
-              # REVISIT: Place the ReadingShape
-
-              # Emit the location of the name, if objectified
-              if n = shape.objectified_fact_type_name_shape
-                sj[:name_shape] = {:x => n.location.x, :y => n.location.y}
-              end
-              sj
-            end
-
-            # Emit Internal Presence Constraints
-            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 = {
-                :uuid => uuid,
-                :min => ipc.min_frequency,
-                :max => ipc.max_frequency,
-                :is_preferred => ipc.is_preferred_identifier,
-                :mandatory => ipc.is_mandatory
-              }
-
-              # Get the role (or excluded role, for a UC)
-              roles = ipc.role_sequence.all_role_ref_in_order.map{|r| r.role}
-              if roles.size > 1 || (!ipc.is_mandatory && ipc.max_frequency == 1)
-                # This can be only a uniqueness constraint. Record the missing role, if any
-                role = (f.all_role.to_a - roles)[0]
-                constraint[:uniqueExcept] = uuids[role]
-              else
-                # An internal mandatory or frequency constraint applies to only one role.
-                # If it's also unique (max == 1), that applies on the counterpart role.
-                # You can also have a mandatory frequency constraint, but that applies on this role.
-                constraint[:role] = uuids[roles[0]]
-              end
-              (j[:constraints] ||= []) << constraint
-            end
-
-            # Add ring constraints
-            f.all_role_in_order.
-              map{|r| r.all_ring_constraint.to_a+r.all_ring_constraint_as_other_role.to_a }.
-              flatten.uniq.each do |ring|
-                (j[:constraints] ||= []) << {
-                    :uuid => (uuids[ring] ||= uuid_from_id(ring)),
-                    :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.location.x,
-                        :y => shape.location.y
-                      }
-                    end,
-                    :ringKind => ring.ring_type,
-                    :roles => [uuids[ring.role], uuids[ring.other_role]]
-                    # REVISIT: Deontic, enforcement
-                  }
-              end
-
-            # REVISIT: RotationSetting
-
-            "    #{j.to_json}"
-          end*",\n"
-        }\n  ],"
-
-        constraints = @vocabulary.constellation.
-          Constraint.values
-        puts "  constraints: [\n#{
-          constraints.sort_by{|c|c.identifying_role_values.inspect}.select{|c| !uuids[c]}.map do |c|
-            uuid = uuids[c] ||= uuid_from_id(c)
-            j = {
-              :uuid => uuid,
-              :type => c.class.basename,
-              :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.location.x,
-                  :y => shape.location.y
-                }
-              end
-            }
-
-            if (c.enforcement)
-              # REVISIT: Deontic constraint
-            end
-            if (c.concept.all_context_note_as_relevant_concept.size > 0)
-              # REVISIT: Context Notes
-            end
-
-            case c
-            when ActiveFacts::Metamodel::PresenceConstraint
-              j[:min_frequency] = c.min_frequency
-              j[:max_frequency] = c.max_frequency
-              j[:is_mandatory] = c.is_mandatory
-              j[:is_preferred_identifier] = c.is_preferred_identifier
-              rss = [c.role_sequence.all_role_ref_in_order.map(&:role)]
-
-              # Ignore internal presence constraints on TypeInheritance fact types
-              next nil if !c.role_sequence.all_role_ref.
-                detect{|rr|
-                  !rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-                }
-
-            when ActiveFacts::Metamodel::RingConstraint
-              next nil  # These are emitted with the corresponding fact type
-
-            when ActiveFacts::Metamodel::SetComparisonConstraint
-              rss = c.
-                all_set_comparison_roles.sort_by{|scr| scr.ordinal}.
-                map{|scr| scr.role_sequence.all_role_ref_in_order.map(&:role) }
-              if (ActiveFacts::Metamodel::SetExclusionConstraint === c)
-                j[:is_mandatory] = c.is_mandatory
-              end
-
-            when ActiveFacts::Metamodel::SubsetConstraint
-              rss = [c.subset_role_sequence, c.superset_role_sequence].
-                map{|rs| rs.all_role_ref_in_order.map(&:role) }
-
-            when ActiveFacts::Metamodel::ValueConstraint
-              next nil  # REVISIT: Should have been handled elsewhere
-              if (c.role)
-                # Should have been handled as role.role_value_constraint
-              elsif (c.value_type)
-                # Should have been handled as object_type.value_constraint
-              end
-              j[:allowed_ranges] = c.all_allowed_range.map{|ar|
-                [ ar.value_range.minimum_bound, ar.value_range.maximum_bound ].
-                  map{|b| [b.value.literal, b.value.unit.name, b.is_inclusive] }
-              }
-
-            else
-              raise "REVISIT: Constraint type not yet dumped to JSON"
-            end
-
-            # rss contains the constrained role sequences; map to uuids
-            j[:role_sequences] = rss.map{|rs|
-              rs.map do |role|
-                uuids[role]
-              end
-            }
-
-            "    #{j.to_json}"
-          end.compact*",\n"
-        }\n  ]"
-
-        puts "}"
-      end
-
-      def role_order(uuids, roles, order)
-        if (roles.size > 9)
-          roles.map{|r| uuids[r] }
-        else
-          roles.map{|r| order.index(r).to_s }*''
-        end
-      end
-
-      def uuid_from_id o
-        irvs = o.identifying_role_values.inspect
-        d = Digest::SHA1.digest irvs
-        # $stderr.puts "#{o.class.basename}: #{irvs}"
-        d[0,4].unpack("H8")[0]+'-'+
-          d[4,2].unpack("H4")[0]+'-'+
-          d[6,2].unpack("H4")[0]+'-'+
-          d[8,2].unpack("H4")[0]+'-'+
-          d[10,6].unpack("H6")[0]
-      end
-
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('json', ActiveFacts::Generate::JSON)

data/lib/activefacts/generate/null.rb

@@ -1,32 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate *no* output for ActiveFacts vocabularies; i.e. just a stub
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # 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::Generate::NULL)

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

@@ -1,246 +0,0 @@
-#
-#       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
-
-	    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 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)