activefacts-compositions 1.9.6 → 1.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9dd27f8a8f6a05f883483391f31e2a026b9a52b4
-  data.tar.gz: cc0355b8f29a879c654d7e36e542a95045e71994
+  metadata.gz: c3f30aa198a18c360d4fee63de36a3764df7d799
+  data.tar.gz: 28db19dcd307a9ab3ab1e7a50fada7023651d6e6
 SHA512:
-  metadata.gz: 2dc13c0b861580a23517fe1fe50f6dd4d8b88a42fb7ee15827119992c090172386efb984855a7ecf81f97a682e3439201f718bd1ae7fcb7aeeb3420317c86230
-  data.tar.gz: 45854d64978972f11839794e6c6fe0cd38a0e09c0c13f66081e9a0580cd4d01503350f144946dd22174b06530c0394b72632f5ac0fa660ba1ddf706e036bcb55
+  metadata.gz: 0b179e371a8f8b47a308d5790c6a21e4dec2c490eb7bd76da9bab58a0c8ae201fbf50c27a6a6b882e3395a9118b75ab16568353e076a17be1fd5197c4b78ae2f
+  data.tar.gz: cb28e3eb273607b31fb7e55fa2e826a5cc965764345a4b80c8096531d33be0dc97e05b7103424b5afd9bee1bc68d7fb9d51341a87967909eba52eaddd1964ed7

data/.gitignore

@@ -12,3 +12,4 @@
 *.rej
 *.orig
 *.diff
+actual

data/Rakefile

@@ -21,3 +21,36 @@ task :bump do
     )
   end
 end
+
+desc "Display differences between expected and actual from the last test run"
+task :actual do
+  system <<-END
+    for actual in `find spec -type d -name actual`
+    do
+      base=`dirname "$actual"`
+      files="`ls $base/actual/* 2>/dev/null`"
+      if [ x"$files" != x"" ]
+      then
+	echo "=================================== $base ==================================="
+	diff -rub $base/expected/ $base/actual |grep -v '^Only in .*expected'
+      fi
+    done
+  END
+end
+
+desc "Accept the last actual test output, making it expected for the next test run"
+task :accept do
+  system <<-END
+    for actual_dir in `find spec -type d -name actual`
+    do
+      base=`dirname "$actual_dir"`
+      expected=`cd "$base/expected"; git ls-files`
+      actual=`cd "$base/actual"; ls $expected 2>/dev/null`
+      if [ x"$actual" != x"" ]
+      then
+	echo "Accepting $actual"
+	(cd "$base/actual"; mv $actual ../expected)
+      fi
+    done
+  END
+end

data/activefacts-compositions.gemspec

@@ -19,14 +19,14 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", ">= 1.10", "~> 1.10.6"
+  spec.add_development_dependency "bundler", ">= 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
   spec.add_development_dependency "activefacts", "~> 1", ">= 1.8"
 
-  spec.add_runtime_dependency("activefacts-api", "~> 1", ">= 1.9.5")
-  spec.add_runtime_dependency("activefacts-metamodel", "~> 1", ">= 1.9.6")
+  spec.add_runtime_dependency("activefacts-api", "~> 1", ">= 1.9.11")
+  spec.add_runtime_dependency("activefacts-metamodel", "~> 1", ">= 1.9.10")
   spec.add_runtime_dependency "tracing", "~> 2", ">= 2.0.6"
 
   spec.add_runtime_dependency "activefacts-cql", "~> 1", ">= 1.8"

data/bin/schema_compositor

@@ -5,111 +5,168 @@
 # Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
 #
 ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
-require 'bundler/setup' # Set up gems listed in the Gemfile.
 $:.unshift File.dirname(File.expand_path(__FILE__))+"/../lib"
 
+require 'pathname'
 require 'activefacts/loadable'
 require 'activefacts/metamodel'
 require 'activefacts/compositions'
 require 'activefacts/generator'
 
