activefacts-generators 1.8.3 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18414a4533151ffe192e7ae375366327595faf25
-  data.tar.gz: 6d31af89a93cfa0d63edf126cacb3df917770cd3
+  metadata.gz: 77fbb0671bf67f5f67b0336451403655fac4794e
+  data.tar.gz: 348bb0ec84c18b602abdf882d580840cf1527b31
 SHA512:
-  metadata.gz: 314a64ec5dcf991328ef3ffcc1fdb18b5f99673bb1c27695d0e9f796ac922c26b0acb94517c146401dbb08d3e6adbc965c6e44b43ce13e22d0bbf8cf021a2b50
-  data.tar.gz: 0ed72bc6312ef1eae1059d5a93f530b056f9cec1ea7b690eaa93f1e6933be4dc4376cf2175f82846e8cf6dd49972714402ce3c539d76a1b828baffd915335905
+  metadata.gz: 1ffb7dbcb73660a6e9a6159c6de6b8be0840be93e8c08e1c7c161fb8454745bd7e07e7727198e785955eb5494ad531103f0044b42e7ff95b28d6c05e8f04aea4
+  data.tar.gz: e90f8fc9bed2cb3e6c92e658841661ae0ac154e303defb5decf30ac71ad2a71a1f0a71d798451f02dc27f1855224d24a3c1bce407f57101ddd50a36e03cd7feb

data/activefacts-generators.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "activefacts-generators"
-  spec.version       = "1.8.3"
+  spec.version       = "1.9.0"
   spec.authors       = ["Clifford Heath"]
   spec.email         = ["clifford.heath@gmail.com"]
 
@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.3"
 
-  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.8"
+  spec.add_runtime_dependency "activefacts-metamodel", "~> 1", ">= 1.9.14"
   spec.add_runtime_dependency "activefacts-rmap", "~> 1", ">= 1.8"
-  spec.add_runtime_dependency "activesupport", "~> 4.2", "~> 4.2.4"
+  spec.add_runtime_dependency "activesupport", "~> 4"
 end

data/lib/activefacts/dependency_analyser.rb

@@ -8,32 +8,32 @@ module ActiveFacts
     def analyse_precursors &block
       @precursors = {}
       @enumerable.each do |item|
-	@precursors[item] = block.call(item)
+        @precursors[item] = block.call(item)
       end
     end
 
     def analyse_precursors_transitive
       all_precursors = proc do |item|
-	  p = @precursors[item]
-	  all =
-	    p + p.map do |precursor|
-	      p.include?(precursor) ? [] : all_precursors.call(precursor)
-	    end.flatten
-	  all.uniq
-	end
+          p = @precursors[item]
+          all =
+            p + p.map do |precursor|
+              p.include?(precursor) ? [] : all_precursors.call(precursor)
+            end.flatten
+          all.uniq
+        end
 
       @precursors_transitive = {}
       @enumerable.each do |item|
-	@precursors_transitive[item] = all_precursors.call(item)
+        @precursors_transitive[item] = all_precursors.call(item)
       end
     end
 
     def analyse_followers
       @followers = Hash.new{|h, k| h[k] = [] }
       @enumerable.each do |item|
-	@precursors[item].each do |precursor|
-	  @followers[precursor] << item
-	end
+        @precursors[item].each do |precursor|
+          @followers[precursor] << item
+        end
       end
     end
 
@@ -44,11 +44,11 @@ module ActiveFacts
       # A follower is an object with us as a precursor, that has no new precursors of its own
       @chasers = {}
       @enumerable.each do |item|
-	@chasers[item] =
-	  @enumerable.select do |follower|
-	    @precursors[follower].include?(item) and
-	    (@precursors_transitive[follower] - @precursors_transitive[item] - [item]).size == 0
-	  end
+        @chasers[item] =
+          @enumerable.select do |follower|
+            @precursors[follower].include?(item) and
+            (@precursors_transitive[follower] - @precursors_transitive[item] - [item]).size == 0
+          end
       end
     end
 
@@ -57,93 +57,93 @@ module ActiveFacts
       emitted = {}
       pass = 0
       until emitted.size == @enumerable.size
