activefacts-compositions 1.9.6 → 1.9.8

data/lib/activefacts/generator/oo.rb

@@ -13,178 +13,184 @@ module ActiveFacts
   module Generators
     # Options are comma or space separated:
     class ObjectOriented
+      def self.options
+        {
+          comments: ['Boolean', "Preceed each role definition with a comment that describes it"]
+        }
+      end
+
       def initialize composition, options = {}
-	@composition = composition
-	@options = options
-	@comments = @options.delete("comments")
+        @composition = composition
+        @options = options
+        @comments = @options.delete("comments")
       end
 
       def generate
-	@composites_emitted = {}
+        @composites_emitted = {}
 
-	retract_intrinsic_types
+        retract_intrinsic_types
 
-	composites =
-	  @composition.
-	  all_composite.
-	  sort_by{|composite| composite.mapping.name}
+        composites =
+          @composition.
+          all_composite.
+          sort_by{|composite| composite.mapping.name}
 
-	prelude(@composition) +
-	generate_classes(composites) +
-	finale
+        (prelude(@composition) +
+        generate_classes(composites) +
+        finale).gsub(/[   ][  ]*$/, '')
       end
 
       def generate_classes composites
-	composites.
-	map do |composite|
-	  generate_class(composite)
-	end.
-	compact.
-	join("\n")
+        composites.
+        map do |composite|
+          generate_class(composite)
+        end.
+        compact.
+        join("\n")
       end
 
       def composite_for object_type
-	@composition.all_composite.detect{|c| c.mapping.object_type == object_type }
+        @composition.all_composite.detect{|c| c.mapping.object_type == object_type }
       end
 
       # We don't need Composites for object types that are built-in to the Ruby API.
       def is_intrinsic_type composite
-	o = composite.mapping.object_type
-	return true if o.name == "_ImplicitBooleanValueType"
-	return false if o.supertype
-	# A value type with no supertype must be emitted if it is the child in any absorption:
-	return !composite.mapping.all_member.detect{|m| m.forward_absorption}
+        o = composite.mapping.object_type
+        return true if o.name == "_ImplicitBooleanValueType"
+        return false if o.supertype
+        # A value type with no supertype must be emitted if it is the child in any absorption:
+        return !composite.mapping.all_member.detect{|m| m.forward_absorption}
       end
 
       def retract_intrinsic_types
-	@composition.
+        @composition.
         all_composite.
         sort_by{|composite| composite.mapping.name}.
-	each do |composite|
-	  o = composite.mapping.object_type
-	  next unless o.is_a?(MM::ValueType)
-	  composite.retract and next if is_intrinsic_type(composite)
-	end
+        each do |composite|
+          o = composite.mapping.object_type
+          next unless o.is_a?(MM::ValueType)
+          composite.retract and next if is_intrinsic_type(composite)
+        end
       end
 
       def inherited_identification
-	''
+        ''
       end
 
       def identified_by_roles identifying_roles
-	"REVISIT: override identified_by_roles\n"
+        "REVISIT: override identified_by_roles\n"
       end
 
       def value_type_declaration object_type
-	"REVISIT: override value_type_declaration\n"
+        "REVISIT: override value_type_declaration\n"
       end
 
       def class_prelude(object_type, supertype)
-	"REVISIT: override class_prelude\n"
+        "REVISIT: override class_prelude\n"
       end
 
       def class_finale(object_type)
-	"REVISIT: override class_finale\n"
+        "REVISIT: override class_finale\n"
       end
 
       def generate_class composite, predefine_role_players = true
