precedence 0.6.0

data/CHANGELOG

@@ -0,0 +1,5 @@
+= 0.6: Initial Release
+Basic precedence network functionality:
+* Earlist/latest start/finish
+* Generating float and determining critical path
+* Diagram generation via dot files	

data/README

@@ -0,0 +1,63 @@
+= Precedence
+
+Precedence is a library that allows for the creation, manipulation and analysis
+of precedence networks.
+
+== Download and Install
+
+Available as a RubyGem from Rubyforge. To install
+ $ gem install precedence
+will fetch the latest gem from Rubyforge and install it.
+
+Source can also be downloaded from  http://rubyforge.org/projects/precedence.
+
+== Example Usage
+ require('precedence')
+ 
+ # Set up network
+ net = Precedence::Network.new('Begin','End')
+ net.new_activity('act-1-1',3,'System specification')
+ net.new_activity('act-1-2',2,'Review')
+ net.new_activity('act-1-3',2,'System re-specification')
+ net.new_activity('act-2-1',3,'Test tool design')
+ net.new_activity('act-2-2',5,'Test tool implementation')
+ net.new_activity('act-3-1',3,'System design')
+ net.new_activity('act-3-2',12,'System implementation')
+ net.new_activity('act-2-3',10,'System testing')
+ net.connect('act-1-1','act-1-2')
+ net.connect('act-1-2','act-1-3')
+ net.connect('act-1-3','act-3-1')
+ net.connect('act-1-2','act-2-1')
+ net.connect('act-2-1','act-2-2')
+ net.connect('act-2-2','act-3-2')
+ net.connect('act-3-1','act-3-2')
+ net.connect('act-3-2','act-2-3')
+ net.fix_connections!
+ 
+ # Generate a diagram
+ File.open('network.dot',File::CREAT|File::TRUNC|File::WRONLY) do|file|
+	file.puts(net.to_dot)
+ end
+ system("dot","-Tpng","-onetwork.png","network.dot")
+ 
+ # Perform some analysis of the activities
+ activity = net.activities['act-1-2']
+ activity.on_critical_path? # => true 
+ activity.earliest_start # => 3.0
+ activity.latest_finish # => 5.0
+ activity.total_float  # => 0 - activities on the critical path have no float
+ 
+== Documentation
+
+The Precedence API online documentation is available at 
+http://precedence.rubyforge.org. 
+
+Refer to the CHANGELOG and TODO files for past changes and upcoming plans.
+
+== Credits
+
+Farrel Lifson <farrel@lifson.info>
+
+== License
+
+This software is made available under the BSD license.

data/TODO

@@ -0,0 +1,22 @@
+= To Do
+
+I plan on adding the following leading up to a 1.0 release
+
+== 0.7
+
+* Adding resource usage (money, coffee, bulldozers) to each activity.
+* Saving and loading precedence networks (probably using YAML).
+
+== 0.8
+
+* Adding an 'each_day' method to the network that will return the set of 
+  activities used on that day.
+* Calculating daily resource usage and generating some graphs from that.
+
+== 0.9
+
+* Generating Gantt charts
+
+== 1.0 and further
+
+* Some probability based reasoning using Beta/Normal distributions.

data/lib/precedence/activity.rb

