activefacts 1.6.0 → 1.7.1

data/lib/activefacts/generate/dm.rb

@@ -1,279 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Generate Ruby code for Data Mapper from an ActiveFacts vocabulary.
-#
-# A testing strategy:
-#   Generate and load a set of models
-#   call DataMapper::finalize to check they're consistent
-#   call DataMapper::Spec.cleanup_models to delete them again
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/persistence'
-require 'activefacts/generate/helpers/oo'
-
-module ActiveFacts
-  module Generate
-    class DM < Helpers::OO #:nodoc:
-      # Generate SQL for DataMapper for an ActiveFacts vocabulary.
-      # Invoke as
-      #   afgen --dm[=options] <file>.cql
-      #   Options:
-      #     dir=<mixins directory>
-      #   Example:
-      #     afgen --dm=dir=app/mixins MyApp.cql
-      include Persistence
-
-      def initialize(vocabulary, *options)
-        @vocabulary = vocabulary
-        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-        @mixins = options.grep(/^dir=/)[-1]
-        @mixins && @mixins.sub!(/^dir=/,'')
-      end
-
-      def puts s
-        @out.puts s
-      end
-
-      def model_file(name)
-        @mixins+'/'+name.gsub(/\s/,'')+'.rb'
-      end
-
-      def class_name(name)
-        name.gsub(/\s/,'')
-      end
-
-      def column_name(column)
-        column.name('_').snakecase
-      end
-
-      def symbol_name(name)
-        name.gsub(/\s/,'_').snakecase
-      end
-
-      def new_output(name)
-        return unless @mixins
-        @out.flush
-        @out = File.open(model_file(name), "w")
-        puts "require 'datamapper'\n\n"
-      end
-
-      def key_fields(ref, reverse = false)
-        # Compute and return child_key and parent_key if necessary
-        fk = ref.from.foreign_keys.detect{|k| k.jump_reference == ref}
-	unless fk
-	  debugger
-	  raise "foreign key not found for #{ref}"
-	end
-        child_key = fk.from_columns.map{|c| column_name(c)}
-        parent_key = fk.to_columns.map{|c| column_name(c)}
-        if child_key != parent_key
-          c, p = *(reverse ? ['parent', 'child'] : ['child', 'parent'])
-          ", :#{c}_key => [:#{child_key*', :'}], :#{p}_key => [:#{parent_key*', :'}]"
-        else
-          ''
-        end
-      end
-
-      public
-
-        def generate(out = $>)      #:nodoc:
-          @out = out
-
-          # Calculate the relational absorption:
-          tables = @vocabulary.tables
-
-          # Figure out which ObjectType will be models (tables and their subtypes)
-          models =
-            @vocabulary.all_object_type.sort_by{|o| o.name}.select do |o|
-              next false if o.name =~ /_?ImplicitBooleanValueType/
-              o.is_table || (o.absorbed_via && o.absorbed_via.role_type == :supertype)
-            end
-          is_model = models.inject({}) { |h, m| h[m] = true; h }
-
-          puts "require 'dm-core'"
-          puts "require 'dm-constraints'"
-          puts "\n"
-
-          # Dump tables until all done, subtypes before supertypes:
-          until models.empty?
-            # Choose another object type that we can dump now:
-            o = models.detect do |o|
-              next true if o.is_table
-              next true if a = o.absorbed_via and a.role_type == :supertype and supertype = a.from and !models.include?(supertype)
-              false
-            end
-            models.delete(o)
-
-            supertype = (a = o.absorbed_via and a.role_type == :supertype) ? supertype = a.from : nil
-            if o.is_a?(ActiveFacts::Metamodel::EntityType)
-              if secondary_supertypes = o.supertypes-[supertype] and
-                secondary_supertypes.size > 0 and
-                secondary_supertypes.detect do |sst|
-                  sst_ref_facts = sst.preferred_identifier.role_sequence.all_role_ref.map{|rr| rr.role.fact_type}.uniq
-                  non_identifying_inheritable_references =
-                    sst.references_from.reject do |ref|
-                      sst_ref_facts.include?(ref.fact_type)
-                    end
-                  non_identifying_inheritable_references.size > 0
-                end
-                raise "Cannot map classes like #{o.name} with roles inherited from external supertypes (#{secondary_supertypes.map{|t|t.name}*", "})"
-              end
-              pi = o.preferred_identifier
-              identifying_role_refs = pi.role_sequence.all_role_ref.sort_by{|role_ref| role_ref.ordinal}
-              identifying_facts = ([o.fact_type]+identifying_role_refs.map{|rr| rr.role.fact_type }).compact.uniq
-            else
-              identifying_facts = []
-            end
-
-            # REVISIT: STI fails where the base class is absorbed into another table, like Incident in Insurance for example.
-            # In this case you get the subtype fields absorbed and should not get an STI model.
-
-            puts "class #{class_name(o.name)}#{supertype ? " < #{class_name(supertype.name)}" : ''}"
-            puts "  include DataMapper::Resource\n\n" unless supertype
-
-            columns = o.columns
-            o.references_from.sort_by{|r| r.to_s}.each do |ref|
-              # A (set of) columns
-              if !columns
-                # absorbed subtypes didn't have columns populated
-                columns = o.all_columns({})
-              end
-
-              next if [:subtype, :supertype].include?(ref.role_type)
-              # debugger if ref_columns.detect{|c| [:subtype, :supertype].include?(c.references[0].role_type)}
-              ref_columns = columns.select{|c| c.references[0] == ref }
-              # puts "  \# #{ref.reading}:"
-              ref_columns.sort_by{|column| column_name(column)}.each do |column|
-                type, params, constraints = column.type
-                length = params[:length]
-                length &&= length.to_i
-                scale = params[:scale]
-                scale &&= scale.to_i
-                type, length = normalise_type(type, length)
-                key = identifying_facts.include?(column.references[0].fact_type) ||
-                  (identifying_facts.empty? && ref.is_self_value)
-                cname = column_name(column)
-                required = column.is_mandatory && !key ? ", :required => true" : "" # Key fields are implicitly required
-                if type == 'Serial'
-                  if !key || o.preferred_identifier.role_sequence.all_role_ref.size != 1
-                    type = 'Integer'
-                  else
-                    key = false # This is implicit
-                  end
-                end
-                $stderr.puts "Warning: non-mandatory key field #{o.name}.#{column.name} is forced to mandatory" if !column.is_mandatory && key
-                puts "  property :#{column_name(column)}, #{type}#{length ? ", :length => "+length.to_s : ''}#{required}#{key ? ', :key => true' : ''}\t\# #{column.comment}"
-              end
-
-              if is_model[ref.to]
-                # An association
-                reverse = false
-                association_type =
-                  case ref.role_type
-                  when :one_one
-                    reverse = true
-                    "has 1,"
-                  when :one_many, :many_one
-                    "belongs_to"
-                  when :supertype
-                    next
-                  when :subtype
-                    next
-                  else
-                    raise "role type #{ref.role_type} not handled"
-                  end
-
-                association_name = (ref.to_names*'_')
-                model_name = association_name != ref.to.name ? model_name = ", '#{class_name(ref.to.name)}'" : ''
-                comment = o.fact_type ? "#{association_name} is involved in #{o.name}" : ref.reading
-                keys = key_fields(ref, reverse)
-                puts "  #{association_type} :#{association_name.downcase}#{model_name}#{keys}\t\# #{comment}"
-              end
-            end
-
-            # Emit the "has n," associations
-            # REVISIT: Need to use ActiveSupport to pluralise these names, or disable inflexion somehow.
-            o.references_to.sort_by{|r| [r.to_s, (r.from_role||r.to_role).ordinal] }.each do |ref|
-              next unless is_model[ref.from]
-              constraint = ''
-              association_type =
-                case ref.role_type
-                when :one_one
-                  "has 1,"
-                when :many_one, :one_many
-                  constraint = ', :constraint => :destroy'    # REVISIT: Check mandatory, and use nullify?
-                  "has n,"
-                else
-                  next
-                end
-              prr = ref.fact_type.preferred_reading.role_sequence.all_role_ref.detect{|rr| rr.role == ref.to_role}
-              association_name = (ref.from_names*'_')
-              if prr && (prr.role.role_name || prr.leading_adjective || prr.trailing_adjective)
-                association_name += "_as_"+symbol_name(ref.to_names*'_')
-              end
-              model_name = association_name != ref.from.name ? model_name = ", '#{class_name(ref.from.name)}'" : ''
-              comment = o.is_a?(ActiveFacts::Metamodel::EntityType) && o.fact_type ? "#{association_name} is involved in #{o.name}" : ref.reading
-              keys = key_fields(ref)
-
-              puts "  #{association_type} :#{association_name.downcase}#{model_name}#{keys}\t\# #{comment}"
-            end
-            puts "end\n\n"
-          end
-        end
-
-
-      # Return DataMapper type and (modified?) length for the passed base type
-      def normalise_type(type, length)
-        dm_type = case type
-          when /^Auto ?Counter$/
-            'Serial'
-
-          when /^Unsigned ?Integer$/,
-            /^Signed ?Integer$/,
-            /^Unsigned ?Small ?Integer$/,
-            /^Signed ?Small ?Integer$/,
-            /^Unsigned ?Tiny ?Integer$/
-            length = nil
-            'Integer'
-
-          when /^Decimal$/
-            'Decimal'
-
-          when /^Fixed ?Length ?Text$/, /^Char$/
-            'String'
-          when /^Variable ?Length ?Text$/, /^String$/
-            'String'
-          when /^Large ?Length ?Text$/, /^Text$/
-            'Text'
-
-          when /^Date ?And ?Time$/, /^Date ?Time$/
-            'DateTime'
-          when /^Date$/
-            'DateTime'
-          when /^Time$/
-            'DateTime'
-          when /^Auto ?Time ?Stamp$/
-            'DateTime'
-
-          when /^Money$/
-            'Decimal'
-          when /^Picture ?Raw ?Data$/, /^Image$/
-            'String'
-          when /^Variable ?Length ?Raw ?Data$/, /^Blob$/
-            'String'
-          when /^BIT$/
-            'Boolean'
-          else
-            # raise "DataMapper type unknown for standard type #{type}"
-            type
-          end
-        [dm_type, length]
-      end
-
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('dm', ActiveFacts::Generate::DM)

