activefacts 0.8.6 → 0.8.8

data/lib/activefacts/generate/oo.rb

@@ -24,7 +24,8 @@ module ActiveFacts
       def roles_dump(o)
         o.all_role.
           select{|role|
-            role.fact_type.all_role.size <= 2
+            role.fact_type.all_role.size <= 2 &&
+              !role.fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
           }.
           sort_by{|role|
             preferred_role_name(role.fact_type.all_role.select{|r2| r2 != role}[0] || role, o)
@@ -68,8 +69,8 @@ module ActiveFacts
           other_player = fact_type.entity_type
           return unless @concept_types_dumped[other_player]
 
-          other_role_name = other_player.name.snakecase
-          other_role_method = role.concept.name.snakecase
+          other_role_name = other_player.name.gsub(/ /,'_').snakecase
+          other_role_method = role.concept.name.gsub(/ /,'_').snakecase
           one_to_one = true
         else
 
@@ -89,14 +90,14 @@ module ActiveFacts
           role_method = preferred_role_name(role)
           other_role_method = one_to_one ? role_method : "all_"+role_method
           # puts "---"+role.role_name if role.role_name
-          if other_role_name != other_player.name.snakecase and
-            role_method == role.concept.name.snakecase
+          if other_role_name != other_player.name.gsub(/ /,'_').snakecase and
+            role_method == role.concept.name.gsub(/ /,'_').snakecase
             other_role_method += "_as_#{other_role_name}"
           end
         end
 
         role_name = role_method
-        role_name = nil if role_name == role.concept.name.snakecase
+        role_name = nil if role_name == role.concept.name.gsub(/ /,'_').snakecase
 
         binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
       end
@@ -105,7 +106,7 @@ module ActiveFacts
         return "" 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.concept.name.snakecase
+          return role.concept.name.gsub(/[- ]/,'_').snakecase
         end
 
         # debug "Looking for preferred_role_name of #{describe_fact_type(role.fact_type, role)}"
@@ -117,7 +118,7 @@ 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
+            reading.text.gsub(/ *\{0\} */,'').gsub(/[- ]/,'_').downcase
         end
 
         # debug "\tleading_adjective=#{(p=preferred_role_ref).leading_adjective}, role_name=#{role.role_name}, role player=#{role.concept.name}, trailing_adjective=#{p.trailing_adjective}"
@@ -129,13 +130,13 @@ module ActiveFacts
         la = preferred_role_ref.leading_adjective
         role_words << la.gsub(/ /,'_') if la && la != "" and !role.role_name
 
-        role_words << (role_name || role.concept.name)
+        role_words << (role_name || role.concept.name.gsub(/ /,'_'))
         # REVISIT: Same when trailing_adjective is a suffix of the role_name
         ta = preferred_role_ref.trailing_adjective
         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
+        n.gsub(' ','_') 
       end
 
       def skip_fact_type(f)
@@ -156,10 +157,10 @@ module ActiveFacts
                 pc.max_frequency == 1
               }
             }
-            as = role_name != role.concept.name.snakecase ? "_as_#{role_name}" : ""
+            as = role_name != role.concept.name.gsub(/ /,'_').snakecase ? "_as_#{role_name}" : ""
             raise "Fact #{fact_type.describe} type is not objectified" unless fact_type.entity_type
             other_role_method = (one_to_one ? "" : "all_") + 
-              fact_type.entity_type.name.snakecase +
+              fact_type.entity_type.name.gsub(/ /,'_').snakecase +
               as
             binary_dump(role, role_name, role.concept, true, one_to_one, nil, nil, other_role_method)
           }

data/lib/activefacts/generate/ordered.rb

@@ -34,6 +34,7 @@ module ActiveFacts
         build_indices
         @concept_types_dumped = {}
         @fact_types_dumped = {}
+        units_dump()
         value_types_dump()
         entity_types_dump()
         fact_types_dump()
@@ -62,10 +63,32 @@ module ActiveFacts
         @constraints_used = {}
       end
 
