activefacts 0.8.18 → 1.0.0

data/lib/activefacts/cql/LexicalRules.treetop

@@ -158,7 +158,7 @@ module ActiveFacts
       end
 
       rule alpha
-	[[:alpha:]]
+	[[:alpha:]_]
       end
 
       rule alphanumeric

data/lib/activefacts/cql/compiler.rb

@@ -96,7 +96,7 @@ module ActiveFacts
         saved_string = @string
         saved_input_length = @input_length
         old_filename = @filename
-        @filename = file+'.cql'   # REVISIT: Use File.dirname(@filename)+@filename ?
+        @filename = File.dirname(old_filename)+'/'+file+'.cql'
 
         # REVISIT: Save and use another @vocabulary for this file?
         File.open(@filename) do |f|

data/lib/activefacts/cql/compiler/clause.rb

@@ -232,26 +232,13 @@ module ActiveFacts
               candidate_fact_types =
                 start_obj.map do |related_type|
                   related_type.all_role.select do |role|
-                    all_roles = role.fact_type.all_role
-                    next if all_roles.size != players.size      # Wrong number of players
+                    # next if role.fact_type.all_reading.size == 0
                     next if role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
+                    next if role.fact_type.all_role.size != players.size      # Wrong number of players
 
-                    all_players = all_roles.map{|r| r.object_type}  # All the players of this candidate fact type
-
-                    next if player_related_types[1..-1].        # We know the first player is compatible, check the rest
-                      detect do |player_types|                  # Make sure that there remains a compatible player
-                        # player_types is an array of the types compatible with the Nth player
-                        compatible_player = nil
-                        all_players.each_with_index do |p, i|
-                          if player_types.include?(p)
-                            compatible_player = p
-                            all_players.delete_at(i)
-                            break
-                          end
-                        end
-                        !compatible_player
-                      end
-
+		    compatible_readings = role.fact_type.compatible_readings(player_related_types)
+		    next unless compatible_readings.size > 0
+		    debug :matching_fails, "These readings are compatible: #{compatible_readings.map(&:expand).inspect}"
                     true
                   end.
                     map{ |role| role.fact_type}
@@ -419,9 +406,14 @@ module ActiveFacts
               if la = role_ref.leading_adjective and !la.empty?
                 # The leading adjectives must match, one way or another
                 la = la.split(/\s+/)
-                # We may have hyphenated adjectives. Break them up to check:
-                iw = intervening_words.map{|w| w.split(/-/)}.flatten
-                return nil unless la[0,iw.size] == iw
+		if (la[0, intervening_words.size] == intervening_words)		# Exact match
+		  iw = intervening_words
+		else
+		  # We may have hyphenated adjectives. Break them up to check:
+		  iw = intervening_words.map{|w| w.split(/-/)}.flatten
+		  return nil unless la[0,iw.size] == iw
+		end
+
                 # Any intervening_words matched, see what remains
                 la.slice!(0, iw.size)
 
@@ -593,7 +585,7 @@ module ActiveFacts
           debug :matching, "Making new fact type for #{@phrases.inspect}" do
             @phrases.each do |phrase|
               next unless phrase.respond_to?(:player)
-              phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :object_type => phrase.player, :guid => :new)
+              phrase.role = vocabulary.constellation.Role(fact_type, fact_type.all_role.size, :object_type => phrase.player, :concept => :new)
               phrase.role.role_name = phrase.role_name if phrase.role_name && phrase.role_name.is_a?(String)
             end
           end
@@ -801,7 +793,7 @@ module ActiveFacts
           @negated = negated
         end
 
-        def to_s
+        def inspect
           'side-effects are [' +
             @role_side_effects.map{|r| r.to_s}*', ' +
             ']' +
@@ -1035,7 +1027,7 @@ module ActiveFacts
                   :max_frequency => @quantifier.max,
                   :min_frequency => @quantifier.min
                 )
