activefacts-generators 1.8.0 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f40edd413e3910347f03b39b1fd1cd36513c15a8
-  data.tar.gz: 0ace4f714d8e1ba990a3d8f81fdf6ac50ec812dd
+  metadata.gz: 1b8cf08b3a5a39113eb4e04697ee25b4f4abdb4f
+  data.tar.gz: aeed8fc142836d0d79321eff69c97b38d016dc45
 SHA512:
-  metadata.gz: 641e9a5ce19aa07e807cde79708ed740ab1b810c913255fe94580fcec9660bdae247f5e49325b39193b3ed2c69e803873730be884c05c82e940eaf5c65b5454b
-  data.tar.gz: 99448103bb436f51228565c94ddc7dd8103f2a014aa4a76bbabdf7844972c97a10fcf0af429f25c16afb1d43a71fd63c29f63f559ea6d1128957c1d952c87a6a
+  metadata.gz: 13ce57f363db35fce13e217a916d17661fcfcd6349c0345d1873d0832a45fff625a5f656eb36cd8e758fb53d93df025234feade6defd6839ce50a9d2c9069f4f
+  data.tar.gz: b3a5c20cb3b066cb77774d88e1b55d3c95053672c079decf4f7f00b79a05e5da89a0c62d46a25a0b6f2ed13c58fe2a9aa1cabcfa0c178702f220db89a59f1e15

data/activefacts-generators.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "activefacts-generators"
-  spec.version       = "1.8.0"
+  spec.version       = "1.8.1"
   spec.authors       = ["Clifford Heath"]
   spec.email         = ["clifford.heath@gmail.com"]
 
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-metamodel", ">= 1.8", "~> 1.8.0"
-  spec.add_runtime_dependency "activefacts-rmap", ">= 1.8", "~> 1.8.0"
+  spec.add_runtime_dependency "activefacts-metamodel", ">= 1.8", "~> 1"
+  spec.add_runtime_dependency "activefacts-rmap", ">= 1.8", "~> 1"
   spec.add_runtime_dependency "activesupport", ">= 4.2", "~> 4.2.4"
 end

data/lib/activefacts/generators/scala.rb

@@ -0,0 +1,184 @@
+#
+#       ActiveFacts Generators.
+#       Generate a Scala module for the ActiveFacts API from an ActiveFacts vocabulary.
+#
+# Copyright (c) 2013 Clifford Heath. Read the LICENSE file.
+#
+require 'activefacts'
+require 'activefacts/metamodel'
+require 'activefacts/generators/helpers/oo'
+require 'activefacts/generators/traits/scala'
+require 'activefacts/registry'
+
+module ActiveFacts
+  module Generators
+    # Generate Scala module containing classes for an ActiveFacts vocabulary.
+    # Invoke as
+    #   afgen --scala[=options] <file>.cql
+    # Options are comma or space separated:
+    # * help list available options
+
+    class Scala < Helpers::OO
+
+      def initialize(vocabulary, *options)
+	super
+	@constraints_used = {}
+        @fact_types_dumped = {}
+      end
+
+    private
+
+      def set_option(option)
+        @mapping = false
+        case option
+        when 'help', '?'
+          $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
+        else super
+        end
+      end
+
+      def fact_type_name(fact_type)
+	fact_type.default_reading.words
+      end
+
+      def vocabulary_start
+        puts @vocabulary.scala_prelude
+
+        @metamodel = @vocabulary.scala_prelude_metamodel
+      end
+
+      def vocabulary_end
+	puts @vocabulary.scala_finale
+        puts "#{@metamodel}\n}\n"
+      end
+
+      def data_type_dump(o)
+      end
+
+      def value_type_dump(o, super_type_name, facets)
+	puts o.scala_definition(super_type_name, facets)
+
+	@metamodel << o.scala_metamodel(super_type_name, facets)
+      end
+
+      def id_role_names o, id_roles
+        id_roles.map do |role|
+          # Ignore identification through a supertype
+          next if role.fact_type.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
+          role.preferred_role_name(o).words.camelcase
+        end.compact
+      end
+
+      def id_role_types id_roles
+        id_roles.map do |role|
+          next if role.fact_type.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
+          if !role.fact_type.entity_type && role.fact_type.all_role.size == 1
+            "Boolean"
+          else
+           role.object_type.name.words.titlecase
+          end
+        end.compact
+      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
+          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]
+      end
+
+      def entity_object(o, 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)
+      end
+
+      def entity_model(o, title_name)
+	@metamodel << o.scala_metamodel(title_name)
+      end
+
+      def non_subtype_dump(o, 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
+
+	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)
+
+	entity_trait(o, title_name, primary_supertype, pis)
+
+	entity_model(o, title_name)
+
+        @constraints_used[pi] = true if pi
+      end
+
+      def identified_by_roles_and_facts(entity_type, identifying_role_refs, identifying_facts)
+        identifying_role_refs.map do |role_ref|
+            [ role_ref.role.scala_preferred_role_name(entity_type),
+              entity_type.name.words.titlecase
+            ]
+          end
+      end
+
+      def skip_fact_type(f)
+	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
+
+	puts fact_type.scala_definition
+
+	@metamodel << fact_type.scala_metamodel
+      end
+
+      def objectified_fact_type_dump o
+	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"
+      end
+
+      def role_dump(role)
+	puts role.scala_role_definition
+      end
+
+    end
+  end
+end
+
+ActiveFacts::Registry.generator('scala', ActiveFacts::Generators::Scala)
+