@@ -0,0 +1,251 @@
+module Precedence
+	
+	# A representation of an activity in a precedence network. Each activity
+	# has a user specified reference, description and duration. When activities
+	# are connected (via the add_post/pre_activities functions) then various
+	# other properties of the activity can be determined such as it's earliest
+	# finish time, float and so on.
+	#
+	
+	class Activity
+		
+		# A textual description of the activity.
+		attr_accessor :description
+		# The time the activity will take to complete.
+		attr_accessor :duration
+		# A unique reference for this activity.
+		attr_reader :reference
+		# The collection of activites that are dependent on the completion of 
+		# this activity.
+		attr_reader :post_activities
+		# The collection of activities that this activity depends on before it 
+		# can begin executing.
+		attr_reader :pre_activities
+				
+		# Creates a new activity. The post_activities and pre_activities 
+		# collections should contain the activities themselves and not their
+		# references.
+		#
+		# *Note*: When assigning a reference for an activity 'start' and 
+		# 'finish' are reserved for internal usage.
+		def initialize(reference,duration=0,description="",post_activities=[],
+			pre_activities=[])
+			if (reference.to_s == 'start') || (reference.to_s == 'finish')
+				raise "The reference '#{reference.to_s}' is reserved"
+			end
+			@reference = reference.to_s
+			@description = description.to_s
+			@duration = duration.to_f			
+			@post_activities = post_activities.to_a
+			@pre_activities = pre_activities.to_a			
+		end
+		
+		# Adds the activities in the parameter list to the post_activities 
+		# collection of this activity and also adds this activity to the
+		# pre_activities collection of each of the activities.
+		def add_post_activities(*post_activities)
+			post_activities.each do |activity|
+				activity.register_pre_activity(self)
+				register_post_activity(activity)
+			end
+		end
+		
+		# Adds the activities in the parameter list to the pre_activities 
+		# collection of this activity and also adds this activity to the
+		# post_activities collection of each of the activities.
+		def add_pre_activities(*pre_activities)
+			pre_activities.each do |activity|
+				activity.register_post_activity(self)
+				register_pre_activity(activity)
+			end
+		end
+		
+		# Removes the list of activities from the post_activities collection of 
+		# the activity.
+		def remove_post_activities(*post_activities)
+			post_activities.each do |activity|
+				activity.deregister_pre_activity(self)
+				deregister_post_activity(activity)
+			end
+		end
+
+		# Removes the list of activities from the pre_activities collection of 
+		# the activity.		
+		def remove_pre_activities(*post_activities)
+			post_activities.each do |activity|
+				activity.deregister_post_activity(self)
+				deregister_pre_activity(activity)
+			end
+		end
+		
+		# The earliest possible time this activity can finish.
+		def earliest_finish
+			return @duration + earliest_start
+		end
+		
+		# The earliest possible time this activity can start.
+		def earliest_start
+			unless @pre_activities.empty?
+				(@pre_activities.max do |a,b|
+					a.earliest_finish <=> b.earliest_finish
+				end).earliest_finish
+			else
+				0.0
+			end			                           		
+		end
+		
+		# The latest possible time this activity can start so as not to delay
+		# any dependent activities.
+		def latest_start
+			return latest_finish - @duration
+		end
+		
+		# The latest possible time this activity can finish so as not to delay
+		# any dependent activities.
+		def latest_finish
+			unless @post_activities.empty?
+				(@post_activities.min do |a,b|
+					a.latest_start <=> b.latest_start
+				end).latest_start
+			else
+				return earliest_finish
+			end
+		end
+		
+		# The maximum earliest finish of this activities pre-activities.
+		def pre_activities_max_earliest_finish
+			unless @pre_activities.empty?
+				(@pre_activities.max do |a,b|
+					a.earliest_finish <=> b.earliest_finish
+				end).earliest_finish
+			else
+				return 0
+			end
+		end
+		
+		# The minimum earliest start of this activities post-activities.
+		def post_activities_min_earliest_start
+			unless @post_activities.empty?
+				(@post_activities.min do |a,b|
+					a.earliest_start <=> b.earliest_start
+				end).earliest_start
+			else
+				return latest_finish
+			end
+		end
+		
+		# If the activity is on the critical path returns true, returns false
+		# otherwise.
+		def on_critical_path?
+			if earliest_finish == latest_finish
+				return true
+			else
+				return false
+			end
+		end
+		
+		# The amount of float this activity has such that it does not delay
+		# the completion of the entire precedence network.
+		def total_float
+			return latest_finish - earliest_finish
+		end
+		
+		# The amount of float this activity has if all preceding and succeeding
+		# activities start as early as possible.
+		#
+		# *Note*: In almost all practical cases this is the same as if all 
+		# preceding and successing activities start as lates as possible and so 
+		# no late_float method is defined.
+		def early_float
+			return post_activities_min_earliest_start - 
+				pre_activities_max_earliest_finish	- @duration	
+		end
+		
+		# Register this activity as a post-activity on the parameter.		
+		def register_post_activity(activity) #:nodoc:
+			unless (@post_activities.detect do |post_activity|
+					activity.reference == post_activity.reference
+				end)
+				@post_activities << activity
+			end
+		end
+		
+		# Register this activity as a pre-activity on the parameter.		
+		def register_pre_activity(activity) #:nodoc:
+			unless (@pre_activities.detect do |pre_activity|
+					activity.reference == pre_activity.reference
+				end)
+				@pre_activities << activity
+			end			
+		end
+		
+		# Deregister this activity as a post-activity on the parameter.		
+		def deregister_post_activity(activity) #:nodoc:
+			if (@post_activities.detect do |post_activity|
+					activity.reference == post_activity.reference
+				end)
+				@post_activities.delete(activity)
+			end
+		end
+
+		# Deregister this activity as a pre-activity on the parameter.				
+		def deregister_pre_activity(activity) #:nodoc:
+			if (@pre_activities.detect do |pre_activity|
+					activity.reference == pre_activity.reference
+				end)
+				@pre_activities.delete(activity)
+			end
+		end
+		
+		# Returns this activity in an Array object.
+		def to_a #:nodoc:
+			return [self]
+		end
+		
+		# Redefines the inspect method.
+		def inspect #:nodoc:
+			"#{@reference}(#{@duration})"
+		end
+		
+		# Redefines the to_s method
+		def to_s #:nodoc:
+			return "Reference: #{@reference}\n"+
+				"Description: #{@description}\n"+
+				"Duration: #{@duration}"+
+				("\nDepends on:\n " unless @pre_activities.empty?).to_s +				
+				(@pre_activities.collect do |activity|
+					activity.reference
+				end).join(',')
+		end
+		
+		# Priviliege settings
+		protected :register_post_activity, :register_pre_activity,
+			:deregister_post_activity, :deregister_pre_activity
+			
+		private :pre_activities_max_earliest_finish,
+			:post_activities_min_earliest_start
+
+					
+	end
+	
+	# Represents the special case of a start or finish activity.
+	class StartFinishActivity < Precedence::Activity #:nodoc:
+		def initialize(reference,description=nil)
+			if (reference.to_s != 'start') and (reference.to_s != 'finish')
+				raise "StartFinishActivity reference may only be set to"+
+					"'start' or 'finish'. Given reference was '#{reference}'."
+			end
+		
+			@reference = reference.to_s
+			if description 
+				@description = description.to_s 
+			else
+				@description = reference.to_s
+			end
+			@duration = duration.to_f			
+			@post_activities = post_activities.to_a
+			@pre_activities = pre_activities.to_a			
+		end		
+	end
+end
+