-              debug :constraint, "Made new embedded PC GUID=#{constraint.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
+              debug :constraint, "Made new embedded PC GUID=#{constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{(e = fact_type.entity_type) ? e.name : role_sequence.describe} in #{fact_type.describe}"
               @quantifier.enforcement.compile(constellation, constraint) if @quantifier.enforcement
               @embedded_presence_constraint = constraint
             end

data/lib/activefacts/cql/compiler/constraint.rb

@@ -28,7 +28,7 @@ module ActiveFacts
               :context_note_kind => @context_kind,
               :discussion => @discussion
             )
-          context_note.relevant_concept = target
+          context_note.relevant_concept = target.concept
           if @agreed_date || @agreed_agents
             agreement = constellation.Agreement(context_note)
             agreement.date = @agreed_date if @agreed_date
@@ -226,7 +226,7 @@ module ActiveFacts
               :is_mandatory => @quantifier.min && @quantifier.min > 0
             )
           @enforcement.compile(@constellation, @constraint) if @enforcement
-	  debug :constraint, "Made new PC GUID=#{@constraint.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{role_sequence.describe}"
+	  debug :constraint, "Made new PC GUID=#{@constraint.concept.guid} min=#{@quantifier.min.inspect} max=#{@quantifier.max.inspect} over #{role_sequence.describe}"
           super
         end
 
@@ -461,7 +461,7 @@ module ActiveFacts
             raise "ambiguous #{@rings*' '} ring constraint, consider #{role_pairs.map{|rp| "#{rp[0].inspect}<->#{rp[1].inspect}"}*', '}"
           end
           if role_pairs.size == 0
-            raise "No matching role pair found for #{@rings*' '} ring constraint"
+            raise "No matching role pair found for #{@rings*' '} ring constraint over #{role_refs.map(&:role).map(&:object_type).map(&:name).inspect}"
           end
 
           rp = role_pairs[0]
@@ -483,7 +483,7 @@ module ActiveFacts
               :ring_type => ring_type
             )
 
-          debug :constraint, "Added #{@constraint.verbalise} #{@constraint.class.roles.keys.map{|k|"#{k} => "+@constraint.send(k).verbalise}*", "}"
+          debug :constraint, "Added #{@constraint.verbalise}"
           super
         end
 

data/lib/activefacts/cql/compiler/entity_type.rb

@@ -30,7 +30,7 @@ module ActiveFacts
 
         def compile
           @entity_type = @vocabulary.valid_entity_type_name(@name) ||
-	    @constellation.EntityType(@vocabulary, @name, :guid => :new)
+	    @constellation.EntityType(@vocabulary, @name, :concept => :new)
           @entity_type.is_independent = true if (@pragmas.include? 'independent')
 
           # REVISIT: CQL needs a way to indicate whether subtype migration can occur.
@@ -122,7 +122,7 @@ module ActiveFacts
           if (pc)
             pc.is_preferred_identifier = true
             pc.name = "#{@entity_type.name}PK" unless pc.name
-            debug "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name} #{pc.class.roles.keys.map{|k|"#{k} => "+pc.send(k).verbalise}*", "}"
+            debug "Existing PC #{pc.verbalise} is now PK for #{@entity_type.name}"
           else
             # Add a unique constraint over all identifying roles
             pc = @constellation.PresenceConstraint(
@@ -135,7 +135,7 @@ module ActiveFacts
                 #:is_mandatory => true,
                 #:min_frequency => 1,
               )
-	    debug :constraint, "Made new preferred PC GUID=#{pc.guid} min=nil max=1 over #{role_sequence.describe}"
+	    debug :constraint, "Made new preferred PC GUID=#{pc.concept.guid} min=nil max=1 over #{role_sequence.describe}"
           end
         end
 
@@ -220,7 +220,7 @@ module ActiveFacts
               :is_preferred_identifier => false,  # We only get here when there is a reference mode on the entity type
               :max_frequency => 1
             )
-	    debug :constraint, "Made new objectification PC GUID=#{pc.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
+	    debug :constraint, "Made new objectification PC GUID=#{pc.concept.guid} min=nil max=1 over #{fact_type.preferred_reading.role_sequence.describe}"
           end
 
           @fact_type = @entity_type.fact_type = fact_type