-	next_items = []
-	blocked =
-	  @enumerable.inject({}) do |hash, item|
-	    next hash if emitted[item]
-	    blockers = item.precursors.select{|precursor| !emitted[precursor]}
-	    if blockers.size > 0
-	      hash[item] = blockers
-	    else
-	      next_items << item
-	    end
-	    hash
-	  end
-	return blocked if next_items.size == 0	# Cannot make progress
-	# puts "PASS #{pass += 1}"
-	next_items.each do |item|
-	  block.call(item)
-	  emitted[item] = true
-	end
+        next_items = []
+        blocked =
+          @enumerable.inject({}) do |hash, item|
+            next hash if emitted[item]
+            blockers = item.precursors.select{|precursor| !emitted[precursor]}
+            if blockers.size > 0
+              hash[item] = blockers
+            else
+              next_items << item
+            end
+            hash
+          end
+        return blocked if next_items.size == 0  # Cannot make progress
+        # puts "PASS #{pass += 1}"
+        next_items.each do |item|
+          block.call(item)
+          emitted[item] = true
+        end
       end
       nil
     end
 
     def each &b
       if block_given?
-	@enumerable.each { |item| yield item}
+        @enumerable.each { |item| yield item}
       else
-	@enumerable
+        @enumerable
       end
     end
 
     def precursors item = nil, &b
       analyse_precursors unless @precursors
       if item
-	if block_given?
-	  Array(@precursors[item]).each { |precursor| yield precursor, item }
-	else
-	  Array(@precursors[item])
-	end
+        if block_given?
+          Array(@precursors[item]).each { |precursor| yield precursor, item }
+        else
+          Array(@precursors[item])
+        end
       else
-	@enumerable.each do |item|
-	  precursors(item, &b)
-	end
+        @enumerable.each do |item|
+          precursors(item, &b)
+        end
       end
     end
 
     def precursors_transitive item, &b
       analyse_precursors_transitive unless @precursors_transitive
       if item
-	if block_given?
-	  Array(@precursors_transitive[item]).each { |precursor| yield precursor, item }
-	else
-	  Array(@precursors_transitive[item])
-	end
+        if block_given?
+          Array(@precursors_transitive[item]).each { |precursor| yield precursor, item }
+        else
+          Array(@precursors_transitive[item])
+        end
       else
-	@enumerable.each do |item|
-	  precursors_transitive(item, &b)
-	end
+        @enumerable.each do |item|
+          precursors_transitive(item, &b)
+        end
       end
     end
 
     def followers item = nil, &b
       analyse_followers unless @followers
       if item
-	if block_given?
-	  Array(@followers[item]).each { |follower| yield follower, item }
-	else
-	  Array(@followers[item])
-	end
+        if block_given?
+          Array(@followers[item]).each { |follower| yield follower, item }
+        else
+          Array(@followers[item])
+        end
       else
-	@enumerable.each do |item|
-	  followers(item, &b)
-	end
+        @enumerable.each do |item|
+          followers(item, &b)
+        end
       end
     end
 
     def chasers item, &b
       analyse_chasers unless @chasers
       if item
-	if block_given?
-	  Array(@chasers[item]).each { |follower| yield follower, item }
-	else
-	  Array(@chasers[item])
-	end
+        if block_given?
+          Array(@chasers[item]).each { |follower| yield follower, item }
+        else
+          Array(@chasers[item])
+        end
       else
-	@enumerable.each do |item|
-	  follower(item, &b)
-	end
+        @enumerable.each do |item|
+          follower(item, &b)
+        end
       end
     end
 
@@ -155,23 +155,23 @@ module ActiveFacts
       @total = 0
       @rank = {}
       @enumerable.each do |item|
-	@total += 
-	  (@rank[item] = weight.call(item) * 1.0)
+        @total += 
+          (@rank[item] = weight.call(item) * 1.0)
       end
       # Normalize:
       @enumerable.each do |item|
-	@rank[item] /= @total
+        @rank[item] /= @total
       end
 
       50.times do |iteration|
