activefacts-generators 1.8.3 → 1.9.0

data/lib/activefacts/generators/metadata/json.rb

@@ -24,27 +24,27 @@ module ActiveFacts
         end
 
         def generate(out = $>)
-	  @metadata = {"types" => {}}
+          @metadata = {"types" => {}}
 
           object_types_dump
 
-	  out.puts ::JSON.pretty_generate(@metadata)
+          out.puts ::JSON.pretty_generate(@metadata)
         end
 
-	# Store the metadata for all types into the types section of the @metadata hash
-	def object_types_dump
-	  types = @metadata["types"]
+        # Store the metadata for all types into the types section of the @metadata hash
+        def object_types_dump
+          types = @metadata["types"]
 
-	  # Compute the relational mapping if not already done:
-	  @tables ||= @vocabulary.tables
+          # Compute the relational mapping if not already done:
+          @tables ||= @vocabulary.tables
 
-	  @vocabulary.all_object_type.
-	  sort_by{|c| c.name}.each do |o|
-	    object_type = o.as_json_metadata
+          @vocabulary.all_object_type.
+          sort_by{|c| c.name}.each do |o|
+            object_type = o.as_json_metadata
 
-	    types[o.name] = object_type if object_type
-	  end
-	end
+            types[o.name] = object_type if object_type
+          end
+        end
 
       end
     end
@@ -53,149 +53,149 @@ module ActiveFacts
   module Metamodel
     class ObjectType
       def as_json_metadata
-	# Using proc avoids polluting the object's namespace with these little methods
-	verbalise_role = proc do |role, plural|
-	  fc = Array.new(role.fact_type.all_role.size, plural ? 'some' : 'one')
-	  reading = role.fact_type.reading_preferably_starting_with_role(role)
+        # Using proc avoids polluting the object's namespace with these little methods
+        verbalise_role = proc do |role, plural|
+          fc = Array.new(role.fact_type.all_role.size, plural ? 'some' : 'one')
+          reading = role.fact_type.reading_preferably_starting_with_role(role)
           fc.reverse! unless reading.role_sequence.all_role_ref.to_a[0].role == role
