module ActiveFacts::Generators::ScalaTraits::Role
Public Instance Methods
scala_preferred_role_name(is_for = nil, &name_builder)
click to toggle source
# File lib/activefacts/generators/traits/scala.rb, line 64 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
scala_role_definition()
click to toggle source
# File lib/activefacts/generators/traits/scala.rb, line 113 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