data/lib/precedence/network.rb

@@ -0,0 +1,187 @@
+require('erb')
+
+module Precedence
+
+	# An overwritten Hash that has all keys as strings
+	class ActivityHash < Hash #:nodoc:
+		def[]=(ref,value)
+			super(ref.to_s, value)
+		end
+		
+		def[](ref)
+			super(ref.to_s)
+		end
+	end	
+	
+	# Represents an entire precedence network.
+	class Network
+	
+		# A hashed collection of all the activities in the network. The index
+		# is the reference of the activity.
+		attr_reader :activities
+		
+		# Initialises the precedence network. The descriptions for the start
+		# and finish activities can be set in the parameters. The start and
+		# finish activities of the network have as references 'start' and
+		# 'finish' respectively (and as such these references are reserved) 
+		# and a duration of 0.
+		def initialize(startDescription='Start',
+			finishDescription='Finish')
+			@start = Precedence::StartFinishActivity.new('start',
+												startDescription)
+			@finish = Precedence::StartFinishActivity.new('finish',
+												finishDescription)
+			@activities = Precedence::ActivityHash.new
+			@activities[@start.reference] = @start
+			@activities[@finish.reference] = @finish
+		end
+		
+		# Creates a new activity and adds it to the precedence network. The 
+		# reference is the only mandatory parameter. The post_activities and
+		# pre_activities parameters should contain the references to activities
+		# already defined within the network and not the actual 
+		# Precedence::Activity object.
+		#
+		# Exapmple usage: 
+		#  precNetwork.new_activity('a2',3,'Activity2',['a1'])
+		# will create a new activity in the network with referecne 'a2' and with
+		# activity 'a1' as a post-activity.
+		def new_activity(reference,duration=0,description="",
+				post_activities=[],pre_activities=[])				
+				
+			post_activities.each do |post_activity_ref|
+				unless @activities[post_activity_ref]
+					raise "Post-activity with reference #{post_activity_ref} "+
+						 "was not found."
+				end
+			end
+			
+			pre_activities.each do |pre_activity_ref|
+				unless @activities[pre_activity_ref]
+					raise "Pre-activity with reference #{pre_activity_ref} "+
+						"was not found."
+				end
+			end
+	
+			activity =
+				Precedence::Activity.new(reference,duration,description)				
+			
+			post_activities.each do |post_activity_ref|
+				activity.add_post_activities(@activities[post_activity_ref])
+			end
+			
+			pre_activities.each do |pre_activity_ref|
+				activity.add_pre_activities(@activities[pre_activity_ref])
+			end				
+	
+			@activities[reference]=activity				
+		end
+
+		# Adds a Precedence::Activity object to the network. This should be a 
+		# single activity (no pre- or post-activities should be referenced from
+		# it) and it's reference should not exist in the network.
+		#
+		# Example usage:
+		#  activity = Precedence::Activity.new('a1',1,'Activity 1')
+		#  precNetwork.add_activity(activity)
+		# will add the existing activity 'a1' to the network.
+		def add_activity(activity)
+			if @activities[activity.reference]
+				raise "Activity #{activity.reference} already exists in the "+
+					"network."
+			end
+			
+			unless activity.post_activities == []
+				raise "Can not add an activity with post activities."
+			end
+			
+			unless activity.pre_activities == []
+				raise "Can not add an activity with pre activities."
+			end
+			
+			@activities[activity.reference] = activity
+			
+		end
+				
+		# Connects two or more activities together. The pre_ref activity will
+		# become a pre-activity to all the activities referenced in the 
+		# post_refs parameter.
+		#
+		# Example uysage:
+		#  precNetwork.connect(:h1,:h2,:h3)
+		# will add activity 'h1' as a pre-activity to activities 'h2' and 'h3'.
+		def connect(pre_ref,*post_refs)
+			unless @activities[pre_ref]
+				raise "Pre-activity with reference #{pre_ref} "+
+					"was not found."
+			end
+			
+			post_refs.each do |post_ref|
+				unless @activities[post_ref]
+					raise "Post-activity with reference #{post_ref} "+
+						"was not found."			
+				end
+			end
+			
+			post_refs.each do |post_ref|
+				@activities[pre_ref].add_post_activities(@activities[post_ref])
+			end
+		end
+		
+		# Ensures that the network is properly connected by connecting any 
+		# activity without pre-activities to the start node and to the finish
+		# node if it has no post-activities.
+		def fix_connections!
+			@activities.each do |ref,activity|
+				next if (ref == 'start' or ref == 'finish')
+				if activity.pre_activities.size == 0
+					connect(:start,ref)
+				end
+				
+				if activity.post_activities.size == 0
+					connect(ref,:finish)
+				end
+			end
+		end
+		
+		# Returns the rdot (Ruby embedded in a dot file) template that is used
+		# by default when generating the precedence network diagrams.
+		def get_rdot_template
+		return <<EOS
+/* Generated by Precedence on <%= Time.now.to_s %> */
+digraph network {
+	rankdir=LR;
+	node [shape=record];	
+		
+	/* Activities */
+	<% @activities.each do |ref,activity| %>
+		<% case ref == 'start' 
+			when 'start'%>
+	"<%= ref %>" [label="<%= activity.description %>"];
+		<% when 'finish' %>
+	"<%= ref %>" [label="{<%= activity.description%>|<%= activity.earliest_finish %>}"];
+		<% else %>
+	"<%= ref %>" [label="<%=ref%>|{{<%=activity.earliest_start%>|<%=activity.latest_start%>}|{<%=activity.description%>|{<%=activity.total_float%>|<%=activity.early_float%>}}|{<%=activity.earliest_finish%>|<%=activity.latest_finish%>}}|<%=activity.duration%>"];
+		<% end %>
+	<% end %>
+				
+	/* Dependencies */
+	<% @activities.each do |ref,activity|%>
+		<% activity.post_activities.each do |post_activity| %>
+	"<%= activity.reference %>" -> "<%= post_activity.reference %>" <% if (activity.on_critical_path? and post_activity.on_critical_path?)%>[style=bold];<% else %>;<% end %>
+		<% end %>
+	<% end %>
+}
+EOS
+		end
+		
+		# Returns a dot file capable of being rendered by the Dot graph renderer
+		# (available from GraphViz http://www.graphviz.org).
+		def to_dot(template=nil)
+			unless template
+				template = get_rdot_template
+			end			
+			return ERB.new(template).result(binding)
+		end		
+	end
+end