-	  fc[reading.role_sequence.all_role_ref_in_order.to_a.index{|rr| rr.role == role}] = 'this'
-	  reading.expand(fc, false)
-	end
-
-	titlize_words = proc do |phrase|
-	  phrase && phrase.split(/\s+/).map{|w| w.sub(/^[a-z]/) {|i| i.upcase}}*' '
-	end
-
-	role_name = proc do |role|
-	  if role.role_name
-	    role.role_name
-	  else
-	    ref = role.preferred_reference
-	    [ titlize_words.call(ref.leading_adjective), role.object_type.name, titlize_words.call(ref.trailing_adjective)].compact*' '
-	  end
-	end
-
-	return nil if name == '_ImplicitBooleanValueType'
-
-	object_type = {}
-	object_type["is_main"] = is_table
-	object_type["id"] = concept.guid.to_s
-	functions = object_type["functions"] = []
-
-	if is_a?(ActiveFacts::Metamodel::EntityType)
-
-	  # Don't emit a binary objectified fact type that plays no roles (except in implicit fact types:
-	  if fact_type and fact_type.all_role.size == 2 and all_role.size == 2
-	    return nil
-	  end
-
-	  # Export the supertypes
-	  (supertypes_transitive-[self]).sort_by{|t| t.name}.each do |supertype|
-	    functions <<
-	      {
-		"title" => "as #{supertype.name}",
-		"type" => "#{supertype.name}"
-	      }
-	  end
-
-	  # Export the subtypes
-	  (subtypes_transitive-[self]).sort_by{|t| t.name}.each do |subtype|
-	    functions <<
-	      {
-		"title" => "as #{subtype.name}",
-		"type" => "#{subtype.name}"
-	      }
-	  end
-
-	  # If an objectified fact type, export the fact type's roles
-	  if fact_type
-	    fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).each do |role|
-	      functions <<
-		{
-		  "title" => "involving #{role_name.call(role)}",
-		  "type" => "#{role.object_type.name}",
-		  "where" => verbalise_role.call(role, true)  # REVISIT: Need plural setting here!
-		}
-	    end
-	  end
-	end
-
-	# Now export the ordinary roles. Get a sorted list first:
-	roles = all_role.reject do |role|
-	    # supertype and subtype roles get handled separately
-	    role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) ||
-	      role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
-	  end.sort_by do |role|
-	    # Where this object type plays two roles in the same fact type,
-	    # we order them by the position of that role in the preferred reading:
-	    [role.fact_type.default_reading, role.fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).index(role)]
-	  end
-
-	# For binary fact types, collect the count of the times the unadorned counterpart role name occurs, so we can adorn it
-	plural_counterpart_counts = roles.inject(Hash.new{0}) do |h, role|
-	  next h unless role.fact_type.all_role.size == 2
-	  uc = role.all_role_ref.detect do |rr|
-	      rs = rr.role_sequence
-	      next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
-	      rs.all_presence_constraint.detect do |pc|
-		  next false unless pc.max_frequency == 1   # It's a uniqueness constraint
-		  true
-		end
-	    end
-	  next h if uc	# Not a plural role
-
-	  counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
-	  h[role_name.call(counterpart_role)] += 1
-	  h
-	end
-
-	roles.each do |role|
-	  type_name = nil
-	  counterpart_name = nil
-
-	  if role.fact_type.entity_type and	      # Role is in an objectified fact type
-	    # For binary objectified fact types, we traverse directly to the other role, not just to the objectification
-	    !(role.fact_type.entity_type.all_role.size == 2 and role.fact_type.all_role.size == 2)
-
-	    type_name = role.fact_type.entity_type.name
-	    counterpart_name = type_name	  # If self plays more than one role in OFT, need to construct a role name
-	    plural = true
-	  elsif role.fact_type.all_role.size == 1
-	    # Handle unary roles
-	    type_name = 'boolean'
-	    counterpart_name = role.fact_type.default_reading
-	    plural = false
-	  else
-	    # Handle binary roles
-	    counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
-	    type_name = counterpart_role.object_type.name
-	    counterpart_name = role_name.call(counterpart_role)
-	    # Figure out whether the counterpart is plural (say "all ..." if so)
-	    uc = role.all_role_ref.detect do |rr|
-		rs = rr.role_sequence
-		next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
-		rs.all_presence_constraint.detect do |pc|
-		    next false unless pc.max_frequency == 1   # It's a uniqueness constraint
-		    true
-		  end
-	      end
-	    plural = !uc
-	    if plural_counterpart_counts[counterpart_name] > 1
-	      counterpart_name += " as " + role_name.call(role)
-	    end
-	  end
-
-	  node = {
-	    "title" => "#{plural ? 'all ' : ''}#{counterpart_name}",
-	    "type" => "#{type_name}",
-	    "where" => verbalise_role.call(role, plural),
-	    "role_id" => role.concept.guid.to_s
-	  }
-	  node["is_list"] = true if plural
-	  functions << node 
-
-	end
-	functions.size > 0 ? object_type : nil
+          fc[reading.role_sequence.all_role_ref_in_order.to_a.index{|rr| rr.role == role}] = 'this'
+          reading.expand(fc, false)
+        end
+
+        titlize_words = proc do |phrase|
+          phrase && phrase.split(/\s+/).map{|w| w.sub(/^[a-z]/) {|i| i.upcase}}*' '
+        end
+
+        role_name = proc do |role|
+          if role.role_name
+            role.role_name
+          else
+            ref = role.preferred_reference
+            [ titlize_words.call(ref.leading_adjective), role.object_type.name, titlize_words.call(ref.trailing_adjective)].compact*' '
+          end
+        end
+
+        return nil if name == '_ImplicitBooleanValueType'
+
+        object_type = {}
+        object_type["is_main"] = is_table
+        object_type["id"] = concept.guid.to_s
+        functions = object_type["functions"] = []
+
+        if is_a?(ActiveFacts::Metamodel::EntityType)
+
+          # Don't emit a binary objectified fact type that plays no roles (except in implicit fact types:
+          if fact_type and fact_type.all_role.size == 2 and all_role.size == 2
+            return nil
+          end
+
+          # Export the supertypes
+          (supertypes_transitive-[self]).sort_by{|t| t.name}.each do |supertype|
+            functions <<
+              {
+                "title" => "as #{supertype.name}",
+                "type" => "#{supertype.name}"
+              }
+          end
+
+          # Export the subtypes
+          (subtypes_transitive-[self]).sort_by{|t| t.name}.each do |subtype|
+            functions <<
+              {
+                "title" => "as #{subtype.name}",
+                "type" => "#{subtype.name}"
+              }
+          end
+
+          # If an objectified fact type, export the fact type's roles
+          if fact_type
+            fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).each do |role|
+              functions <<
+                {
+                  "title" => "involving #{role_name.call(role)}",
+                  "type" => "#{role.object_type.name}",
+                  "where" => verbalise_role.call(role, true)  # REVISIT: Need plural setting here!
+                }
+            end
+          end
+        end
+
+        # Now export the ordinary roles. Get a sorted list first:
+        roles = all_role.reject do |role|
+            # supertype and subtype roles get handled separately
+            role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) ||
+              role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+          end.sort_by do |role|
+            # Where this object type plays two roles in the same fact type,
+            # we order them by the position of that role in the preferred reading:
+            [role.fact_type.default_reading, role.fact_type.preferred_reading.role_sequence.all_role_ref_in_order.map(&:role).index(role)]
+          end
+
+        # For binary fact types, collect the count of the times the unadorned counterpart role name occurs, so we can adorn it
+        plural_counterpart_counts = roles.inject(Hash.new{0}) do |h, role|
+          next h unless role.fact_type.all_role.size == 2
+          uc = role.all_role_ref.detect do |rr|
+              rs = rr.role_sequence
+              next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
+              rs.all_presence_constraint.detect do |pc|
+                  next false unless pc.max_frequency == 1   # It's a uniqueness constraint
+                  true
+                end
+            end
+          next h if uc  # Not a plural role
+
+          counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
+          h[role_name.call(counterpart_role)] += 1
+          h
+        end
+
+        roles.each do |role|
+          type_name = nil
+          counterpart_name = nil
+
+          if role.fact_type.entity_type and           # Role is in an objectified fact type
+            # For binary objectified fact types, we traverse directly to the other role, not just to the objectification
+            !(role.fact_type.entity_type.all_role.size == 2 and role.fact_type.all_role.size == 2)
+
+            type_name = role.fact_type.entity_type.name
+            counterpart_name = type_name          # If self plays more than one role in OFT, need to construct a role name
+            plural = true
+          elsif role.fact_type.all_role.size == 1
+            # Handle unary roles
+            type_name = 'boolean'
+            counterpart_name = role.fact_type.default_reading
+            plural = false
+          else
+            # Handle binary roles
+            counterpart_role = (role.fact_type.all_role.to_a - [role])[0]
+            type_name = counterpart_role.object_type.name
+            counterpart_name = role_name.call(counterpart_role)
+            # Figure out whether the counterpart is plural (say "all ..." if so)
+            uc = role.all_role_ref.detect do |rr|
+                rs = rr.role_sequence
+                next false if rs.all_role_ref.size != 1   # Looking for a UC over just this one role
+                rs.all_presence_constraint.detect do |pc|
+                    next false unless pc.max_frequency == 1   # It's a uniqueness constraint
+                    true
+                  end
+              end
+            plural = !uc
+            if plural_counterpart_counts[counterpart_name] > 1
+              counterpart_name += " as " + role_name.call(role)
+            end
+          end
+
+          node = {
+            "title" => "#{plural ? 'all ' : ''}#{counterpart_name}",
+            "type" => "#{type_name}",
+            "where" => verbalise_role.call(role, plural),
+            "role_id" => role.concept.guid.to_s
+          }
+          node["is_list"] = true if plural
+          functions << node 
+
+        end
+        functions.size > 0 ? object_type : nil
       end
     end
   end