-# Parse options into a hash, and values for each option into a hash
-options = {}
-while ARGV[0] =~ /^-/
-  option, value = ARGV.shift.split(/=/, 2)
-  options[option.sub(/^-*/,'')] =
-    (value =~ /,/ ? value.split(',') : Array(value)).
-    inject({}){|h,s| k, v = s.split(/=/, 2); h[k] = v || true; h }
-end
+class SchemaCompositor
+  attr_reader :options
+  attr_reader :compositors
+  attr_reader :generators
 
-# Load and enumerate all available compositors:
-compositions_path = "activefacts/compositions"
-Loadable.new(compositions_path).
-enumerate.
-select do |filename|
-  begin
-    require(pathname = compositions_path+"/"+filename)
-  rescue LoadError => e
-  rescue Exception => e
-    puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+  # Parse options into a hash, and values for each option into a hash
+  def initialize argv
+    @options = {}
+    while argv[0] =~ /^-/
+      option, value = argv.shift.split(/=/, 2)
+      @options[option.sub(/^-*/,'')] =
+	(value =~ /,/ ? value.split(',') : Array(value)).
+	inject({}){|h,s| k, v = s.split(/=/, 2); h[k] = v || true; h }
+    end
   end
-end
 
-# Load and enumerate all available generators
-generators_path = "activefacts/generator"
-Loadable.new(generators_path).
-enumerate.
-select do |filename|
-  begin
-    require(pathname = generators_path+"/"+filename)
-  rescue LoadError => e
-  rescue Exception => e
-    puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+  # Load and enumerate all available modules in this path
+  def enumerate_available path
+    Loadable.new(path).
+    enumerate.
+    select do |filename|
+      begin
+	require(pathname = path+"/"+filename)
+      rescue LoadError => e
+      rescue Exception => e
+	$stderr.puts "Can't load #{pathname}: #{e.class}: #{e.message} #{e.backtrace[0]}"
+      end
+    end
   end
-end
 
-if options['help']
-  puts "Available compositors:\n\t#{ActiveFacts::Compositions.compositors.keys.sort*"\n\t"}\n\n"
-  puts "Available generators:\n\t#{ActiveFacts::Generators.generators.keys.sort*"\n\t"}\n\n"
-  exit
-end
-
-# Arrange the requested compositors and generators:
-compositors = []
-generators = []
-options.clone.each do |option, mode|
-  if action = ActiveFacts::Compositions.compositors[option]
-    options.delete(option)
-    compositors << [action, mode]
-  elsif action = ActiveFacts::Generators.generators[option]
-    options.delete(option)
-    generators << [action, mode]
-  end
-  if mode && mode['help']
-    puts "REVISIT: Help for #{option} is not yet available"
+  def arrange_actions
+    # Arrange the requested compositors and generators:
+    @compositors = []
+    @generators = []
+    @options.clone.each do |option, mode|
+      if action = ActiveFacts::Compositions.compositors[option]
+	options.delete(option)
+	check_options(action, mode)
+	@compositors << [action, mode]
+      elsif action = ActiveFacts::Generators.generators[option]
+	options.delete(option)
+	check_options(action, mode)
+	@generators << [action, mode]
+      else
+	$stderr.puts "Action --#{option} is not recognised"
+	exit 1
+      end
+      if mode && mode['help']
+	puts "Help for #{option} is not yet available"
+      end
+    end
   end
-end
 
-# Process each input file:
-ARGV.each do |arg|
-  filename, input_options = *arg.split(/=/, 2)
+  def process_files argv
+    # Process each input file:
+    argv.each do |arg|
+      filename, input_options = *arg.split(/=/, 2)
 
-  # Load the correct file type input method
-  pathname, basename, extension = * /(?:(.*)[\/\\])?(.*)\.([^.]*)$/.match(filename).captures
-  input_handler = "activefacts/input/#{extension}"
-  require input_handler
+      # Load the correct file type input method
+      pathname, basename, extension = * /(?:(.*)[\/\\])?(.*)\.([^.]*)$/.match(filename).captures
+      input_handler = "activefacts/input/#{extension}"
+      require input_handler
 
-  input_class = extension.upcase
-  input_klass = ActiveFacts::Input.const_get(input_class.to_sym)
-  raise "Expected #{input_handler} to define #{input_class}" unless input_klass
+      input_class = extension.upcase
+      input_klass = ActiveFacts::Input.const_get(input_class.to_sym)
+      raise "Expected #{input_handler} to define #{input_class}" unless input_klass
 