-	return nil if @composites_emitted[composite]
-
-	mapping = composite.mapping
-	object_type = mapping.object_type
-	is_entity_type = object_type.is_a?(MM::EntityType)
-	forward_declarations = []
-
-	# Emit supertypes before subtypes
-	supertype_composites =
-	  object_type.all_supertype.map{|s| composite_for(s) }.compact
-	forward_declarations +=
-	  supertype_composites.map{|c| generate_class(c, false)}.compact
-
-	@composites_emitted[composite] = true
-
-	# Select the members that will be declared as O-O roles:
-	mapping.re_rank
-	members = mapping.
-	  all_member.
-	  sort_by{|m| m.ordinal}.
-	  reject do |m|
-	    m.is_a?(MM::Absorption) and
-	      m.forward_absorption || m.child_role.fact_type.is_a?(MM::TypeInheritance)
-	  end
-
-	if predefine_role_players
-	  # The idea was good, but we need to avoid triggering a forward reference problem.
-	  # We only do it when we're not dumping a supertype dependency.
-	  #
-	  # For those roles that derive from Mappings, produce class definitions to avoid forward references:
-	  forward_composites =
-	    members.
-	      select{ |m| m.is_a?(MM::Mapping) }.
-	      map{ |m| composite_for m.object_type }.
-	      compact.
-	      sort_by{|c| c.mapping.name}
-	  forward_declarations +=
-	    forward_composites.map{|c| generate_class(c)}.compact
-	end
-
-	forward_declarations = forward_declarations.map{|f| "#{f}\n"}*''
-
-	primary_supertype =
-	  if is_entity_type
-	    object_type.identifying_supertype ||
-	      object_type.supertypes[0]	# Hopefully there's only one!
-	  else
-	    object_type.supertype || object_type
-	  end
-
-	type_declaration =
-	  if is_entity_type
-	    if primary_supertype and object_type.identification_is_inherited
-	      inherited_identification
-	    else
-	      identifying_roles =
-		if object_type.fact_type && object_type.fact_type.is_unary
-		  # Objectified unary; find the absorption over the LinkFactType
-		  members.
-		    select{|m| m.is_a?(MM::Absorption) && m.child_role.base_role.fact_type.entity_type}.
-		    map{|m| m.child_role}
-		else
-		  object_type.preferred_identifier.role_sequence.all_role_ref.map(&:role).
-		  map do |role|
-		    members.detect{|m| m.all_role.include?(role)}
-		  end
-		end
-	      identified_by_roles identifying_roles
-	    end
-	  else
-	    value_type_declaration object_type
-	  end
-
-	forward_declarations +
-	class_prelude(object_type, primary_supertype) +
-	  type_declaration +
-	  members.
-	  map do |component|
-	    (@comments ? comment(component) + "\n" : '') +
-	    role_definition(component)
-	  end*'' +
-	class_finale(object_type)
+        return nil if @composites_emitted[composite]
+
+        mapping = composite.mapping
+        object_type = mapping.object_type
+        is_entity_type = object_type.is_a?(MM::EntityType)
+        forward_declarations = []
+
+        # Emit supertypes before subtypes
+        supertype_composites =
+          object_type.all_supertype.map{|s| composite_for(s) }.compact
+        forward_declarations +=
+          supertype_composites.map{|c| generate_class(c, false)}.compact
+
+        @composites_emitted[composite] = true
+
+        # Select the members that will be declared as O-O roles:
+        mapping.re_rank
+        members = mapping.
+          all_member.
+          sort_by{|m| m.ordinal}.
+          reject do |m|
+            m.is_a?(MM::Absorption) and
+              m.forward_absorption || m.child_role.fact_type.is_a?(MM::TypeInheritance)
+          end
+
+        if predefine_role_players
+          # The idea was good, but we need to avoid triggering a forward reference problem.
+          # We only do it when we're not dumping a supertype dependency.
+          #
+          # For those roles that derive from Mappings, produce class definitions to avoid forward references:
+          forward_composites =
+            members.
+              select{ |m| m.is_a?(MM::Mapping) }.
+              map{ |m| composite_for m.object_type }.
+              compact.
+              sort_by{|c| c.mapping.name}
+          forward_declarations +=
+            forward_composites.map{|c| generate_class(c)}.compact
+        end
+
+        forward_declarations = forward_declarations.map{|f| "#{f}\n"}*''
+
+        primary_supertype =
+          if is_entity_type
+            object_type.identifying_supertype ||
+              object_type.supertypes[0] # Hopefully there's only one!
+          else
+            object_type.supertype || object_type
+          end
+
+        type_declaration =
+          if is_entity_type
+            if primary_supertype and object_type.identification_is_inherited
+              inherited_identification
+            else
+              identifying_roles =
+                if object_type.fact_type && object_type.fact_type.is_unary
+                  # Objectified unary; find the absorption over the LinkFactType
+                  members.
+                    select{|m| m.is_a?(MM::Absorption) && m.child_role.base_role.fact_type.entity_type}.
+                    map{|m| m.child_role}
+                else
+                  object_type.preferred_identifier.role_sequence.all_role_ref.map(&:role).
+                  map do |role|
+                    members.detect{|m| m.all_role.include?(role)}
+                  end
+                end
+              identified_by_roles identifying_roles
+            end
+          else
+            value_type_declaration object_type
+          end
+
+        forward_declarations +
+        class_prelude(object_type, primary_supertype) +
+          type_declaration +
+          members.
+          map do |component|
+            (@comments ? comment(component) + "\n" : '') +
+            role_definition(component)
+          end*'' +
+        class_finale(object_type)
       end
 
       def role_definition component
