module ActiveFacts::Metamodel

Constants

VERSION

Public Class Methods

plays_over(roles, options = :both) click to toggle source

Some queries in constraints must be over the proximate roles, some over the counterpart roles. Return the common superclass of the appropriate roles, and the actual roles

# File lib/activefacts/metamodel/extensions.rb, line 1443
def self.plays_over roles, options = :both   # Or :proximate, :counterpart
  # If we can stay inside this objectified FT, there's no query:
  roles = Array(roles)  # To be safe, in case we get a role collection proxy
  return nil if roles.size == 1 or
    options != :counterpart && roles.map{|role| role.fact_type}.uniq.size == 1
  proximate_sups, counterpart_sups, obj_sups, counterpart_roles, objectification_roles =
    *roles.inject(nil) do |d_c_o, role|
      object_type = role.object_type
      fact_type = role.fact_type

      proximate_role_supertypes = object_type.supertypes_transitive

      # A role in an objectified fact type may indicate either the objectification or the counterpart player.
      # This could be ambiguous. Figure out both and prefer the counterpart over the objectification.
      counterpart_role_supertypes =
        if fact_type.all_role.size > 2
          possible_roles = fact_type.all_role.select{|r| d_c_o && d_c_o[1].include?(r.object_type) }
          if possible_roles.size == 1 # Only one candidate matches the types of the possible variables
            counterpart_role = possible_roles[0]
            d_c_o[1]  # No change
          else
            # puts "#{constraint_type} #{name}: Awkward, try counterpart-role query on a >2ary '#{fact_type.default_reading}'"
            # Try all roles; hopefully we don't have two roles with a matching candidate here:
            # Find which role is compatible with the existing supertypes, if any
            if d_c_o
              st = nil
              counterpart_role =
                fact_type.all_role.detect{|r| ((st = r.object_type.supertypes_transitive) & d_c_o[1]).size > 0}
              st
            else
              counterpart_role = nil  # This can't work, we don't have any basis for a decision (must be objectification)
              []
            end
            #fact_type.all_role.map{|r| r.object_type.supertypes_transitive}.flatten.uniq
          end
        else
          # Get the supertypes of the counterpart role (care with unaries):
          ftr = role.fact_type.all_role.to_a
          (counterpart_role = ftr[0] == role ? ftr[-1] : ftr[0]).object_type.supertypes_transitive
        end

      if fact_type.entity_type
        objectification_role_supertypes =
          fact_type.entity_type.supertypes_transitive+object_type.supertypes_transitive
        # Find the objectification role here:
        return nil unless role.link_fact_type   # REVISIT: Link Fact Types are missing; happens from half-baked surrogate transform
        objectification_role = role.link_fact_type.all_role.detect{|r| !r.is_a?(MirrorRole)}
      else
        objectification_role_supertypes = counterpart_role_supertypes
        objectification_role = counterpart_role
      end

      if !d_c_o
        d_c_o = [proximate_role_supertypes, counterpart_role_supertypes, objectification_role_supertypes, [counterpart_role], [objectification_role]]
        #puts "role player supertypes starts #{d_c_o.map{|dco| dco.map(&:name).inspect}*' or '}"
      else
        #puts "continues #{[proximate_role_supertypes, counterpart_role_supertypes, objectification_role_supertypes]map{|dco| dco.map(&:name).inspect}*' or '}"
        d_c_o[0] &= proximate_role_supertypes
        d_c_o[1] &= counterpart_role_supertypes
        d_c_o[2] &= objectification_role_supertypes
        d_c_o[3] << (counterpart_role || objectification_role)
        d_c_o[4] << (objectification_role || counterpart_role)
      end
      d_c_o
    end # inject

  # Discount a subtype step over an object type that's not a player here,
  # if we can use an objectification step to an object type that is:
  if counterpart_sups.size > 0 && obj_sups.size > 0 && counterpart_sups[0] != obj_sups[0]
    trace :query, "ambiguous query, could be over #{counterpart_sups[0].name} or #{obj_sups[0].name}"
    if !roles.detect{|r| r.object_type == counterpart_sups[0]} and roles.detect{|r| r.object_type == obj_sups[0]}
      trace :query, "discounting #{counterpart_sups[0].name} in favour of direct objectification"
      counterpart_sups = []
    end
  end

  # Choose the first entry in the first non-empty supertypes list:
  if options != :counterpart && proximate_sups[0]
    [ proximate_sups[0], roles ]
  elsif !counterpart_sups.empty?
    [ counterpart_sups[0], counterpart_roles ]
  else
    [ obj_sups[0], objectification_roles ]
  end
end