-  # Read the input file:
-  vocabulary =
-    if input_klass
-      begin
-	input_klass.readfile(filename, *input_options)
-      rescue => e
-	$stderr.puts "#{e.message}"
-	if trace :exception
-	  $stderr.puts "\t#{e.backtrace*"\n\t"}"
-	else
-	  $stderr.puts "\t#{e.backtrace[0]}"
+      # Read the input file:
+      vocabulary =
+	if input_klass
+	  begin
+	    input_klass.readfile(filename, *input_options)
+	  rescue => e
+	    $stderr.puts "#{e.message}"
+	    if trace :exception
+	      $stderr.puts "\t#{e.backtrace*"\n\t"}"
+	    else
+	      $stderr.puts "\t#{e.backtrace[0]}"
+	    end
+	    exit 1
+	  end
+	end
+      exit 0 unless vocabulary
+      vocabulary.finalise unless vocabulary == true
+
+      # Run each compositor
+      @compositors.each do |compositor_klass, mode|
+	compositor = compositor_klass.new(vocabulary.constellation, basename, mode||{})
+	compositor.generate
+
+	# Run each generator
+	@generators.each do |generator, mode|
+	  output = generator.new(compositor.composition, mode||{}).generate
+	  puts output if output
 	end
-	exit 1
       end
     end
-  exit 0 unless vocabulary
-  vocabulary.finalise unless vocabulary == true
-
-  # Run each compositor
-  compositors.each do |compositor_klass, mode|
-    compositor = compositor_klass.new(vocabulary.constellation, basename, mode||{})
-    compositor.generate
-
-    # Run each generator
-    generators.each do |generator, mode|
-      output = generator.new(compositor.composition, mode||{}).generate
-      puts output if output
+  end
+
+  def action_name action
+    action.name.sub(/ActiveFacts::[^:]+::/,'').gsub(/::/,'/').downcase
+  end
+
+  def display_options action, stream = $stdout
+    options = action.options
+    name = action.name.sub(/ActiveFacts::[^:]+::/,'').gsub(/::/,'/').downcase
+    if options.empty?
+      stream.puts "There are no options for --#{action_name action}"
+    else
+      stream.puts "Options for --#{name} (say e.g. --#{action_name action}=option1=value,option2)"
+      options.keys.sort.each do |key|
+	type, description = *options[key]
+	tag =
+	  key.to_s +
+	  case type
+	  when NilClass,'Boolean', TrueClass
+	    ''
+	  when Numeric
+	    ' num'
+	  when Pathname
+	    ' file'
+	  else
+	    ' str'
+	  end
+
+	stream.puts "\t#{tag}#{' '*(24-tag.size)}#{description}"
+      end
     end
   end
+
+  # Ensure that the options provided are supported by the action
+  def check_options action, mode
+    if mode['help']
+      display_options(action)
+      exit
+    end
+    options = action.options
+    unsupported = mode.keys.select{|k| !options.has_key?(k.to_sym)}
+    return if unsupported.empty?
+    $stderr.puts "Action --#{action_name action} does not support #{unsupported.size >1 ? 'these options' : 'this option'}: #{unsupported*', '}"
+    display_options(action, $stderr)
+    exit 1
+  end
 end
+
+sc = SchemaCompositor.new(ARGV)
+sc.enumerate_available('activefacts/compositions')
+sc.enumerate_available('activefacts/generator')
+if sc.options['help']
+  puts "Available compositors:\n\t#{ActiveFacts::Compositions.compositors.keys.sort*"\n\t"}\n\n"
+  puts "Available generators:\n\t#{ActiveFacts::Generators.generators.keys.sort*"\n\t"}\n\n"
+  puts "To get help for a particular action, follow it by =help, e.g. --relational=help"
+  exit
+end
+
+sc.arrange_actions
+sc.process_files ARGV

data/lib/activefacts/compositions/binary.rb

@@ -1,7 +1,7 @@
 ### Composition
 # ActiveFacts Compositions, Binary Compositor.
 #