data/lib/activefacts/generators/ruby.rb

@@ -45,7 +45,7 @@ module ActiveFacts
       end
 
       def emit_mapping o
-	return
+        return
         case @mapping
         when 'sql'
           puts "    table"
@@ -55,11 +55,11 @@ module ActiveFacts
       end
 
       def data_type_dump(o)
-	value_type_dump(o, o.name, {}) if o.all_role.size > 0
+        value_type_dump(o, o.name, {}) if o.all_role.size > 0
       end
 
       def value_type_dump(o, super_type_name, facets)
-	puts o.ruby_definition
+        puts o.ruby_definition
       end
 
       def subtype_dump(o, supertypes, pi = nil)
@@ -124,7 +124,7 @@ module ActiveFacts
       end
 
       def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, counterpart_role_name = nil, counterpart_method_name = nil)
-	puts role.as_binary(role_name, role_player, mandatory, one_to_one, readings, counterpart_role_name, counterpart_method_name)
+        puts role.as_binary(role_name, role_player, mandatory, one_to_one, readings, counterpart_role_name, counterpart_method_name)
       end
 
     end

data/lib/activefacts/generators/scala.rb

@@ -21,8 +21,8 @@ module ActiveFacts
     class Scala < Helpers::OO
 
       def initialize(vocabulary, *options)