data/lib/precedence.rb

@@ -0,0 +1,2 @@
+require('precedence/activity')
+require('precedence/network')

data/tests/tc_activity.rb

@@ -0,0 +1,343 @@
+require('lib/precedence/activity')
+
+class TC_Activity < Test::Unit::TestCase #:nodoc:
+
+	def setup
+		@activity1 = Precedence::Activity.new(:activity1,1,"Activity One")
+		@activity2 = Precedence::Activity.new(:activity2,2,"Activity Two")
+		@activity3 = Precedence::Activity.new(:activity3,3,"Activity Three")
+		@activity4 = Precedence::Activity.new(:activity4,4,"Activity Four")
+		@activity5 = Precedence::Activity.new(:activity5,5,"Activity Five")
+		@activity6 = Precedence::Activity.new(:activity6,6,"Activity Six")
+		@activity7 = Precedence::Activity.new(:activity7,7,"Activity Seven")
+		@activity8 = Precedence::Activity.new(:activity8,8,"Activity Eight")
+	end
+		
+	def test_initialize
+	
+		assert_raises(RuntimeError) do
+			Precedence::Activity.new(:start)
+		end		
+		assert_raises(RuntimeError) do
+			Precedence::Activity.new(:finish)
+		end
+		
+		prec = nil
+		assert_nothing_raised do
+			prec = Precedence::Activity.new(:reference)
+		end
+		assert_equal(:reference.to_s, prec.reference)
+		assert_equal("",prec.description)
+		assert_equal(0,prec.duration)
+		assert_equal([],prec.post_activities)
+		assert_equal([],prec.pre_activities)
+		
+		assert_nothing_raised do
+			prec = Precedence::Activity.new(:reference,1)
+		end
+		assert_equal(:reference.to_s, prec.reference)
+		assert_equal("", prec.description)
+		assert_equal(1,prec.duration)
+		assert_equal([],prec.post_activities)
+				assert_equal([],prec.pre_activities)
+		
+		assert_nothing_raised do
+			prec = Precedence::Activity.new(:reference,1,"description")
+		end
+		assert_equal(:reference.to_s, prec.reference)
+		assert_equal("description", prec.description)
+		assert_equal(1,prec.duration)
+		assert_equal([],prec.post_activities)
+		assert_equal([],prec.pre_activities)
+		
+		prec2 = nil
+		assert_nothing_raised do
+			prec2 = Precedence::Activity.new(:reference,1,"description",prec)
+		end
+		assert_equal(:reference.to_s, prec2.reference)
+		assert_equal("description", prec2.description)
+		assert_equal(1,prec2.duration)
+		assert_equal([prec],prec2.post_activities)
+		assert_equal([],prec.pre_activities)
+		
+		prec3 = nil
+		assert_nothing_raised do
+			prec3 = Precedence::Activity.new(:reference,1,"description")
+		end
+		assert_nothing_raised do
+			prec2 = Precedence::Activity.new(:reference,1,"description",prec,
+				prec3)
+		end
+		assert_equal(:reference.to_s, prec2.reference)
+		assert_equal("description", prec2.description)
+		assert_equal(1,prec2.duration)
+		assert_equal([prec],prec2.post_activities)
+		assert_equal([prec3],prec2.pre_activities)
+	end
+	
+	def test_to_a
+		assert_equal([@activity1],@activity1.to_a)
+	end
+	
+	def test_add_post_activities
+		assert_nothing_raised do
+			@activity1.add_post_activities(@activity2)
+		end
+		assert_equal(@activity2.to_a,@activity1.post_activities)
+		assert_equal(@activity1.to_a,@activity2.pre_activities)
+		
+		assert_nothing_raised do
+			@activity1.add_post_activities(@activity2)
+		end
+		assert_equal(1,@activity1.post_activities.size)		
+		assert_equal(1,@activity2.pre_activities.size)
+		
+		assert_nothing_raised do
+			@activity1.add_post_activities(@activity3,@activity4)
+		end
+		assert_equal([@activity2,@activity3,@activity4],
+			@activity1.post_activities)
+		assert_equal(@activity1.to_a,@activity3.pre_activities)
+		assert_equal(@activity1.to_a,@activity4.pre_activities)
+	end
+	
+	def test_add_pre_activities
+		assert_nothing_raised do
+			@activity1.add_pre_activities(@activity2)
+		end
+		assert_equal(@activity2.to_a,@activity1.pre_activities)
+		assert_equal(@activity1.to_a,@activity2.post_activities)
+		
+		assert_nothing_raised do
+			@activity1.add_pre_activities(@activity2)
+		end
+		assert_equal(1,@activity1.pre_activities.size)		
+		assert_equal(1,@activity2.post_activities.size)
+		
+		assert_nothing_raised do
+			@activity1.add_pre_activities(@activity3,@activity4)
+		end
+		assert_equal([@activity2,@activity3,@activity4],
+			@activity1.pre_activities)
+		assert_equal(@activity1.to_a,@activity3.post_activities)
+		assert_equal(@activity1.to_a,@activity4.post_activities)
+	end
+	
+	def test_remove_post_activities
+		@activity1.add_post_activities(@activity2)
+		assert_nothing_raised do
+			@activity1.remove_post_activities(@activity2)
+		end
+		assert_equal([],@activity1.post_activities)
+		assert_equal([],@activity2.pre_activities)
+		
+		@activity1.add_post_activities(@activity2,@activity3)
+		assert_nothing_raised do
+			@activity1.remove_post_activities(@activity2,@activity3)
+		end
+		assert_equal([],@activity1.post_activities)
+		assert_equal([],@activity2.pre_activities)
+		assert_equal([],@activity3.pre_activities)
+	end
+	
+	def test_remove_pre_activities
+		@activity1.add_pre_activities(@activity2)
+		assert_nothing_raised do
+			@activity1.remove_pre_activities(@activity2)
+		end
+		assert_equal([],@activity1.pre_activities)
+		assert_equal([],@activity2.post_activities)
+		
+		@activity1.add_pre_activities(@activity2,@activity3)
+		assert_nothing_raised do
+			@activity1.remove_pre_activities(@activity2,@activity3)
+		end
+		assert_equal([],@activity1.pre_activities)
+		assert_equal([],@activity2.post_activities)
+		assert_equal([],@activity3.post_activities)
+	end
+	
+	def test_earliest_finish
+		assert_equal(1,@activity1.earliest_finish)
+		
+		# a1-a2
+		@activity1.add_post_activities(@activity2)
+		assert_equal(3,@activity2.earliest_finish)
+		
+		# a1-a3-a4
+		#  '-a2-'
+		@activity1.add_post_activities(@activity3)
+		@activity3.add_post_activities(@activity4)
+		@activity2.add_post_activities(@activity4)
+		assert_equal(8,@activity4.earliest_finish)			
+	end
+	
+	def test_latest_finish
+		assert_equal(1,@activity1.latest_finish)
+		
+		# a1-a2
+		@activity1.add_post_activities(@activity2)
+		assert_equal(3,@activity2.latest_finish)
+		
+		# a1-a3-a4
+		#  '-a2-'
+		@activity1.add_post_activities(@activity3)
+		@activity3.add_post_activities(@activity4)
+		@activity2.add_post_activities(@activity4)
+		assert_equal(2,@activity2.latest_start)
+	end
+	
+	def test_on_critical_path?
+		# a1-a2
+		@activity1.add_post_activities(@activity2)
+		assert_equal(true,@activity1.on_critical_path?)
+		assert_equal(true,@activity2.on_critical_path?)
+		
+		# a1-a3-a4
+		#  '-a2-'
+		@activity1.add_post_activities(@activity3)
+		@activity3.add_post_activities(@activity4)
+		@activity2.add_post_activities(@activity4)
+		assert_equal(true,@activity1.on_critical_path?)
+		assert_equal(false,@activity2.on_critical_path?)
+		assert_equal(true,@activity3.on_critical_path?)
+		assert_equal(true,@activity4.on_critical_path?)
+	end
+	
+	def test_total_float
+		# a1-a3-a4
+		#  '-a2-'
+		@activity1.add_post_activities(@activity2)
+		@activity1.add_post_activities(@activity3)
+		@activity3.add_post_activities(@activity4)
+		@activity2.add_post_activities(@activity4)
+
+		assert_equal(0,@activity1.total_float)
+		assert_equal(0,@activity3.total_float)
+		assert_equal(0,@activity4.total_float)
+		assert_equal(1,@activity2.total_float)		
+	end
+	
+	def test_early_total_floats
+		# a1-a3---.      
+		# a2-a4-a6-a7
+		#   'a5-a7'
+		@activity1.duration = 1
+		@activity2.duration = 3
+		@activity3.duration = 2
+		@activity4.duration = 4
+		@activity5.duration = 2
+		@activity6.duration = 1
+		@activity7.duration = 2
+		@activity8.duration = 4
+		
+		@activity1.add_post_activities(@activity3)
+		@activity2.add_post_activities(@activity4,@activity5)
+		@activity3.add_post_activities(@activity8)
+		@activity4.add_post_activities(@activity6)
+		@activity5.add_post_activities(@activity7)
+		@activity6.add_post_activities(@activity8)
+		@activity7.add_post_activities(@activity8)
+		
+		assert_equal(true,@activity2.on_critical_path?)
+		assert_equal(true,@activity4.on_critical_path?)
+		assert_equal(true,@activity6.on_critical_path?)
+		assert_equal(true,@activity8.on_critical_path?)
+		
+		assert_equal(false,@activity1.on_critical_path?)
+		assert_equal(false,@activity3.on_critical_path?)
+		assert_equal(false,@activity5.on_critical_path?)
+		assert_equal(false,@activity7.on_critical_path?)
+		
+		assert_equal(0,@activity1.earliest_start)
+		assert_equal(5,@activity1.latest_start)
+		assert_equal(1,@activity1.earliest_finish)
+		assert_equal(6,@activity1.latest_finish)
+		assert_equal(5,@activity1.total_float)
+		assert_equal(0,@activity1.early_float)
+		
+		assert_equal(0,@activity2.earliest_start)
+		assert_equal(0,@activity2.latest_start)
+		assert_equal(3,@activity2.earliest_finish)
+		assert_equal(3,@activity2.latest_finish)
+		assert_equal(0,@activity2.total_float)
+		assert_equal(0,@activity2.early_float)
+
+		assert_equal(1,@activity3.earliest_start)
+		assert_equal(6,@activity3.latest_start)
+		assert_equal(3,@activity3.earliest_finish)
+		assert_equal(8,@activity3.latest_finish)
+		assert_equal(5,@activity3.total_float)
+		assert_equal(5,@activity3.early_float)
+		
+		assert_equal(3,@activity4.earliest_start)
+		assert_equal(3,@activity4.latest_start)
+		assert_equal(7,@activity4.earliest_finish)
+		assert_equal(7,@activity4.latest_finish)
+		assert_equal(0,@activity4.total_float)
+		assert_equal(0,@activity4.early_float)
+		
+		assert_equal(3,@activity5.earliest_start)
+		assert_equal(4,@activity5.latest_start)
+		assert_equal(5,@activity5.earliest_finish)
+		assert_equal(6,@activity5.latest_finish)
+		assert_equal(1,@activity5.total_float)
+		assert_equal(0,@activity5.early_float)
+		
+		assert_equal(7,@activity6.earliest_start)
+		assert_equal(7,@activity6.latest_start)
+		assert_equal(8,@activity6.earliest_finish)
+		assert_equal(8,@activity6.latest_finish)
+		assert_equal(0,@activity6.total_float)
+		assert_equal(0,@activity6.early_float)
+		
+		assert_equal(5,@activity7.earliest_start)
+		assert_equal(6,@activity7.latest_start)
+		assert_equal(7,@activity7.earliest_finish)
+		assert_equal(8,@activity7.latest_finish)
+		assert_equal(1,@activity7.total_float)
+		assert_equal(1,@activity7.early_float)
+		
+		assert_equal(8,@activity8.earliest_start)
+		assert_equal(8,@activity8.latest_start)
+		assert_equal(12,@activity8.earliest_finish)
+		assert_equal(12,@activity8.latest_finish)
+		assert_equal(0,@activity8.total_float)
+		assert_equal(0,@activity8.early_float)		
+	end
+	
+	def test_to_s
+		assert_equal("Reference: activity1\nDescription: Activity One\n"+
+			"Duration: 1.0",@activity1.to_s)
+
+		@activity1.add_pre_activities(@activity2,@activity3)
+		assert_equal("Reference: activity1\nDescription: Activity One\n"+
+			"Duration: 1.0\nDepends on:\n activity2,activity3",@activity1.to_s)
+		
+			
+	end
+end
+
+class TC_StartFinishActivity < Test::Unit::TestCase
+	def test_new
+		assert_raises(RuntimeError) do
+			Precedence::StartFinishActivity.new('bogus')
+		end	
+		
+		assert_nothing_raised do
+			Precedence::StartFinishActivity.new('start')
+		end	
+		
+		assert_nothing_raised do
+			Precedence::StartFinishActivity.new('finish')
+		end
+		
+		assert_nothing_raised do
+			Precedence::StartFinishActivity.new(:finish)
+		end
+
+		assert_nothing_raised do
+			Precedence::StartFinishActivity.new(:start)
+		end
+	end
+end