-#	Fans of RDF will like this one.
+#       Fans of RDF will like this one.
 #
 # Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
 #
@@ -10,23 +10,27 @@ require "activefacts/compositions"
 module ActiveFacts
   module Compositions
     class Binary < Compositor
+      def self.options
+        {}
+      end
+
       def generate
-	super
+        super
 
-	trace :binary!, "Constructing Binary Composition" do
-	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
-	    mapping = @binary_mappings[object_type]
-	    mapping.re_rank
-	    composite = @constellation.Composite(mapping, composition: @composition)
-	  end
-	end
+        trace :binary!, "Constructing Binary Composition" do
+          @binary_mappings.keys.sort_by(&:name).each do |object_type|
+            mapping = @binary_mappings[object_type]
+            mapping.re_rank
+            composite = @constellation.Composite(mapping, composition: @composition)
+          end
+        end
 
-	trace :binary!, "Full binary composition" do
-	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
-	    mapping = @binary_mappings[object_type]
-	    mapping.show_trace 
-	  end
-	end
+        trace :binary!, "Full binary composition" do
+          @binary_mappings.keys.sort_by(&:name).each do |object_type|
+            mapping = @binary_mappings[object_type]
+            mapping.show_trace 
+          end
+        end
 
       end
     end

data/lib/activefacts/compositions/compositor.rb

@@ -1,13 +1,13 @@
 #
 # ActiveFacts Compositions, Fundamental Compositor
 # 
-#	All Compositors derive from this one, which can calculate the basic binary bi-directional mapping
+#       All Compositors derive from this one, which can calculate the basic binary bi-directional mapping
 #
-#	The term "reference" used here means either an Absorption
-#	(one direction of a binary fact type relating two object types),
-#	or an Indicator (for a unary fact type).
+#       The term "reference" used here means either an Absorption
+#       (one direction of a binary fact type relating two object types),
+#       or an Indicator (for a unary fact type).
 #
-#	n-ary fact types and other objectified fact types are factored out by using the associated LinkFactTypes.
+#       n-ary fact types and other objectified fact types are factored out by using the associated LinkFactTypes.
 #
 # Copyright (c) 2015 Clifford Heath. Read the LICENSE file.
 #
@@ -15,141 +15,142 @@ require "activefacts/metamodel"
 
 module ActiveFacts
   module Compositions
-    private
-      MM = ActiveFacts::Metamodel
     class Compositor
       attr_reader :options, :name, :composition
 
+      def self.options
+        {}
+      end
+
       def initialize constellation, name, options = {}
-	@constellation = constellation
-	@name = name
-	@options = options
-	$stderr.puts "Unknown options: #{options.inspect}" unless options.empty?
+        @constellation = constellation
+        @name = name
+        @options = options
       end
 
       # Generate all Mappings into @binary_mappings for a binary composition of all ObjectTypes in this constellation
       def generate
-	# Retract an existing composition by this name
-	if existing = @constellation.Name[[@name]] and
-	    @composition = existing.composition
-	  @composition.all_composite.to_a.each{|composite| composite.retract}
-	  @composition.retract
-	end
-
-	@composition = @constellation.Composition(:new, :name => @name)
-	preload_preferred_identifiers
-	populate_references
+        # Retract an existing composition by this name
+        if existing = @constellation.Name[[@name]] and
+            @composition = existing.composition
+          @composition.all_composite.to_a.each{|composite| composite.retract}
+          @composition.retract
+        end
+
+        @composition = @constellation.Composition(:new, :name => @name)
+        preload_preferred_identifiers
+        populate_references
       end
 
     private
       # Preferred identifiers are cached, but the process produces trace output
       # that appears in the "tutti" mode used in testing. This precludes that.
       def preload_preferred_identifiers
-	@constellation.EntityType.map{|k, et| et.preferred_identifier }
+        @constellation.EntityType.map{|k, et| et.preferred_identifier }
       end
 
       def populate_reference object_type, role
