GoNodes 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gonodes.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Mike Bethany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Original_README.md

@@ -0,0 +1,41 @@
+NOTE: If in doubt about how to submit your project, read SUBMISSION_GUIDELINES
+
+Combinatorics is a fascinating branch of mathematics that every programmer should
+have at least a working knowledge of. In this exercise, you'll research the
+topic as a group, and then produce some code that serves as an interesting
+example of what you learned.
+
+This is primarily a research exercise, but in order to get credit for working on
+it, each student is expected to produce working code that either does something
+useful on its own or alternatively serves as a tool for other projects to use.
+
+While working on this assignment, please keep the following guidelines in mind:
+
+* You can research any area of combinatorics of interest to you, but in
+  particular, you should look into graph theory because it is most directly
+  applicable to programming problems and is fairly accessible without too much
+  background information. In addition to the tremendous amount of information
+  on wikipedia, there is a [free book on Graph
+  Theory](http://code.google.com/p/graph-theory-algorithms-book/) that might 
+  be a good place to start. 
+
+* You should actively share resources with your fellow students in the session,
+  as well as discuss your ideas and questions as they arise. This will make it
+  possible to sift through the information much faster, and also help with
+  figuring out what areas might be worth focusing on. The open-endedness of this
+  exercise is intentional, so don't let it overwhelm you: Work together!
+
+* Once you've gained a basic understanding of what combinatorics is about, you
+  should think of either a program you can write that uses some combinatorial
+  concepts, or think about building some library code that will make it easier
+  for others to use combinatorial structures and algorithms in their own code.
+  Be sure to include some practical examples no matter which approach you
+  choose.
+  
+* Don't spend too much time on concepts that feel far outside of your reach, and
+  similarly, don't worry about picking a very advanced concept to demonstrate in
+  your programs. Instead, stick to the things that seem most fundamental, and
+  work with us to figure out whether what you have in mind will be a good fit
+  for this assignment. You can submit your project ideas via university-web for
+  feedback at any time during the course, and it's recommended to do so before
+  putting a lot of work into any particular idea.

data/README.markdown

@@ -0,0 +1,86 @@
+# GoNodes
+An easy way to create simple, weighted graphs. Even randomly populated ones!
+
+## Description
+If you need to create simple (in the mathematical sense), weighted graphs with  
+random values for the connections and weights then this is the gem for you.
+
+## Install
+`$ gem install gonodes`
+
+## Instructions
+The main entry into the app is the GoNodes::Graph class so I'll only cover  
+that class here. To learn how to customize usage of the library check out the  
+specs.
+
+### GoNodes::Graph
+To create your graph you might initialize a new instance like so:
+
+    graph = GoNodes::Graph.new(
+								node_count: 4, 
+								completeness: 0.5,
+							  	random_edges: true,
+							    random_weights: {median: 10, range: 4}
+							)
+
+#### GoNodes::Graph Parameters
+**node_count:**  
+*integer*  
+How many nodes there will be in the graph.  
+
+**completeness:**  
+*float*  
+The percentage of connectivity between the nodes with. A complete graph has an   
+edge going from every node to every other node. For instance if you had 5 nodes  
+then you would have 10 edges.  
+
+1.0 would be 100% complete  
+0.25 would be 25% complete  
+
+**random\_edges:**  
+*boolean*  
+If this is set to true then edges will be randomly generated between nodes  
+instead of being created in a repeatable manner.  
+
+**random\_weights:**  
+*(hash of values)*  
+To create random weights between for your edges you can specify the median  
+value and how much to randomly deviate from that number. So if you had a  
+median of 10 and a range of 4 then your weights assigned to your edges would  
+be from 8 to 12 inclusively.
+
+## Example usage
+
+	# A complete, simple graph with all nodes connected
+	graph = GoNodes::Graph.new(node_count: 12)
+	puts graph
+
+	# A full graph with all the features used
+	graph = GoNodes::Graph.new(     node_count: 8, 
+	                              completeness: 0.5,
+	                              random_edges: true,
+	                            random_weights: {median: 50, range: 10}
+	                          )
+	puts graph
+
+## License
+Copyright (c) 2011 Mike Bethany
+
+Permission is hereby granted, free of charge, to any person obtaining  
+a copy of this software and associated documentation files (the  
+"Software"), to deal in the Software without restriction, including  
+without limitation the rights to use, copy, modify, merge, publish,  
+distribute, sublicense, and/or sell copies of the Software, and to  
+permit persons to whom the Software is furnished to do so, subject to  
+the following conditions:  
+
+The above copyright notice and this permission notice shall be  
+included in all copies or substantial portions of the Software.  
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,  
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF  
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND  
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE  
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION  
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/SUBMSSIONS_GUIDES.md

@@ -0,0 +1,5 @@
+Fork this repository and hack away! When you are ready for a review, log into the RMU web app and request a review for the appropriate exercise. You can do this as often as you'd like, a general rule of thumb is to request feedback early and often.
+
+Other students in the session will be able to see your code on github, and it's okay to collaborate as long as the work you submit is mostly of your own creation. That said, do not share your solution or the problem description with anyone outside of the session without talking to me about it first. Instructors in this course will not share your submission with anyone outside of your session except RMU staff without your permission.
+
+NOTE: No work done after 7/28 will be evaluated, be sure to request an initial review way before then!

data/_spike/combo.c

@@ -0,0 +1,69 @@
+// From:
+// http://snippets.dzone.com/posts/show/4666
+// http://compprog.wordpress.com/2007/10/17/generating-combinations-1/
+
+#include <stdio.h>
+
+/* Prints out a combination like {1, 2} */
+void printc(int comb[], int k) {
+	printf("{");
+	int i;
+	
+	for (i = 0; i < k; ++i)
+	{printf("%d, ", comb[i] + 1);}
+	
+	printf("\b\b}\n");
+}
+
+/*
+	next_comb(int comb[], int k, int n)
+	Generates the next combination of n elements as k after comb
+
+	comb => the previous combination ( use (0, 1, 2, ..., k) for first)
+	k 	 => the size of the subsets to generate
+	n    => the size of the original set
+
+	Returns: 1 if a valid combination was found 0, otherwise
+*/
+int next_comb(int comb[], int k, int n) {
+	int i = k - 1;
+	++comb[i];
+	while ((i >= 0) && (comb[i] >= n - k + 1 + i))
+	{
+		--i;
+		++comb[i];
+	}
+
+	if (comb[0] > n - k) /* Combination (n-k, n-k+1, ..., n) reached */
+		return 0; /* No more combinations can be generated */
+
+	/* comb now looks like (..., x, n, n, n, ..., n).
+	Turn it into (..., x, x + 1, x + 2, ...) */
+	for (i = i + 1; i < k; ++i)
+	{comb[i] = comb[i - 1] + 1;}
+
+	return 1;
+}
+
+int main(int argc, char *argv[]) {
+	int n = 10000; 	/* The size of the set; for {1, 2, 3, 4} it's 4 */
+	int k = 2; 		/* The size of the subsets; for {1, 2}, {1, 3}, ... it's 2 */
+	int comb[16]; 	/* comb[i] is the index of the i-th element in the combination */
+
+	/* Setup comb for the initial combination */
+	int i;
+	for (i = 0; i < k; ++i)
+	{ comb[i] = i; }
+
+	/* Print the first combination */
+	//printc(comb, k);
+
+	/* Generate and print all the other combinations */
+	while (next_comb(comb, k, n))
+	{
+		//printc(comb, k);
+	}
+
+	printf("\n all done\n");
+	return 0;
+}

data/_spike/examples.rb

@@ -0,0 +1,14 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'gonodes'
+
+# A complete, simple graph with all nodes connected
+graph = GoNodes::Graph.new(node_count: 12)
+puts graph
+
+# A full graph with all the features used
+graph = GoNodes::Graph.new(     node_count: 8, 
+                              completeness: 0.5,
+                              random_edges: true,
+                            random_weights: {median: 50, range: 10}
+                          )
+puts graph

data/_spike/speed.rb

@@ -0,0 +1,27 @@
+# 1 = A ... 26 = Z, 27 = AA, 28 = AB ... etc
+def alpha_new(number)
+  "A".tap {|a| (number-1).times {a.succ!}}
+end
+
+def alpha_old(number)
+ alpha = ""
+ begin
+   alpha << ((number-=1) % 26) + 65
+ end while (number /= 26) > 0
+ alpha.reverse
+end
+#puts alpha_old(64 * 1024)
+
+# t = Time.now
+# (20000).times {|x| alpha_new(x) }
+# puts Time.now - t
+
+# t = Time.now
+# (10000).times {|x| alpha_new(x) }
+# puts Time.now - t
+# => 20.895054
+
+t = Time.now
+(5000).times {|x| alpha_old(x) }
+puts Time.now - t
+# => 0.011024

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery {"rspec2"}

data/gonodes.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gonodes/version"
+
+Gem::Specification.new do |s|
+  s.name        = "GoNodes"
+  s.version     = GoNodes::VERSION
+  s.authors     = ["Mike Bethany"]
+  s.email       = ["mikbe.tk@gmail.com"]
+  s.homepage    = "http://mikbe.tk/projects#gonodes"
+  s.summary     = %q{An easy way to create simple, weighted graphs. Even randomly populated ones!}
+  s.description = %q{If you need to create simple (in the mathematical sense), weighted graphs with  
+  random values for the connections and weights then this is the gem for you.}
+
+  s.rubyforge_project = "gonodes"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
+end

data/lib/gonodes.rb

@@ -0,0 +1,13 @@
+require "delegate"
+require "set"
+
+require "monkeypatch/set"
+
+require "gonodes/version"
+
+require "gonodes/error"
+require "gonodes/node"
+require "gonodes/node_list"
+require "gonodes/edge"
+require "gonodes/edge_list"
+require "gonodes/graph"

data/lib/gonodes/edge.rb

@@ -0,0 +1,77 @@
+module GoNodes
+  
+  class Edge
+    
+    attr_accessor :name, :start_node, :end_node, :weight, :direction
+    
+    def initialize(params={})
+      
+      @start_node = params[:start_node] if params[:start_node]
+      @end_node   = params[:end_node]   if params[:end_node]
+    
+      @weight     = params[:weight]     if params[:weight]
+
+      @directed   = !!params[:directed] if params[:directed]
+      @directed ||= false
+    
+      set_direction
+      create_name
+      
+    end
+    
+    def to_s
+      ["      name: #{@name}",
+       "    weight: #{@weight}",
+       " direction: #{@direction}"].join("\n")
+    end
+    
+    def is_directed?
+      @directed
+    end
+    
+    def set_direction
+      return unless is_directed? && @start_node && @end_node
+
+      @direction = "#{@start_node.name} -> #{@end_node.name}"
+    end
+    
+    def create_name
+      return unless @start_node && @end_node
+      start_name  = convert_node_name(@start_node)
+      end_name    = convert_node_name(@end_node)
+      
+      @name = "{#{start_name},#{end_name}}"
+    end
+    
+    def ==(other_edge)
+      
+      self_nodes  = [self.start_node, self.end_node]
+      other_nodes = [other_edge.start_node, other_edge.end_node]
+
+      unless self.is_directed? || other_edge.is_directed?
+        self_nodes.sort!
+        other_nodes.sort!
+      end
+      
+      [self_nodes, self.is_directed?, self.weight] == 
+        [other_nodes, other_edge.is_directed?, other_edge.weight]
+    end
+    
+    def <=>(other_edge)
+      self_nodes  = [self.start_node, self.end_node]
+      other_nodes = [other_edge.start_node, other_edge.end_node]
+      
+      [self_nodes, self.is_directed?, self.weight] <=> 
+        [other_nodes, other_edge.is_directed?, other_edge.weight]
+    end
+    
+    private 
+    
+    def convert_node_name(node)
+      return node.name if node.name.is_a? Numeric
+      "#{node.name.inspect}".downcase
+    end
+    
+  end
+  
+end

data/lib/gonodes/edge_list.rb

@@ -0,0 +1,73 @@
+module GoNodes
+  
+  class EdgeList < DelegateClass(Set)
+
+    attr_reader :completeness
+
+    def initialize(node_list)
+      @node_list = node_list
+      @edges = Set.new
+      super(@edges)
+    end
+    
+    def to_s
+      @edges.map{|edge| edge.to_s}.join("\n\n")
+    end
+
+    def self.new_with_count(params)
+      EdgeList.new(params[:node_list]).
+        populate_with_count(params[:count])
+    end
+
+    def self.new_with_completeness(params)
+      EdgeList.new(params[:node_list]).
+        populate_with_completeness(params[:completeness])
+    end
+
+    def ==(other_edge_list)
+      self.sort == other_edge_list.sort
+    end
+    
+    def populate_with_count(edge_count)
+      @completeness = (edge_count.to_f / maximum_edges).round(2)
+      
+      node_list_combo = possible_edges.cycle
+      
+      @edges.clear
+      edge_count.times do
+        start_node, end_node = node_list_combo.next
+        @edges << Edge.new(
+          start_node: start_node,
+          end_node:   end_node 
+        )
+      end
+      self
+    end
+
+    def populate_with_completeness(completeness)
+      edge_count = normalized_edge_count(completeness)
+      populate_with_count(edge_count)
+    end
+
+    def add_edge(edge_params)
+      @edges << Edge.new(edge_params)
+      self
+    end
+
+    def normalized_edge_count(completeness)
+      (maximum_edges * completeness).to_i
+    end
+    
+    # refactor after everything works - slow with more than a few hundred
+    # if loopback edges are required I could use repeated_combination
+    def possible_edges
+      @possible_edges ||= @node_list.to_a.combination(2).to_a
+    end
+    
+    def maximum_edges
+      (@node_list.count * (@node_list.count - 1)) / 2
+    end
+    
+  end
+  
+end

data/lib/gonodes/error.rb

@@ -0,0 +1,9 @@
+module GoNodes
+  
+  module Error
+    
+    exceptions = [:BadNodeName] # %{NoNodeName SomeOtherError}
+    exceptions.each {|e| const_set(e, Class.new(StandardError))}
+    
+  end
+end

data/lib/gonodes/graph.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+
+module GoNodes
+  
+  class Graph
+
+    attr_reader :nodes, :edges
+
+    def initialize(params={})
+
+      @nodes = NodeList.new
+      @nodes.populate_with_count(params[:node_count]) if params[:node_count]
+      @nodes.populate_with_names(params[:node_names]) if params[:node_names]
+
+      @edges = EdgeList.new(@nodes)
+      completeness = params[:completeness] ? params[:completeness] : 1.0
+
+      if params[:random_edges] && completeness != 1.0
+        randomize_edges(completeness)
+      else
+        @edges.populate_with_completeness(completeness)
+      end
+
+      randomize_weights(params[:random_weights]) if params[:random_weights]
+    end
+
+    def completeness
+      @edges.completeness
+    end
+
+    def ==(other_graph)
+      @nodes == other_graph.nodes && @edges == other_graph.edges
+    end
+
+    def randomize_edges(completeness)
+      edge_count = @edges.normalized_edge_count(completeness)
+      edge_nodes = @edges.possible_edges.sample(edge_count)
+      edge_nodes.each do |nodes|
+        @edges.add_edge(start_node: nodes[0], end_node: nodes[1])
+      end
+    end
+
+    def randomize_weights(random_weights)
+      median = random_weights[:median]
+      range  = random_weights[:range]
+      @edges.each do |edge|
+        edge.weight = median + rand(range) - (range / 2)
+      end
+    end
+
+    def to_s
+      "Nodes:\n#{@nodes.to_s}\n\nEdges:\n#{@edges.to_s}"
+    end
+
+  end
+
+end

data/lib/gonodes/node.rb

@@ -0,0 +1,29 @@
+module GoNodes
+  
+  class Node
+    
+    attr_reader :name
+    
+    def initialize(name=nil)
+      raise GoNodes::Error::BadNodeName, 
+        "Nodes may only be named using a symbol, string, or number" unless 
+        [NilClass, String, Symbol].include?(name.class) || name.is_a?(Numeric)
+      
+      @name = name ? name : self.object_id
+    end
+    
+    def to_s
+      @name
+    end
+    
+    def ==(other_node)
+      self.name == other_node.name
+    end
+  
+    def <=>(other_node)
+      self.name <=> other_node.name
+    end
+  
+  end
+  
+end

data/lib/gonodes/node_list.rb

@@ -0,0 +1,52 @@
+module GoNodes
+
+  class NodeList < DelegateClass(Set)
+
+    def initialize
+      @nodes = Set.new
+      super(@nodes)
+    end
+
+    def to_s
+      @nodes.to_a.join(", ")
+    end
+
+    def self.new_with_count(count)
+      node_list = NodeList.new
+      node_list.populate_with_count(count)
+      node_list
+    end
+
+    def self.new_with_names(names)
+      node_list = NodeList.new
+      node_list.populate_with_names(names)
+      node_list
+    end
+    
+    def [](node_name)
+      @nodes.select{|node,_| node.name == node_name}.first
+    end
+
+    def ==(other_node_list)
+      self.sort == other_node_list.sort
+    end
+
+    def populate_with_count(node_count)
+      return unless node_count
+      alpha = "A"
+      @nodes.clear
+      node_count.times do
+        @nodes << Node.new(alpha)
+        alpha = alpha.succ
+      end
+    end
+
+    def populate_with_names(node_names)
+      return unless node_names
+      @nodes.clear
+      node_names.each { |name| @nodes << Node.new(name)}
+    end
+
+  end
+  
+end

data/lib/gonodes/version.rb

@@ -0,0 +1,3 @@
+module GoNodes
+  VERSION = "0.0.1"
+end

data/lib/monkeypatch/set.rb

@@ -0,0 +1,9 @@
+require 'set'
+
+class Set
+
+  def last
+    @hash.keys.last
+  end
+
+end

data/spec/gonodes/edge_list_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe GoNodes::EdgeList do
+
+  describe "a new EdgeList" do
+    
+    it "should initialize using a number of edges" do
+      node_list = GoNodes::NodeList.new_with_count(4)
+      edge_list = GoNodes::EdgeList.new_with_count(
+        node_list: node_list, 
+        count: 6
+      )
+      
+      edge_list.count.should == 6
+    end
+    
+    it "should initialize using a completeness percentage" do
+      node_list = GoNodes::NodeList.new_with_count(4)
+      edge_list = GoNodes::EdgeList.new_with_completeness(
+        node_list: node_list, 
+        completeness: 0.5
+      )
+
+      edge_list.count.should == 3
+    end
+
+    it "should create an empty set if no count or completeness are given" do
+      node_list = GoNodes::NodeList.new_with_count(4)
+      edge_list = GoNodes::EdgeList.new(node_list)
+
+      edge_list.should be_empty
+    end
+    
+  end
+  
+  context "when populating using a completeness percentage" do
+    
+    it "should create the appropriate number of edges" do
+      node_list = GoNodes::NodeList.new_with_count(4)
+      edge_list = GoNodes::EdgeList.new(node_list)
+    
+      edge_list.populate_with_completeness(1.0)
+    
+      edge_list.count.should == 6
+    end
+  
+    it "should normalize completeness level if not evenly divisible to edges" do
+      node_list = GoNodes::NodeList.new_with_count(5)
+      edge_list = GoNodes::EdgeList.new(node_list)
+    
+      edge_list.populate_with_completeness(0.66)
+
+      edge_list.completeness.should == 0.6
+    end
+
+    it "should create edges using the given nodes" do
+      node_list = GoNodes::NodeList.new_with_count(2)
+      edge_list = GoNodes::EdgeList.new(node_list)
+      edge_list.populate_with_completeness(1.0)
+
+      edge_list.first.start_node.name.should == "A"
+    end
+    
+    it "should add new edge using edge parameters" do
+      node_list = GoNodes::NodeList.new_with_count(2)
+      edge_list = GoNodes::EdgeList.new(node_list)
+
+      edge_list.possible_edges.each do |edge|
+        edge_list.add_edge(start_node: edge[0], end_node: edge[1])
+      end
+      edge_list.first.start_node.should_not be_nil
+    end
+
+  end
+
+  context "when populating using a number of edges" do
+  
+    it "should create the specified number of edges" do
+      node_list = GoNodes::NodeList.new_with_count(5)
+      edge_list = GoNodes::EdgeList.new(node_list)
+    
+      edge_list.populate_with_count(10)
+
+      edge_list.count.should == 10
+    end
+
+  end
+
+  context "when testing equality" do
+
+    it "should equate edgelists with equal edges" do
+      node_list1 = GoNodes::NodeList.new_with_names(%w{B A})
+      edge_list1 = GoNodes::EdgeList.new(node_list1)
+      edge_list1.populate_with_completeness(1.0)
+
+      node_list2 = GoNodes::NodeList.new_with_names(%w{A B})
+      edge_list2 = GoNodes::EdgeList.new(node_list2)
+      edge_list2.populate_with_completeness(1.0)
+
+      edge_list1.should == edge_list2
+    end
+    
+    it "should not equate edgelists with unequal edges" do
+      node_list1 = GoNodes::NodeList.new_with_names(%w{A B})
+      edge_list1 = GoNodes::EdgeList.new(node_list1)
+      edge_list1.populate_with_completeness(1.0)
+
+      node_list2 = GoNodes::NodeList.new_with_names(%w{A C})
+      edge_list2 = GoNodes::EdgeList.new(node_list2)
+      edge_list2.populate_with_completeness(1.0)
+      
+      edge_list1.should_not == edge_list2
+    end
+
+  end
+
+  it "should calculate an array of possible edges" do
+    node_list = GoNodes::NodeList.new_with_names(%w{A B C})
+    edge_list = GoNodes::EdgeList.new(node_list)
+    
+    edge_list.possible_edges.should == [
+      [node_list["A"], node_list["B"]],
+      [node_list["A"], node_list["C"]],
+      [node_list["B"], node_list["C"]],
+    ]
+    
+  end
+
+  it "should output a human readable list when printed" do
+    node_list = GoNodes::NodeList.new_with_count(3)
+    edge_list = GoNodes::EdgeList.new(node_list)
+    edge_list.populate_with_completeness(1.0)
+
+    edge_list.to_s.should == 
+      "      name: {\"a\",\"b\"}\n" + 
+      "    weight: \n direction: \n\n" +
+      "      name: {\"a\",\"c\"}\n" +
+      "    weight: \n direction: \n\n" +
+      "      name: {\"b\",\"c\"}\n" +
+      "    weight: \n direction: "
+
+  end
+
+end

data/spec/gonodes/edge_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe GoNodes::Edge do
+
+  it "should set its start node" do
+    node1 = GoNodes::Node.new(:A)
+    edge  = GoNodes::Edge.new(start_node: node1)
+    edge.start_node.should == node1
+  end
+
+  it "should set its end node" do
+    node2 = GoNodes::Node.new(:B)
+    edge  = GoNodes::Edge.new(end_node: node2)
+    edge.end_node.should == node2
+  end
+
+  it "should set its weight" do
+    edge = GoNodes::Edge.new(weight: 4)
+    edge.weight.should == 4
+  end
+
+  it "should set its direction" do
+    edge = GoNodes::Edge.new(directed: true)
+    edge.is_directed?.should be_true
+  end
+
+  it "should default to undirected if direction is not specified" do
+    edge = GoNodes::Edge.new
+    edge.is_directed?.should be_false
+  end
+
+  it "should set a direction of start_node -> end_node if it is directed" do
+    node1 = GoNodes::Node.new(:A)
+    node2 = GoNodes::Node.new(:B)
+    
+    edge  = GoNodes::Edge.new(start_node: node1, end_node: node2, directed: true)
+    
+    edge.direction.should == "A -> B"
+  end
+
+  it "should create a lower case name for itself based on its end points" do
+    node1 = GoNodes::Node.new(:A)
+    node2 = GoNodes::Node.new(:B)
+    
+    edge  = GoNodes::Edge.new(start_node: node1, end_node: node2)
+    
+    edge.name.should == "{:a,:b}"
+  end
+
+  it "should create a name using numerically named end points" do
+    require 'bigdecimal'
+    names = [BigDecimal("#{Math::PI}"), BigDecimal("#{Math::E}")]
+    node1 = GoNodes::Node.new(names[0])
+    node2 = GoNodes::Node.new(names[1])
+    
+    edge  = GoNodes::Edge.new(start_node: node1, end_node: node2)
+    
+    edge.name.should == "{#{names[0]},#{names[1]}}"
+  end
+
+  context 'when testing equality' do
+    
+    it 'should equate edges having the same properites' do
+      node1 = GoNodes::Node.new(:A)
+      node2 = GoNodes::Node.new(:B)
+      node3 = GoNodes::Node.new(:A)
+      node4 = GoNodes::Node.new(:B)
+    
+      edge1 = GoNodes::Edge.new(
+        start_node: node1,
+        end_node:   node2,
+        directed:   true,
+        weight:     10
+      )
+      edge2 = GoNodes::Edge.new(
+        start_node: node3,
+        end_node:   node4,
+        directed:   true,
+        weight:     10
+      )
+
+      edge1.should == edge2
+    end
+    
+    it 'should not equate edges with only some similar properties' do
+      node1 = GoNodes::Node.new(:A)
+      node2 = GoNodes::Node.new(:B)
+      node3 = GoNodes::Node.new(:A)
+      node4 = GoNodes::Node.new(:C)
+    
+      edge1 = GoNodes::Edge.new(
+        start_node: node1,
+        end_node:   node2
+      )
+      edge2 = GoNodes::Edge.new(
+        start_node: node3,
+        end_node:   node4
+      )
+      
+      edge1.should_not == edge2
+    end
+    
+    it "shouldn't == directed with same endpoints but different directions" do
+      node1 = GoNodes::Node.new(:A)
+      node2 = GoNodes::Node.new(:B)
+      node3 = GoNodes::Node.new(:B)
+      node4 = GoNodes::Node.new(:A)
+    
+      edge1 = GoNodes::Edge.new(
+        start_node: node1,
+        end_node:   node2,
+        directed:   true
+      )
+      edge2 = GoNodes::Edge.new(
+        start_node: node3,
+        end_node:   node4,
+        directed:   true
+      )
+      
+      edge1.should_not == edge2
+    end
+  
+   it "should equate undirected edges with same endpoints in different order" do
+     node1 = GoNodes::Node.new(:A)
+     node2 = GoNodes::Node.new(:B)
+     node3 = GoNodes::Node.new(:B)
+     node4 = GoNodes::Node.new(:A)
+   
+     edge1 = GoNodes::Edge.new(
+       start_node: node1,
+       end_node:   node2,
+       directed:   false
+     )
+     edge2 = GoNodes::Edge.new(
+       start_node: node3,
+       end_node:   node4,
+       directed:   false
+     )
+     
+     edge1.should == edge2
+   end
+  
+  end
+  
+  context "when sorting" do
+    
+    it "should sort using nodes, weight, and is_directed" do
+      node1 = GoNodes::Node.new(:A)
+      node2 = GoNodes::Node.new(:B)
+      node3 = GoNodes::Node.new(:A)
+      node4 = GoNodes::Node.new(:D)
+    
+      edge1 = GoNodes::Edge.new(
+        start_node: node3,
+        end_node:   node4,
+        directed:   true,
+        weight:     10
+      )
+      edge2 = GoNodes::Edge.new(
+        start_node: node1,
+        end_node:   node2,
+        directed:   true,
+        weight:     10
+      )
+      
+      [edge1, edge2].sort.should == [edge2, edge1]
+      
+    end
+    
+  end
+  
+  it "should output human readable information when printed" do
+    node1 = GoNodes::Node.new(:A)
+    node2 = GoNodes::Node.new(:B)
+  
+    edge  = GoNodes::Edge.new(
+      start_node: node1,
+      end_node:   node2,
+      directed:   true,
+      weight:     10
+    )
+
+    edge.to_s.should == 
+"""      name: {:a,:b}
+    weight: 10
+ direction: A -> B"""
+     
+  end
+
+end

data/spec/gonodes/graph_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe GoNodes::Graph do
+  
+  let(:graph) {GoNodes::Graph.new}
+    
+  it "should create the specified number of nodes" do
+    graph = GoNodes::Graph.new(node_count: 4)
+    graph.nodes.count.should == 4
+  end
+  
+  it "should create nodes using a provided array of names" do
+    graph = GoNodes::Graph.new(node_names: %w{D E F 7 5 4})
+    graph.nodes.collect{|node| node.name}.sort.should == %w{D E F 7 5 4}.sort
+  end
+  
+  it "should set the specified level of completeness" do
+    graph = GoNodes::Graph.new(node_count: 4, completeness: 0.5)
+    graph.completeness.should == 0.5
+  end
+
+  it "should set completeness to 100% if it is not specified" do
+    graph = GoNodes::Graph.new(node_count: 4)
+    graph.completeness.should == 1.0
+  end
+
+  it "should equate graphs will all things being equal" do
+    graph1 = GoNodes::Graph.new(node_count: 4, completeness: 1.0)
+    graph2 = GoNodes::Graph.new(node_count: 4, completeness: 1.0)
+    graph1.should == graph2
+  end
+
+  it "should create not generate random graphs normally" do
+    settings = {node_count: 50, completeness: 0.1, random_edges: false}
+    graphs = 10.times.collect{GoNodes::Graph.new(settings)}
+    
+    graphs.combination(2).all? do |combo|
+      combo[0] == combo[1]
+    end.should be_true
+    
+  end
+
+  it "should create randomly generated graphs" do
+    settings = {node_count: 50, completeness: 0.1, random_edges: true}
+    graphs = 10.times.collect{GoNodes::Graph.new(settings)}
+    
+    graphs.combination(2).any? do |combo|
+      combo[0] != combo[1]
+    end.should be_true
+  end
+
+  it "should make randomly weighted edges using a median and range" do
+    settings = {
+      node_count: 4, 
+      random_weights: {median: 50, range: 10}
+    }
+    graphs = 10.times.collect{GoNodes::Graph.new(settings)}
+    
+    graphs.combination(2).any? do |combo|
+      combo[0] != combo[1]
+    end.should be_true
+  end
+
+  it "should print out a human readable represenation of the graph" do
+    graph = GoNodes::Graph.new(node_count: 3, completeness: 1.0)
+    graph.to_s.should == 
+      "Nodes:\n" + 
+      "A, B, C\n\n" + 
+      "Edges:\n" + 
+      "      name: {\"a\",\"b\"}\n" + 
+      "    weight: \n direction: \n\n" + 
+      "      name: {\"a\",\"c\"}\n" +
+      "    weight: \n direction: \n\n" + 
+      "      name: {\"b\",\"c\"}\n" + 
+      "    weight: \n direction: "
+  end
+
+end

data/spec/gonodes/node_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe GoNodes::Node do
+  
+  describe "a new node" do
+    
+    it "should set the specified name" do
+      node = GoNodes::Node.new("A")
+      node.name.should == "A"
+    end
+    
+    it "should set its name to its object ID if no name is specified" do
+      node = GoNodes::Node.new
+      node.name.should == node.object_id
+    end
+
+    it "should set any type of number as its name" do
+      require 'bigdecimal'
+      numbers = [42, 4.2, BigDecimal("#{Math::PI}")]
+      numbers.collect {|name| GoNodes::Node.new(name).name}.should == numbers
+    end
+
+    it "should raise an exception if something other than alphanumerics or numbers are given as a name" do
+      expect{GoNodes::Node.new(String)}.should raise_error(GoNodes::Error::BadNodeName)
+    end
+
+  end
+
+  it 'should not change its name if the object that originally specified its name changes' do
+    name = "A"
+    node = GoNodes::Node.new(name)
+    expect{name.succ!}.should_not change(node, :name) 
+  end
+    
+  it "should equate two nodes with the same name" do
+    node1 = GoNodes::Node.new("A")
+    node2 = GoNodes::Node.new("A")
+    node1.should == node2
+  end
+  
+  it "should sort by node name" do
+    node1 = GoNodes::Node.new("Z")
+    node2 = GoNodes::Node.new("A")
+    
+    [node1, node2].sort.should == [node2, node1]
+  end
+  
+  it "should output its name when printed" do
+    node1 = GoNodes::Node.new("Z")
+    node1.to_s.should == "Z"
+  end
+  
+end

data/spec/gonodes/nodes_list_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe GoNodes::NodeList do
+
+  let(:node_list){GoNodes::NodeList.new}
+
+  describe "a new NodeList" do
+    
+    it "should initialize using a number of nodes" do
+      node_list = GoNodes::NodeList.new_with_count(15)
+      node_list.last.name.should == "O"
+    end
+    
+    it "should initialize using an array of node names" do
+      node_list = GoNodes::NodeList.new_with_names(%w{A B C D E F G})
+      node_list.last.name.should == "G"
+    end
+    
+  end
+
+  context "when populating the node list" do
+  
+    it "should create an empty set if none were specified when initialized" do
+      GoNodes::NodeList.new
+      node_list.should be_empty
+    end
+  
+    it "should create the specified number of nodes" do
+      node_list.populate_with_count(4)
+      node_list.count.should == 4
+    end
+    
+    it "should name nodes alphabetically" do
+      node_list.populate_with_count(4)
+      node_list.last.name.should == "D"
+    end
+    
+    it "should name nodes alphabetically" do
+      node_list.populate_with_count(4)
+      node_list.first.name.should == "A"
+    end
+  
+    it "should name nodes uniquely when there are more than 26 node_list" do
+      node_list.populate_with_count(64 * 1024)
+      node_list.last.name.should == "CRXP"
+    end
+  
+    it "should create nodes using an array of node names" do
+      node_list.populate_with_names(%w{A B C 1 2 3})
+      node_list.collect{|node| node.name}.sort.should == %w{A B C 1 2 3}.sort
+    end
+    
+  end
+
+  context "when accessing the node list using square brackets []" do
+    
+    it "should return the Node object matching the node name" do
+      node_list.populate_with_count(4)
+      node_list["A"].should eql(node_list.first)
+    end
+    
+    it "should not use the index of keys but the keys themselves" do
+      node_list.populate_with_names([10,11,12,13])
+      node_list[0].should be_nil
+    end
+    
+    it "should return the correct node when using numbers" do
+      node_list.populate_with_names([10.4,11.6,12.1,13.78])
+      node_list[13.78].should eql(node_list.last)
+    end
+    
+  end
+
+  context "when testing equality" do
+
+    it "should equate regardless of order" do
+      node_list1 = GoNodes::NodeList.new_with_names(%w{A B})
+      node_list2 = GoNodes::NodeList.new_with_names(%w{B A})
+      
+      node_list1.should == node_list2
+    end
+
+  end
+
+  it "it should print out a human readable list of nodes" do
+    node_list = GoNodes::NodeList.new_with_names(%w{A B})
+    
+    node_list.to_s.should == "A, B"
+
+  end
+
+end

data/spec/monkeypatch/set_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Set do
+  
+  it "should have a last if it has a first" do
+    set = Set.new
+    set.should respond_to(:last) if set.respond_to? :first
+  end
+
+  it "should return the last value of the set" do
+    set = Set.new
+    
+    set << "A"
+    set << "M"
+    set << "Z"
+    
+    set.last.should == "Z"
+  end
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+$: << '.'
+
+require 'rspec'
+require 'gonodes'

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: GoNodes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mike Bethany
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-20 00:00:00.000000000Z
+dependencies: []
+description: ! "If you need to create simple (in the mathematical sense), weighted
+  graphs with  \n  random values for the connections and weights then this is the
+  gem for you."
+email:
+- mikbe.tk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- Original_README.md
+- README.markdown
+- Rakefile
+- SUBMSSIONS_GUIDES.md
+- _spike/combo
+- _spike/combo.c
+- _spike/examples.rb
+- _spike/speed.rb
+- autotest/discover.rb
+- gonodes.gemspec
+- lib/.DS_Store
+- lib/gonodes.rb
+- lib/gonodes/edge.rb
+- lib/gonodes/edge_list.rb
+- lib/gonodes/error.rb
+- lib/gonodes/graph.rb
+- lib/gonodes/node.rb
+- lib/gonodes/node_list.rb
+- lib/gonodes/version.rb
+- lib/monkeypatch/set.rb
+- spec/gonodes/edge_list_spec.rb
+- spec/gonodes/edge_spec.rb
+- spec/gonodes/graph_spec.rb
+- spec/gonodes/node_spec.rb
+- spec/gonodes/nodes_list_spec.rb
+- spec/monkeypatch/set_spec.rb
+- spec/spec_helper.rb
+homepage: http://mikbe.tk/projects#gonodes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: gonodes
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: An easy way to create simple, weighted graphs. Even randomly populated ones!
+test_files: []