activefacts 1.6.0 → 1.7.1

data/lib/activefacts/generate/traits/datavault.rb

@@ -1,241 +0,0 @@
-#
-#	ActiveFacts Schema Transform
-#	Transform a loaded ActiveFacts vocabulary to suit ActiveRecord
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/generate/helpers/inject'
-
-module ActiveFacts
-  module Generate
-    module DataVaultTraits
-
-      module ObjectType
-
-	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
-	  # Find or assert the surrogate value type
-	  auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	    constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
-
-	  # Create a subtype to identify this entity type:
-	  vt_name = self.name + ' '+suffix
-	  my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	    constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
-
-	  # Create a fact type
-	  identifying_fact_type = constellation.FactType(:concept => :new)
-	  my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
-	  self.injected_surrogate_role = my_role
-	  id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
-
-	  # Create a reading (which needs a RoleSequence)
-	  reading = constellation.Reading(
-	    :fact_type => identifying_fact_type,
-	    :ordinal => 0,
-	    :role_sequence => [:new],
-	    :text => "{0} has {1}"
-	  )
-	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
-	  constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
-
-	  # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
-	  one_id = constellation.PresenceConstraint(
-	      :concept => :new,
-	      :vocabulary => vocabulary,
-	      :name => self.name+'HasOne'+suffix,
-	      :role_sequence => [:new],
-	      :is_mandatory => true,
-	      :min_frequency => 1,
-	      :max_frequency => 1,
-	      :is_preferred_identifier => false
-	    )
-	  @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
-
-	  one_me = constellation.PresenceConstraint(
-	      :concept => :new,
-	      :vocabulary => vocabulary,
-	      :name => self.name+suffix+'IsOfOne'+self.name,
-	      :role_sequence => [:new],
-	      :is_mandatory => false,
-	      :min_frequency => 0,
-	      :max_frequency => 1,
-	      :is_preferred_identifier => true
-	    )
-	  @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
-	end
-      end
-
-      module ValueType
-	def dv_needs_surrogate
-	  !is_auto_assigned
-	end
-
-	def dv_inject_surrogate
-	  trace :transform_surrogate, "Adding surrogate ID to Value Type #{name}"
-	  add_surrogate('Auto Counter', 'ID')
-	end
-      end
-
-      module EntityType
-	def dv_identifying_refs_from
-	  pi = preferred_identifier
-	  rrs = pi.role_sequence.all_role_ref
-
-  #	  REVISIT: This is actually a ref to us, not from
-  #	  if absorbed_via
-  #	    return [absorbed_via]
-  #	  end
-
-	  rrs.map do |rr|
-	    r = references_from.detect{|ref| rr.role == ref.to_role }
-	    unless r
-	      debugger
-	      raise "failed to find #{name} identifying reference for #{rr.role.object_type.name} in #{references_from.inspect}"
-	    end
-	    r
-	  end
-	end
-
-	def dv_needs_surrogate
-
-	  # A recursive proc to replace any reference to an Entity Type by its identifying references:
-	  trace :transform_surrogate_expansion, "Expanding key for #{name}"
-	  substitute_identifying_refs = proc do |object|
-	    if ref = object.absorbed_via
-	      # This shouldn't be necessary, but see the absorbed_via comment above.
-	      absorbed_into = ref.from
-	      trace :transform_surrogate_expansion, "recursing to handle absorption of #{object.name} into #{absorbed_into.name}"
-	      [substitute_identifying_refs.call(absorbed_into)]
-	    else
-	      irf = object.dv_identifying_refs_from
-	      trace :transform_surrogate_expansion, "Iterating for #{object.name} over #{irf.inspect}" do
-		irf.each_with_index do |ref, i|
-		  next if ref.is_unary
-		  next if ref.to_role.object_type.kind_of?(ActiveFacts::Metamodel::ValueType)
-		  recurse_to = ref.to_role.object_type
-
-		  trace :transform_surrogate_expansion, "#{i}: recursing to expand #{recurse_to.name} key in #{ref}" do
-		    irf[i] = substitute_identifying_refs.call(recurse_to)
-		  end
-		end
-	      end
-	      irf
-	    end
-	  end
-	  irf = substitute_identifying_refs.call(self)
-
-	  trace :transform_surrogate, "Does #{name} need a surrogate? it's identified by #{irf.inspect}" do
-
-	    pk_fks = dv_identifying_refs_from.map do |ref|
-	      ref.to && ref.to.is_table ? ref.to : nil
-	    end
-
-	    irf.flatten!
-
-	    # Multi-part identifiers are only allowed if:
-	    # * each part is a foreign key (i.e. it's a join table),
-	    # * there are no other columns (that might require updating) and
-	    # * the object is not the target of a foreign key:
-	    if irf.size >= 2
-	      if pk_fks.include?(nil)
-		trace :transform_surrogate, "#{self.name} needs a surrogate because its multi-part key contains a non-table"
-		return true
-	      elsif references_to.size != 0
-		trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect} but is also an FK target"
-		return true
-	      elsif (references_from-dv_identifying_refs_from).size > 0
-		# There are other attributes to worry about
-		return true
-	      else
-		trace :transform_surrogate, "#{self.name} is a join table between #{pk_fks.map(&:name).inspect}"
-		return false
-	      end
-	      return true
-	    end
-
-	    # Single-part key. It must be an Auto Counter, or we will add a surrogate
-
-	    identifying_type = irf[0].to
-	    if identifying_type.dv_needs_surrogate
-	      trace :transform_surrogate, "#{self.name} needs a surrogate because #{irf[0].to.name} is not an AutoCounter, but #{identifying_type.supertypes_transitive.map(&:name).inspect}"
-	      return true
-	    end
-
-	    false
-	  end
-	end
-
-	def dv_inject_surrogate
-	  trace :transform_surrogate, "Injecting a surrogate key into #{self.name}"
-
-	  # Disable the preferred identifier:
-	  pi = preferred_identifier
-	  trace :transform_surrogate, "pi for #{name} was '#{pi.describe}'"
-	  pi.is_preferred_identifier = false
-	  @preferred_identifier = nil	# Kill the cache
-
-	  dv_add_surrogate
-
-	  trace :transform_surrogate, "pi for #{name} is now '#{preferred_identifier.describe}'"
-	end
-
-	def dv_add_surrogate type_name = 'Auto Counter', suffix = 'ID'
-	 # Find or assert the surrogate value type
-	 auto_counter = vocabulary.valid_value_type_name(type_name) ||
-	   constellation.ValueType(:vocabulary => vocabulary, :name => type_name, :concept => :new)
-
-	 # Create a subtype to identify this entity type:
-	 vt_name = self.name + ' '+suffix
-	 my_id = @vocabulary.valid_value_type_name(vt_name) ||
-	   constellation.ValueType(:vocabulary => vocabulary, :name => vt_name, :concept => :new, :supertype => auto_counter)
-
-	 # Create a fact type
-	 identifying_fact_type = constellation.FactType(:concept => :new)
-	 my_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 0, :object_type => self)
-	 @injected_surrogate_role = my_role
-	 id_role = constellation.Role(:concept => :new, :fact_type => identifying_fact_type, :ordinal => 1, :object_type => my_id)
-
-	 # Create a reading (which needs a RoleSequence)
-	 reading = constellation.Reading(
-	   :fact_type => identifying_fact_type,
-	   :ordinal => 0,
-	   :role_sequence => [:new],
-	   :text => "{0} has {1}"
-	 )
-	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 0, :role => my_role)
-	 constellation.RoleRef(:role_sequence => reading.role_sequence, :ordinal => 1, :role => id_role)
-
-	 # Create two uniqueness constraints for the one-to-one. Each needs a RoleSequence (two RoleRefs)
-	 one_id = constellation.PresenceConstraint(
-	     :concept => :new,
-	     :vocabulary => vocabulary,
-	     :name => self.name+'HasOne'+suffix,
-	     :role_sequence => [:new],
-	     :is_mandatory => true,
-	     :min_frequency => 1,
-	     :max_frequency => 1,
-	     :is_preferred_identifier => false
-	   )
-	 @constellation.RoleRef(:role_sequence => one_id.role_sequence, :ordinal => 0, :role => my_role)
-
-	 one_me = constellation.PresenceConstraint(
-	     :concept => :new,
-	     :vocabulary => vocabulary,
-	     :name => self.name+suffix+'IsOfOne'+self.name,
-	     :role_sequence => [:new],
-	     :is_mandatory => false,
-	     :min_frequency => 0,
-	     :max_frequency => 1,
-	     :is_preferred_identifier => true
-	   )
-	 @constellation.RoleRef(:role_sequence => one_me.role_sequence, :ordinal => 0, :role => id_role)
-
-	 return my_id
-	end
-
-      end
-
-      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
-    end
-  end
-end