-	super
-	@constraints_used = {}
+        super
+        @constraints_used = {}
         @fact_types_dumped = {}
       end
 
@@ -35,14 +35,14 @@ module ActiveFacts
           $stderr.puts "Usage:\t\tafgen --scala[=option,option] input_file.cql\n"+
               "\t\tmeta\t\tModify the mapping to suit a metamodel"
           exit 0
-	when /^meta/
-	  @is_metamodel = true
+        when /^meta/
+          @is_metamodel = true
         else super
         end
       end
 
       def fact_type_name(fact_type)
-	fact_type.default_reading.words
+        fact_type.default_reading.words
       end
 
       def vocabulary_start
@@ -52,7 +52,7 @@ module ActiveFacts
       end
 
       def vocabulary_end
-	puts @vocabulary.scala_finale
+        puts @vocabulary.scala_finale
         puts "#{@metamodel}\n}\n"
       end
 
@@ -60,9 +60,9 @@ module ActiveFacts
       end
 
       def value_type_dump(o, super_type_name, facets)
-	puts o.scala_definition(super_type_name, facets)
+        puts o.scala_definition(super_type_name, facets)
 
-	@metamodel << o.scala_metamodel(super_type_name, facets)
+        @metamodel << o.scala_metamodel(super_type_name, facets)
       end
 
       def id_role_names o, id_roles
@@ -85,57 +85,57 @@ module ActiveFacts
       end
 
       def all_identifying_roles(o)
-	pis = []
-	# This places the subtype identifying roles before the supertype's. Reverse the list to change this.
-	id_roles = []
-	o.supertypes_transitive.each do |supertype|
-	  pi = supertype.preferred_identifier
-	  next if pis.include?(pi)   # Seen this identifier already?
-	  pis << pi
+        pis = []
+        # This places the subtype identifying roles before the supertype's. Reverse the list to change this.
+        id_roles = []
+        o.supertypes_transitive.each do |supertype|
+          pi = supertype.preferred_identifier
+          next if pis.include?(pi)   # Seen this identifier already?
+          pis << pi
           identifying_role_refs = pi.role_sequence.all_role_ref_in_order