data/lib/activefacts/generate/help.rb

@@ -1,64 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Provides help for afgen - from afgen --help
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/persistence'
-
-module ActiveFacts
-  module Generate
-    # Generate nothing from an ActiveFacts vocabulary. This is useful to check the file can be read ok.
-    # Invoke as
-    #   afgen --null <file>.cql
-    class HELP
-    private
-      def initialize(vocabulary, *options)
-	generators = $:.
-	  map{|path|
-            Dir[path+"/activefacts/generate/**/*.rb"].
-	      reject{|p|
-		p =~ %r{/(transform|helpers)/}
-	      }.
-	      map{|p|
-                p.sub(%r{.*/activefacts/generate/}, '').sub(/\.rb/,'')
-              }
-          }
-	transformers = $:.
-	  map{|path|
-            Dir[path+"/activefacts/generate/transform/**/*.rb"].
-	      map{|p|
-                p.sub(%r{.*/activefacts/generate/}, '').sub(/\.rb/,'')
-	      }
-          }
-
-        puts %Q{
-Usage: afgen [ --transformer[=options] ... ] [ --generator[=options] ... ] file.inp[=options]
-        options are comma-separated lists. Use =help to get more information.
-
-Available generators are:
-        #{generators.flatten.uniq.sort.join("\n\t")
-}
-
-Available transformers are:
-        #{transformers.flatten.uniq.sort.join("\n\t")
-}
-
-inp is the name of a file input handler. Available input handlers are:
-        #{$:.map{|path|
-            Dir[path+"/activefacts/input/**.rb"].map{|p|
-                p.sub(%r{.*/}, '').sub(/\.rb/,'')
-            }
-        }.flatten.uniq.sort.join("\n\t")
-}
-}
-      end
-
-    public
-      def generate(out = $>)
-      end
-    end
-  end
-end
-
-ActiveFacts::Registry.generator('help', ActiveFacts::Generate::HELP)

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