data/tests/tc_network.rb

@@ -0,0 +1,208 @@
+require('lib/precedence/network')
+
+class TC_ActivityHash < Test::Unit::TestCase
+	def test_all
+		activityHash = nil
+		assert_nothing_raised do
+			activityHash = Precedence::ActivityHash.new
+		end
+		
+		assert_nothing_raised do
+			activityHash[:test] = "test"
+		end
+		assert_equal("test",activityHash[:test])
+		assert_equal("test",activityHash['test'])		
+	end
+end
+
+class TC_Network < Test::Unit::TestCase
+
+	def setup
+		@network = Precedence::Network.new
+		@activity1 = Precedence::Activity.new('a1',1,'Activity1')
+		@activity2 = Precedence::Activity.new('a2',1,'Activity2')
+		@activity3 = Precedence::Activity.new('a3',1,'Activity3')
+	end
+
+	def test_initialize
+		net = nil
+		assert_nothing_raised do 
+			net = Precedence::Network.new
+		end
+		assert_equal(2,net.activities.size)
+		assert_equal('start',net.activities[:start].reference)
+		assert_equal('finish',net.activities[:finish].reference)
+		assert_equal('Start',net.activities[:start].description)
+		assert_equal('Finish',net.activities[:finish].description)
+		
+		assert_nothing_raised do 
+			net = Precedence::Network.new('Begin','End')
+		end
+		assert_equal('Begin',net.activities[:start].description)
+		assert_equal('End',net.activities[:finish].description)
+	end
+	
+	def test_new_activity
+		assert_raises(ArgumentError) do
+			@network.new_activity()
+		end
+	
+		assert_nothing_raised do
+			@network.new_activity('a1',1)
+		end
+		assert_equal(3,@network.activities.size)
+		assert_equal('a1',@network.activities['a1'].reference)
+		assert_equal(1,@network.activities['a1'].duration)
+		
+		assert_nothing_raised do
+			@network.new_activity('a2',2,'Activity Two')
+		end	
+		assert_equal(4,@network.activities.size)
+		assert_equal('a2',@network.activities['a2'].reference)
+		assert_equal('Activity Two',@network.activities['a2'].description)
+		assert_equal(2,@network.activities['a2'].duration)
+		
+		assert_nothing_raised do
+			@network.new_activity('a3',3,'Activity Three')
+		end	
+		assert_equal(5,@network.activities.size)
+		assert_equal('a3',@network.activities['a3'].reference)
+		assert_equal('Activity Three',@network.activities['a3'].description)
+		assert_equal(3,@network.activities['a3'].duration)
+		
+		assert_nothing_raised do
+			@network.new_activity('a4',4,'Activity Four',['a3'])
+		end	
+		assert_equal(6,@network.activities.size)
+		assert_equal('a4',@network.activities['a4'].reference)
+		assert_equal('Activity Four',@network.activities['a4'].description)
+		assert_equal(4,@network.activities['a4'].duration)
+		assert_equal(1,@network.activities['a4'].post_activities.size)
+		assert_equal('a3',@network.activities['a4'].post_activities[0].reference)
+		assert_equal('a4',@network.activities['a3'].pre_activities[0].reference)
+		
+		assert_nothing_raised do
+			@network.new_activity('a5',5,'Activity Five',['a3'],['a4'])
+		end	
+		assert_equal(7,@network.activities.size)
+		assert_equal('a5',@network.activities['a5'].reference)
+		assert_equal('Activity Five',@network.activities['a5'].description)
+		assert_equal(5,@network.activities['a5'].duration)
+		assert_equal(1,@network.activities['a5'].post_activities.size)
+		assert_equal(1,@network.activities['a5'].pre_activities.size)
+		assert_equal('a3',@network.activities['a5'].post_activities[0].reference)
+		assert_equal('a5',@network.activities['a3'].pre_activities[1].reference)
+		assert_equal('a4',@network.activities['a5'].pre_activities[0].reference)
+		assert_equal('a5',@network.activities['a4'].post_activities[1].reference)
+		
+		assert_raises(RuntimeError) do
+			@network.new_activity('a6',6,'Activity Six',['a7'])
+		end
+		
+		assert_raises(RuntimeError) do
+			@network.new_activity('a6',6,'Activity Six',['a5','a7'])
+		end
+		assert_equal(nil,
+			@network.activities['a5'].pre_activities.detect do |activity|
+											activity.reference == 'a6'
+										end)
+	
+		assert_raises(RuntimeError) do
+			@network.new_activity('a6',6,'Activity Six',[],['a5','a7'])
+		end
+		assert_equal(nil,
+			@network.activities['a5'].post_activities.detect do |activity|
+											activity.reference == 'a6'
+										end)
+	end
+	
+	def test_add_activity
+		assert_nothing_raised do
+			@network.add_activity(@activity1)
+		end
+		assert_equal(3,@network.activities.size)
+		assert_equal(@activity1,@network.activities[@activity1.reference])
+		
+		assert_raises(RuntimeError) do
+			@network.add_activity(@activity1)
+		end
+		
+		@network = Precedence::Network.new
+		@activity1.add_post_activities(@activity2)
+		assert_raises(RuntimeError) do
+			@network.add_activity(@activity1)
+		end	
+		assert_equal(2,@network.activities.size)	
+	end
+	
+	def test_connect
+		@network.add_activity(@activity1)
+		@network.add_activity(@activity2)
+		
+		assert_nothing_raised do
+			@network.connect(@activity1.reference,@activity2.reference)
+		end
+		assert_equal(1,@activity1.post_activities.size)
+		assert_equal(1,@activity2.pre_activities.size)
+		assert_equal('a2',@activity1.post_activities[0].reference)
+		assert_equal('a1',@activity2.pre_activities[0].reference)
+		
+		assert_raises(RuntimeError) do
+			@network.connect(@activity1.reference,'bogus reference')
+		end
+		assert_equal(1,@activity1.post_activities.size)
+		assert_equal('a2',@activity1.post_activities[0].reference)
+		
+		assert_raises(RuntimeError) do
+			@network.connect('bogus reference','a2')
+		end
+		assert_equal(1,@activity2.pre_activities.size)
+		assert_equal('a1',@activity2.pre_activities[0].reference)
+	end	
+		
+	def test_fix_connections!
+		@network.add_activity(@activity1)
+		@network.add_activity(@activity2)
+		@network.add_activity(@activity3)
+		@network.connect('start',@activity1.reference)
+		@network.connect(@activity1.reference,@activity2.reference)
+		@network.connect(@activity3.reference,'finish')
+		@network.fix_connections!
+		assert_equal(1,@activity2.post_activities.size)
+		assert_equal('finish',@activity2.post_activities[0].reference)
+		assert_equal(1,@activity3.pre_activities.size)
+		assert_equal('start',@activity3.pre_activities[0].reference)		
+	end
+	
+	def test_to_dot
+		net = Precedence::Network.new('Begin','End')
+		net.new_activity('act-1-1',3,'System specification')
+		net.new_activity('act-1-2',2,'Review')
+		net.new_activity('act-1-3',2,'System re-specification')
+		net.new_activity('act-2-1',3,'Test tool design')
+		net.new_activity('act-2-2',5,'Test tool implementation')
+		net.new_activity('act-3-1',3,'System design')
+		net.new_activity('act-3-2',12,'System implementation')
+		net.new_activity('act-2-3',10,'System testing')
+		net.connect('act-1-1','act-1-2')
+		net.connect('act-1-2','act-1-3')
+		net.connect('act-1-3','act-3-1')
+		net.connect('act-1-2','act-2-1')
+		net.connect('act-2-1','act-2-2')
+		net.connect('act-2-2','act-3-2')
+		net.connect('act-3-1','act-3-2')
+		net.connect('act-3-2','act-2-3')
+		net.fix_connections!
+
+		assert_nothing_raised do
+			File.open('test_to_dot.dot',File::CREAT|File::TRUNC|File::WRONLY) do|f|
+				f.puts(net.to_dot)
+			end
+		end
+		$stdout.puts("\nTest dot file test_to_dot.dot file generated.")
+		
+		if system("dot","-Tpng","-otest_to_dot.png","test_to_dot.dot")
+			$stdout.puts("Test png file test_to_dot.png files generated.")
+		end
+	end
+end