-	@enumerable.each do |item|
-	  links = (precursors(item) + followers(item)).uniq
-	  linked_rank = links.map do |l|
-	      onward_links = (precursors(l) + followers(l)).uniq || @enumerable.size
-	      @rank[l] / onward_links.size
-	    end.inject(&:+) || 0
-	  @rank[item] = (1.0-damping) + damping*linked_rank
-	end
+        @enumerable.each do |item|
+          links = (precursors(item) + followers(item)).uniq
+          linked_rank = links.map do |l|
+              onward_links = (precursors(l) + followers(l)).uniq || @enumerable.size
+              @rank[l] / onward_links.size
+            end.inject(&:+) || 0
+          @rank[item] = (1.0-damping) + damping*linked_rank
+        end
       end
 
       @rank

data/lib/activefacts/generators/absorption.rb

@@ -30,7 +30,7 @@ module ActiveFacts
       end
 
       def generate(out = $>)  #:nodoc:
-	@out = out
+        @out = out
         no_absorption = 0
         single_absorption_vts = 0
         single_absorption_ets = 0

data/lib/activefacts/generators/composition.rb

@@ -19,97 +19,97 @@ module ActiveFacts
       include RMap
 
       def initialize(vocabulary, *options)
-	@vocabulary = vocabulary
-	@vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
-	@underscore = options.include?("underscore") ? "_" : ""
+        @vocabulary = vocabulary
+        @vocabulary = @vocabulary.Vocabulary.values[0] if ActiveFacts::API::Constellation === @vocabulary
+        @underscore = options.include?("underscore") ? "_" : ""
       end
 
       def puts s
-	@out.puts s
+        @out.puts s
       end
 
     public
       def generate(out = $>)      #:nodoc:
-	@out = out
+        @out = out
 
-	tables_emitted = {}
+        tables_emitted = {}
 
-	puts "require '#{@vocabulary.name}'"
-	puts "require 'activefacts/composition'"
-	puts "\n#{@vocabulary.name}_ER = ActiveFacts::Composition.new(#{@vocabulary.name}) do"
-	@vocabulary.tables.each do |table|
-	  puts "  composite :\"#{table.name.gsub(' ',@underscore)}\" do"
+        puts "require '#{@vocabulary.name}'"
+        puts "require 'activefacts/composition'"
+        puts "\n#{@vocabulary.name}_ER = ActiveFacts::Composition.new(#{@vocabulary.name}) do"
+        @vocabulary.tables.each do |table|
+          puts "  composite :\"#{table.name.gsub(' ',@underscore)}\" do"
 
-	  pk = table.identifier_columns
-	  identity_column = pk[0] if pk[0].is_auto_assigned
+          pk = table.identifier_columns
+          identity_column = pk[0] if pk[0].is_auto_assigned
 
-	  fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
-	  fk_columns = table.columns.select do |column|
-	    column.references[0].is_simple_reference
-	  end
+          fk_refs = table.references_from.select{|ref| ref.is_simple_reference }
+          fk_columns = table.columns.select do |column|
+            column.references[0].is_simple_reference
+          end
 