@@ -231,7 +231,7 @@ module ActiveFacts
         def add_supertype(supertype_name, not_identifying)
           debug :supertype, "Adding #{not_identifying ? '' : 'identifying '}supertype #{supertype_name} to #{@entity_type.name}" do
             supertype = @vocabulary.valid_entity_type_name(supertype_name) ||
-	      @constellation.EntityType(@vocabulary, supertype_name, :guid => :new) # Should always already exist
+	      @constellation.EntityType(@vocabulary, supertype_name, :concept => :new) # Should always already exist
 
             # Did we already know about this supertyping?
             return if @entity_type.all_type_inheritance_as_subtype.detect{|ti| ti.supertype == supertype}
@@ -239,15 +239,15 @@ module ActiveFacts
             # By default, the first supertype identifies this entity type
             is_identifying_supertype = !not_identifying && @entity_type.all_type_inheritance_as_subtype.size == 0
 
-            inheritance_fact = @constellation.TypeInheritance(@entity_type, supertype, :guid => :new)
+            inheritance_fact = @constellation.TypeInheritance(@entity_type, supertype, :concept => :new)
 
             assimilations = @pragmas.select { |p| ['absorbed', 'separate', 'partitioned'].include? p}
             raise "Conflicting assimilation pragmas #{assimilations*', '}" if assimilations.size > 1
             inheritance_fact.assimilation = assimilations[0]
 
             # Create a reading:
-            sub_role = @constellation.Role(inheritance_fact, 0, :object_type => @entity_type, :guid => :new)
-            super_role = @constellation.Role(inheritance_fact, 1, :object_type => supertype, :guid => :new)
+            sub_role = @constellation.Role(inheritance_fact, 0, :object_type => @entity_type, :concept => :new)
+            super_role = @constellation.Role(inheritance_fact, 1, :object_type => supertype, :concept => :new)
 
             rs = @constellation.RoleSequence(:new)
             @constellation.RoleRef(rs, 0, :role => sub_role)
@@ -275,7 +275,7 @@ module ActiveFacts
             pc1.min_frequency = 1
             pc1.max_frequency = 1
             pc1.is_preferred_identifier = false
-	    debug :constraint, "Made new subtype PC GUID=#{pc1.guid} min=1 max=1 over #{p1rs.describe}"
+	    debug :constraint, "Made new subtype PC GUID=#{pc1.concept.guid} min=1 max=1 over #{p1rs.describe}"
 
             p2rs = @constellation.RoleSequence(:new)
             constellation.RoleRef(p2rs, 0).role = super_role
@@ -288,7 +288,7 @@ module ActiveFacts
             # The supertype role often identifies the subtype:
             pc2.is_preferred_identifier = inheritance_fact.provides_identification
 	    debug :supertype, "identification of #{@entity_type.name} via supertype #{supertype.name} was #{inheritance_fact.provides_identification ? '' : 'not '}added"
-	    debug :constraint, "Made new supertype PC GUID=#{pc2.guid} min=1 max=1 over #{p2rs.describe}"
+	    debug :constraint, "Made new supertype PC GUID=#{pc2.concept.guid} min=1 max=1 over #{p2rs.describe}"
           end
         end
 
@@ -301,8 +301,8 @@ module ActiveFacts
             unless vt = @vocabulary.valid_object_type_name(vt_name) or
 		   vt = @vocabulary.valid_object_type_name(vt_name = "#{name} #{mode}")
               base_vt = @vocabulary.valid_value_type_name(mode) ||
-		  @constellation.ValueType(@vocabulary, mode, :guid => :new)
-              vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt, :guid => :new)
+		  @constellation.ValueType(@vocabulary, mode, :concept => :new)
+              vt = @constellation.ValueType(@vocabulary, vt_name, :supertype => base_vt, :concept => :new)
               if parameters
                 length, scale = *parameters
                 vt.length = length if length
@@ -335,8 +335,8 @@ module ActiveFacts
           unless fact_type
             fact_type = @constellation.FactType(:new)
             fact_types << fact_type