-	parent = @binary_mappings[role.object_type]
-
-	return if role.fact_type.all_role.size > 2
-	if role.fact_type.all_role.size != 1
-	  counterpart = role.counterpart
-	  rt = role_type(counterpart)
-	  if rt == :many_many
-	    raise "Fact type must be objectified: #{role.fact_type.default_reading}"
-	  end
-
-	  a = @constellation.Absorption(
-	      :new,
-	      name: role_name(counterpart),
-	      parent: parent,
-	      object_type: counterpart.object_type,
-	      parent_role: role,
-	      child_role: counterpart
-	    )
-	  # Populate the absorption/reverse_absorption (putting the "many" or optional side as reverse)
-	  if r = @component_by_fact[role.fact_type]
-	    # Second occurrence of this fact type, set the direction:
-	    if a.is_preferred_direction
-	      a.reverse_absorption = r
-	    else  # Set this as the reverse absorption
-	      a.forward_absorption = r
-	    end
-	  else
-	    # First occurrence of this fact type
-	    @component_by_fact[role.fact_type] = a
-	  end
-	else	# It's an indicator
-	  a = @constellation.Indicator(
-	      :new,
-	      name: role.name,
-	      parent: parent,
-	      role: role
-	    )
-	  @component_by_fact[role.fact_type] = a  # For completeness, in case a subclass uses it
-	end
-	trace :binarize, "Populating #{a.inspect}"
+        parent = @binary_mappings[role.object_type]
+
+        return if role.fact_type.all_role.size > 2
+        if role.fact_type.all_role.size != 1
+          counterpart = role.counterpart
+          rt = role_type(counterpart)
+          if rt == :many_many
+            raise "Fact type must be objectified: #{role.fact_type.default_reading}"
+          end
+
+          a = @constellation.Absorption(
+              :new,
+              name: role_name(counterpart),
+              parent: parent,
+              object_type: counterpart.object_type,
+              parent_role: role,
+              child_role: counterpart
+            )
+          # Populate the absorption/reverse_absorption (putting the "many" or optional side as reverse)
+          if r = @component_by_fact[role.fact_type]
+            # Second occurrence of this fact type, set the direction:
+            if a.is_preferred_direction
+              a.reverse_absorption = r
+            else  # Set this as the reverse absorption
+              a.forward_absorption = r
+            end
+          else
+            # First occurrence of this fact type
+            @component_by_fact[role.fact_type] = a
+          end
+        else    # It's an indicator
+          a = @constellation.Indicator(
+              :new,
+              name: role.name,
+              parent: parent,
+              role: role
+            )
+          @component_by_fact[role.fact_type] = a  # For completeness, in case a subclass uses it
+        end
+        trace :binarize, "Populating #{a.inspect}"
       end
 
       def populate_references
-	# A table of Mappings by object type, with a default Mapping for each:
-	@binary_mappings = Hash.new do |h, object_type|
-	  h[object_type] = @constellation.Mapping(
-	      :new,
-	      name: object_type.name,
-	      object_type: object_type
-	    )
-	end
-	@component_by_fact = {}
-
-	@constellation.ObjectType.each do |key, object_type|
-	  trace :binarize, "Populating possible absorptions for #{object_type.name}" do
-	    @binary_mappings[object_type]  # Ensure we create the top Mapping even if it has no references
-
-	    object_type.all_role.each do |role|
-	      # Exclude base roles in objectified fact types (unless unary); just use link fact types
-	      next if role.fact_type.entity_type && role.fact_type.all_role.size != 1
-	      next if role.variable   # REVISIT: Continue to ignore roles in derived fact types?
-	      populate_reference object_type, role
-	    end
-	    if object_type.is_a?(ActiveFacts::Metamodel::ValueType)
-	      # This requires a change in the metamodel to use TypeInheritance for ValueTypes
-	      if object_type.supertype
-		trace :binarize, "REVISIT: Eliding supertype #{object_type.supertype.name} for #{object_type.name}"
-	      end
-	      object_type.all_value_type_as_supertype.each do |subtype|
-		trace :binarize, "REVISIT: Eliding subtype #{subtype.name} for #{object_type.name}"
-	      end
-	    end
-	  end
-	end
+        # A table of Mappings by object type, with a default Mapping for each:
+        @binary_mappings = Hash.new do |h, object_type|
+          h[object_type] = @constellation.Mapping(
+              :new,
+              name: object_type.name,
+              object_type: object_type
+            )
+        end
+        @component_by_fact = {}
+
+        @constellation.ObjectType.each do |key, object_type|
+          trace :binarize, "Populating possible absorptions for #{object_type.name}" do
+            @binary_mappings[object_type]  # Ensure we create the top Mapping even if it has no references
+
+            object_type.all_role.each do |role|
+              # Exclude base roles in objectified fact types (unless unary); just use link fact types
+              next if role.fact_type.entity_type && role.fact_type.all_role.size != 1
+              next if role.variable   # REVISIT: Continue to ignore roles in derived fact types?
+              populate_reference object_type, role
+            end
+            if object_type.is_a?(ActiveFacts::Metamodel::ValueType)
+              # This requires a change in the metamodel to use TypeInheritance for ValueTypes
+              if object_type.supertype
+                trace :binarize, "REVISIT: Eliding supertype #{object_type.supertype.name} for #{object_type.name}"
+              end
+              object_type.all_value_type_as_supertype.each do |subtype|
+                trace :binarize, "REVISIT: Eliding subtype #{subtype.name} for #{object_type.name}"
+              end
+            end
+          end
+        end
       end
 
       def role_name role