data/tests/ts_precedence.rb

@@ -0,0 +1,14 @@
+require('test/unit')
+
+require('tests/tc_activity')
+require('tests/tc_network')
+
+class TS_Precedence < Test::Unit::TestSuite
+	def initialize(name="Precedence Test Suite")
+		super(name)
+		@tests << TC_Activity.suite
+		@tests << TC_StartFinishActivity.suite
+		@tests << TC_ActivityHash.suite
+		@tests << TC_Network.suite
+	end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: precedence
+version: !ruby/object:Gem::Version 
+  version: 0.6.0
+date: 2005-05-15
+summary: A library for the creation manipulation and analysis of precedence networks.
+require_paths: 
+  - lib
+email: farrel@lifson.info
+homepage: http://precedence.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: precedence
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Farrel Lifson
+files: 
+  - lib/precedence
+  - lib/precedence.rb
+  - lib/precedence/activity.rb
+  - lib/precedence/network.rb
+  - tests/tc_activity.rb
+  - tests/tc_network.rb
+  - tests/ts_precedence.rb
+  - README
+  - CHANGELOG
+  - TODO
+test_files: 
+  - tests/ts_precedence.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+  - CHANGELOG
+  - TODO
+executables: []
+extensions: []
+requirements: []
+dependencies: []