-            entity_role = @constellation.Role(fact_type, 0, :object_type => @entity_type, :guid => :new)
-            identifying_role = @constellation.Role(fact_type, 1, :object_type => identifying_type, :guid => :new)
+            entity_role = @constellation.Role(fact_type, 0, :object_type => @entity_type, :concept => :new)
+            identifying_role = @constellation.Role(fact_type, 1, :object_type => identifying_type, :concept => :new)
           end
           @identification[0].role = identifying_role
 
@@ -403,7 +403,7 @@ module ActiveFacts
               :is_preferred_identifier => false,
               :is_mandatory => true
             )
-	    debug :constraint, "Made new refmode PC GUID=#{constraint.guid} min=1 max=1 over #{rs0.describe}"
+	    debug :constraint, "Made new refmode PC GUID=#{constraint.concept.guid} min=1 max=1 over #{rs0.describe}"
           else
             debug :mode, "Using existing EntityType PresenceConstraint"
           end
@@ -431,7 +431,7 @@ module ActiveFacts
               :is_preferred_identifier => true,
               :is_mandatory => false
             )
-	    debug :constraint, "Made new refmode ValueType PC GUID=#{constraint.guid} min=0 max=1 over #{rs1.describe}"
+	    debug :constraint, "Made new refmode ValueType PC GUID=#{constraint.concept.guid} min=0 max=1 over #{rs1.describe}"
           else
             debug :mode, "Marking existing ValueType PresenceConstraint as preferred"
             rs1.all_presence_constraint.single.is_preferred_identifier = true

data/lib/activefacts/cql/compiler/expression.rb

@@ -93,7 +93,7 @@ module ActiveFacts
           vocabulary = context.vocabulary
           constellation = vocabulary.constellation
 	  vocabulary.valid_value_type_name(name) ||
-	    constellation.ValueType(vocabulary, name, :guid => :new)
+	    constellation.ValueType(vocabulary, name, :concept => :new)
         end
 
         def is_naked_object_type
@@ -194,7 +194,7 @@ module ActiveFacts
             v = context.vocabulary
             @boolean ||=
 	      v.constellation.ValueType[[[v.name], 'Boolean']] ||
-	      v.constellation.ValueType(v, 'Boolean', :guid => :new)
+	      v.constellation.ValueType(v, 'Boolean', :concept => :new)
             @player = @boolean
           end
         end
@@ -337,7 +337,7 @@ module ActiveFacts
             # REVISIT: Calculate the units of the result from the units in @divisor
             # REVISIT: Do we want integer division?
             v = context.vocabulary
-            @player = v.constellation.ValueType(v, 'Real', :guid => :new)
+            @player = v.constellation.ValueType(v, 'Real', :concept => :new)
           end
         end
 

data/lib/activefacts/cql/compiler/fact.rb

@@ -10,7 +10,7 @@ module ActiveFacts
 
         def compile
           @population = @constellation.Population[[@vocabulary.identifying_role_values, @population_name]] ||
-	      @constellation.Population(@vocabulary, @population_name, :guid => :new)
+	      @constellation.Population(@vocabulary, @population_name, :concept => :new)
 
           @context = CompilationContext.new(@vocabulary)
           @context.bind @clauses

data/lib/activefacts/cql/compiler/fact_type.rb

@@ -97,7 +97,7 @@ module ActiveFacts
           if @name
 	    entity_type = @vocabulary.valid_entity_type_name(@name)
             raise "You can't objectify #{@name}, it already exists" if entity_type
-            @entity_type = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type, :guid => :new)
+            @entity_type = @constellation.EntityType(@vocabulary, @name, :fact_type => @fact_type, :concept => :new)
 	  end
 
           prepare_roles @clauses
@@ -286,15 +286,23 @@ module ActiveFacts
 	  debug :constraint, "Need to check #{@fact_type.default_reading.inspect} for a uniqueness constraint"
           fact_type.check_and_add_spanning_uniqueness_constraint = proc do
 	    debug :constraint, "Checking #{@fact_type.default_reading.inspect} for a uniqueness constraint"