+      def units_dump
+        done_banner = false
+        units = @vocabulary.all_unit.to_a.sort_by{|u| u.name.gsub(/ /,'')}
+        while units.size > 0
+          if !done_banner
+            done_banner = true
+            units_banner
+          end
+          i = 0
+          while i < units.size
+            unit = units[i]
+            i += 1
+            # Skip this one if the precursors haven't yet been dumped:
+            next if unit.all_derivation_as_derived_unit.detect{|d| units.include?(d.base_unit) }
+
+            unit_dump(unit)
+            units.delete(unit)
+            i -= 1
+          end
+        end
+      end
+
       def value_types_dump
         done_banner = false
         @value_type_dumped = {}
-        @vocabulary.all_concept.sort_by{|o| o.name}.each{|o|
+        @vocabulary.all_concept.sort_by{|o| o.name.gsub(/ /,'')}.each{|o|
             next unless o.is_a?(ActiveFacts::Metamodel::ValueType)
 
             value_type_banner unless done_banner
@@ -81,7 +104,7 @@ module ActiveFacts
       def value_type_chain_dump(o)
         return if @value_type_dumped[o]
         value_type_chain_dump(o.supertype) if (o.supertype && !@value_type_dumped[o.supertype])
-        value_type_dump(o)
+        value_type_dump(o) if o.name != "_ImplicitBooleanValueType"
         @value_type_dumped[o] = true
       end
 
@@ -95,7 +118,7 @@ module ActiveFacts
         done_banner = false
         sorted = @vocabulary.all_concept.select{|o|
           o.is_a?(ActiveFacts::Metamodel::EntityType) # and !o.fact_type
-        }.sort_by{|o| o.name}
+        }.sort_by{|o| o.name.gsub(/ /,'')}
         panic = nil
         while true do
           count_this_pass = 0
@@ -181,99 +204,17 @@ module ActiveFacts
         # Here, we must find the role_ref containing the adjectives that we need for each identifier,
         # which will be attached to the uniqueness constraint on this object in the binary FT that
         # attaches that identifying role.
-        role_refs = pi.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
+        identifying_role_refs = pi.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
 
         # We need to get the adjectives for the roles from the identifying fact's preferred readings:
-        identifying_facts = ([o.fact_type]+role_refs.map{|rr| rr.role.fact_type }).compact.uniq
-        preferred_readings = identifying_facts.inject({}){|reading_hash, fact_type|
-            pr = fact_type.preferred_reading
-            reading_hash[fact_type] = pr
-            reading_hash
-          }
-        #p identifying_facts.map{|f| f.preferred_reading }
+        identifying_facts = ([o.fact_type]+identifying_role_refs.map{|rr| rr.role.fact_type }).compact.uniq
 
-        identifying_roles = role_refs.map(&:role)
-        identification = identified_by_roles_and_facts(o, identifying_roles, identifying_facts, preferred_readings)
+        identification = identified_by_roles_and_facts(o, identifying_role_refs, identifying_facts)
         #identifying_facts.each{|f| @fact_types_dumped[f] = true }
 
         identification
       end
 
-      def fact_readings_with_constraints(fact_type, fact_constraints = nil)
-        define_role_names = true
-        fact_constraints ||= @presence_constraints_by_fact[fact_type]
-        readings = fact_type.all_reading_by_ordinal.inject([]) do |reading_array, reading|
-          reading_array << expanded_reading(reading, fact_constraints, define_role_names)
-
-          define_role_names = false     # No need to define role names in subsequent readings
-
-          reading_array
-        end
-
-        readings
-      end
-
-      def expanded_reading(reading, fact_constraints, define_role_names)
-        # Find all role numbers in order of occurrence in this reading:
-        role_refs = reading.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
-        role_numbers = reading.text.scan(/\{(\d)\}/).flatten.map{|m| Integer(m) }
-        roles = role_numbers.map{|m| role_refs[m].role }
-        # debug "Considering #{reading.text} having #{role_numbers.inspect}"
-
-        # Find the constraints that constrain frequency over each role we can verbalise:
-        frequency_constraints = []
-        value_restrictions = []
-        roles.each do |role|
-          # Find a mandatory constraint that's *not* unique; this will need an extra reading
-          role_is_first_in = reading.fact_type.all_reading.detect{|r|
-              role == r.role_sequence.all_role_ref.sort_by{|role_ref|
-                  role_ref.ordinal
-                }[0].role
-            }
-
-          if vr = role.role_value_restriction
-            if @constraints_used[vr]
-              vr = nil
-            else
-              @constraints_used[vr] = true
-              vr = vr.describe
-            end
-          end
-          value_restrictions << vr
-          if (role == roles.last)   # First role of the reading?
-            # REVISIT: With a ternary, doing this on other than the last role can be ambiguous,
-            # in case both the 2nd and 3rd roles have frequencies. Think some more!
-
-            constraint = fact_constraints.find{|c|  # Find a UC that spans all other Roles
-                # internal uniqueness constraints span all roles but one, the residual:
-                c.is_a?(ActiveFacts::Metamodel::PresenceConstraint) &&
-                  !@constraints_used[c] &&  # Already verbalised
-                  roles-c.role_sequence.all_role_ref.map(&:role) == [role]
-              }
-            # Index the frequency implied by the constraint under the role position in the reading
-            if constraint     # Mark this constraint as "verbalised" so we don't do it again:
-              @constraints_used[constraint] = true
-            end
-            frequency_constraints << show_frequency(role, constraint)
-          else
-            frequency_constraints << show_frequency(role, nil)
-          end
-        end
-
-        expanded = reading.expand(frequency_constraints, define_role_names, value_restrictions)
-
-        if (ft_rings = @ring_constraints_by_fact[reading.fact_type]) &&
-           (ring = ft_rings.detect{|rc| !@constraints_used[rc]})
-          @constraints_used[ring] = true
-          append_ring_to_reading(expanded, ring)
-        end
-        expanded
-      end
-
-      def show_frequency role, constraint
-        constraint ? constraint.frequency : nil
-      end
-
       def describe_fact_type(fact_type, highlight = nil)
         (fact_type.entity_type ? fact_type.entity_type.name : "")+
         describe_roles(fact_type.all_role, highlight)
@@ -347,6 +288,7 @@ module ActiveFacts
           roles.map(&:fact_type).uniq.select{|fact_type|
               # The fact type hasn't already been dumped but all its role players have
               !@fact_types_dumped[fact_type] &&
+                !fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType) &&
                 !fact_type.all_role.detect{|r| !@concept_types_dumped[r.concept] } &&
                 !fact_type.entity_type
 #                !(fact_type.entity_type && (p = @precursors[fact_type.entity_type]) && p.size > 0)
@@ -402,28 +344,6 @@ module ActiveFacts
         @concept_types_dumped[fact_type.entity_type] = true if fact_type.entity_type
       end
 
-      # Arrange for objectified fact types to appear in order of name, after other fact types.
-      # Facts are ordered alphabetically by the names of their role players,
-      # then by preferred_reading (subtyping fact types have no preferred_reading).
-      def fact_type_key(fact_type)
-        role_names =
-          if (pr = fact_type.preferred_reading)
-            pr.role_sequence.
-              all_role_ref.
-              sort_by{|role_ref| role_ref.ordinal}.
-              map{|role_ref| [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" } +
-              [pr.text]
-          else
-            fact_type.all_role.map{|role| role.concept.name }
-          end
-
-        (fact_type.entity_type ? [fact_type.entity_type.name] : [""]) + role_names
-      end
-
-      def role_ref_key(role_ref)
-        [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-"
-      end
-
       # Dump fact types.
       def fact_types_dump
         # REVISIT: Uniqueness on the LHS of a binary can be coded using "distinct"
@@ -437,6 +357,7 @@ module ActiveFacts
         fact_collection.keys.select{|fact_id|
                 fact_type = fact_collection[fact_id] and
                 !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) and
+                !fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType) and
                 !@fact_types_dumped[fact_type] and
                 !skip_fact_type(fact_type) and
                 !fact_type.all_role.detect{|r| r.concept.is_a?(ActiveFacts::Metamodel::EntityType) }
@@ -453,7 +374,8 @@ module ActiveFacts
 
         # REVISIT: Find out why some fact types are missed during entity dumping:
         @vocabulary.constellation.FactType.values.select{|fact_type|
-            !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
+            !fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) &&
+              !fact_type.is_a?(ActiveFacts::Metamodel::ImplicitFactType)
           }.sort_by{|fact_type|
             fact_type_key(fact_type)
           }.each{|fact_type|
@@ -481,16 +403,73 @@ module ActiveFacts
         }
       end
 
+      # Arrange for objectified fact types to appear in order of name, after other fact types.
+      # Facts are ordered alphabetically by the names of their role players,
+      # then by preferred_reading (subtyping fact types have no preferred_reading).
+      def fact_type_key(fact_type)
+        role_names =
+          if (pr = fact_type.preferred_reading)
+            pr.role_sequence.
+              all_role_ref.
+              sort_by{|role_ref| role_ref.ordinal}.
+              map{|role_ref| [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" } +
+              [pr.text]
+          else
+            fact_type.all_role.map{|role| role.concept.name }
+          end
+
+        (fact_type.entity_type ? [fact_type.entity_type.name] : [""]) + role_names
+      end
+
+      def role_ref_key(role_ref)
+        [ role_ref.leading_adjective, role_ref.role.concept.name, role_ref.trailing_adjective ].compact*"-" +
+        " in " +
+        role_ref.role.fact_type.preferred_reading.expand
+      end
+
       def constraint_sort_key(c)
         case c
         when ActiveFacts::Metamodel::RingConstraint
-          [1, c.ring_type, c.role.concept.name, c.other_role.concept.name, c.name||""]
-        when ActiveFacts::Metamodel::SetComparisonConstraint
-          [2, c.all_set_comparison_roles.map{|scrs| scrs.role_sequence.all_role_ref.map{|rr| role_ref_key(rr)}}, c.name||""]
+          [ 1,
+            c.ring_type,
+            c.role.concept.name,
+            c.other_role.concept.name,
+            c.name||""
+          ]
+        when ActiveFacts::Metamodel::SetExclusionConstraint
+          [ 2+(c.is_mandatory ? 0 : 1),
+            c.all_set_comparison_roles.map{|scrs|
+              scrs.role_sequence.all_role_ref.map{|rr|
+                role_ref_key(rr)
+              }
+            },
+            c.name||""
+          ]
+        when ActiveFacts::Metamodel::SetEqualityConstraint
+          [ 4,
+            c.all_set_comparison_roles.map{|scrs|
+              scrs.role_sequence.all_role_ref.map{|rr|
+                role_ref_key(rr)
+              }
+            },
+            c.name||""
+          ]
         when ActiveFacts::Metamodel::SubsetConstraint
-          [3, [c.superset_role_sequence, c.subset_role_sequence].map{|rs| rs.all_role_ref.map{|rr| role_ref_key(rr)}}, c.name||""]
+          [ 5,
+            [c.superset_role_sequence, c.subset_role_sequence].map{|rs|
+              rs.all_role_ref.map{|rr|
+                role_ref_key(rr)
+              }
+            },
+            c.name||""
+          ]
         when ActiveFacts::Metamodel::PresenceConstraint
-          [4, c.role_sequence.all_role_ref.map{|rr| role_ref_key(rr)}, c.name||""]
+          [ 6,
+            c.role_sequence.all_role_ref.map{|rr|
+              role_ref_key(rr)
+            },
+            c.name||""
+          ]
         end
       end
 
@@ -501,9 +480,14 @@ module ActiveFacts
           if c.is_a?(ActiveFacts::Metamodel::PresenceConstraint)
             # Skip uniqueness constraints that cover all roles of a fact type, they're implicit
             fact_types = c.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
-            next if fact_types.size == 1 &&
+            if fact_types.size == 1 &&
+              !c.role_sequence.all_role_ref.detect{|rr| rr.join_node } &&
               c.max_frequency == 1 &&         # Uniqueness
               fact_types[0].all_role.size == c.role_sequence.all_role_ref.size
+              # debugger if !$constraint_id || c.constraint_id.object_id == $foo
+              # $constraint_id ||= 1
+              next
+            end
 
             # Skip internal PresenceConstraints over TypeInheritances:
             next if c.role_sequence.all_role_ref.size == 1 &&
@@ -529,6 +513,12 @@ module ActiveFacts
         debug "Should override vocabulary_end"
       end
 
+      def units_banner
+      end
+
+      def unit_dump unit
+      end
+
       def value_type_banner
         debug "Should override value_type_banner"
       end

data/lib/activefacts/generate/ruby.rb

@@ -45,38 +45,34 @@ module ActiveFacts
       end
 
       def value_type_dump(o)
-        is_special_supertype = !o.supertype && %w{Date Time DateAndTime}.include?(o.name)
-
-        # We map DateAndTime to DateTime; if such a ValueType exists, don't dump this one
-        return if is_special_supertype && o.name == 'DateAndTime' && o.constellation.ValueType[[[o.vocabulary.name], 'DateTime']]
-
-        return if !o.supertype && !is_special_supertype
-        if o.supertype && o.name == o.supertype.name
-          # In ActiveFacts, parameterising a ValueType will create a new ValueType
-          # throw Can't handle parameterized value type of same name as its ValueType" if ...
-        end
-
         length = (l = o.length) && l > 0 ? ":length => #{l}" : nil
         scale = (s = o.scale) && s > 0 ? ":scale => #{s}" : nil
         params = [length,scale].compact * ", "
 
+        return if
+          !o.supertype &&                   # No supertype, i.e. a base type
+          o.all_role.size == 0 &&           # No roles
+          !o.is_independent &&              # not independent
+          o.all_instance.size == 0          # No instances
+
         name = o.name
         ruby_type_name =
-          case o.supertype ? o.supertype.name : o.name
-            when "VariableLengthText"; "String"
-            when "Date"; "::Date"
-            when "DateAndTime"; "::DateTime"
-            when "Time"; "::Time"
-            else o.supertype.name
-          end
-
-        name = name.sub(/^[a-z]/) {|i| i.upcase}
+            if o.supertype
+              o.supertype.name.gsub(/ /,'')
+            else
+              o.name.gsub(/ /,'')
+            end
+        name = name.sub(/^[a-z]/) {|i| i.upcase}.gsub(/ /,'')
+        if ruby_type_name == name
+          ruby_type_name = '::'+ruby_type_name
+        end
+
         puts "  class #{name} < #{ruby_type_name}\n" +
              "    value_type #{params}\n"
         if @sql and o.is_table
           puts "    table"
         end
-        puts "    restrict #{o.value_restriction.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" if o.value_restriction
+        puts "    restrict #{o.value_constraint.all_allowed_range_sorted.map{|ar| ar.to_s}*", "}\n" if o.value_constraint
         puts "    \# REVISIT: #{o.name} is in units of #{o.unit.name}\n" if o.unit
         roles_dump(o)
         puts "  end\n\n"
@@ -86,9 +82,9 @@ module ActiveFacts
         primary_supertype = o && (o.identifying_supertype || o.supertypes[0])
         secondary_supertypes = o.supertypes-[primary_supertype]
 
-        puts "  class #{o.name} < #{ primary_supertype.name }"
+        puts "  class #{o.name.gsub(/ /,'')} < #{ primary_supertype.name.gsub(/ /,'') }"
         puts "    identified_by #{identified_by(o, pi)}" if pi
-        puts "    supertypes "+secondary_supertypes.map(&:name)*", " if secondary_supertypes.size > 0
+        puts "    supertypes "+secondary_supertypes.map{|st| st.name.gsub(/ /,'')}*", " if secondary_supertypes.size > 0
         if @sql and o.is_table
           puts "    table"
         end
@@ -99,7 +95,7 @@ module ActiveFacts
       end
 
       def non_subtype_dump(o, pi)
-        puts "  class #{o.name}"
+        puts "  class #{o.name.gsub(/ /,'')}"
 
         # We want to name the absorption role only when it's absorbed along its single identifying role.
         puts "    identified_by #{identified_by(o, pi)}"
@@ -124,10 +120,10 @@ module ActiveFacts
         pi = o.preferred_identifier
         pi = nil if pi && primary_supertype && primary_supertype.preferred_identifier == pi
 
-        puts "  class #{name}" +
-          (primary_supertype ? " < "+primary_supertype.name : "") +
+        puts "  class #{name.gsub(/ /,'')}" +
+          (primary_supertype ? " < "+primary_supertype.name.gsub(/ /,'') : "") +
           "\n" +
-          secondary_supertypes.map{|sst| "    supertype :#{sst.name}"}*"\n" +
+          secondary_supertypes.map{|sst| "    supertype :#{sst.name.gsub(/ /,'_')}"}*"\n" +
           (pi ? "    identified_by #{identified_by(o, pi)}" : "")
         puts "    table" if @sql and o.is_table
         fact_roles_dump(fact_type)
@@ -137,9 +133,9 @@ module ActiveFacts
         @fact_types_dumped[fact_type] = true
       end
 
-      def identified_by_roles_and_facts(entity_type, identifying_roles, identifying_facts, preferred_readings)
-        identifying_roles.map{|role|
-            ":"+preferred_role_name(role, entity_type)
+      def identified_by_roles_and_facts(entity_type, identifying_role_refs, identifying_facts)
+        identifying_role_refs.map{|role_ref|
+            ":"+preferred_role_name(role_ref.role, entity_type)
           }*", "
       end
 
@@ -149,33 +145,33 @@ module ActiveFacts
 
       def binary_dump(role, role_name, role_player, mandatory = nil, one_to_one = nil, readings = nil, other_role_name = nil, other_method_name = nil)
         # Find whether we need the name of the other role player, and whether it's defined yet:
-        if role_name.camelcase(true) == role_player.name.sub(/^[a-z]/) {|i| i.upcase}
+        if role_name.camelcase(true) == role_player.name.gsub(/ /,'').sub(/^[a-z]/) {|i| i.upcase}
           # Don't use Class name if implied by rolename
           role_reference = nil
         else
           role_reference = ":class => "+concept_reference(role_player)
         end
-        other_role_name = ":counterpart => :"+other_role_name if other_role_name
+        other_role_name = ":counterpart => :"+other_role_name.gsub(/ /,'_') if other_role_name
 
         line = "    #{one_to_one ? "one_to_one" : "has_one" } " +
-                [ ":"+role_name,
+                [ ":"+role_name.gsub(/ /,'_'),
                   role_reference,
                   mandatory ? ":mandatory => true" : nil,
                   readings,
                   other_role_name,
-                  (vr = role.role_value_restriction) ? ":restrict => #{vr}" : nil
+                  (vr = role.role_value_constraint) ? ":restrict => #{vr}" : nil
                 ].compact*", "+"  "
         line += " "*(48-line.length) if line.length < 48
-        line += "\# See #{role_player.name}.#{other_method_name}" if other_method_name
+        line += "\# See #{role_player.name.gsub(/ /,'')}.#{other_method_name}" if other_method_name
         puts line
-        #puts "    \# REVISIT: #{other_role_name} has values restricted to #{role.role_value_restriction}\n" if role.role_value_restriction
+        #puts "    \# REVISIT: #{other_role_name} has values restricted to #{role.role_value_constraint}\n" if role.role_value_constraint
       end
 
       def concept_reference concept
         if !@concept_types_dumped[concept]
-          '"'+concept.name+'"'
+          '"'+concept.name.gsub(/ /,'')+'"'
         else
-          role_reference = concept.name
+          role_reference = concept.name.gsub(/ /,'')
         end
       end