-	"REVISIT: override role_definition\n"
+        "REVISIT: override role_definition\n"
       end
 
       def comment component
-	if component.is_a?(MM::Absorption)
-	  component.parent_role.fact_type.reading_preferably_starting_with_role(component.parent_role).expand([], false)
-	else
-	  component.name
-	end
+        if component.is_a?(MM::Absorption)
+          component.parent_role.fact_type.reading_preferably_starting_with_role(component.parent_role).expand([], false)
+        else
+          component.name
+        end
       end
 
-      MM = ActiveFacts::Metamodel
+      MM = ActiveFacts::Metamodel unless const_defined?(:MM)
     end
   end
 end

data/lib/activefacts/generator/rails/models.rb

@@ -0,0 +1,237 @@
+#
+#       ActiveFacts Rails Models Generator
+#
+# Copyright (c) 2009-2016 Clifford Heath. Read the LICENSE file.
+#
+require 'digest/sha1'
+require 'activefacts/metamodel'
+require 'activefacts/registry'
+require 'activefacts/compositions'
+require 'activefacts/generator'
+require 'activefacts/compositions/traits/rails'
+
+module ActiveFacts
+  module Generators
+    module Rails
+      class Models
+        HEADER = "# Auto-generated from CQL, edits will be lost"
+        def self.options
+          ({
+            output:     [String,    "Overwrite model files into this output directory"],
+            concern:    [String,    "Namespace for the concerns"],
+            validation: ['Boolean', "Disable generation of validations"],
+          })
+        end
+
+        def initialize composition, options = {}
+          @composition = composition
+          @options = options
+          @option_output = options.delete("output")
+          @option_concern = options.delete("concern")
+          @option_validations = options.include?('validations') ? options.delete("validations") : true
+        end
+
+        def warn *a
+          $stderr.puts *a
+        end
+
+        def generate
+          list_extant_files if @option_output
+
+          @ok = true
+          models =
+            @composition.
+            all_composite.
+            sort_by{|composite| composite.mapping.name}.
+            map{|composite| generate_composite composite}.
+            compact*"\n"
+
+          warn "\# #{@composition.name} generated with errors" unless @ok
+          delete_old_generated_files if @option_output
+
+          models
+        end
+
+        def list_extant_files
+          @preexisting_files = Dir[@option_output+'/*.rb']
+        end
+
+        def delete_old_generated_files
+          remaining = []
+          cleaned = 0
+          @preexisting_files.each do |pathname|
+            if generated_file_exists(pathname) == true
+              File.unlink(pathname) 
+              cleaned += 1
+            else
+              remaining << pathname
+            end
+          end
+          $stderr.puts "Cleaned up #{cleaned} old generated files" if @preexisting_files.size > 0
+          $stderr.puts "Remaining non-generated files:\n\t#{remaining*"\n\t"}" if remaining.size > 0
+        end
+
+        def generated_file_exists pathname
+          File.open(pathname, 'r') do |existing|
+            first_lines = existing.read(1024)     # Make it possible to pass over a magic charset comment
+            if first_lines.length == 0 or first_lines =~ %r{^#{HEADER}}
+              return true
+            end
+          end
+          return false    # File exists, but is not generated
+        rescue Errno::ENOENT
+          return nil      # File does not exist
+        end
+
+        def create_if_ok filename
+          # Create a file in the output directory, being careful not to overwrite carelessly
+          out = $stdout
+          if @option_output
+            pathname = (@option_output+'/'+filename).gsub(%r{//+}, '/')
+            @preexisting_files.reject!{|f| f == pathname }    # Don't clean up this file
+            if generated_file_exists(pathname) == false
+              warn "not overwriting non-generated file #{pathname}"
+              @ok = false
+              return nil
+            end
+            out = File.open(pathname, 'w')
+          end
+          out
+        end
+
+        def generate_composite composite
+          model =
+            (@option_concern ? "module #{@option_concern}\n" : '') +
+            model_body(composite).gsub(/^./, @option_concern ? '  \0' : '\0') +
+            (@option_concern ? "end\n" : '')
+
+          return model unless @option_output
+
+          filename = composite.rails.singular_name+'.rb'
+          out = create_if_ok(filename)
+          return nil unless out
+          out.puts "#{HEADER}\n\n"+model
+        ensure
+          out.close if out
+          nil
+        end
+
+        def model_header composite
+          [
+          "module #{composite.rails.class_name}",
+          "  extend ActiveSupport::Concern",
+          "  included do"
+          ]
+        end
+
+        def model_key composite
+          identifier_columns = composite.primary_index.all_index_field
+          if identifier_columns.size == 1
+            [
+            "    self.primary_key = '#{identifier_columns.single.component.column_name.snakecase}'",
+            ''    # Leave a blank line
+            ]
+          else
+            []
+          end
+        end
+
+        def model_body composite
+          (
+            model_header(composite) +
+            model_key(composite) +
+            to_associations(composite) +
+            from_associations(composite) +
+            column_constraints(composite) +
+            [
+            "  end",
+            "end"
+            ]
+          ).
+          compact.
+          map{|l| l+"\n"}.
+          join('').
+          gsub(/\n\n\n+/,"\n\n")  # At most double-spaced
+        end
+
+        def to_associations composite
+          # Each outbound foreign key generates a belongs_to association:
+          composite.all_foreign_key_as_source_composite.
+          sort_by{ |fk| fk.all_foreign_key_field.map(&:component).flat_map(&:path).map(&:rank_key) }.
+          flat_map do |fk|
+            association_name = fk.rails.from_association_name
+
+            if association_name != fk.composite.rails.singular_name
+              # A different class_name is implied, emit an explicit one:
+              class_name = ", :class_name => '#{fk.composite.rails.class_name}'"
+            end
+
+            foreign_key = ", :foreign_key => :#{fk.all_foreign_key_field.single.component.column_name.snakecase}"
+            if foreign_key == fk.composite.rails.singular_name+'_id'
+              # See lib/active_record/reflection.rb, method #derive_foreign_key
+              foreign_key = ''
+            end
+
+            [
+            fk.absorption ? "    \# #{fk.absorption.comment}" : nil,
+            "    belongs_to :#{association_name}#{class_name}#{foreign_key}",
+            fk.absorption ? '' : nil,
+            ]
+          end.compact
+        end
+
+        def from_associations composite
+          # has_one/has_many Associations
+          composite.all_foreign_key_as_target_composite.
+          sort_by{ |fk| fk.all_foreign_key_field.map(&:component).flat_map(&:path).map(&:rank_key) }.
+          flat_map do |fk|
+
+            if fk.all_foreign_key_field.size > 1
+              raise "Can't emit Rails associations for multi-part foreign key with #{fk.references.inspect}. Did you mean to use --surrogate?"
+            end
+
+            association_type, association_name = *fk.rails.to_association
+
+            [
+              # REVISIT: We want the reverse-order comment here really
+              fk.absorption ? "    \# #{fk.absorption.comment}" : nil,
+              %Q{    #{association_type} :#{association_name}} +
+              %Q{, :class_name => '#{fk.source_composite.rails.class_name}'} +
+              %Q{, :foreign_key => :#{fk.all_foreign_key_field.single.component.column_name.snakecase}} +
+              %Q{, :dependent => :destroy}
+            ] +
+            # If fk.absorption.source_composite is a join table, we can emit a has_many :through for each other key
+            # REVISIT: We could alternately do this for all belongs_to's in the source composite
+            if fk.source_composite.primary_index.all_index_field.size > 1
+              fk.source_composite.primary_index.all_index_field.map(&:component).flat_map do |ic|
+                next nil if ic.is_a?(MM::Indicator)      # or use rails.plural_name(ic.references[0].to_names) ?
+                onward_fks = ic.all_foreign_key_field.map(&:foreign_key)
+                next nil if onward_fks.size == 0 or onward_fks.detect{|fk| fk.composite == composite} # Skip the back-reference
+                # REVISIT: This far association name needs to be augmented for its role name
+                "    has_many :#{onward_fks[0].composite.rails.plural_name}, :through => :#{association_name}"
+              end.compact
+            else
+              []
+            end +
+            [fk.absorption ? '' : nil]
+          end
+        end
+
+        def column_constraints composite
+          return [] unless @option_validations
+          ccs =
+            composite.mapping.all_leaf.flat_map do |component|
+              next unless component.path_mandatory
+              next if component.is_a?(Metamodel::Mapping) && component.object_type.is_a?(Metamodel::ValueType) && component.is_auto_assigned
+              [ "    validates :#{component.column_name.snakecase}, :presence => true" ]
+            end.compact
+          ccs.unshift("") unless ccs.empty?
+          ccs
+        end
+
+        MM = ActiveFacts::Metamodel unless const_defined?(:MM)
+      end
+    end
+    publish_generator Rails::Models
+  end
+end