-            if !@fact_type.all_role.
+	    existing_pc = nil
+            found = @fact_type.all_role.
 		detect do |role|
                   role.all_role_ref.detect do |rr|
                     # This RoleSequence, to be relevant, must only reference roles of this fact type
                     rr.role_sequence.all_role_ref.all? {|rr2| rr2.role.fact_type == @fact_type} and
                     # The RoleSequence must have at least one uniqueness constraint
-                    rr.role_sequence.all_presence_constraint.detect{|pc| pc.max_frequency == 1}
+                    rr.role_sequence.all_presence_constraint.detect do |pc|
+		      if pc.max_frequency == 1
+			existing_pc = pc
+		      end
+		    end
 		  end
                 end
+	    true  # A place for a breakpoint
+
+            if !found
 	      # There's no existing uniqueness constraint over the roles of this fact type. Add one
 	      pc = @constellation.PresenceConstraint(
 		:new,
@@ -304,7 +312,9 @@ module ActiveFacts
 		:max_frequency => 1,
 		:is_preferred_identifier => true # (prefer || !!@fact_type.entity_type)
 	      )
-	      debug :constraint, "Made new fact type implicit PC GUID=#{pc.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
+	      debug :constraint, "Made new fact type implicit PC GUID=#{pc.concept.guid} #{pc.name} min=nil max=1 over #{rs.describe}"
+	    elsif pc
+	      debug :constraint, "Will rely on existing UC GUID=#{pc.concept.guid} #{pc.name} to be used as PI over #{rs.describe}"
             end
 	  end
         end

data/lib/activefacts/cql/compiler/shared.rb

@@ -65,7 +65,7 @@ module ActiveFacts
 
           if !player && @allowed_forward_terms.include?(name)
 	    @vocabulary.valid_entity_type_name(name)  # No need for the result here, just no exceptional condition
-            player = constellation.EntityType(@vocabulary, name, :guid => :new)
+            player = constellation.EntityType(@vocabulary, name, :concept => :new)
           end
 
           player

data/lib/activefacts/cql/compiler/value_type.rb

@@ -104,14 +104,14 @@ module ActiveFacts
           base_type = nil
           if (@base_type_name != @name)
 	    unless base_type = @vocabulary.valid_value_type_name(@base_type_name)
-              base_type = @constellation.ValueType(@vocabulary, @base_type_name, :guid => :new)
+              base_type = @constellation.ValueType(@vocabulary, @base_type_name, :concept => :new)
               return base_type if @base_type_name == @name
             end
           end
 
           # Create and initialise the ValueType:
 	  vt = @vocabulary.valid_value_type_name(@name) ||
-	    @constellation.ValueType(@vocabulary, @name, :guid => :new)
+	    @constellation.ValueType(@vocabulary, @name, :concept => :new)
           vt.is_independent = true if (@pragmas.include? 'independent')
           vt.supertype = base_type if base_type
           vt.length = length if length

data/lib/activefacts/generate/cql.rb

@@ -42,40 +42,15 @@ module ActiveFacts
         puts "\n"
       end
 
-      def value_type_dump(o)
-        # Ignore Value Types that don't do anything:
-        return if
-          !o.supertype &&
-          o.all_role.size == 0 &&
-          !o.is_independent &&
-          !o.value_constraint &&
-          o.all_context_note_as_relevant_concept.size == 0 &&
-          o.all_instance.size == 0
+      def data_type_dump(o)
+	value_type_dump(o, o.name, {}) if o.all_role.size > 0
+      end
+
+      def value_type_dump(o, super_type_name, facets)
         # No need to dump it if the only thing it does is be a supertype; it'll be created automatically
         # return if o.all_value_type_as_supertype.size == 0
 