-	  identifying_role_refs.each do |id_role_ref|
-	    # Have we seen this role in another identifier?
-	    next if id_roles.detect{|idr| idr == id_role_ref.role }
-	    id_roles << id_role_ref.role
-	  end
-	end
-	[id_roles, pis]
+          identifying_role_refs.each do |id_role_ref|
+            # Have we seen this role in another identifier?
+            next if id_roles.detect{|idr| idr == id_role_ref.role }
+            id_roles << id_role_ref.role
+          end
+        end
+        [id_roles, pis]
       end
 
       def entity_object(o, title_name, id_names, id_types)
-	puts o.scala_object(title_name, id_names, id_types)
+        puts o.scala_object(title_name, id_names, id_types)
       end
 
       def entity_trait(o, title_name, primary_supertype, pis)
-	puts o.scala_trait(title_name, primary_supertype, pis)
+        puts o.scala_trait(title_name, primary_supertype, pis)
       end
 
       def entity_model(o, title_name)
-	@metamodel << o.scala_metamodel(title_name)
+        @metamodel << o.scala_metamodel(title_name)
       end
 
       def non_subtype_dump(o, pi)
-	subtype_dump(o, nil, pi)
+        subtype_dump(o, nil, pi)
       end
 
       def subtype_dump(o, supertypes, pi = nil)
-	if supertypes
-	  primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
-	end
-	title_name = o.name.words.titlecase
+        if supertypes
+          primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
+        end
+        title_name = o.name.words.titlecase
 
-	id_roles, pis = *all_identifying_roles(o)
-	id_names = id_role_names(o, id_roles)
-	id_types = id_role_types(id_roles)
-	identification = pi ? identified_by(o, pi) : nil
+        id_roles, pis = *all_identifying_roles(o)
+        id_names = id_role_names(o, id_roles)
+        id_types = id_role_types(id_roles)
+        identification = pi ? identified_by(o, pi) : nil
 
-	# REVISIT: We don't want an object for abstract classes,
-	# i.e. where subtypes have a disjoint mandatory constraint
-	entity_object(o, title_name, id_names, id_types)
+        # REVISIT: We don't want an object for abstract classes,
+        # i.e. where subtypes have a disjoint mandatory constraint
+        entity_object(o, title_name, id_names, id_types)
 
-	entity_trait(o, title_name, primary_supertype, pis)
+        entity_trait(o, title_name, primary_supertype, pis)
 
-	entity_model(o, title_name)
+        entity_model(o, title_name)
 
         @constraints_used[pi] = true if pi
       end
@@ -149,31 +149,31 @@ module ActiveFacts
       end
 
       def skip_fact_type(f)
-	f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+        f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
       end
 
       # Dump one fact type.
       def fact_type_dump(fact_type, name)
         @fact_types_dumped[fact_type] = true
-	return objectified_fact_type_dump(fact_type.entity_type) if fact_type.entity_type
+        return objectified_fact_type_dump(fact_type.entity_type) if fact_type.entity_type
 
-	puts fact_type.scala_definition
+        puts fact_type.scala_definition
 
-	@metamodel << fact_type.scala_metamodel
+        @metamodel << fact_type.scala_metamodel
       end
 
       def objectified_fact_type_dump o
-	puts o.scala_objectification
-	@metamodel << o.scala_objectification_metamodel
+        puts o.scala_objectification
+        @metamodel << o.scala_objectification_metamodel
       end
 
       def unary_dump(role, role_name)
-	scala_role_name = role_name.words.camelcase
-	puts "    val #{scala_role_name}: Boolean"
+        scala_role_name = role_name.words.camelcase
+        puts "    val #{scala_role_name}: Boolean"
       end
 
       def role_dump(role)
-	puts role.scala_role_definition
+        puts role.scala_role_definition
       end
 
     end