data/lib/activefacts/generators/traits/scala.rb

@@ -0,0 +1,442 @@
+#
+#       ActiveFacts Generators.
+#
+# Metamodel Traits for mapping to Scala
+#
+# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
+#
+module ActiveFacts
+  module Generators
+    module ScalaTraits
+      module Vocabulary
+	def scala_prelude
+	  title_name = name.words.titlecase
+
+	  "package model\n"+
+	  "\n"+
+	  "import scala.language.implicitConversions\n" +
+	  "\n" +
+	  "object #{title_name} extends LocalStorageConstellation with #{title_name}\n" +
+	  "\n" +
+	  "trait #{title_name} extends Model {\n" +
+	  # REVISIT: I think this next line should be model, not metaModel
+	  "  val metaModel = new #{title_name}Model()\n" +
+	  "\n"
+	end
+
+	def scala_prelude_metamodel
+	  title_name = name.words.titlecase
+	  "class #{title_name}Model extends FBMModel with LocalStorageConstellation {\n" +
+	  "  implicit val constellation: Constellation = this\n"
+	end
+
+	def scala_finale
+	  "}\n"+
+	  "\n"
+	end
+      end
+
+      module ObjectType
+	# Map the ObjectType name to a Scala class name
+	def scala_type_name
+	  oo_type_name
+	end
+
+	# Map the Scala class name to a default role name
+	def scala_default_role_name
+	  oo_default_role_name
+	end
+
+        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.scala_preferred_role_name(self) + ':' + role.scala_preferred_role_name(r.object_type)
+            end
+        end
+      end
+
+      module Role
+        def scala_preferred_role_name(is_for = nil, &name_builder)
+	  # REVISIT: Modify this to suit Scala
+
+	  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 scala_role_definition
+	  return if fact_type.entity_type
+
+	  if fact_type.all_role.size == 1
+	    scala_role_name = scala_preferred_role_name.words.camelcase
+	    return "    val #{scala_role_name}: Boolean"
+	  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
+
+	  return if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+
+	  other_role = fact_type.all_role.select{|r| r != self}[0]
+	  other_role_name = other_role.scala_preferred_role_name
+	  scala_role_name = other_role_name.words.camelcase
+	  other_type_name = other_role.object_type.name.words.titlecase
+
+	  if is_functional
+	    if is_mandatory
+	      # Define a getter for a mandatory value:
+	      "    val #{scala_role_name}: #{other_type_name}"
+	      if !fact_type.is_existential
+		"    def #{scala_role_name}_=(_value: #{other_type_name}) = { #{scala_role_name} = _value }"
+	      end
+	    else
+	      # Define a getter for an optional value:
+	      # REVISIT: The role number here depends on the metamodel ordering of the fact type roles.
+	      # This likely should follow the role order of the preferred reading, from which the fact name is derived.
+	      # The code here collows the order of definition of the roles in the fact type,
+	      # which might not be the same as the order of the preferred reading:
+	      fact_name = fact_type.scala_name.titlecase
+	      role_number = fact_type.all_role_in_order.index(other_role)+1
+
+	      "    def #{scala_role_name}: Option[#{other_type_name}] = {\n" +
+	      "      constellation.getBinaryFact(metaModel.#{fact_name.words.camelcase}, this).map(x => {\n" +
+	      "        x.head.asInstanceOf[FBMModel.BinaryFact].rolePlayers._#{role_number}.asInstanceOf[#{other_type_name}]\n" +
+	      "      })\n" +
+	      "    }\n" +
+	      if !fact_type.is_existential
+		# Define a setter for an optional value:
+		"    def #{scala_role_name}_=(value: Option[#{other_type_name}]) = {\n" +
+		"      value match {\n" +
+		"        case None =>\n" +
+		"        case Some(m) => constellation.assertBinaryFact(#{fact_name.words.titlecase}(this, m))\n" +
+		"      }\n" +
+		"    }"
+	      else
+		''
+	      end
+	    end
+	  elsif other_role.object_type.fact_type
+	    # An objectified fact type
+	    <<"END"
+      def all#{scala_role_name.words.titlecase}(implicit constellation: Constellation): Seq[#{other_type_name}] = {
+	constellation.getObjectifiedFact(metaModel.#{scala_role_name.words.camelcase}, this).getOrElse(Nil).flatMap(x => x match {
+	  case o: #{other_type_name} => Some(o)
+	  case _ => None
+	})
+      }
+END
+	  else
+	    <<"END"
+      /*
+      def all#{scala_role_name.words.titlecase}(implicit constellation: Constellation): Seq[#{other_type_name}] = {
+	constellation.getFact(metaModel.#{scala_role_name.words.camelcase}, this).getOrElse(Nil).flatMap(x => x match {
+	  # REVISIT: This is incorrect; we want to return the other role player in the fact
+	  case o: #{other_type_name} => Some(o)
+	  case _ => None
+	})
+      }
+      */
+END
+	  end
+	end
+      end
+
+      module ValueType
+	DataTypeMap = {
+	  "Signed Integer" => "Int",
+	  "Unsigned Integer" => "Int",
+	  "Real" => "Double",
+	  "Char" => "String",
+	  # REVISIT: More will be needed here.
+	}
+	LengthTypes = [ "String", "Decimal" ]
+	ScaleTypes = [ "Decimal" ]
+
+	def scala_definition(super_type_name, facets)
+	  vt_name = name.words.titlecase
+	  if d = DataTypeMap[super_type_name]
+	    super_type_name = d
+	  end
+	  super_type_title = super_type_name.words.titlecase
+	  super_type_camel = super_type_name.words.camelcase
+
+	  sometimes_optional =  all_role.detect do |r|
+	    r.fact_type.all_role.size == 2 && (c = (r.fact_type.all_role.to_a-[r])[0]) and !c.is_mandatory
+	  end
+
+	  "  case class #{vt_name}(value: #{super_type_title})(implicit val constellation: Constellation) extends FBMModel.ValueTypeValue[#{super_type_title}] {\n" +
+	  "    val objectType = metaModel.#{vt_name.words.camelcase}\n" +
+#	  REVISIT: scala_type_params +
+#	  REVISIT: scala_value_restriction + # puts "    restrict #{value_constraint.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" if value_constraint
+#	  REVISIT: scala_units +  # puts "    \# REVISIT: #{vt_name} is in units of #{unit.name}\n" if unit
+	  absorbed_roles.map do |role|
+            role.scala_role_definition
+          end.
+          compact*"\n" +
+	  "  }\n" +
+
+	  # Add implicit casts for the underlying data type:
+	  "  implicit def #{super_type_camel}2#{vt_name}(value: #{super_type_title})(implicit constellation: Constellation): #{vt_name} = #{vt_name}(value)\n" +
+	  if sometimes_optional
+	    "  implicit def #{super_type_camel}2#{vt_name}Option(value: #{super_type_title})(implicit constellation: Constellation): Option[#{vt_name}] = Some(#{vt_name}(value))\n"
+	  else
+	    ""
+	  end +
+	  "\n"
+	end
+
+	def scala_metamodel(super_type_name, facets)
+	  vt_name = name.words.titlecase
+	  super_type_title = super_type_name.words.titlecase
+	  # REVISIT: Remove facets that do not apply to the Scala data types
+	  params = [
+	    LengthTypes.include?(super_type_name) ? facets[:length] : nil,
+	    ScaleTypes.include?(super_type_name) ? facets[:scale] : nil
+	  ].compact * ", "
+
+	  "  val #{name.words.camelcase} = assertEntity(FBMModel.ValueType(FBMModel.DomainObjectTypeName(\"#{vt_name}\"), FBMModel.#{super_type_title}Type(#{params}), Nil))\n"
+	end
+      end
+
+      module EntityType
+	def scala_object(title_name, id_names, id_types)
+	  "  object #{title_name} {\n" +
+	  "    def apply(" +
+	    (id_names.zip(id_types).map do |(name, type_name)|
+	      "#{name}: #{type_name}"
+	    end * ', '
+	    ) +
+	  ")(implicit constellation: Constellation) = {\n" +
+
+	  # Define the constant storage for the identifying role values:
+	  id_names.map do |name|
+	    "      val _#{name} = #{name}"
+	  end*"\n" +
+	  "      val _constellation = constellation\n" +
+	  "      assertEntity(new #{title_name} {\n" +
+	    id_names.map do |name|
+	      "        val #{name} = _#{name}"
+	    end*"\n" +
+	  "        val constellation = _constellation\n" +
+	  "      })\n" +	# Ends new block and assertEntity
+	  "    }\n" +		# Ends apply()
+	  "  }\n" +		# Ends object{} 
+	  "\n"
+	end
+
+	def scala_trait(title_name, primary_supertype, pis)
+	  s = 'override ' unless supertypes.empty?
+
+	  "  trait #{title_name} extends #{primary_supertype ? primary_supertype.name.words.titlecase : 'FBMModel.Entity'} {\n" +
+	  "    #{s}val objectType = metaModel.#{name.words.camelcase}\n" +
+	  (fact_type ? "  // REVISIT: Here, we should use fact_roles_dump(fact_type)\n\n" : '') +
+	  absorbed_roles.map do |role|
+            role.scala_role_definition
+          end.
+          compact*"\n" +
+	  "    #{s}val identifier: Seq[Seq[FBMModel.Identifier[_]]] = Seq(#{
+	    pis.map do |pi|
+	      'Seq(' +
+		pi.role_sequence.all_role_ref_in_order.map do |id_role_ref|
+		  id_role_ref.role.object_type.name.words.camelcase
+		end*', ' +
+	      ')'
+	    end*', '
+	  })\n" +
+	  "  }\n" +		# Ends trait{}
+	  "\n"
+	end
+
+	def scala_metamodel(title_name)
+	  pi = preferred_identifier
+	  # The following finds the closest non-inheritance identifier
+	  #while pi.role_sequence.all_role_ref.size == 1 and
+	  #    (role = pi.role_sequence.all_role_ref.single.role).fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+	  #  pi = role.fact_type.supertype_role.object_type.preferred_identifier
+	  #end
+	  identifying_parameters =
+	    pi.role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type.name.words.camelcase }*', '
+
+	  supertypes_list =
+	    if supertypes.empty?
+	      'Nil'
+	    else
+	      "List(#{supertypes.map{|s| s.name.words.camelcase}*', '})"
+	    end
+	  "  val #{name.words.camelcase} = assertEntity(FBMModel.EntityType(FBMModel.DomainObjectTypeName(\"#{title_name}\"), #{supertypes_list}, Seq(#{identifying_parameters})))\n"
+	end
+
+	def scala_shared(o, supertypes, pi = nil)
+	  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
+
+	  # REVISIT: We don't want an object for abstract classes,
+	  # i.e. where subtypes have a disjoint mandatory constraint
+	  entity_object(title_name, id_names, id_types)
+
+	  entity_trait(o, title_name, primary_supertype, pis)
+
+	  entity_model(o, title_name)
+	end
+
+	def id_role_names id_roles
+	  id_roles.map do |role|
+	    # Ignore identification through a supertype
+	    next if role.fact_type.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
+	    role.scala_preferred_role_name(self).words.camelcase
+	  end.compact
+	end
+
+	def id_role_types id_roles
+	  id_roles.map do |role|
+	    next if role.fact_type.kind_of?(ActiveFacts::Metamodel::TypeInheritance)
+	    if !role.fact_type.entity_type && role.fact_type.all_role.size == 1
+	      "Boolean"
+	    else
+	      role.object_type.name.words.titlecase
+	    end
+	  end.compact
+	end
+
+	def scala_objectification
+	  # REVISIT: This disregards any supertypes and their identifiers
+  #       primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
+  #       secondary_supertypes = o.supertypes-[primary_supertype]
+
+	  pi = preferred_identifier
+	  id_roles = []
+	  identifying_role_refs = pi.role_sequence.all_role_ref_in_order
+	  identifying_role_refs.each do |id_role_ref|
+	    id_roles << id_role_ref.role
+	  end
+	  id_names = id_role_names id_roles
+	  id_types = id_role_types id_roles
+
+	  "  case class #{name.words.titlecase}(#{
+	    id_names.zip(id_types).map {|(n, t)|
+	      "#{n}: #{t}"
+	    }*', '
+	  }) extends FBMModel.ObjectifiedFact {\n" +
+	  "    // REVISIT: Here, we should use fact_roles_dump(fact_type)\n" +
+	  absorbed_roles.map do |role|
+            role.scala_role_definition
+          end.
+          compact*"\n" +
+	  "  }"
+	end
+
+	def scala_objectification_metamodel
+	  identifying_parameters = preferred_identifier.role_sequence.all_role_ref_in_order.map{|rr| rr.role.object_type.name.words.camelcase }*', '
+	  "  val #{name.words.camelcase} = assertEntity(FBMModel.ObjectifiedType(FBMModel.DomainObjectTypeName(\"#{name.words.titlecase}\"), Nil, Seq(#{identifying_parameters})))\n"
+	end
+      end
+
+      module FactType
+        def scala_name
+          default_reading.words
+        end
+
+        def scala_definition
+          # Dump a non-objectified fact type
+          name_words = scala_name
+          role_names = preferred_reading.role_sequence.all_role_ref_in_order.map do |rr|
+              rr.role.scala_preferred_role_name.words.camelcase
+            end
+          role_types = preferred_reading.role_sequence.all_role_ref_in_order.map do |rr|
+              rr.role.object_type.name.words.camelcase
+            end
+
+          "  case class #{name_words.titlecase}(#{role_names.zip(role_types).map{|n, t| n+': '+t}*', '})(implicit val constellation: Constellation) extends FBMModel.BinaryFact {\n" +
+          "    def factType = metaModel.#{name_words.camelcase}\n" +
+          "    def rolePlayers = (#{role_names*', '})\n" +
+          "  }\n\n"
+        end
+
+        def scala_metamodel
+          name_words = scala_name
+          role_names = preferred_reading.role_sequence.all_role_ref_in_order.map do |rr|
+              rr.role.scala_preferred_role_name.words.camelcase
+            end
+          "  val #{name_words.camelcase} = assertEntity(FBMModel.BinaryFactType(FBMModel.FactTypeName(\"#{name_words.titlecase}\"), (#{role_names*', '})))\n"
+        end
+
+        # 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.scala_preferred_role_name(entity_type)
+	  end.
+	  map do |role| 
+	    role_name = role.scala_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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activefacts-generators
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.8.1
 platform: ruby
 authors:
 - Clifford Heath
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2015-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,7 +67,7 @@ dependencies:
         version: '1.8'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -77,7 +77,7 @@ dependencies:
         version: '1.8'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: activefacts-rmap
   requirement: !ruby/object:Gem::Requirement
@@ -87,7 +87,7 @@ dependencies:
         version: '1.8'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -97,7 +97,7 @@ dependencies:
         version: '1.8'
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.8.0
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +150,7 @@ files:
 - lib/activefacts/generators/rails/models.rb
 - lib/activefacts/generators/rails/schema.rb
 - lib/activefacts/generators/ruby.rb
+- lib/activefacts/generators/scala.rb
 - lib/activefacts/generators/sql/mysql.rb
 - lib/activefacts/generators/sql/server.rb
 - lib/activefacts/generators/stats.rb
@@ -158,6 +159,7 @@ files:
 - lib/activefacts/generators/traits/oo.rb
 - lib/activefacts/generators/traits/ordered.rb
 - lib/activefacts/generators/traits/ruby.rb
+- lib/activefacts/generators/traits/scala.rb
 - lib/activefacts/generators/transform/datavault.rb
 - lib/activefacts/generators/transform/surrogate.rb
 - lib/activefacts/registry.rb