-=begin
-        # Leave this out, pending a proper on-demand system for dumping VT's
-        # A ValueType that is only used as a reference mode need not be emitted here.
-        if o.all_value_type_as_supertype.size == 0 &&
-          !o.all_role.
-            detect do |role|
-              (other_roles = role.fact_type.all_role.to_a-[role]).size != 1 ||      # Not a role in a binary FT
-              !(object_type = other_roles[0].object_type).is_a?(ActiveFacts::Metamodel::EntityType) ||  # Counterpart is not an ET
-              (pi = object_type.preferred_identifier).role_sequence.all_role_ref.size != 1 ||   # Entity PI has > 1 roles
-              pi.role_sequence.all_role_ref.single.role != role                     # This isn't the identifying role
-            end
-          puts "About to skip #{o.name}"
-          debugger
-          return
-        end
-
-        # We'll dump the subtypes before any roles, so we don't need to dump this here.
-        # ... except that isn't true, we won't do that so we can't skip it now
-        #return if
-        #  o.all_value_type_as_supertype.size != 0 &&    # We have subtypes
-        #  o.all_role.size != 0
-=end
+        # REVISIT: A ValueType that is only used as a reference mode need not be emitted here.
 
 	puts o.as_cql
       end
@@ -216,7 +191,7 @@ module ActiveFacts
         end
         (entity_type.is_independent ? ' independent' : '') +
           " identified by its #{value_residual}#{constraint_text}#{mapping_pragma(entity_type, true)}" +
-	  entity_type.all_context_note_as_relevant_concept.map do |cn|
+	  entity_type.concept.all_context_note_as_relevant_concept.map do |cn|
 	    cn.verbalise
 	  end.join("\n") +
           (fact_readings.size > 0 ? " where\n\t" : "") +
@@ -253,7 +228,7 @@ module ActiveFacts
         (entity_type.is_independent ? ' independent' : '') +
           " identified by #{ irn*" and " }" +
           mapping_pragma(entity_type, true) +
-	  entity_type.all_context_note_as_relevant_concept.map do |cn|
+	  entity_type.concept.all_context_note_as_relevant_concept.map do |cn|
 	    cn.verbalise
 	  end.join("\n") +
           " where\n\t"+identifying_fact_text
@@ -656,7 +631,7 @@ module ActiveFacts
           }#{
             unit && " "+unit.name
           }#{
-	    all_context_note_as_relevant_concept.map do |cn|
+	    concept.all_context_note_as_relevant_concept.map do |cn|
 	      cn.verbalise
 	    end.join("\n")
 	  }#{
@@ -687,6 +662,7 @@ module ActiveFacts
         end +
 
 	all_derivation_as_derived_unit.
+	  sort_by{|d| d.base_unit.name}.
           # REVISIT: Sort base units
           # REVISIT: convert negative powers to division?
           map do |der|

data/lib/activefacts/generate/helpers/oo.rb

@@ -97,11 +97,12 @@ module ActiveFacts
           binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
         end
 
-        def preferred_role_name(role, is_for = nil)
-          return "" if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+        def preferred_role_name(role, is_for = nil, &b)
+	  b ||= proc {|names| names.map(&:downcase)*'_' }   # Make snake_case by default
+          return b.call([]) if role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
 
           if is_for && role.fact_type.entity_type == is_for && role.fact_type.all_role.size == 1
-            return role.object_type.name.gsub(/[- ]/,'_').snakecase
+            return b.call(role.object_type.name.gsub(/[- ]/,'_').split(/_/))
           end
 
           # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
@@ -112,8 +113,11 @@ module ActiveFacts
 
           # Unaries are a hack, with only one role for what is effectively a binary:
           if (role.fact_type.all_role.size == 1)
-            return (role.role_name && role.role_name.snakecase) ||
-              reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_').downcase
+            return b.call(
+	      ( (role.role_name && role.role_name.snakecase) ||
+		reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_')
+	      ).split(/_/)
+	    )
           end
 
           # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.object_type.name}, trailing_adjective=#{p.trailing_adjective}"
@@ -131,7 +135,7 @@ module ActiveFacts
           role_words << ta.gsub(/[- ]/,'_') if ta && ta != "" and !role_name
           n = role_words.map{|w| w.gsub(/([a-z])([A-Z]+)/,'\1_\2').downcase}*"_"
           # debug "\tresult=#{n}"
-          n.gsub(' ','_') 
+          return b.call(n.gsub(' ','_').split(/_/))
         end
 
         def skip_fact_type(f)