@@ -1,16 +0,0 @@
-require 'activefacts/vocabulary'
-
-module ActiveFacts
-  module TraitInjector
-    def self.included other
-      overlap = Metamodel.constants & other.constants
-      overlap.each do |const|
-	mix_into = Metamodel.const_get(const)
-	mix_in = other.const_get(const)
-	mix_into.instance_exec {
-	  include(mix_in)
-	}
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-#
-#       ActiveFacts Generators.
-#       Base class for generators of class libraries in any object-oriented language that supports the ActiveFacts API.
-#
-# Copyright (c) 2009 Clifford Heath. Read the LICENSE file.
-#
-require 'activefacts/vocabulary'
-require 'activefacts/generate/helpers/ordered'
-require 'activefacts/generate/traits/oo'
-
-module ActiveFacts
-  module Generate
-
-    module Helpers
-      # Base class for generators of object-oriented class libraries for an ActiveFacts vocabulary.
-      class OO < OrderedDumper  #:nodoc:
-        def constraints_dump
-          # Stub, not needed.
-        end
-
-        def value_type_banner
-        end
-
-        def value_type_end
-        end
-
-        def entity_type_dump(o)
-          o.ordered_dumped!
-          pi = o.preferred_identifier
-
-          supers = o.supertypes
-          if (supers.size > 0)
-            # Ignore identification by a supertype:
-            pi = nil if pi && pi.role_sequence.all_role_ref.detect{|rr| rr.role.fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance) }
-            subtype_dump(o, supers, pi)
-          else
-            non_subtype_dump(o, pi)
-          end
-          pi.ordered_dumped! if pi
-        end
-
-        # Dump the roles for an object type (excluding the roles of a fact type which is objectified)
-        def roles_dump(o)
-          o.all_role.
-            select{|role|
-              role.fact_type.all_role.size <= 2 &&
-                !role.fact_type.is_a?(ActiveFacts::Metamodel::LinkFactType)
-            }.
-            sort_by{|role|
-	      other_role = role.fact_type.all_role.select{|r2| r2 != role}[0] || role
-              other_role.preferred_role_name(o) + ':' + role.preferred_role_name(other_role.object_type)
-            }.each{|role| 
-              role_dump(role)
-            }
-        end
-
-        def role_dump(role)
-          fact_type = role.fact_type
-          if fact_type.all_role.size == 1
-            unary_dump(role, role.preferred_role_name)
-            return
-	  end
-          return if role.fact_type.entity_type
-
-          if fact_type.all_role.size != 2
-            # Shouldn't come here, except perhaps for an invalid model
-            return  # ternaries and higher are always objectified
-          end
-
-          # REVISIT: TypeInheritance
-          if fact_type.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-            # trace "Ignoring role #{role} in #{fact_type}, subtype fact type"
-            # REVISIT: What about secondary subtypes?
-            # REVISIT: What about dumping the relational mapping when using separate tables?
-            return
-          end
-
-          return unless role.is_functional
-
-          other_role = fact_type.all_role.select{|r| r != role}[0]
-          other_role_name = other_role.preferred_role_name
-          other_player = other_role.object_type
-
-          # It's a one_to_one if there's a uniqueness constraint on the other role:
-          one_to_one = other_role.is_functional
-          return if one_to_one &&
-              !other_role.object_type.ordered_dumped
-
-          # Find role name:
-          role_method = role.preferred_role_name
-          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.oo_default_role_name and
-	      role_method == role.object_type.oo_default_role_name
-	    # debugger
-            other_role_method += "_as_#{other_role_name}"
-          end
-
-          role_name = role_method
-          role_name = nil if role_name == role.object_type.oo_default_role_name
-
-b = role.ruby_role_definition
-puts b
-
-          # binary_dump(role, other_role_name, other_player, role.is_mandatory, one_to_one, nil, role_name, other_role_method)
-        end
-
-        def skip_fact_type(f)
-          # REVISIT: There might be constraints we have to merge into the nested entity or subtype.  These will come up as un-handled constraints.
-          !f.entity_type ||
-            f.is_a?(ActiveFacts::Metamodel::TypeInheritance)
-        end
-
-        # An objectified fact type has internal roles that are always "has_one":
-        def fact_roles_dump(fact_type)
-          fact_type.all_role.sort_by{|role|
-              role.preferred_role_name(fact_type.entity_type)
-            }.each{|role| 
-              role_name = role.preferred_role_name(fact_type.entity_type)
-              one_to_one = role.is_unique
-              as = role_name != role.object_type.oo_default_role_name ? "_as_#{role_name}" : ""
-#	      debugger if as != ''
-              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.oo_default_role_name +
-                as
-              binary_dump(role, role_name, role.object_type, true, one_to_one, nil, nil, other_role_method)
-            }
-        end
-
-        def entity_type_banner
-        end
-
-        def entity_type_group_end
-        end
-
-        def append_ring_to_reading(reading, ring)
-          # REVISIT: trace "Should override append_ring_to_reading"
-        end
-
-        def fact_type_banner
-        end
-
-        def fact_type_end
-        end
-
-        def constraint_banner
-          # trace "Should override constraint_banner"
-        end
-
-        def constraint_end
-          # trace "Should override constraint_end"
-        end
-
-        def constraint_dump(c)
-          # trace "Should override constraint_dump"
-        end
-
-      end
-    end
-  end
-end