data/lib/activefacts/generate/traits/oo.rb

@@ -1,73 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Base class for generators of class libraries in any object-oriented language that supports the ActiveFacts API.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module Generate
-    module OOTraits
-      module ObjectType
-	# Map the ObjectType name to an OO class name
-	def oo_type_name
-	  name.words.capcase
-	end
-
-	# Map the OO class name to a default role name
-	def oo_default_role_name
-          name.words.snakecase
-	end
-      end
-
-      module Role
-	def oo_role_definition
-          return if fact_type.entity_type
-
-          if fact_type.all_role.size == 1
-	    return "    maybe :#{preferred_role_name}\n"
-          elsif fact_type.all_role.size != 2
-            # Shouldn't come here, except perhaps for an invalid model
-            return  # ternaries and higher are always objectified
-          end
-
-          # REVISIT: TypeInheritance
-          if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-            # trace "Ignoring role #{self} in #{fact_type}, subtype fact type"
-            # REVISIT: What about secondary subtypes?
-            # REVISIT: What about dumping the relational mapping when using separate tables?
-            return
-          end
-
-          return unless is_functional
-
-          counterpart_role = fact_type.all_role.select{|r| r != self}[0]
-          counterpart_type = counterpart_role.object_type
-          counterpart_role_name = counterpart_role.preferred_role_name
-          counterpart_type_default_role_name = counterpart_type.oo_default_role_name
-
-          # It's a one_to_one if there's a uniqueness constraint on the other role:
-          one_to_one = counterpart_role.is_functional
-          return if one_to_one &&
-              false # REVISIT: !@object_types_dumped[counterpart_role.object_type]
-
-          # Find role name:
-          role_method = preferred_role_name
-          counterpart_role_method = one_to_one ? role_method : "all_"+role_method
-          # puts "---"+role.role_name if role.role_name
-          if counterpart_role_name != counterpart_type.oo_default_role_name and
-	      role_method == self.object_type.oo_default_role_name
-#	    debugger
-            counterpart_role_method += "_as_#{counterpart_role_name}"
-          end
-
-          role_name = role_method
-          role_name = nil if role_name == object_type.oo_default_role_name
-
-          as_binary(counterpart_role_name, counterpart_type, is_mandatory, one_to_one, nil, role_name, counterpart_role_method)
-	end
-      end
-
-      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
-    end
-  end
-end