-	  columns =
-	    table.columns.map do |column|
-	      [column, column.references.map{|r| r.to_names }]
-	    end.sort_by do |column, refnames|
-	      refnames
-	    end
-	  previous_flattening = []
-	  ref_prefix = []
-	  columns.each do |column, refnames|
-	    ref_prefix = column.references[0...previous_flattening.size]
-	    # Pop back. Not a succinct algorithm, but easy to check
-	    while previous_flattening.size > ref_prefix.size
-	      previous_flattening.pop
-	      puts '    '+'  '*previous_flattening.size+"end\n"
-	    end
-	    while ref_prefix.size > 0 and previous_flattening != ref_prefix
-	      previous_flattening.pop
-	      ref_prefix.pop
-	      puts '    '+'  '*previous_flattening.size+"end\n"
-	    end
-	    loop do
-	      ref = column.references[ref_prefix.size]
-	      if ref.is_self_value
-		# REVISIT: I think these should be 'insert :value, :as => "XYZ"'
-		role_name = "value".snakecase
-		reading = "Intrinsic value of #{role_name}"
-	      elsif ref.is_to_objectified_fact
-		# REVISIT: It's ugly to have to handle these special cases here
-		role_name = ref.to.name.words.snakecase
-		reading = ref.from_role.link_fact_type.default_reading
-	      else
-		if ref.is_unary && ref.is_from_objectified_fact && ref != column.references.last
-		  # Use the name of the objectification on the path to other absorbed fact types:
-		  role_name = ref.to_role.fact_type.entity_type.name.words.snakecase
-		else
-		  role_name = ref.to_role.preferred_role_name
-		end
-		# puts ">>>>> #{ref.inspect}: #{role_name} <<<<<<"
-		reading = ref.fact_type.default_reading
-	      end
-	      if ref == column.references.last
-		# REVISIT: Avoid the "as" here when the value is implied by the role_name:
-		puts '    '+'  '*ref_prefix.size+"nest :#{role_name}, :as => \"#{column.name}\"\t\t# #{reading}"
-		break
-	      else
-		puts '    '+'  '*ref_prefix.size+"flatten :#{role_name} do\t\t# #{reading}"
-		ref_prefix.push ref
-	      end
-	    end
-	    previous_flattening = ref_prefix
-	  end
+          columns =
+            table.columns.map do |column|
+              [column, column.references.map{|r| r.to_names }]
+            end.sort_by do |column, refnames|
+              refnames
+            end
+          previous_flattening = []
+          ref_prefix = []
+          columns.each do |column, refnames|
+            ref_prefix = column.references[0...previous_flattening.size]
+            # Pop back. Not a succinct algorithm, but easy to check
+            while previous_flattening.size > ref_prefix.size
+              previous_flattening.pop
+              puts '    '+'  '*previous_flattening.size+"end\n"
+            end
+            while ref_prefix.size > 0 and previous_flattening != ref_prefix
+              previous_flattening.pop
+              ref_prefix.pop
+              puts '    '+'  '*previous_flattening.size+"end\n"
+            end
+            loop do
+              ref = column.references[ref_prefix.size]
+              if ref.is_self_value
+                # REVISIT: I think these should be 'insert :value, :as => "XYZ"'
+                role_name = "value".snakecase
+                reading = "Intrinsic value of #{role_name}"
+              elsif ref.is_to_objectified_fact
+                # REVISIT: It's ugly to have to handle these special cases here
+                role_name = ref.to.name.words.snakecase
+                reading = ref.from_role.link_fact_type.default_reading
+              else
+                if ref.is_unary && ref.is_from_objectified_fact && ref != column.references.last
+                  # Use the name of the objectification on the path to other absorbed fact types:
+                  role_name = ref.to_role.fact_type.entity_type.name.words.snakecase
+                else
+                  role_name = ref.to_role.preferred_role_name
+                end
+                # puts ">>>>> #{ref.inspect}: #{role_name} <<<<<<"
+                reading = ref.fact_type.default_reading
+              end
+              if ref == column.references.last
+                # REVISIT: Avoid the "as" here when the value is implied by the role_name:
+                puts '    '+'  '*ref_prefix.size+"nest :#{role_name}, :as => \"#{column.name}\"\t\t# #{reading}"
+                break
+              else
+                puts '    '+'  '*ref_prefix.size+"flatten :#{role_name} do\t\t# #{reading}"
+                ref_prefix.push ref
+              end
+            end
+            previous_flattening = ref_prefix
+          end
 
-	  while previous_flattening.size > 0
-	    previous_flattening.pop
-	    puts '    '+'  '*previous_flattening.size+"end\n"
-	  end
-	  puts "  end\n\n"
+          while previous_flattening.size > 0
+            previous_flattening.pop
+            puts '    '+'  '*previous_flattening.size+"end\n"
+          end
+          puts "  end\n\n"
 
-	  tables_emitted[table] = true
+          tables_emitted[table] = true
 
-	end
-	puts "end\n"
+        end
+        puts "end\n"
       end
 
     end