-#	if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) && role == role.fact_type.subtype_role
-#	  return "Is "+role.object_type.name
-#	end
-	role = role.base_role unless role.base_role.fact_type.all_role.size == 1
-	String::Words.new(role.preferred_reference.role_name(nil)).capwords*' '
+#       if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) && role == role.fact_type.subtype_role
+#         return "Is "+role.object_type.name
+#       end
+        role = role.base_role unless role.base_role.fact_type.all_role.size == 1
+        String::Words.new(role.preferred_reference.role_name(nil)).capwords*' '
       end
 
       def role_type role
-	fact_type = role.fact_type
-	if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-	  return role.object_type == fact_type.supertype ? :supertype : :subtype
-	end
-
-	return :unary if fact_type.all_role.size == 1
-
-	if fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
-	  # Prevent an unnecessary from-1 search:
-	  from_1 = true
-	  # Change the to_1 search to detect a one-to-one:
-	  role = fact_type.implying_role
-	  fact_type = role.fact_type
-	end
-
-	# List the UCs on this fact type:
+        fact_type = role.fact_type
+        if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+          return role.object_type == fact_type.supertype ? :supertype : :subtype
+        end
+
+        return :unary if fact_type.all_role.size == 1
+
+        if fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+          # Prevent an unnecessary from-1 search:
+          from_1 = true
+          # Change the to_1 search to detect a one-to-one:
+          role = fact_type.implying_role
+          fact_type = role.fact_type
+        end
+
+        # List the UCs on this fact type:
         all_uniqueness_constraints =
           fact_type.all_role.map do |fact_role|
             fact_role.all_role_ref.map do |rr|
@@ -159,7 +160,7 @@ module ActiveFacts
             end
           end.flatten.uniq
 
-	# It's to-1 if a UC exists over exactly this role:
+        # It's to-1 if a UC exists over exactly this role:
         to_1 =
           all_uniqueness_constraints.
             detect do |c|
@@ -186,16 +187,16 @@ module ActiveFacts
 
       # Display the primitive binary mapping:
       def show_references
-	trace :composition, "Displaying the mappings:" do
-	  @binary_mappings.keys.sort_by(&:name).each do |object_type|
-	    mapping = @binary_mappings[object_type]
-	    trace :composition, "#{object_type.name}" do
-	      mapping.all_member.each do |component|
-		trace :composition, component.inspect
-	      end
-	    end
-	  end
-	end
+        trace :composition, "Displaying the mappings:" do
+          @binary_mappings.keys.sort_by(&:name).each do |object_type|
+            mapping = @binary_mappings[object_type]
+            trace :composition, "#{object_type.name}" do
+              mapping.all_member.each do |component|
+                trace :composition, component.inspect
+              end
+            end
+          end
+        end
       end
 
     end