data/lib/activefacts/generate/traits/ordered.rb

@@ -1,33 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generation support superclass that sequences entity types to avoid forward references.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module Generate #:nodoc:
-    module OrderedTraits
-      module DumpedFlag
-	attr_reader :ordered_dumped
-
-	def ordered_dumped!
-	  @ordered_dumped = true
-	end
-      end
-
-      module ObjectType
-	include DumpedFlag
-      end
-
-      module FactType
-	include DumpedFlag
-      end
-
-      module Constraint
-	include DumpedFlag
-      end
-
-      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
-    end
-  end
-end

data/lib/activefacts/generate/traits/ruby.rb

@@ -1,210 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate Ruby classes for the ActiveFacts API from an ActiveFacts vocabulary.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-module ActiveFacts
-  module Generate
-    module RubyTraits
-      module Vocabulary
-	def prelude
-	  if @mapping == 'sql'
-	    require 'activefacts/persistence'
-	    @tables = self.tables
-	  end
-
-	  "require 'activefacts/api'\n" +
-	    (@mapping == 'sql' ? "require 'activefacts/persistence'\n" : '') +
-	    "\nmodule ::#{self.name}\n\n"
-	end
-
-	def finale
-	  "end"
-	end
-      end
-
-      module ObjectType
-	def absorbed_roles
-          all_role.
-            select do |role|
-              role.fact_type.all_role.size <= 2 &&
-                !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
-            end.
-            sort_by do |role|
-              r = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
-	      r.preferred_role_name(self) + ':' + role.preferred_role_name(r.object_type)
-            end
-	end
-
-	# Map the ObjectType name to a Ruby class name
-	def ruby_type_name
-	  oo_type_name
-	end
-
-	# Map the Ruby class name to a default role name
-	def ruby_default_role_name
-	  oo_default_role_name
-	end
-
-
-	def ruby_type_reference
-	  if !ordered_dumped
-	    '"'+name.gsub(/ /,'')+'"'
-	  else
-	    role_reference = name.gsub(/ /,'')
-	  end
-	end
-      end
-
-      module Role
-        def preferred_role_name(is_for = nil, &name_builder)
-
-	  if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-	    # Subtype and Supertype roles default to TitleCase names, and have no role_name to worry about:
-	    return (name_builder || proc {|names| names.titlecase}).call(object_type.name.words)
-	  end
-
-	  name_builder ||= proc {|names| names.map(&:downcase)*'_' }   # Make snake_case by default
-
-	  # Handle an objectified unary role:
-          if is_for && fact_type.entity_type == is_for && fact_type.all_role.size == 1
-            return name_builder.call(object_type.name.words)
-          end
-
-          # trace "Looking for preferred_role_name of #{describe_fact_type(fact_type, self)}"
-          reading = fact_type.preferred_reading
-          preferred_role_ref = reading.role_sequence.all_role_ref.detect{|reading_rr|
-              reading_rr.role == self
-            }
-
-          if fact_type.all_role.size == 1
-            return name_builder.call(
-	      role_name ?
-		role_name.snakewords :
-		reading.text.gsub(/ *\{0\} */,' ').gsub(/[- ]+/,'_').words
-	    )
-          end
-
-	  if role_name && role_name != ""
-	    role_words = [role_name]
-	  else
-	    role_words = []
-
-	    la = preferred_role_ref.leading_adjective
-	    role_words += la.words.snakewords if la && la != ""
-
-	    role_words += object_type.name.words.snakewords
-
-	    ta = preferred_role_ref.trailing_adjective
-	    role_words += ta.words.snakewords if ta && ta != ""
-	  end
-
-          # n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
-	  n = role_words*'_'
-          # trace "\tresult=#{n}"
-          return name_builder.call(n.gsub(' ','_').split(/_/))
-        end
-
-	def as_binary(role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
-	  ruby_role_name = ":"+role_name.words.snakecase
-
-	  # Find whether we need the name of the other role player, and whether it's defined yet:
-	  implied_role_name = role_player.name.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
-	  if role_name.camelcase != implied_role_name
-	    # Only use Class name if it's not implied by the rolename
-	    role_reference = ":class => "+role_player.ruby_type_reference
-	  end
-
-	  other_role_name = ":counterpart => :"+other_role_name.gsub(/ /,'_') if other_role_name
-
-	  if vr = role_value_constraint
-	    value_restriction = ":restrict => #{vr}"
-	  end
-
-	  options = [
-	      ruby_role_name,
-	      role_reference,
-	      mandatory ? ":mandatory => true" : nil,
-	      readings,
-	      other_role_name,
-	      value_restriction
-	    ].compact
-
-	  debugger if ruby_role_name == 'astronomicalobject'
-
-	  line = "    #{one_to_one ? "one_to_one" : "has_one" } #{options*', '}  "
-	  if other_method_name
-	    line += " "*(48-line.length) if line.length < 48
-	    line += "\# See #{role_player.name.gsub(/ /,'')}.#{other_method_name}"
-	  end
-	  line+"\n"
-	end
-
-	def ruby_role_definition
-	  oo_role_definition
-	end
-      end
-
-      module ValueType
-	def ruby_definition
-	  return if name == "_ImplicitBooleanValueType"
-
-	  ruby_length = length && length > 0 ? ":length => #{length}" : nil
-	  ruby_scale = scale && scale > 0 ? ":scale => #{scale}" : nil
-	  params = [ruby_length,ruby_scale].compact * ", "
-
-	  base_type = supertype || self
-	  base_type_name = base_type.ruby_type_name
-	  ruby_name = ruby_type_name
-	  if base_type_name == ruby_name
-	    base_type_name = '::'+base_type_name
-	  end
-
-	  "  class #{ruby_name} < #{base_type_name}\n" +
-	  "    value_type #{params}\n" +
-	  #emit_mapping self if is_table
-	  (value_constraint ?
-	    "    restrict #{value_constraint.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" :
-	    ""
-	  ) +
-	  (unit ?
-	    "    \# REVISIT: #{ruby_name} is in units of #{unit.name}\n" :
-	    ""
-	  ) +
-	  absorbed_roles.map do |role|
-	    role.ruby_role_definition
-	  end.
-	  compact*"" +
-	  "  end\n\n"
-	end
-      end
-
-      module FactType
-        # An objectified fact type has internal roles that are always "has_one":
-        def fact_roles
-	  raise "Fact #{describe} type is not objectified" unless entity_type
-          all_role.sort_by do |role|
-	    role.preferred_role_name(entity_type)
-	  end.
-	  map do |role| 
-	    role_name = role.preferred_role_name(entity_type)
-	    one_to_one = role.all_role_ref.detect{|rr|
-	      rr.role_sequence.all_role_ref.size == 1 &&
-	      rr.role_sequence.all_presence_constraint.detect{|pc|
-		pc.max_frequency == 1
-	      }
-	    }
-	    counterpart_role_method = (one_to_one ? "" : "all_") + 
-	      entity_type.oo_default_role_name +
-	      (role_name != role.object_type.oo_default_role_name ? "_as_#{role_name}" : '')
-	    role.as_binary(role_name, role.object_type, true, one_to_one, nil, nil, counterpart_role_method)
-	  end.
-	  join('')
-	end
-      end
-
-      include ActiveFacts::TraitInjector	# Must be last in this module, after all submodules have been defined
-    end
-  end
-end