├── docs
    ├── index.md
    ├── support.md
    └── index.html
├── .gitignore
├── lib
    ├── abuelo
    │   ├── version.rb
    │   ├── exceptions
    │   │   └── exceptions.rb
    │   ├── node.rb
    │   ├── edge.rb
    │   ├── algorithms
    │   │   └── dijkstra.rb
    │   └── graph.rb
    └── abuelo.rb
├── .travis.yml
├── Gemfile
├── Rakefile
├── spec
    ├── spec_helper.rb
    ├── edge_spec.rb
    ├── node_spec.rb
    ├── algorithms
    │   └── dijkstra_spec.rb
    └── graph_spec.rb
├── CHANGELOG.md
├── javascripts
    └── scale.fix.js
├── Gemfile.lock
├── abuelo.gemspec
├── MIT-LICENSE
├── params.json
├── CODE_OF_CONDUCT.md
├── stylesheets
    ├── github-light.css
    ├── stylesheet.css
    ├── styles.css
    └── normalize.css
├── index.html
└── README.md


/docs/index.md:
--------------------------------------------------------------------------------
1 | # Index
2 | 


--------------------------------------------------------------------------------
/docs/support.md:
--------------------------------------------------------------------------------
1 | # Test
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | *~
2 | .bundle
3 | .yardoc
4 | doc/*
5 | pkg
6 | log
7 | test/tmp/*


--------------------------------------------------------------------------------
/lib/abuelo/version.rb:
--------------------------------------------------------------------------------
1 | module Abuelo
2 |   VERSION = '0.1.0'.freeze
3 | end
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: ruby
2 | rvm:
3 |   - 2.3.0
4 |   - 2.2.4
5 |   - 2.1.8
6 |   - 2.0.0


--------------------------------------------------------------------------------
/Gemfile:
--------------------------------------------------------------------------------
1 | source 'https://rubygems.org'
2 | 
3 | # Specify your gem's dependencies in abuelo.gemspec
4 | gemspec
5 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | require 'bundler/gem_tasks'
2 | require 'rspec/core/rake_task'
3 | 
4 | task default: :tests
5 | task tests: [:spec]
6 | 
7 | RSpec::Core::RakeTask.new(:spec)
8 | 


--------------------------------------------------------------------------------
/lib/abuelo.rb:
--------------------------------------------------------------------------------
1 | require 'abuelo/graph'
2 | require 'abuelo/node'
3 | require 'abuelo/edge'
4 | require 'abuelo/algorithms/dijkstra'
5 | require 'abuelo/exceptions/exceptions'
6 | 


--------------------------------------------------------------------------------
/lib/abuelo/exceptions/exceptions.rb:
--------------------------------------------------------------------------------
 1 | module Abuelo
 2 |   module Exceptions
 3 |     class NodeAlreadyExistsError < StandardError
 4 |     end
 5 | 
 6 |     class EdgeAlreadyExistsError < StandardError
 7 |     end
 8 | 
 9 |     class NoNodeError < StandardError
10 |     end
11 |   end
12 | end
13 | 


--------------------------------------------------------------------------------
/spec/spec_helper.rb:
--------------------------------------------------------------------------------
 1 | $LOAD_PATH << File.join(File.dirname(__FILE__), '/../lib')
 2 | require "#{File.dirname(__FILE__)}/../lib/abuelo"
 3 | require 'pry'
 4 | 
 5 | RSpec.configure do |config|
 6 |   config.run_all_when_everything_filtered = true
 7 |   config.filter_run :focus
 8 |   config.order = 'random'
 9 | end
10 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # 0.1.0 - 2016-02-24
 2 | * implemented Dijkstra's algorithm
 3 | 
 4 | # 0.0.2 - 2016-02-21
 5 | * new possibility to build a graph: adjacency matrix
 6 | * added code of conduct
 7 | * refactoring to better meet community standards
 8 | * dropped support for Ruby < 2.0.0
 9 | 
10 | # 0.0.1 - 2016-01-17
11 | hello world


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
1 | <h1>Hello World</h1>
2 | <script>
3 | !function(a,b,c,d,e,f){e=b.createElement("script"),e.type="text/javascript",e.async=!0,e.src="https://steadyhq.com/js/widget.js",f=b.getElementsByTagName("script")[0],f.parentNode.insertBefore(e,f),e.onload=function(){new Steady.Widget(c,d)}}(window,document,"schmalbart","de");
4 | </script>
5 | 


--------------------------------------------------------------------------------
/javascripts/scale.fix.js:
--------------------------------------------------------------------------------
 1 | var metas = document.getElementsByTagName('meta');
 2 | var i;
 3 | if (navigator.userAgent.match(/iPhone/i)) {
 4 |   for (i=0; i<metas.length; i++) {
 5 |     if (metas[i].name == "viewport") {
 6 |       metas[i].content = "width=device-width, minimum-scale=1.0, maximum-scale=1.0";
 7 |     }
 8 |   }
 9 |   document.addEventListener("gesturestart", gestureStart, false);
10 | }
11 | function gestureStart() {
12 |   for (i=0; i<metas.length; i++) {
13 |     if (metas[i].name == "viewport") {
14 |       metas[i].content = "width=device-width, minimum-scale=0.25, maximum-scale=1.6";
15 |     }
16 |   }
17 | }


--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
 1 | PATH
 2 |   remote: .
 3 |   specs:
 4 |     abuelo (0.1.0)
 5 | 
 6 | GEM
 7 |   remote: https://rubygems.org/
 8 |   specs:
 9 |     coderay (1.1.0)
10 |     diff-lcs (1.2.5)
11 |     method_source (0.8.2)
12 |     pry (0.10.1)
13 |       coderay (~> 1.1.0)
14 |       method_source (~> 0.8.1)
15 |       slop (~> 3.4)
16 |     rake (10.4.2)
17 |     rspec (3.3.0)
18 |       rspec-core (~> 3.3.0)
19 |       rspec-expectations (~> 3.3.0)
20 |       rspec-mocks (~> 3.3.0)
21 |     rspec-core (3.3.2)
22 |       rspec-support (~> 3.3.0)
23 |     rspec-expectations (3.3.1)
24 |       diff-lcs (>= 1.2.0, < 2.0)
25 |       rspec-support (~> 3.3.0)
26 |     rspec-mocks (3.3.2)
27 |       diff-lcs (>= 1.2.0, < 2.0)
28 |       rspec-support (~> 3.3.0)
29 |     rspec-support (3.3.0)
30 |     slop (3.6.0)
31 | 
32 | PLATFORMS
33 |   ruby
34 | 
35 | DEPENDENCIES
36 |   abuelo!
37 |   bundler (~> 1.7)
38 |   pry
39 |   rake
40 |   rspec
41 | 


--------------------------------------------------------------------------------
/abuelo.gemspec:
--------------------------------------------------------------------------------
 1 | $LOAD_PATH.push File.expand_path('../lib', __FILE__)
 2 | require 'abuelo/version'
 3 | 
 4 | Gem::Specification.new do |spec|
 5 |   spec.name        = 'abuelo'
 6 |   spec.version     = Abuelo::VERSION
 7 |   spec.summary     = 'Abuelo'
 8 |   spec.description = 'Abuelo is a graph theory library.'
 9 |   spec.authors     = ['Dirk Holzapfel']
10 |   spec.email       = 'cache.zero@mailbox.org'
11 |   spec.homepage    =
12 |     'http://github.com/dirkholzapfel/abuelo'
13 |   spec.license       = 'MIT'
14 | 
15 |   spec.files         = `git ls-files`.split("\n")
16 |   spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
17 |   spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
18 |   spec.require_paths = ['lib']
19 | 
20 |   # Development
21 |   spec.add_development_dependency 'bundler', '~> 1.7'
22 |   spec.add_development_dependency 'rake'
23 |   spec.add_development_dependency 'pry'
24 | 
25 |   # Testing
26 |   spec.add_development_dependency 'rspec'
27 | end
28 | 


--------------------------------------------------------------------------------
/MIT-LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) 2016 Dirk Holzapfel
3 | 
4 | 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:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | 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.


--------------------------------------------------------------------------------
/lib/abuelo/node.rb:
--------------------------------------------------------------------------------
 1 | module Abuelo
 2 |   #
 3 |   # Class Node provides a representation of a node.
 4 |   # A node has a name. Any object may be attached on initialization.
 5 |   #
 6 |   # @author Dirk Holzapfel <cache.zero@mailbox.org>
 7 |   #
 8 |   class Node
 9 |     # @return [String] name
10 |     attr_reader :name
11 | 
12 |     # @return [Object] attached object
13 |     attr_reader :object
14 | 
15 |     # @return [Abuelo::Graph] associated graph
16 |     attr_accessor :graph
17 | 
18 |     #
19 |     # Initialiazises the node with its name.
20 |     #
21 |     # @param [String] name of the node
22 |     # @param [Object] object to attach to the node.
23 |     #  This is useful on some algorithm implementations.
24 |     #
25 |     def initialize(name, object = nil)
26 |       @name   = name
27 |       @object = object
28 |     end
29 | 
30 |     #
31 |     # @return [Array<Abuelo::Edge>] list of edges starting from the node
32 |     #
33 |     def edges
34 |       graph.edges_for_node(self) if graph
35 |     end
36 | 
37 |     #
38 |     # @return [Array<Abuelo::Node>] list of nodes that are adjacent to the node
39 |     #
40 |     def neighbours
41 |       edges.map(&:node_2)
42 |     end
43 | 
44 |     #
45 |     # @return [String] human readable representation of node
46 |     #
47 |     def to_s
48 |       @name
49 |     end
50 | 
51 |     #
52 |     # Equality check.
53 |     #
54 |     # @param [Abuelo::Node] other
55 |     #
56 |     # @return [Boolean] true if name is equal
57 |     #
58 |     def ==(other)
59 |       name == other.name
60 |     end
61 |   end
62 | end
63 | 


--------------------------------------------------------------------------------
/lib/abuelo/edge.rb:
--------------------------------------------------------------------------------
 1 | module Abuelo
 2 |   #
 3 |   # Class Edge provides a representation of an edge.
 4 |   # An edge connects two nodes(start-node and end-node) and has a weight.
 5 |   #
 6 |   # @author Dirk Holzapfel <cache.zero@mailbox.org>
 7 |   #
 8 |   class Edge
 9 |     # @return [Abuelo::Node] start-node
10 |     attr_reader :node_1
11 | 
12 |     # @return [Abuelo::Node] end-node
13 |     attr_reader :node_2
14 | 
15 |     # @return [Numeric] weight
16 |     attr_reader :weight
17 | 
18 |     #
19 |     # Initialiazises the edge with its two nodes and its weight.
20 |     #
21 |     # @param [Abuelo::Node] node_1 start-node
22 |     # @param [Abuelo::Node] node_2 end-node
23 |     # @param [Numeric] weight of the edge
24 |     #
25 |     def initialize(node_1, node_2, weight = 1)
26 |       @node_1 = node_1
27 |       @node_2 = node_2
28 |       @weight = weight
29 |     end
30 | 
31 |     #
32 |     # @return [Abuelo::Edge] a new edge with same weight but reversed start- and end-node.
33 |     #
34 |     def symmetric
35 |       Abuelo::Edge.new(node_2, node_1, weight)
36 |     end
37 | 
38 |     #
39 |     # Comparison based on weight.
40 |     #
41 |     # @param [Abuelo::Edge] other
42 |     #
43 |     # @return [-1, 0, +1]
44 |     #
45 |     def <=>(other)
46 |       weight <=> other.weight
47 |     end
48 | 
49 |     #
50 |     # Equality check.
51 |     #
52 |     # @param [Abuelo::Edge] other
53 |     #
54 |     # @return [Boolean] true if start-, end-node and weight of both edges are equal
55 |     #
56 |     def ==(other)
57 |       node_1 == other.node_1 &&
58 |         node_2 == other.node_2 &&
59 |         weight == other.weight
60 |     end
61 | 
62 |     #
63 |     # @return [String] human readable representation of edge
64 |     #
65 |     def to_s
66 |       "#{node_1} -> #{node_2} with weight #{weight}"
67 |     end
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/spec/edge_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | 
 3 | RSpec.describe Abuelo::Edge do
 4 |   let(:node_1) { Abuelo::Node.new('node 1') }
 5 |   let(:node_2) { Abuelo::Node.new('node 2') }
 6 | 
 7 |   let(:edge) { described_class.new(node_1, node_2, 3) }
 8 | 
 9 |   context 'initialization' do
10 |     it 'sets the weight to 1 if not given' do
11 |       expect(described_class.new(node_1, node_2).weight).to eq 1
12 |     end
13 |   end
14 | 
15 |   context 'accessors' do
16 |     it 'has following getters' do
17 |       expect(edge.respond_to?(:node_1)).to be true
18 |       expect(edge.respond_to?(:node_2)).to be true
19 |       expect(edge.respond_to?(:weight)).to be true
20 |     end
21 |   end
22 | 
23 |   describe '#symmetric' do
24 |     it 'returns an edge object with the same weight, but reversed nodes' do
25 |       symmetric = edge.symmetric
26 |       expect(symmetric.node_1).to eq edge.node_2
27 |       expect(symmetric.node_2).to eq edge.node_1
28 |       expect(symmetric.weight).to eq edge.weight
29 |     end
30 |   end
31 | 
32 |   describe '#to_s' do
33 |     it 'is human readable' do
34 |       expect(edge.to_s).to eq 'node 1 -> node 2 with weight 3'
35 |     end
36 |   end
37 | 
38 |   describe '#==(other)' do
39 |     it 'is true when the nodes and weight match' do
40 |       other = Abuelo::Edge.new(node_1, node_2, 3)
41 |       expect(edge == other).to be true
42 |     end
43 | 
44 |     it 'is false when the nodes do not match' do
45 |       other = Abuelo::Edge.new(node_2, node_1, 3)
46 |       expect(edge == other).to be false
47 |     end
48 | 
49 |     it 'is false when the weight does not match' do
50 |       other = Abuelo::Edge.new(node_1, node_2, 1)
51 |       expect(edge == other).to be false
52 |     end
53 |   end
54 | 
55 |   context 'order' do
56 |     it 'is sorted by its weight' do
57 |       edge_1 = described_class.new(node_1, node_2, 1)
58 |       edge_2 = described_class.new(node_1, node_2, 2)
59 |       edge_3 = described_class.new(node_1, node_2, 3)
60 | 
61 |       edges = [edge_3, edge_1, edge_2]
62 | 
63 |       expect(edges.sort).to eq [edge_1, edge_2, edge_3]
64 |     end
65 |   end
66 | end
67 | 


--------------------------------------------------------------------------------
/spec/node_spec.rb:
--------------------------------------------------------------------------------
 1 | require 'spec_helper'
 2 | 
 3 | RSpec.describe Abuelo::Node do
 4 |   let(:node) { described_class.new('node 1') }
 5 | 
 6 |   context 'initialization' do
 7 |     it 'sets object to nil if not given' do
 8 |       expect(node.object).to be nil
 9 |     end
10 |   end
11 | 
12 |   context 'accessors' do
13 |     it 'has following getters' do
14 |       expect(node.respond_to?(:name)).to be true
15 |       expect(node.respond_to?(:object)).to be true
16 |       expect(node.respond_to?(:graph)).to be true
17 |     end
18 | 
19 |     it 'has following setters' do
20 |       expect(node.respond_to?(:graph=)).to be true
21 |     end
22 |   end
23 | 
24 |   describe '#edges' do
25 |     it 'calls edges_for_node on its graph' do
26 |       graph = Abuelo::Graph.new
27 |       node.graph = graph
28 |       expect(graph).to receive(:edges_for_node).with(node)
29 |       node.edges
30 |     end
31 | 
32 |     it 'responds with nil if the node has no associated graph' do
33 |       expect(node.edges).to be nil
34 |     end
35 |   end
36 | 
37 |   describe '#neighbours' do
38 |     it 'returns an array with all nodes that are connected via an edge to the node' do
39 |       graph = Abuelo::Graph.new(directed: true, adjacency_matrix: <<-matrix
40 |         0 1 1
41 |         0 0 0
42 |         0 0 0
43 |         matrix
44 |       )
45 |       node_1 = graph.find_node_by_name('node 1')
46 |       node_2 = graph.find_node_by_name('node 2')
47 |       node_3 = graph.find_node_by_name('node 3')
48 | 
49 |       expect(node_1.neighbours).to match_array [node_2, node_3]
50 |       expect(node_2.neighbours).to eq []
51 |       expect(node_3.neighbours).to eq []
52 |     end
53 |   end
54 | 
55 |   describe '#to_s' do
56 |     it 'responds with its name' do
57 |       expect(node.to_s).to eq 'node 1'
58 |     end
59 |   end
60 | 
61 |   describe '#==(other)' do
62 |     it 'is true when the names match' do
63 |       other = Abuelo::Node.new('node 1')
64 |       expect(node == other).to be true
65 |     end
66 | 
67 |     it 'is false when the names do not match' do
68 |       other = Abuelo::Node.new('node 2')
69 |       expect(node == other).to be false
70 |     end
71 |   end
72 | end
73 | 


--------------------------------------------------------------------------------
/params.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "Abuelo",
3 |   "tagline": "Abuelo is a graph theory library",
4 |   "body": "### Welcome to GitHub Pages.\r\nThis automatic page generator is the easiest way to create beautiful pages for all of your projects. Author your page content here [using GitHub Flavored Markdown](https://guides.github.com/features/mastering-markdown/), select a template crafted by a designer, and publish. After your page is generated, you can check out the new `gh-pages` branch locally. If you’re using GitHub Desktop, simply sync your repository and you’ll see the new branch.\r\n\r\n### Designer Templates\r\nWe’ve crafted some handsome templates for you to use. Go ahead and click 'Continue to layouts' to browse through them. You can easily go back to edit your page before publishing. After publishing your page, you can revisit the page generator and switch to another theme. Your Page content will be preserved.\r\n\r\n### Creating pages manually\r\nIf you prefer to not use the automatic generator, push a branch named `gh-pages` to your repository to create a page manually. In addition to supporting regular HTML content, GitHub Pages support Jekyll, a simple, blog aware static site generator. Jekyll makes it easy to create site-wide headers and footers without having to copy them across every page. It also offers intelligent blog support and other advanced templating features.\r\n\r\n### Authors and Contributors\r\nYou can @mention a GitHub username to generate a link to their profile. The resulting `<a>` element will link to the contributor’s GitHub Profile. For example: In 2007, Chris Wanstrath (@defunkt), PJ Hyett (@pjhyett), and Tom Preston-Werner (@mojombo) founded GitHub.\r\n\r\n### Support or Contact\r\nHaving trouble with Pages? Check out our [documentation](https://help.github.com/pages) or [contact support](https://github.com/contact) and we’ll help you sort it out.\r\n\r\n<script>\r\n!function(a,b,c,d,e,f){e=b.createElement(\"script\"),e.type=\"text/javascript\",e.async=!0,e.src=\"https://steadyhq.com/js/widget.js\",f=b.getElementsByTagName(\"script\")[0],f.parentNode.insertBefore(e,f),e.onload=function(){new Steady.Widget(c,d)}}(window,document,\"schmalbart\",\"de\");\r\n</script>\r\n",
5 |   "note": "Don't delete this file! It's used internally to help with page regeneration."
6 | }


--------------------------------------------------------------------------------
/lib/abuelo/algorithms/dijkstra.rb:
--------------------------------------------------------------------------------
 1 | module Abuelo
 2 |   module Algorithms
 3 |     #
 4 |     # Class Dijkstra implements Dijkstra's algorithm for finding shortest paths between
 5 |     # nodes in a graph.
 6 |     #
 7 |     # See https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
 8 |     #
 9 |     # Possible improvement: use a priority queue to improve runtime.
10 |     #
11 |     # @author Dirk Holzapfel <cache.zero@mailbox.org>
12 |     #
13 |     class Dijkstra
14 |       #
15 |       # @param [Abuelo::Graph] graph
16 |       # @param [Abuelo::Node] start_node
17 |       #
18 |       # @raise [Abuelo::Exceptions::NoNodeError] if the start_node is
19 |       #   not a Abuelo::Node
20 |       #
21 |       def initialize(graph, start_node)
22 |         if !start_node.is_a?(Abuelo::Node)
23 |           raise Abuelo::Exceptions::NoNodeError.new('start_node is not a Abuelo::Node')
24 |         end
25 | 
26 |         @graph          = graph
27 |         @start_node     = start_node
28 |         @distances      = {}
29 |         @previous_nodes = {}
30 |         init
31 |         process
32 |       end
33 | 
34 |       #
35 |       # Calculates the shortest distance from the start_node to the given node.
36 |       #
37 |       # @param [Abuelo::Node] node
38 |       #
39 |       # @return [Numeric, nil] the distance to the node or nil if node is unreachable
40 |       #
41 |       def shortest_distance_to(node)
42 |         @distances[node]
43 |       end
44 | 
45 |       #
46 |       # Calculates the shortest path from the start_node to the given node.
47 |       #
48 |       # @param [Abuelo::Node] node
49 |       #
50 |       # @return [Array<Abuelo::Node>, nil] list of nodes from start_node to the given node
51 |       #  that are a possible solution for the shortest path. Nil if node is unreachable.
52 |       #
53 |       def shortest_path_to(node)
54 |         return nil if @previous_nodes[node].nil?
55 | 
56 |         nodes = [node]
57 |         while previous_node = @previous_nodes[nodes[0]] do
58 |           nodes.unshift(previous_node)
59 |         end
60 | 
61 |         nodes
62 |       end
63 | 
64 | 
65 |       private
66 | 
67 |       def init
68 |         @graph.nodes.each do |node|
69 |           @distances[node] = Float::INFINITY
70 |           @previous_nodes[node] = nil
71 |         end
72 | 
73 |         @distances[@start_node] = 0
74 |       end
75 | 
76 |       def process
77 |         unvisited_nodes = @graph.nodes
78 | 
79 |         until unvisited_nodes.empty? do
80 |           node = unvisited_nodes.min_by { |node| @distances[node] }
81 |           unvisited_nodes.delete(node)
82 | 
83 |           unvisited_neighbours = unvisited_nodes & node.neighbours
84 |           unvisited_neighbours.each do |neighbour|
85 |             new_edge_weight = @graph.find_edge(node, neighbour).weight
86 |             alternative_distance = @distances[node] + new_edge_weight
87 |             if alternative_distance < @distances[neighbour]
88 |               @distances[neighbour] = alternative_distance
89 |               @previous_nodes[neighbour] = node
90 |             end
91 |           end
92 |         end
93 |       end
94 |     end
95 |   end
96 | end
97 | 


--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
 1 | # Contributor Covenant Code of Conduct
 2 | 
 3 | ## Our Pledge
 4 | 
 5 | In the interest of fostering an open and welcoming environment, we as
 6 | contributors and maintainers pledge to making participation in our project and
 7 | our community a harassment-free experience for everyone, regardless of age, body
 8 | size, disability, ethnicity, gender identity and expression, level of experience,
 9 | nationality, personal appearance, race, religion, or sexual identity and
10 | orientation.
11 | 
12 | ## Our Standards
13 | 
14 | Examples of behavior that contributes to creating a positive environment
15 | include:
16 | 
17 | * Using welcoming and inclusive language
18 | * Being respectful of differing viewpoints and experiences
19 | * Gracefully accepting constructive criticism
20 | * Focusing on what is best for the community
21 | * Showing empathy towards other community members
22 | 
23 | Examples of unacceptable behavior by participants include:
24 | 
25 | * The use of sexualized language or imagery and unwelcome sexual attention or
26 | advances
27 | * Trolling, insulting/derogatory comments, and personal or political attacks
28 | * Public or private harassment
29 | * Publishing others' private information, such as a physical or electronic
30 |   address, without explicit permission
31 | * Other conduct which could reasonably be considered inappropriate in a
32 |   professional setting
33 | 
34 | ## Our Responsibilities
35 | 
36 | Project maintainers are responsible for clarifying the standards of acceptable
37 | behavior and are expected to take appropriate and fair corrective action in
38 | response to any instances of unacceptable behavior.
39 | 
40 | Project maintainers have the right and responsibility to remove, edit, or
41 | reject comments, commits, code, wiki edits, issues, and other contributions
42 | that are not aligned to this Code of Conduct, or to ban temporarily or
43 | permanently any contributor for other behaviors that they deem inappropriate,
44 | threatening, offensive, or harmful.
45 | 
46 | ## Scope
47 | 
48 | This Code of Conduct applies both within project spaces and in public spaces
49 | when an individual is representing the project or its community. Examples of
50 | representing a project or community include using an official project e-mail
51 | address, posting via an official social media account, or acting as an appointed
52 | representative at an online or offline event. Representation of a project may be
53 | further defined and clarified by project maintainers.
54 | 
55 | ## Enforcement
56 | 
57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
58 | reported by contacting the project team at [cache.zero+abuelo@mailbox.org]. All
59 | complaints will be reviewed and investigated and will result in a response that
60 | is deemed necessary and appropriate to the circumstances. The project team is
61 | obligated to maintain confidentiality with regard to the reporter of an incident.
62 | Further details of specific enforcement policies may be posted separately.
63 | 
64 | Project maintainers who do not follow or enforce the Code of Conduct in good
65 | faith may face temporary or permanent repercussions as determined by other
66 | members of the project's leadership.
67 | 
68 | ## Attribution
69 | 
70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
71 | available at [http://contributor-covenant.org/version/1/4][version]
72 | 
73 | [homepage]: http://contributor-covenant.org
74 | [version]: http://contributor-covenant.org/version/1/4/
75 | 


--------------------------------------------------------------------------------
/stylesheets/github-light.css:
--------------------------------------------------------------------------------
  1 | /*
  2 | The MIT License (MIT)
  3 | 
  4 | Copyright (c) 2016 GitHub, Inc.
  5 | 
  6 | Permission is hereby granted, free of charge, to any person obtaining a copy
  7 | of this software and associated documentation files (the "Software"), to deal
  8 | in the Software without restriction, including without limitation the rights
  9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 10 | copies of the Software, and to permit persons to whom the Software is
 11 | furnished to do so, subject to the following conditions:
 12 | 
 13 | The above copyright notice and this permission notice shall be included in all
 14 | copies or substantial portions of the Software.
 15 | 
 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 22 | SOFTWARE.
 23 | 
 24 | */
 25 | 
 26 | .pl-c /* comment */ {
 27 |   color: #969896;
 28 | }
 29 | 
 30 | .pl-c1 /* constant, variable.other.constant, support, meta.property-name, support.constant, support.variable, meta.module-reference, markup.raw, meta.diff.header */,
 31 | .pl-s .pl-v /* string variable */ {
 32 |   color: #0086b3;
 33 | }
 34 | 
 35 | .pl-e /* entity */,
 36 | .pl-en /* entity.name */ {
 37 |   color: #795da3;
 38 | }
 39 | 
 40 | .pl-smi /* variable.parameter.function, storage.modifier.package, storage.modifier.import, storage.type.java, variable.other */,
 41 | .pl-s .pl-s1 /* string source */ {
 42 |   color: #333;
 43 | }
 44 | 
 45 | .pl-ent /* entity.name.tag */ {
 46 |   color: #63a35c;
 47 | }
 48 | 
 49 | .pl-k /* keyword, storage, storage.type */ {
 50 |   color: #a71d5d;
 51 | }
 52 | 
 53 | .pl-s /* string */,
 54 | .pl-pds /* punctuation.definition.string, string.regexp.character-class */,
 55 | .pl-s .pl-pse .pl-s1 /* string punctuation.section.embedded source */,
 56 | .pl-sr /* string.regexp */,
 57 | .pl-sr .pl-cce /* string.regexp constant.character.escape */,
 58 | .pl-sr .pl-sre /* string.regexp source.ruby.embedded */,
 59 | .pl-sr .pl-sra /* string.regexp string.regexp.arbitrary-repitition */ {
 60 |   color: #183691;
 61 | }
 62 | 
 63 | .pl-v /* variable */ {
 64 |   color: #ed6a43;
 65 | }
 66 | 
 67 | .pl-id /* invalid.deprecated */ {
 68 |   color: #b52a1d;
 69 | }
 70 | 
 71 | .pl-ii /* invalid.illegal */ {
 72 |   color: #f8f8f8;
 73 |   background-color: #b52a1d;
 74 | }
 75 | 
 76 | .pl-sr .pl-cce /* string.regexp constant.character.escape */ {
 77 |   font-weight: bold;
 78 |   color: #63a35c;
 79 | }
 80 | 
 81 | .pl-ml /* markup.list */ {
 82 |   color: #693a17;
 83 | }
 84 | 
 85 | .pl-mh /* markup.heading */,
 86 | .pl-mh .pl-en /* markup.heading entity.name */,
 87 | .pl-ms /* meta.separator */ {
 88 |   font-weight: bold;
 89 |   color: #1d3e81;
 90 | }
 91 | 
 92 | .pl-mq /* markup.quote */ {
 93 |   color: #008080;
 94 | }
 95 | 
 96 | .pl-mi /* markup.italic */ {
 97 |   font-style: italic;
 98 |   color: #333;
 99 | }
100 | 
101 | .pl-mb /* markup.bold */ {
102 |   font-weight: bold;
103 |   color: #333;
104 | }
105 | 
106 | .pl-md /* markup.deleted, meta.diff.header.from-file */ {
107 |   color: #bd2c00;
108 |   background-color: #ffecec;
109 | }
110 | 
111 | .pl-mi1 /* markup.inserted, meta.diff.header.to-file */ {
112 |   color: #55a532;
113 |   background-color: #eaffea;
114 | }
115 | 
116 | .pl-mdr /* meta.diff.range */ {
117 |   font-weight: bold;
118 |   color: #795da3;
119 | }
120 | 
121 | .pl-mo /* meta.output */ {
122 |   color: #1d3e81;
123 | }
124 | 
125 | 


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-us">
 3 |   <head>
 4 |     <meta charset="UTF-8">
 5 |     <title>Abuelo by dirkholzapfel</title>
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 7 |     <link rel="stylesheet" type="text/css" href="stylesheets/normalize.css" media="screen">
 8 |     <link href='https://fonts.googleapis.com/css?family=Open+Sans:400,700' rel='stylesheet' type='text/css'>
 9 |     <link rel="stylesheet" type="text/css" href="stylesheets/stylesheet.css" media="screen">
10 |     <link rel="stylesheet" type="text/css" href="stylesheets/github-light.css" media="screen">
11 |   </head>
12 |   <body>
13 |     <section class="page-header">
14 |       <h1 class="project-name">Abuelo</h1>
15 |       <h2 class="project-tagline">Abuelo is a graph theory library</h2>
16 |       <a href="https://github.com/dirkholzapfel/abuelo" class="btn">View on GitHub</a>
17 |       <a href="https://github.com/dirkholzapfel/abuelo/zipball/master" class="btn">Download .zip</a>
18 |       <a href="https://github.com/dirkholzapfel/abuelo/tarball/master" class="btn">Download .tar.gz</a>
19 |     </section>
20 | 
21 |     <section class="main-content">
22 |       <h3>
23 | <a id="welcome-to-github-pages" class="anchor" href="#welcome-to-github-pages" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Welcome to GitHub Pages.</h3>
24 | 
25 | <p>This automatic page generator is the easiest way to create beautiful pages for all of your projects. Author your page content here <a href="https://guides.github.com/features/mastering-markdown/">using GitHub Flavored Markdown</a>, select a template crafted by a designer, and publish. After your page is generated, you can check out the new <code>gh-pages</code> branch locally. If you’re using GitHub Desktop, simply sync your repository and you’ll see the new branch.</p>
26 | 
27 | <h3>
28 | <a id="designer-templates" class="anchor" href="#designer-templates" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Designer Templates</h3>
29 | 
30 | <p>We’ve crafted some handsome templates for you to use. Go ahead and click 'Continue to layouts' to browse through them. You can easily go back to edit your page before publishing. After publishing your page, you can revisit the page generator and switch to another theme. Your Page content will be preserved.</p>
31 | 
32 | <h3>
33 | <a id="creating-pages-manually" class="anchor" href="#creating-pages-manually" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Creating pages manually</h3>
34 | 
35 | <p>If you prefer to not use the automatic generator, push a branch named <code>gh-pages</code> to your repository to create a page manually. In addition to supporting regular HTML content, GitHub Pages support Jekyll, a simple, blog aware static site generator. Jekyll makes it easy to create site-wide headers and footers without having to copy them across every page. It also offers intelligent blog support and other advanced templating features.</p>
36 | 
37 | <h3>
38 | <a id="authors-and-contributors" class="anchor" href="#authors-and-contributors" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Authors and Contributors</h3>
39 | 
40 | <p>You can @mention a GitHub username to generate a link to their profile. The resulting <code>&lt;a&gt;</code> element will link to the contributor’s GitHub Profile. For example: In 2007, Chris Wanstrath (<a href="https://github.com/defunkt" class="user-mention">@defunkt</a>), PJ Hyett (<a href="https://github.com/pjhyett" class="user-mention">@pjhyett</a>), and Tom Preston-Werner (<a href="https://github.com/mojombo" class="user-mention">@mojombo</a>) founded GitHub.</p>
41 | 
42 | <h3>
43 | <a id="support-or-contact" class="anchor" href="#support-or-contact" aria-hidden="true"><span aria-hidden="true" class="octicon octicon-link"></span></a>Support or Contact</h3>
44 | 
45 | <p>Having trouble with Pages? Check out our <a href="https://help.github.com/pages">documentation</a> or <a href="https://github.com/contact">contact support</a> and we’ll help you sort it out.</p>
46 | 
47 | 
48 | 
49 |       <footer class="site-footer">
50 |         <span class="site-footer-owner"><a href="https://github.com/dirkholzapfel/abuelo">Abuelo</a> is maintained by <a href="https://github.com/dirkholzapfel">dirkholzapfel</a>.</span>
51 | 
52 |         <span class="site-footer-credits">This page was generated by <a href="https://pages.github.com">GitHub Pages</a> using the <a href="https://github.com/jasonlong/cayman-theme">Cayman theme</a> by <a href="https://twitter.com/jasonlong">Jason Long</a>.</span>
53 |       </footer>
54 | 
55 |     </section>
56 | 
57 |   
58 |   </body>
59 | </html>
60 | 


--------------------------------------------------------------------------------
/lib/abuelo/graph.rb:
--------------------------------------------------------------------------------
  1 | module Abuelo
  2 |   #
  3 |   # Class Graph provides a representation of a graph.
  4 |   #
  5 |   # A graph consists of nodes (= vertices, points) and edges (= lines, arcs).
  6 |   # The graph may be undirected or directed. For the sake of simplicity Abuelo sticks
  7 |   # with the same vocabulary (nodes, edges) for directed and undirected graphs in
  8 |   # contrast to theoretical graph theory.
  9 |   #
 10 |   # @author Dirk Holzapfel <cache.zero@mailbox.org>
 11 |   #
 12 |   class Graph
 13 |     #
 14 |     # @param [Hash] opts the options to create a graph with
 15 |     # @option opts [Boolean] :directed defines if the graph is directed or undirected.
 16 |     #                        (defaults to false == undirected)
 17 |     # @option opts [String] :adjacency_matrix a representation of the graph in form
 18 |     #                       of an adjacency matrix
 19 |     #
 20 |     # @example Build a graph with the help of an adjacency matrix
 21 |     #  adjacency_matrix = <<-matrix
 22 |     #     0 42  0
 23 |     #    42  0 23
 24 |     #     0 23  0
 25 |     #    matrix
 26 |     #  graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
 27 |     #
 28 |     def initialize(opts = {})
 29 |       @nodes = {} # @nodes = { node_name => node_object }
 30 |       @edges = {} # @edges = { node_object => { node_object => edge }}
 31 |       @directed = opts.fetch(:directed, false)
 32 |       init_by_adjacency_matrix(opts[:adjacency_matrix]) if opts[:adjacency_matrix]
 33 |     end
 34 | 
 35 |     #
 36 |     # @return [Boolean] true if the graph is directed, false if it is undirected
 37 |     #
 38 |     def directed?
 39 |       @directed
 40 |     end
 41 | 
 42 |     #
 43 |     # @return [Boolean] true if the graph is undirected, false if it is directed
 44 |     #
 45 |     def undirected?
 46 |       !directed?
 47 |     end
 48 | 
 49 |     #
 50 |     # @return [Integer] the order of the graph == the number of nodes
 51 |     #
 52 |     def order
 53 |       nodes.count
 54 |     end
 55 | 
 56 |     #
 57 |     # @return [Integer] the size of the graph == the number of edges
 58 |     #
 59 |     def size
 60 |       edges.count
 61 |     end
 62 | 
 63 |     #
 64 |     # @return [Array<Abuelo::Node>] list of nodes of the graph
 65 |     #
 66 |     def nodes
 67 |       @nodes.values
 68 |     end
 69 | 
 70 |     #
 71 |     # Adds a node to the graph.
 72 |     #
 73 |     # @param [Abuelo::Node] node to add
 74 |     #
 75 |     # @return [Abuelo::Graph] the graph
 76 |     #
 77 |     # @raise [Abuelo::Exceptions::NodeAlreadyExistsError] if the node is
 78 |     #   already contained in the graph
 79 |     #
 80 |     def add_node(node)
 81 |       raise Abuelo::Exceptions::NodeAlreadyExistsError if has_node?(node)
 82 | 
 83 |       @nodes[node.name] = node
 84 |       node.graph = self
 85 | 
 86 |       self
 87 |     end
 88 | 
 89 |     #
 90 |     # Checks if the given node is contained in the graph.
 91 |     #
 92 |     # @param [Abuelo::Node] node
 93 |     #
 94 |     # @return [Boolean]
 95 |     #
 96 |     def has_node?(node)
 97 |       has_node_with_name?(node.name)
 98 |     end
 99 | 
100 |     #
101 |     # Checks if a node with the given name is contained in the graph.
102 |     #
103 |     # @param [String] name of the node
104 |     #
105 |     # @return [Boolean]
106 |     #
107 |     def has_node_with_name?(name)
108 |       !find_node_by_name(name).nil?
109 |     end
110 | 
111 |     #
112 |     # Returns the node with the given name if it is contained in the graph.
113 |     #
114 |     # @param [String] name of the node
115 |     #
116 |     # @return [Abuelo::Node, nil] the node if found, otherwise nil
117 |     #
118 |     def find_node_by_name(name)
119 |       @nodes[name]
120 |     end
121 | 
122 |     #
123 |     # @return [Array<Abuelo::Edge>, Array<Array(Abuelo::Edge, Abuelo::Edge)>]
124 |     #   list of edges of the graph if directed,
125 |     #   list of list of symmetric pairs of edges of the graph if undirected
126 |     #
127 |     # @example directed graph
128 |     #  "graph.edges" #=> [edge_from_node_1_to_node_2]
129 |     #
130 |     # @example undirected graph
131 |     #  "graph.edges" #=> [[edge_from_node_1_to_node_2, edge_from_node_2_to_node_1]]
132 |     #
133 |     def edges
134 |       edges = @edges.keys.flat_map { |key| @edges[key].values }
135 | 
136 |       if directed?
137 |         edges
138 |       else
139 |         edges.each_slice(2).to_a
140 |       end
141 |     end
142 | 
143 |     #
144 |     # Adds an edge to the graph.
145 |     # Auto-adds the symmetric counterpart if graph is undirected.
146 |     #
147 |     # @param [Abuelo::Edge] edge to add
148 |     #
149 |     # @return [Abuelo::Graph] the graph
150 |     #
151 |     # @raise [Abuelo::Exceptions::EdgeAlreadyExistsError] if the edge is
152 |     #   already contained in the graph
153 |     #
154 |     def add_edge(edge, opts = {})
155 |       raise Abuelo::Exceptions::EdgeAlreadyExistsError if has_edge?(edge)
156 | 
157 |       @edges[edge.node_1] ||= {}
158 |       @edges[edge.node_1][edge.node_2] = edge
159 | 
160 |       if undirected? && !opts[:symmetric]
161 |         add_edge(edge.symmetric, symmetric: true)
162 |       end
163 | 
164 |       self
165 |     end
166 | 
167 |     #
168 |     # Checks if the given edge is contained in the graph.
169 |     #
170 |     # @param [Abuelo::Edge] edge
171 |     #
172 |     # @return [Boolean]
173 |     #
174 |     def has_edge?(edge)
175 |       !find_edge(edge.node_1, edge.node_2).nil?
176 |     end
177 | 
178 |     #
179 |     # Returns the edge if there is one between the two given nodes.
180 |     #
181 |     # @param [Abuelo::Node] node_1
182 |     # @param [Abuelo::Node] node_2
183 |     #
184 |     # @return [Abuelo::Edge, nil] the edge if found, otherwise nil
185 |     #
186 |     def find_edge(node_1, node_2)
187 |       @edges[node_1][node_2] if @edges[node_1]
188 |     end
189 | 
190 |     #
191 |     # Returns all edges that start from the given node.
192 |     #
193 |     # @param [Abuelo::Node] node <description>
194 |     #
195 |     # @return [Array<Abuelo::Edge>] list of edges that start from the given node
196 |     #
197 |     def edges_for_node(node)
198 |       Hash(@edges[node]).values
199 |     end
200 | 
201 | 
202 |     private
203 | 
204 |     def init_by_adjacency_matrix(adjacency_matrix)
205 |       nodes = {}
206 |       1.upto(adjacency_matrix.lines.count) do |i|
207 |         node = Abuelo::Node.new("node #{i}")
208 |         nodes[i] = node
209 |         add_node(node)
210 |       end
211 | 
212 |       adjacency_matrix.split(/\r?\n/).each_with_index do |row, row_index|
213 |         row.split(' ').map(&:to_i).each_with_index do |weight, column_index|
214 |           if weight != 0
215 |             edge = Abuelo::Edge.new(nodes[row_index+1], nodes[column_index+1], weight)
216 |             add_edge(edge, symmetric: true)
217 |           end
218 |         end
219 |       end
220 |     end
221 |   end
222 | end
223 | 


--------------------------------------------------------------------------------
/stylesheets/stylesheet.css:
--------------------------------------------------------------------------------
  1 | * {
  2 |   box-sizing: border-box; }
  3 | 
  4 | body {
  5 |   padding: 0;
  6 |   margin: 0;
  7 |   font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
  8 |   font-size: 16px;
  9 |   line-height: 1.5;
 10 |   color: #606c71; }
 11 | 
 12 | a {
 13 |   color: #1e6bb8;
 14 |   text-decoration: none; }
 15 |   a:hover {
 16 |     text-decoration: underline; }
 17 | 
 18 | .btn {
 19 |   display: inline-block;
 20 |   margin-bottom: 1rem;
 21 |   color: rgba(255, 255, 255, 0.7);
 22 |   background-color: rgba(255, 255, 255, 0.08);
 23 |   border-color: rgba(255, 255, 255, 0.2);
 24 |   border-style: solid;
 25 |   border-width: 1px;
 26 |   border-radius: 0.3rem;
 27 |   transition: color 0.2s, background-color 0.2s, border-color 0.2s; }
 28 |   .btn + .btn {
 29 |     margin-left: 1rem; }
 30 | 
 31 | .btn:hover {
 32 |   color: rgba(255, 255, 255, 0.8);
 33 |   text-decoration: none;
 34 |   background-color: rgba(255, 255, 255, 0.2);
 35 |   border-color: rgba(255, 255, 255, 0.3); }
 36 | 
 37 | @media screen and (min-width: 64em) {
 38 |   .btn {
 39 |     padding: 0.75rem 1rem; } }
 40 | 
 41 | @media screen and (min-width: 42em) and (max-width: 64em) {
 42 |   .btn {
 43 |     padding: 0.6rem 0.9rem;
 44 |     font-size: 0.9rem; } }
 45 | 
 46 | @media screen and (max-width: 42em) {
 47 |   .btn {
 48 |     display: block;
 49 |     width: 100%;
 50 |     padding: 0.75rem;
 51 |     font-size: 0.9rem; }
 52 |     .btn + .btn {
 53 |       margin-top: 1rem;
 54 |       margin-left: 0; } }
 55 | 
 56 | .page-header {
 57 |   color: #fff;
 58 |   text-align: center;
 59 |   background-color: #159957;
 60 |   background-image: linear-gradient(120deg, #155799, #159957); }
 61 | 
 62 | @media screen and (min-width: 64em) {
 63 |   .page-header {
 64 |     padding: 5rem 6rem; } }
 65 | 
 66 | @media screen and (min-width: 42em) and (max-width: 64em) {
 67 |   .page-header {
 68 |     padding: 3rem 4rem; } }
 69 | 
 70 | @media screen and (max-width: 42em) {
 71 |   .page-header {
 72 |     padding: 2rem 1rem; } }
 73 | 
 74 | .project-name {
 75 |   margin-top: 0;
 76 |   margin-bottom: 0.1rem; }
 77 | 
 78 | @media screen and (min-width: 64em) {
 79 |   .project-name {
 80 |     font-size: 3.25rem; } }
 81 | 
 82 | @media screen and (min-width: 42em) and (max-width: 64em) {
 83 |   .project-name {
 84 |     font-size: 2.25rem; } }
 85 | 
 86 | @media screen and (max-width: 42em) {
 87 |   .project-name {
 88 |     font-size: 1.75rem; } }
 89 | 
 90 | .project-tagline {
 91 |   margin-bottom: 2rem;
 92 |   font-weight: normal;
 93 |   opacity: 0.7; }
 94 | 
 95 | @media screen and (min-width: 64em) {
 96 |   .project-tagline {
 97 |     font-size: 1.25rem; } }
 98 | 
 99 | @media screen and (min-width: 42em) and (max-width: 64em) {
100 |   .project-tagline {
101 |     font-size: 1.15rem; } }
102 | 
103 | @media screen and (max-width: 42em) {
104 |   .project-tagline {
105 |     font-size: 1rem; } }
106 | 
107 | .main-content :first-child {
108 |   margin-top: 0; }
109 | .main-content img {
110 |   max-width: 100%; }
111 | .main-content h1, .main-content h2, .main-content h3, .main-content h4, .main-content h5, .main-content h6 {
112 |   margin-top: 2rem;
113 |   margin-bottom: 1rem;
114 |   font-weight: normal;
115 |   color: #159957; }
116 | .main-content p {
117 |   margin-bottom: 1em; }
118 | .main-content code {
119 |   padding: 2px 4px;
120 |   font-family: Consolas, "Liberation Mono", Menlo, Courier, monospace;
121 |   font-size: 0.9rem;
122 |   color: #383e41;
123 |   background-color: #f3f6fa;
124 |   border-radius: 0.3rem; }
125 | .main-content pre {
126 |   padding: 0.8rem;
127 |   margin-top: 0;
128 |   margin-bottom: 1rem;
129 |   font: 1rem Consolas, "Liberation Mono", Menlo, Courier, monospace;
130 |   color: #567482;
131 |   word-wrap: normal;
132 |   background-color: #f3f6fa;
133 |   border: solid 1px #dce6f0;
134 |   border-radius: 0.3rem; }
135 |   .main-content pre > code {
136 |     padding: 0;
137 |     margin: 0;
138 |     font-size: 0.9rem;
139 |     color: #567482;
140 |     word-break: normal;
141 |     white-space: pre;
142 |     background: transparent;
143 |     border: 0; }
144 | .main-content .highlight {
145 |   margin-bottom: 1rem; }
146 |   .main-content .highlight pre {
147 |     margin-bottom: 0;
148 |     word-break: normal; }
149 | .main-content .highlight pre, .main-content pre {
150 |   padding: 0.8rem;
151 |   overflow: auto;
152 |   font-size: 0.9rem;
153 |   line-height: 1.45;
154 |   border-radius: 0.3rem; }
155 | .main-content pre code, .main-content pre tt {
156 |   display: inline;
157 |   max-width: initial;
158 |   padding: 0;
159 |   margin: 0;
160 |   overflow: initial;
161 |   line-height: inherit;
162 |   word-wrap: normal;
163 |   background-color: transparent;
164 |   border: 0; }
165 |   .main-content pre code:before, .main-content pre code:after, .main-content pre tt:before, .main-content pre tt:after {
166 |     content: normal; }
167 | .main-content ul, .main-content ol {
168 |   margin-top: 0; }
169 | .main-content blockquote {
170 |   padding: 0 1rem;
171 |   margin-left: 0;
172 |   color: #819198;
173 |   border-left: 0.3rem solid #dce6f0; }
174 |   .main-content blockquote > :first-child {
175 |     margin-top: 0; }
176 |   .main-content blockquote > :last-child {
177 |     margin-bottom: 0; }
178 | .main-content table {
179 |   display: block;
180 |   width: 100%;
181 |   overflow: auto;
182 |   word-break: normal;
183 |   word-break: keep-all; }
184 |   .main-content table th {
185 |     font-weight: bold; }
186 |   .main-content table th, .main-content table td {
187 |     padding: 0.5rem 1rem;
188 |     border: 1px solid #e9ebec; }
189 | .main-content dl {
190 |   padding: 0; }
191 |   .main-content dl dt {
192 |     padding: 0;
193 |     margin-top: 1rem;
194 |     font-size: 1rem;
195 |     font-weight: bold; }
196 |   .main-content dl dd {
197 |     padding: 0;
198 |     margin-bottom: 1rem; }
199 | .main-content hr {
200 |   height: 2px;
201 |   padding: 0;
202 |   margin: 1rem 0;
203 |   background-color: #eff0f1;
204 |   border: 0; }
205 | 
206 | @media screen and (min-width: 64em) {
207 |   .main-content {
208 |     max-width: 64rem;
209 |     padding: 2rem 6rem;
210 |     margin: 0 auto;
211 |     font-size: 1.1rem; } }
212 | 
213 | @media screen and (min-width: 42em) and (max-width: 64em) {
214 |   .main-content {
215 |     padding: 2rem 4rem;
216 |     font-size: 1.1rem; } }
217 | 
218 | @media screen and (max-width: 42em) {
219 |   .main-content {
220 |     padding: 2rem 1rem;
221 |     font-size: 1rem; } }
222 | 
223 | .site-footer {
224 |   padding-top: 2rem;
225 |   margin-top: 2rem;
226 |   border-top: solid 1px #eff0f1; }
227 | 
228 | .site-footer-owner {
229 |   display: block;
230 |   font-weight: bold; }
231 | 
232 | .site-footer-credits {
233 |   color: #819198; }
234 | 
235 | @media screen and (min-width: 64em) {
236 |   .site-footer {
237 |     font-size: 1rem; } }
238 | 
239 | @media screen and (min-width: 42em) and (max-width: 64em) {
240 |   .site-footer {
241 |     font-size: 1rem; } }
242 | 
243 | @media screen and (max-width: 42em) {
244 |   .site-footer {
245 |     font-size: 0.9rem; } }
246 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Abuelo
  2 | [![Build Status](https://travis-ci.org/dirkholzapfel/abuelo.svg?branch=master)](https://travis-ci.org/dirkholzapfel/abuelo)
  3 | [![Join the chat at https://gitter.im/dirkholzapfel/abuelo](https://badges.gitter.im/dirkholzapfel/abuelo.svg)](https://gitter.im/dirkholzapfel/abuelo?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
  4 | 
  5 | Abuelo is a graph theory library written in Ruby that allows you to build a representation of a graph.
  6 | 
  7 | A graph consists of nodes (= vertices, points) and edges (= lines, arcs). The graph may be undirected or directed. For the sake of simplicity Abuelo sticks with the same vocabulary (nodes, edges) for directed and undirected graphs in contrast to theoretical graph theory.
  8 | 
  9 | Abuelo supports Ruby >= 2.0.0
 10 | 
 11 | ## Examples
 12 | ### Undirected graph
 13 | ```ruby
 14 | graph  = Abuelo::Graph.new
 15 | 
 16 | node_1 = Abuelo::Node.new('node 1')
 17 | node_2 = Abuelo::Node.new('node 2')
 18 | node_3 = Abuelo::Node.new('node 3')
 19 | edge_1 = Abuelo::Edge.new(node_1, node_2, 42)
 20 | edge_2 = Abuelo::Edge.new(node_2, node_3, 23)
 21 | 
 22 | graph.add_node(node_1)
 23 |      .add_node(node_2)
 24 |      .add_node(node_3)
 25 |      .add_edge(edge_1)
 26 |      .add_edge(edge_2)
 27 | 
 28 | graph.order                       # => 3
 29 | graph.size                        # => 2
 30 | graph.nodes                       # => [node_1, node_2, node_3]
 31 | graph.has_node?(node_1)           # => true
 32 | graph.has_node_with_name?('foo')  # => false
 33 | graph.find_node_by_name('node 1') # => node_1
 34 | graph.edges                       # => [[edge_1, edge_1.symmetric], [edge_2, edge_2.symmetric]]
 35 | graph.has_edge?(edge_1)           # => true
 36 | graph.has_edge?(edge_1.symmetric) # => true
 37 | graph.find_edge(node_1, node_2)   # => edge_1
 38 | graph.find_edge(node_2, node_1)   # => edge_1.symmetric
 39 | graph.edges_for_node(node_2)      # => [edge_1.symmetric, edge_2]
 40 | 
 41 | node_1.edges                      # => [edge_1]
 42 | node_1.neighbours                 # => [node_2]
 43 | ```
 44 | 
 45 | ### Directed graph
 46 | ```ruby
 47 | graph  = Abuelo::Graph.new(directed: true)
 48 | 
 49 | node_1 = Abuelo::Node.new('node 1')
 50 | node_2 = Abuelo::Node.new('node 2')
 51 | node_3 = Abuelo::Node.new('node 3')
 52 | edge_1 = Abuelo::Edge.new(node_1, node_2, 42)
 53 | edge_2 = Abuelo::Edge.new(node_2, node_3, 23)
 54 | 
 55 | graph.add_node(node_1)
 56 |      .add_node(node_2)
 57 |      .add_node(node_3)
 58 |      .add_edge(edge_1)
 59 |      .add_edge(edge_2)
 60 | 
 61 | graph.order                       # => 3
 62 | graph.size                        # => 2
 63 | graph.nodes                       # => [node_1, node_2, node_3]
 64 | graph.has_node?(node_1)           # => true
 65 | graph.has_node_with_name?('foo')  # => false
 66 | graph.find_node_by_name('node 1') # => node_1
 67 | graph.edges                       # => [edge_1, edge_2]
 68 | graph.has_edge?(edge_1)           # => true
 69 | graph.has_edge?(edge_1.symmetric) # => false
 70 | graph.find_edge(node_1, node_2)   # => edge_1
 71 | graph.find_edge(node_2, node_1)   # => nil
 72 | graph.edges_for_node(node_2)      # => [edge_2]
 73 | 
 74 | node_1.edges                      # => [edge_1]
 75 | node_1.neighbours                 # => [node_2]
 76 | ```
 77 | 
 78 | ### Initialize a graph with an adjacency matrix
 79 | The above, object oriented way to build graphs is the recommended way to work with this library.
 80 | But you can also build a graph with an [adjacency matrix](https://en.wikipedia.org/wiki/Adjacency_matrix).
 81 | That is a nice shortcut used in some tests and may be a good alternative if you use Abuelo in the console to play around.
 82 | 
 83 | A zero indicates there is no edge between the nodes, an Integer indicates that there is an edge with the given weight between the nodes. The nodes are automatically named, starting with "node 1".
 84 | The above example can be built like this:
 85 | 
 86 | #### Undirected graphs
 87 | Be aware that you have to provide all symmetric edges in an adjacency matrix for an undirected graph - the lib does not add them automatically as it happens with the `.add_edge` method.
 88 | 
 89 | ```ruby
 90 | adjacency_matrix = <<-matrix
 91 |   0  42 0
 92 |   42 0  23
 93 |   0  23 0
 94 |   matrix
 95 | 
 96 | # The above matrix corresponds to this internal representation
 97 | #
 98 | #          | node 1 | node 2 | node 3 |
 99 | #  ------------------------------------
100 | #  node 1  | 0      | 42     | 0      |
101 | #  node 2  | 42     | 0      | 23     |
102 | #  node 3  | 0      | 23     | 0      |
103 | 
104 | graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
105 | node_1 = graph.find_node_by_name('node 1')
106 | node_2 = graph.find_node_by_name('node 2')
107 | graph.find_edge(node_1, node_2).weight # => 42
108 | ```
109 | #### Directed graphs
110 | ```ruby
111 | adjacency_matrix = <<-matrix
112 |   0 42 0
113 |   0 0  23
114 |   0 0  0
115 |   matrix
116 | 
117 | # The above matrix corresponds to this internal representation
118 | #
119 | #          | node 1 | node 2 | node 3 |
120 | #  ------------------------------------
121 | #  node 1  | 0      | 42     | 0      |
122 | #  node 2  | 0      | 0      | 23     |
123 | #  node 3  | 0      | 0      | 0      |
124 | 
125 | graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix, directed: true)
126 | ```
127 | ## Algorithms
128 | ### Dijkstra
129 | This is the example from https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
130 | 
131 | <a title="By Ibmua (Work by uploader.) [Public domain], via Wikimedia Commons" href="https://commons.wikimedia.org/wiki/File%3ADijkstra_Animation.gif"><img width="256" alt="Dijkstra Animation" src="https://upload.wikimedia.org/wikipedia/commons/5/57/Dijkstra_Animation.gif"/></a>
132 | 
133 | ```ruby
134 | adjacency_matrix = <<-matrix
135 |   0  7  9  0  0 14
136 |   7  0  10 15 0 0
137 |   9  10 0  11 0 2
138 |   0  15 11 0  6 0
139 |   0  0  0  6  0 9
140 |   14 0  2  0  9 0
141 | matrix
142 | 
143 | graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
144 | start_node = graph.find_node_by_name('node 1')
145 | node_5 = graph.find_node_by_name('node 5')
146 | 
147 | dijkstra = Abuelo::Algorithms::Dijkstra.new(graph, start_node)
148 | dijkstra.shortest_distance_to(node_5) # => 20
149 | dijkstra.shortest_path_to(node_5).map(&:to_s) # => ['node 1', 'node 3', 'node 6', 'node 5']
150 | ```
151 | 
152 | ## Documentation
153 | [YARD](http://yardoc.org) documentation is available at [rubydoc](http://www.rubydoc.info/github/dirkholzapfel/abuelo).
154 | 
155 | ## Future
156 | * Implement graph algorithms
157 |   * [Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm)
158 |   * [Prim's algorithm](https://en.wikipedia.org/wiki/Prim%27s_algorithm)
159 | * Implement visualization of graph
160 | * Add priority queue to Dijkstra's algorithm implementation
161 | 
162 | ## Installation
163 | Abuelo is a gem which you can install with:
164 | ```
165 | gem install abuelo
166 | ```
167 | 
168 | In Rails 3+, add the following to your ```Gemfile```:
169 | ```
170 | gem 'abuelo'
171 | ```
172 | 
173 | ## Credits
174 | Dirk Holzapfel ([@cachezero](https://twitter.com/cachezero))
175 | 
176 | [cachezero.net](http://cachezero.net)
177 | 
178 | [Abuelo](http://www.ronabuelopanama.com)
179 | 
180 | ### Contributors
181 | [dirkholzapfel](https://github.com/dirkholzapfel),
182 | [mbirman](https://github.com/mbirman),
183 | [sergey-kintsel](https://github.com/sergey-kintsel)
184 | 


--------------------------------------------------------------------------------
/stylesheets/styles.css:
--------------------------------------------------------------------------------
  1 | @font-face {
  2 |   font-family: 'Noto Sans';
  3 |   font-weight: 400;
  4 |   font-style: normal;
  5 |   src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot');
  6 |   src: url('../fonts/Noto-Sans-regular/Noto-Sans-regular.eot?#iefix') format('embedded-opentype'),
  7 |        local('Noto Sans'),
  8 |        local('Noto-Sans-regular'),
  9 |        url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff2') format('woff2'),
 10 |        url('../fonts/Noto-Sans-regular/Noto-Sans-regular.woff') format('woff'),
 11 |        url('../fonts/Noto-Sans-regular/Noto-Sans-regular.ttf') format('truetype'),
 12 |        url('../fonts/Noto-Sans-regular/Noto-Sans-regular.svg#NotoSans') format('svg');
 13 | }
 14 | 
 15 | @font-face {
 16 |   font-family: 'Noto Sans';
 17 |   font-weight: 700;
 18 |   font-style: normal;
 19 |   src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot');
 20 |   src: url('../fonts/Noto-Sans-700/Noto-Sans-700.eot?#iefix') format('embedded-opentype'),
 21 |        local('Noto Sans Bold'),
 22 |        local('Noto-Sans-700'),
 23 |        url('../fonts/Noto-Sans-700/Noto-Sans-700.woff2') format('woff2'),
 24 |        url('../fonts/Noto-Sans-700/Noto-Sans-700.woff') format('woff'),
 25 |        url('../fonts/Noto-Sans-700/Noto-Sans-700.ttf') format('truetype'),
 26 |        url('../fonts/Noto-Sans-700/Noto-Sans-700.svg#NotoSans') format('svg');
 27 | }
 28 | 
 29 | @font-face {
 30 |   font-family: 'Noto Sans';
 31 |   font-weight: 400;
 32 |   font-style: italic;
 33 |   src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot');
 34 |   src: url('../fonts/Noto-Sans-italic/Noto-Sans-italic.eot?#iefix') format('embedded-opentype'),
 35 |        local('Noto Sans Italic'),
 36 |        local('Noto-Sans-italic'),
 37 |        url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff2') format('woff2'),
 38 |        url('../fonts/Noto-Sans-italic/Noto-Sans-italic.woff') format('woff'),
 39 |        url('../fonts/Noto-Sans-italic/Noto-Sans-italic.ttf') format('truetype'),
 40 |        url('../fonts/Noto-Sans-italic/Noto-Sans-italic.svg#NotoSans') format('svg');
 41 | }
 42 | 
 43 | @font-face {
 44 |   font-family: 'Noto Sans';
 45 |   font-weight: 700;
 46 |   font-style: italic;
 47 |   src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot');
 48 |   src: url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.eot?#iefix') format('embedded-opentype'),
 49 |        local('Noto Sans Bold Italic'),
 50 |        local('Noto-Sans-700italic'),
 51 |        url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff2') format('woff2'),
 52 |        url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.woff') format('woff'),
 53 |        url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.ttf') format('truetype'),
 54 |        url('../fonts/Noto-Sans-700italic/Noto-Sans-700italic.svg#NotoSans') format('svg');
 55 | }
 56 | 
 57 | body {
 58 |   background-color: #fff;
 59 |   padding:50px;
 60 |   font: 14px/1.5 "Noto Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
 61 |   color:#727272;
 62 |   font-weight:400;
 63 | }
 64 | 
 65 | h1, h2, h3, h4, h5, h6 {
 66 |   color:#222;
 67 |   margin:0 0 20px;
 68 | }
 69 | 
 70 | p, ul, ol, table, pre, dl {
 71 |   margin:0 0 20px;
 72 | }
 73 | 
 74 | h1, h2, h3 {
 75 |   line-height:1.1;
 76 | }
 77 | 
 78 | h1 {
 79 |   font-size:28px;
 80 | }
 81 | 
 82 | h2 {
 83 |   color:#393939;
 84 | }
 85 | 
 86 | h3, h4, h5, h6 {
 87 |   color:#494949;
 88 | }
 89 | 
 90 | a {
 91 |   color:#39c;
 92 |   text-decoration:none;
 93 | }
 94 | 
 95 | a:hover {
 96 |   color:#069;
 97 | }
 98 | 
 99 | a small {
100 |   font-size:11px;
101 |   color:#777;
102 |   margin-top:-0.3em;
103 |   display:block;
104 | }
105 | 
106 | a:hover small {
107 |   color:#777;
108 | }
109 | 
110 | .wrapper {
111 |   width:860px;
112 |   margin:0 auto;
113 | }
114 | 
115 | blockquote {
116 |   border-left:1px solid #e5e5e5;
117 |   margin:0;
118 |   padding:0 0 0 20px;
119 |   font-style:italic;
120 | }
121 | 
122 | code, pre {
123 |   font-family:Monaco, Bitstream Vera Sans Mono, Lucida Console, Terminal, Consolas, Liberation Mono, DejaVu Sans Mono, Courier New, monospace;
124 |   color:#333;
125 |   font-size:12px;
126 | }
127 | 
128 | pre {
129 |   padding:8px 15px;
130 |   background: #f8f8f8;
131 |   border-radius:5px;
132 |   border:1px solid #e5e5e5;
133 |   overflow-x: auto;
134 | }
135 | 
136 | table {
137 |   width:100%;
138 |   border-collapse:collapse;
139 | }
140 | 
141 | th, td {
142 |   text-align:left;
143 |   padding:5px 10px;
144 |   border-bottom:1px solid #e5e5e5;
145 | }
146 | 
147 | dt {
148 |   color:#444;
149 |   font-weight:700;
150 | }
151 | 
152 | th {
153 |   color:#444;
154 | }
155 | 
156 | img {
157 |   max-width:100%;
158 | }
159 | 
160 | header {
161 |   width:270px;
162 |   float:left;
163 |   position:fixed;
164 |   -webkit-font-smoothing:subpixel-antialiased;
165 | }
166 | 
167 | header ul {
168 |   list-style:none;
169 |   height:40px;
170 |   padding:0;
171 |   background: #f4f4f4;
172 |   border-radius:5px;
173 |   border:1px solid #e0e0e0;
174 |   width:270px;
175 | }
176 | 
177 | header li {
178 |   width:89px;
179 |   float:left;
180 |   border-right:1px solid #e0e0e0;
181 |   height:40px;
182 | }
183 | 
184 | header li:first-child a {
185 |   border-radius:5px 0 0 5px;
186 | }
187 | 
188 | header li:last-child a {
189 |   border-radius:0 5px 5px 0;
190 | }
191 | 
192 | header ul a {
193 |   line-height:1;
194 |   font-size:11px;
195 |   color:#999;
196 |   display:block;
197 |   text-align:center;
198 |   padding-top:6px;
199 |   height:34px;
200 | }
201 | 
202 | header ul a:hover {
203 |   color:#999;
204 | }
205 | 
206 | header ul a:active {
207 |   background-color:#f0f0f0;
208 | }
209 | 
210 | strong {
211 |   color:#222;
212 |   font-weight:700;
213 | }
214 | 
215 | header ul li + li + li {
216 |   border-right:none;
217 |   width:89px;
218 | }
219 | 
220 | header ul a strong {
221 |   font-size:14px;
222 |   display:block;
223 |   color:#222;
224 | }
225 | 
226 | section {
227 |   width:500px;
228 |   float:right;
229 |   padding-bottom:50px;
230 | }
231 | 
232 | small {
233 |   font-size:11px;
234 | }
235 | 
236 | hr {
237 |   border:0;
238 |   background:#e5e5e5;
239 |   height:1px;
240 |   margin:0 0 20px;
241 | }
242 | 
243 | footer {
244 |   width:270px;
245 |   float:left;
246 |   position:fixed;
247 |   bottom:50px;
248 |   -webkit-font-smoothing:subpixel-antialiased;
249 | }
250 | 
251 | @media print, screen and (max-width: 960px) {
252 | 
253 |   div.wrapper {
254 |     width:auto;
255 |     margin:0;
256 |   }
257 | 
258 |   header, section, footer {
259 |     float:none;
260 |     position:static;
261 |     width:auto;
262 |   }
263 | 
264 |   header {
265 |     padding-right:320px;
266 |   }
267 | 
268 |   section {
269 |     border:1px solid #e5e5e5;
270 |     border-width:1px 0;
271 |     padding:20px 0;
272 |     margin:0 0 20px;
273 |   }
274 | 
275 |   header a small {
276 |     display:inline;
277 |   }
278 | 
279 |   header ul {
280 |     position:absolute;
281 |     right:50px;
282 |     top:52px;
283 |   }
284 | }
285 | 
286 | @media print, screen and (max-width: 720px) {
287 |   body {
288 |     word-wrap:break-word;
289 |   }
290 | 
291 |   header {
292 |     padding:0;
293 |   }
294 | 
295 |   header ul, header p.view {
296 |     position:static;
297 |   }
298 | 
299 |   pre, code {
300 |     word-wrap:normal;
301 |   }
302 | }
303 | 
304 | @media print, screen and (max-width: 480px) {
305 |   body {
306 |     padding:15px;
307 |   }
308 | 
309 |   header ul {
310 |     width:99%;
311 |   }
312 | 
313 |   header li, header ul li + li + li {
314 |     width:33%;
315 |   }
316 | }
317 | 
318 | @media print {
319 |   body {
320 |     padding:0.4in;
321 |     font-size:12pt;
322 |     color:#444;
323 |   }
324 | }
325 | 


--------------------------------------------------------------------------------
/stylesheets/normalize.css:
--------------------------------------------------------------------------------
  1 | /*! normalize.css v3.0.2 | MIT License | git.io/normalize */
  2 | 
  3 | /**
  4 |  * 1. Set default font family to sans-serif.
  5 |  * 2. Prevent iOS text size adjust after orientation change, without disabling
  6 |  *    user zoom.
  7 |  */
  8 | 
  9 | html {
 10 |   font-family: sans-serif; /* 1 */
 11 |   -ms-text-size-adjust: 100%; /* 2 */
 12 |   -webkit-text-size-adjust: 100%; /* 2 */
 13 | }
 14 | 
 15 | /**
 16 |  * Remove default margin.
 17 |  */
 18 | 
 19 | body {
 20 |   margin: 0;
 21 | }
 22 | 
 23 | /* HTML5 display definitions
 24 |    ========================================================================== */
 25 | 
 26 | /**
 27 |  * Correct `block` display not defined for any HTML5 element in IE 8/9.
 28 |  * Correct `block` display not defined for `details` or `summary` in IE 10/11
 29 |  * and Firefox.
 30 |  * Correct `block` display not defined for `main` in IE 11.
 31 |  */
 32 | 
 33 | article,
 34 | aside,
 35 | details,
 36 | figcaption,
 37 | figure,
 38 | footer,
 39 | header,
 40 | hgroup,
 41 | main,
 42 | menu,
 43 | nav,
 44 | section,
 45 | summary {
 46 |   display: block;
 47 | }
 48 | 
 49 | /**
 50 |  * 1. Correct `inline-block` display not defined in IE 8/9.
 51 |  * 2. Normalize vertical alignment of `progress` in Chrome, Firefox, and Opera.
 52 |  */
 53 | 
 54 | audio,
 55 | canvas,
 56 | progress,
 57 | video {
 58 |   display: inline-block; /* 1 */
 59 |   vertical-align: baseline; /* 2 */
 60 | }
 61 | 
 62 | /**
 63 |  * Prevent modern browsers from displaying `audio` without controls.
 64 |  * Remove excess height in iOS 5 devices.
 65 |  */
 66 | 
 67 | audio:not([controls]) {
 68 |   display: none;
 69 |   height: 0;
 70 | }
 71 | 
 72 | /**
 73 |  * Address `[hidden]` styling not present in IE 8/9/10.
 74 |  * Hide the `template` element in IE 8/9/11, Safari, and Firefox < 22.
 75 |  */
 76 | 
 77 | [hidden],
 78 | template {
 79 |   display: none;
 80 | }
 81 | 
 82 | /* Links
 83 |    ========================================================================== */
 84 | 
 85 | /**
 86 |  * Remove the gray background color from active links in IE 10.
 87 |  */
 88 | 
 89 | a {
 90 |   background-color: transparent;
 91 | }
 92 | 
 93 | /**
 94 |  * Improve readability when focused and also mouse hovered in all browsers.
 95 |  */
 96 | 
 97 | a:active,
 98 | a:hover {
 99 |   outline: 0;
100 | }
101 | 
102 | /* Text-level semantics
103 |    ========================================================================== */
104 | 
105 | /**
106 |  * Address styling not present in IE 8/9/10/11, Safari, and Chrome.
107 |  */
108 | 
109 | abbr[title] {
110 |   border-bottom: 1px dotted;
111 | }
112 | 
113 | /**
114 |  * Address style set to `bolder` in Firefox 4+, Safari, and Chrome.
115 |  */
116 | 
117 | b,
118 | strong {
119 |   font-weight: bold;
120 | }
121 | 
122 | /**
123 |  * Address styling not present in Safari and Chrome.
124 |  */
125 | 
126 | dfn {
127 |   font-style: italic;
128 | }
129 | 
130 | /**
131 |  * Address variable `h1` font-size and margin within `section` and `article`
132 |  * contexts in Firefox 4+, Safari, and Chrome.
133 |  */
134 | 
135 | h1 {
136 |   font-size: 2em;
137 |   margin: 0.67em 0;
138 | }
139 | 
140 | /**
141 |  * Address styling not present in IE 8/9.
142 |  */
143 | 
144 | mark {
145 |   background: #ff0;
146 |   color: #000;
147 | }
148 | 
149 | /**
150 |  * Address inconsistent and variable font size in all browsers.
151 |  */
152 | 
153 | small {
154 |   font-size: 80%;
155 | }
156 | 
157 | /**
158 |  * Prevent `sub` and `sup` affecting `line-height` in all browsers.
159 |  */
160 | 
161 | sub,
162 | sup {
163 |   font-size: 75%;
164 |   line-height: 0;
165 |   position: relative;
166 |   vertical-align: baseline;
167 | }
168 | 
169 | sup {
170 |   top: -0.5em;
171 | }
172 | 
173 | sub {
174 |   bottom: -0.25em;
175 | }
176 | 
177 | /* Embedded content
178 |    ========================================================================== */
179 | 
180 | /**
181 |  * Remove border when inside `a` element in IE 8/9/10.
182 |  */
183 | 
184 | img {
185 |   border: 0;
186 | }
187 | 
188 | /**
189 |  * Correct overflow not hidden in IE 9/10/11.
190 |  */
191 | 
192 | svg:not(:root) {
193 |   overflow: hidden;
194 | }
195 | 
196 | /* Grouping content
197 |    ========================================================================== */
198 | 
199 | /**
200 |  * Address margin not present in IE 8/9 and Safari.
201 |  */
202 | 
203 | figure {
204 |   margin: 1em 40px;
205 | }
206 | 
207 | /**
208 |  * Address differences between Firefox and other browsers.
209 |  */
210 | 
211 | hr {
212 |   box-sizing: content-box;
213 |   height: 0;
214 | }
215 | 
216 | /**
217 |  * Contain overflow in all browsers.
218 |  */
219 | 
220 | pre {
221 |   overflow: auto;
222 | }
223 | 
224 | /**
225 |  * Address odd `em`-unit font size rendering in all browsers.
226 |  */
227 | 
228 | code,
229 | kbd,
230 | pre,
231 | samp {
232 |   font-family: monospace, monospace;
233 |   font-size: 1em;
234 | }
235 | 
236 | /* Forms
237 |    ========================================================================== */
238 | 
239 | /**
240 |  * Known limitation: by default, Chrome and Safari on OS X allow very limited
241 |  * styling of `select`, unless a `border` property is set.
242 |  */
243 | 
244 | /**
245 |  * 1. Correct color not being inherited.
246 |  *    Known issue: affects color of disabled elements.
247 |  * 2. Correct font properties not being inherited.
248 |  * 3. Address margins set differently in Firefox 4+, Safari, and Chrome.
249 |  */
250 | 
251 | button,
252 | input,
253 | optgroup,
254 | select,
255 | textarea {
256 |   color: inherit; /* 1 */
257 |   font: inherit; /* 2 */
258 |   margin: 0; /* 3 */
259 | }
260 | 
261 | /**
262 |  * Address `overflow` set to `hidden` in IE 8/9/10/11.
263 |  */
264 | 
265 | button {
266 |   overflow: visible;
267 | }
268 | 
269 | /**
270 |  * Address inconsistent `text-transform` inheritance for `button` and `select`.
271 |  * All other form control elements do not inherit `text-transform` values.
272 |  * Correct `button` style inheritance in Firefox, IE 8/9/10/11, and Opera.
273 |  * Correct `select` style inheritance in Firefox.
274 |  */
275 | 
276 | button,
277 | select {
278 |   text-transform: none;
279 | }
280 | 
281 | /**
282 |  * 1. Avoid the WebKit bug in Android 4.0.* where (2) destroys native `audio`
283 |  *    and `video` controls.
284 |  * 2. Correct inability to style clickable `input` types in iOS.
285 |  * 3. Improve usability and consistency of cursor style between image-type
286 |  *    `input` and others.
287 |  */
288 | 
289 | button,
290 | html input[type="button"], /* 1 */
291 | input[type="reset"],
292 | input[type="submit"] {
293 |   -webkit-appearance: button; /* 2 */
294 |   cursor: pointer; /* 3 */
295 | }
296 | 
297 | /**
298 |  * Re-set default cursor for disabled elements.
299 |  */
300 | 
301 | button[disabled],
302 | html input[disabled] {
303 |   cursor: default;
304 | }
305 | 
306 | /**
307 |  * Remove inner padding and border in Firefox 4+.
308 |  */
309 | 
310 | button::-moz-focus-inner,
311 | input::-moz-focus-inner {
312 |   border: 0;
313 |   padding: 0;
314 | }
315 | 
316 | /**
317 |  * Address Firefox 4+ setting `line-height` on `input` using `!important` in
318 |  * the UA stylesheet.
319 |  */
320 | 
321 | input {
322 |   line-height: normal;
323 | }
324 | 
325 | /**
326 |  * It's recommended that you don't attempt to style these elements.
327 |  * Firefox's implementation doesn't respect box-sizing, padding, or width.
328 |  *
329 |  * 1. Address box sizing set to `content-box` in IE 8/9/10.
330 |  * 2. Remove excess padding in IE 8/9/10.
331 |  */
332 | 
333 | input[type="checkbox"],
334 | input[type="radio"] {
335 |   box-sizing: border-box; /* 1 */
336 |   padding: 0; /* 2 */
337 | }
338 | 
339 | /**
340 |  * Fix the cursor style for Chrome's increment/decrement buttons. For certain
341 |  * `font-size` values of the `input`, it causes the cursor style of the
342 |  * decrement button to change from `default` to `text`.
343 |  */
344 | 
345 | input[type="number"]::-webkit-inner-spin-button,
346 | input[type="number"]::-webkit-outer-spin-button {
347 |   height: auto;
348 | }
349 | 
350 | /**
351 |  * 1. Address `appearance` set to `searchfield` in Safari and Chrome.
352 |  * 2. Address `box-sizing` set to `border-box` in Safari and Chrome
353 |  *    (include `-moz` to future-proof).
354 |  */
355 | 
356 | input[type="search"] {
357 |   -webkit-appearance: textfield; /* 1 */ /* 2 */
358 |   box-sizing: content-box;
359 | }
360 | 
361 | /**
362 |  * Remove inner padding and search cancel button in Safari and Chrome on OS X.
363 |  * Safari (but not Chrome) clips the cancel button when the search input has
364 |  * padding (and `textfield` appearance).
365 |  */
366 | 
367 | input[type="search"]::-webkit-search-cancel-button,
368 | input[type="search"]::-webkit-search-decoration {
369 |   -webkit-appearance: none;
370 | }
371 | 
372 | /**
373 |  * Define consistent border, margin, and padding.
374 |  */
375 | 
376 | fieldset {
377 |   border: 1px solid #c0c0c0;
378 |   margin: 0 2px;
379 |   padding: 0.35em 0.625em 0.75em;
380 | }
381 | 
382 | /**
383 |  * 1. Correct `color` not being inherited in IE 8/9/10/11.
384 |  * 2. Remove padding so people aren't caught out if they zero out fieldsets.
385 |  */
386 | 
387 | legend {
388 |   border: 0; /* 1 */
389 |   padding: 0; /* 2 */
390 | }
391 | 
392 | /**
393 |  * Remove default vertical scrollbar in IE 8/9/10/11.
394 |  */
395 | 
396 | textarea {
397 |   overflow: auto;
398 | }
399 | 
400 | /**
401 |  * Don't inherit the `font-weight` (applied by a rule above).
402 |  * NOTE: the default cannot safely be changed in Chrome and Safari on OS X.
403 |  */
404 | 
405 | optgroup {
406 |   font-weight: bold;
407 | }
408 | 
409 | /* Tables
410 |    ========================================================================== */
411 | 
412 | /**
413 |  * Remove most spacing between table cells.
414 |  */
415 | 
416 | table {
417 |   border-collapse: collapse;
418 |   border-spacing: 0;
419 | }
420 | 
421 | td,
422 | th {
423 |   padding: 0;
424 | }
425 | 


--------------------------------------------------------------------------------
/spec/algorithms/dijkstra_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | 
  3 | RSpec.describe Abuelo::Algorithms::Dijkstra do
  4 |   describe '#initialize(graph, start_node)' do
  5 |     it 'raises an error if the start_node is not a Abuelo::Node' do
  6 |       expect do
  7 |         described_class.new(Abuelo::Graph.new, 'foo')
  8 |       end.to raise_error(Abuelo::Exceptions::NoNodeError)
  9 |     end
 10 |   end
 11 | 
 12 |   context 'undirected graph' do
 13 |     # This is the example from https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
 14 |     adjacency_matrix = <<-matrix
 15 |       0  7  9  0  0 14
 16 |       7  0  10 15 0 0
 17 |       9  10 0  11 0 2
 18 |       0  15 11 0  6 0
 19 |       0  0  0  6  0 9
 20 |       14 0  2  0  9 0
 21 |     matrix
 22 |     
 23 |     let(:undirected_graph) do
 24 |       Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
 25 |     end
 26 |     let(:start_node) { undirected_graph.find_node_by_name('node 1') }
 27 |     let(:dijkstra)   { described_class.new(undirected_graph, start_node) }
 28 | 
 29 |     describe '#shortest_distance_to(node)' do
 30 |       it 'is 0 for the start node' do
 31 |         expect(dijkstra.shortest_distance_to(start_node)).to eq 0
 32 |       end
 33 | 
 34 |       it 'is Float::INFINITY for an unreachable node' do
 35 |         unreachable_node = Abuelo::Node.new('unreachable node')
 36 |         undirected_graph.add_node(unreachable_node)
 37 |         expect(dijkstra.shortest_distance_to(unreachable_node)).to eq Float::INFINITY
 38 |       end
 39 | 
 40 |       it 'is nil when the node is not part of the graph' do
 41 |         unknown_node = Abuelo::Node.new('foo')
 42 |         expect(dijkstra.shortest_distance_to(unknown_node)).to be nil
 43 |       end
 44 | 
 45 |       context 'wikipedia example' do
 46 |         it 'is 0 for node 1' do
 47 |           node = undirected_graph.find_node_by_name('node 1')
 48 |           expect(dijkstra.shortest_distance_to(node)).to eq 0
 49 |         end
 50 | 
 51 |         it 'is 7 for node 2' do
 52 |           node = undirected_graph.find_node_by_name('node 2')
 53 |           expect(dijkstra.shortest_distance_to(node)).to eq 7
 54 |         end
 55 | 
 56 |         it 'is 9 for node 3' do
 57 |           node = undirected_graph.find_node_by_name('node 3')
 58 |           expect(dijkstra.shortest_distance_to(node)).to eq 9
 59 |         end
 60 | 
 61 |         it 'is 20 for node 4' do
 62 |           node = undirected_graph.find_node_by_name('node 4')
 63 |           expect(dijkstra.shortest_distance_to(node)).to eq 20
 64 |         end
 65 | 
 66 |         it 'is 20 for node 5' do
 67 |           node = undirected_graph.find_node_by_name('node 5')
 68 |           expect(dijkstra.shortest_distance_to(node)).to eq 20
 69 |         end
 70 | 
 71 |         it 'is 11 for node 6' do
 72 |           node = undirected_graph.find_node_by_name('node 6')
 73 |           expect(dijkstra.shortest_distance_to(node)).to eq 11
 74 |         end
 75 |       end
 76 |     end
 77 | 
 78 |     describe '#shortest_path_to(node)' do
 79 |       it 'is nil for the start node' do
 80 |         expect(dijkstra.shortest_path_to(start_node)).to be nil
 81 |       end
 82 | 
 83 |       it 'is nil for an unreachable node' do
 84 |         unreachable_node = Abuelo::Node.new('unreachable node')
 85 |         undirected_graph.add_node(unreachable_node)
 86 |         expect(dijkstra.shortest_path_to(unreachable_node)).to be nil
 87 |       end
 88 | 
 89 |       it 'is nil when the node is not part of the graph' do
 90 |         unknown_node = Abuelo::Node.new('foo')
 91 |         expect(dijkstra.shortest_path_to(unknown_node)).to be nil
 92 |       end
 93 | 
 94 |       context 'wikipedia example' do
 95 |         it 'solves the problem for node 1' do
 96 |           node = undirected_graph.find_node_by_name('node 1')
 97 |           expect(dijkstra.shortest_path_to(node)).to be nil
 98 |         end
 99 | 
100 |         it 'solves the problem for node 2' do
101 |           node = undirected_graph.find_node_by_name('node 2')
102 |           shortest_path = ['node 1', 'node 2']
103 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
104 |         end
105 | 
106 |         it 'solves the problem for node 3' do
107 |           node = undirected_graph.find_node_by_name('node 3')
108 |           shortest_path = ['node 1', 'node 3']
109 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
110 |         end
111 | 
112 |         it 'solves the problem for node 4' do
113 |           node = undirected_graph.find_node_by_name('node 4')
114 |           shortest_path = ['node 1', 'node 3', 'node 4']
115 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
116 |         end
117 | 
118 |         it 'solves the problem for node 5' do
119 |           node = undirected_graph.find_node_by_name('node 5')
120 |           shortest_path = ['node 1', 'node 3', 'node 6', 'node 5']
121 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
122 |         end
123 | 
124 |         it 'solves the problem for node 6' do
125 |           node = undirected_graph.find_node_by_name('node 6')
126 |           shortest_path = ['node 1', 'node 3', 'node 6']
127 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
128 |         end
129 |       end
130 |     end
131 |   end
132 | 
133 |   context 'directed graph' do
134 |     adjacency_matrix = <<-matrix
135 |       0  7 0  0  0 0
136 |       0  0 10 15 0 0
137 |       9  0 0  11 0 2
138 |       0  0 11 0  6 0
139 |       0  0 0  0  0 0
140 |       14 0 0  0  9 0
141 |     matrix
142 |     
143 |     let(:directed_graph) do
144 |       Abuelo::Graph.new(adjacency_matrix: adjacency_matrix, directed: true)
145 |     end
146 |     let(:start_node) { directed_graph.find_node_by_name('node 1') }
147 |     let(:dijkstra)   { described_class.new(directed_graph, start_node) }
148 | 
149 |     describe '#shortest_distance_to(node)' do
150 |       it 'is 0 for the start node' do
151 |         expect(dijkstra.shortest_distance_to(start_node)).to eq 0
152 |       end
153 | 
154 |       it 'is Float::INFINITY for an unreachable node' do
155 |         unreachable_node = Abuelo::Node.new('unreachable node')
156 |         directed_graph.add_node(unreachable_node)
157 |         expect(dijkstra.shortest_distance_to(unreachable_node)).to eq Float::INFINITY
158 |       end
159 | 
160 |       it 'is nil when the node is not part of the graph' do
161 |         unknown_node = Abuelo::Node.new('foo')
162 |         expect(dijkstra.shortest_distance_to(unknown_node)).to be nil
163 |       end
164 | 
165 |       context 'example' do
166 |         it 'is 0 for node 1' do
167 |           node = directed_graph.find_node_by_name('node 1')
168 |           expect(dijkstra.shortest_distance_to(node)).to eq 0
169 |         end
170 | 
171 |         it 'is 7 for node 2' do
172 |           node = directed_graph.find_node_by_name('node 2')
173 |           expect(dijkstra.shortest_distance_to(node)).to eq 7
174 |         end
175 | 
176 |         it 'is 9 for node 3' do
177 |           node = directed_graph.find_node_by_name('node 3')
178 |           expect(dijkstra.shortest_distance_to(node)).to eq 17
179 |         end
180 | 
181 |         it 'is 20 for node 4' do
182 |           node = directed_graph.find_node_by_name('node 4')
183 |           expect(dijkstra.shortest_distance_to(node)).to eq 22
184 |         end
185 | 
186 |         it 'is 20 for node 5' do
187 |           node = directed_graph.find_node_by_name('node 5')
188 |           expect(dijkstra.shortest_distance_to(node)).to eq 28
189 |         end
190 | 
191 |         it 'is 11 for node 6' do
192 |           node = directed_graph.find_node_by_name('node 6')
193 |           expect(dijkstra.shortest_distance_to(node)).to eq 19
194 |         end
195 |       end
196 |     end
197 | 
198 |     describe '#shortest_path_to(node)' do
199 |       it 'is nil for the start node' do
200 |         expect(dijkstra.shortest_path_to(start_node)).to be nil
201 |       end
202 | 
203 |       it 'is nil for an unreachable node' do
204 |         unreachable_node = Abuelo::Node.new('unreachable node')
205 |         directed_graph.add_node(unreachable_node)
206 |         expect(dijkstra.shortest_path_to(unreachable_node)).to be nil
207 |       end
208 | 
209 |       it 'is nil when the node is not part of the graph' do
210 |         unknown_node = Abuelo::Node.new('foo')
211 |         expect(dijkstra.shortest_path_to(unknown_node)).to be nil
212 |       end
213 | 
214 |       context 'example' do
215 |         it 'solves the problem for node 1' do
216 |           node = directed_graph.find_node_by_name('node 1')
217 |           expect(dijkstra.shortest_path_to(node)).to be nil
218 |         end
219 | 
220 |         it 'solves the problem for node 2' do
221 |           node = directed_graph.find_node_by_name('node 2')
222 |           shortest_path = ['node 1', 'node 2']
223 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
224 |         end
225 | 
226 |         it 'solves the problem for node 3' do
227 |           node = directed_graph.find_node_by_name('node 3')
228 |           shortest_path = ['node 1', 'node 2', 'node 3']
229 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
230 |         end
231 | 
232 |         it 'solves the problem for node 4' do
233 |           node = directed_graph.find_node_by_name('node 4')
234 |           shortest_path = ['node 1', 'node 2', 'node 4']
235 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
236 |         end
237 | 
238 |         it 'solves the problem for node 5' do
239 |           node = directed_graph.find_node_by_name('node 5')
240 |           shortest_path = ['node 1', 'node 2', 'node 3', 'node 6', 'node 5']
241 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
242 |         end
243 | 
244 |         it 'solves the problem for node 6' do
245 |           node = directed_graph.find_node_by_name('node 6')
246 |           shortest_path = ['node 1', 'node 2', 'node 3', 'node 6']
247 |           expect(dijkstra.shortest_path_to(node).map(&:to_s)).to eq shortest_path
248 |         end
249 |       end
250 |     end
251 |   end
252 | end
253 | 


--------------------------------------------------------------------------------
/spec/graph_spec.rb:
--------------------------------------------------------------------------------
  1 | require 'spec_helper'
  2 | 
  3 | RSpec.describe Abuelo::Graph do
  4 |   let(:node_1) { Abuelo::Node.new('node 1') }
  5 |   let(:node_2) { Abuelo::Node.new('node 2') }
  6 |   let(:node_3) { Abuelo::Node.new('node 3') }
  7 |   let(:edge_1) { Abuelo::Edge.new(node_1, node_2, 42) }
  8 |   let(:edge_2) { Abuelo::Edge.new(node_2, node_3, 23) }
  9 | 
 10 |   let(:directed_graph) do
 11 |     described_class.new(directed: true)
 12 |                    .add_node(node_1)
 13 |                    .add_node(node_2)
 14 |                    .add_node(node_3)
 15 |                    .add_edge(edge_1)
 16 |                    .add_edge(edge_2)
 17 |   end
 18 | 
 19 |   let(:undirected_graph) do
 20 |     described_class.new
 21 |                    .add_node(node_1)
 22 |                    .add_node(node_2)
 23 |                    .add_node(node_3)
 24 |                    .add_edge(edge_1)
 25 |                    .add_edge(edge_2)
 26 |   end
 27 | 
 28 |   context 'directed graph' do
 29 |     describe '#initialize' do
 30 |       it 'can be initialized with an adjacency matrix with weights' do
 31 |         adjacency_matrix = <<-matrix
 32 |           0  7  9  0 0 14
 33 |           7  0 10 15 0  0
 34 |           9 10  0 11 0  2
 35 |           0  0 11  0 6  0
 36 |           0  0  0  6 0  9
 37 |           0  0  2  0 9  0
 38 |           matrix
 39 | 
 40 |           graph = described_class.new(adjacency_matrix: adjacency_matrix, directed: true)
 41 |           node_1 = graph.find_node_by_name('node 1')
 42 |           node_2 = graph.find_node_by_name('node 2')
 43 |           node_4 = graph.find_node_by_name('node 4')
 44 | 
 45 |           expect(graph.order).to eq 6
 46 |           expect(graph.size).to eq 16
 47 | 
 48 |           expect(graph.has_node_with_name?('node 1')).to be true
 49 |           expect(graph.has_node_with_name?('node 0')).to be false
 50 |           expect(graph.has_node_with_name?('node 7')).to be false
 51 | 
 52 |           expect(graph.find_edge(node_1, node_4)).to be nil
 53 | 
 54 |           edge_1_2 = graph.find_edge(node_1, node_2)
 55 |           expect(edge_1_2.weight).to eq 7
 56 |       end
 57 |     end
 58 | 
 59 |     describe '#undirected?' do
 60 |       it 'is false' do
 61 |         expect(directed_graph.undirected?).to be false
 62 |       end
 63 |     end
 64 | 
 65 |     describe '#directed?' do
 66 |       it 'is true' do
 67 |         expect(directed_graph.directed?).to be true
 68 |       end
 69 |     end
 70 | 
 71 |     describe 'order' do
 72 |       it 'returns the count of nodes' do
 73 |         expect(directed_graph.order).to eq 3
 74 |       end
 75 |     end
 76 | 
 77 |     describe 'size' do
 78 |       it 'returns the count of edges' do
 79 |         expect(directed_graph.size).to eq 2
 80 |       end
 81 |     end
 82 | 
 83 |     context 'nodes' do
 84 |       describe '#nodes' do
 85 |         it 'returns the nodes of the graph' do
 86 |           expect(directed_graph.nodes).to match_array [node_1, node_2, node_3]
 87 |         end
 88 |       end
 89 | 
 90 |       describe '#add_node(node)' do
 91 |         it 'adds the node to the graph' do
 92 |           new_node = Abuelo::Node.new('node 4')
 93 | 
 94 |           expect do
 95 |             directed_graph.add_node(new_node)
 96 |           end.to change { directed_graph.nodes.count }.by 1
 97 | 
 98 |           expect(directed_graph.has_node?(new_node)).to be true
 99 |         end
100 | 
101 |         it 'raises an error if a node with the same name in the graph exists' do
102 |           new_node = Abuelo::Node.new('node 1')
103 | 
104 |           expect do
105 |             directed_graph.add_node(new_node)
106 |           end.to raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
107 |         end
108 | 
109 |         it 'sets the graph of the node to itself' do
110 |           new_node = Abuelo::Node.new('node 4')
111 | 
112 |           expect do
113 |             directed_graph.add_node(new_node)
114 |           end.to change { new_node.graph }.to(directed_graph)
115 |         end
116 |       end
117 | 
118 |       describe '#has_node?(node)' do
119 |         it 'returns true if node is in the graph. checks object name' do
120 |           expect(directed_graph.has_node?(node_1)).to be true
121 |         end
122 | 
123 |         it 'returns false if node is not in the graph. checks object name' do
124 |           new_node = Abuelo::Node.new('node 99')
125 |           expect(directed_graph.has_node?(new_node)).to be false
126 |         end
127 |       end
128 | 
129 |       describe '#has_node_with_name?(name)' do
130 |         it 'returns true if a node with the given name is in the graph' do
131 |           expect(directed_graph.has_node_with_name?('node 1')).to be true
132 |         end
133 | 
134 |         it 'returns false if no node with the given name is in the graph' do
135 |           expect(directed_graph.has_node_with_name?('foo')).to be false
136 |         end
137 |       end
138 |     end
139 | 
140 |     context 'edges' do
141 |       describe '#edges' do
142 |         it 'returns the edges of the graph' do
143 |           expect(directed_graph.edges).to match_array [edge_1, edge_2]
144 |         end
145 |       end
146 | 
147 |       describe '#add_edge(edge)' do
148 |         it 'adds the edge to the graph' do
149 |           new_edge = Abuelo::Edge.new(node_2, node_1, 23)
150 | 
151 |           expect do
152 |             directed_graph.add_edge(new_edge)
153 |           end.to change { directed_graph.edges.count }.by 1
154 | 
155 |           expect(directed_graph.has_edge?(new_edge)).to be true
156 |         end
157 | 
158 |         it 'raises an error if an edge with the same name nodes in the graph exists' do
159 |           new_edge = Abuelo::Edge.new(node_1, node_2, 23)
160 | 
161 |           expect do
162 |             directed_graph.add_edge(new_edge)
163 |           end.to raise_error(Abuelo::Exceptions::EdgeAlreadyExistsError)
164 |         end
165 |       end
166 | 
167 |       describe '#edges_for_node(node)' do
168 |         it 'returns all edges that start from the given node' do
169 |           expect(directed_graph.edges_for_node(node_1)).to eq [edge_1]
170 |           expect(directed_graph.edges_for_node(node_2)).to eq [edge_2]
171 |           expect(directed_graph.edges_for_node(node_3)).to eq []
172 |         end
173 |       end
174 | 
175 |       describe '#has_edge?(edge)' do
176 |         it 'returns true if there is an edge with similiar nodes in the graph' do
177 |           expect(directed_graph.has_edge?(edge_1)).to be true
178 |         end
179 | 
180 |         it 'does not have a symmetric edge automatically' do
181 |           expect(directed_graph.has_edge?(edge_1.symmetric)).to be false
182 |         end
183 | 
184 |         it 'returns false if there is no edge with similiar nodes in the graph' do
185 |           other_edge = Abuelo::Edge.new(node_2, node_1, 23)
186 |           expect(directed_graph.has_edge?(other_edge)).to be false
187 |         end
188 |       end
189 | 
190 |       describe '#find_edge(node_1, node_2)' do
191 |         it 'returns the edge if it can be found in the graph' do
192 |           expect(directed_graph.find_edge(node_1, node_2)).to eq edge_1
193 |         end
194 | 
195 |         it 'returns nil if the edge cannot be found in the graph' do
196 |           expect(directed_graph.find_edge(node_2, node_1)).to be nil
197 |         end
198 |       end
199 |     end
200 |   end
201 | 
202 |   context 'undirected graph' do
203 |     describe '#initialize' do
204 |       it 'can be initialized with an adjacency matrix with weights' do
205 |         adjacency_matrix = <<-matrix
206 |            0  7  9  0 0 14
207 |            7  0 10 15 0  0
208 |            9 10  0 11 0  2
209 |            0 15 11  0 6  0
210 |            0  0  0  6 0  9
211 |           14  0  2  0 9  0
212 |           matrix
213 | 
214 |           graph = described_class.new(adjacency_matrix: adjacency_matrix)
215 |           node_1 = graph.find_node_by_name('node 1')
216 |           node_2 = graph.find_node_by_name('node 2')
217 |           node_4 = graph.find_node_by_name('node 4')
218 | 
219 |           expect(graph.order).to eq 6
220 |           expect(graph.size).to eq 9
221 | 
222 |           expect(graph.has_node_with_name?('node 1')).to be true
223 |           expect(graph.has_node_with_name?('node 0')).to be false
224 |           expect(graph.has_node_with_name?('node 7')).to be false
225 | 
226 |           expect(graph.find_edge(node_1, node_4)).to be nil
227 | 
228 |           edge_1_2 = graph.find_edge(node_1, node_2)
229 |           expect(edge_1_2.weight).to eq 7
230 |       end
231 |     end
232 | 
233 |     describe '#undirected?' do
234 |       it 'is true' do
235 |         expect(undirected_graph.undirected?).to be true
236 |       end
237 |     end
238 | 
239 |     describe '#directed?' do
240 |       it 'is false' do
241 |         expect(undirected_graph.directed?).to be false
242 |       end
243 |     end
244 | 
245 |     describe 'order' do
246 |       it 'returns the count of nodes' do
247 |         expect(undirected_graph.order).to eq 3
248 |       end
249 |     end
250 | 
251 |     describe 'size' do
252 |       it 'returns the count of edges' do
253 |         expect(undirected_graph.size).to eq 2
254 |       end
255 |     end
256 | 
257 |     context 'nodes' do
258 |       describe '#nodes' do
259 |         it 'returns the nodes of the graph' do
260 |           expect(undirected_graph.nodes).to match_array [node_1, node_2, node_3]
261 |         end
262 |       end
263 | 
264 |       describe '#add_node(node)' do
265 |         it 'adds the node to the graph' do
266 |           new_node = Abuelo::Node.new('node 4')
267 | 
268 |           expect do
269 |             undirected_graph.add_node(new_node)
270 |           end.to change { undirected_graph.nodes.count }.by 1
271 | 
272 |           expect(undirected_graph.has_node?(new_node)).to be true
273 |         end
274 | 
275 |         it 'raises an error if a node with the same name in the graph exists' do
276 |           new_node = Abuelo::Node.new('node 1')
277 | 
278 |           expect do
279 |             undirected_graph.add_node(new_node)
280 |           end.to raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
281 |         end
282 | 
283 |         it 'sets the graph of the node to itself' do
284 |           new_node = Abuelo::Node.new('node 4')
285 | 
286 |           expect do
287 |             undirected_graph.add_node(new_node)
288 |           end.to change { new_node.graph }.to(undirected_graph)
289 |         end
290 |       end
291 | 
292 |       describe '#has_node?(node)' do
293 |         it 'returns true if node is in the graph. checks object name' do
294 |           expect(undirected_graph.has_node?(node_1)).to be true
295 |         end
296 | 
297 |         it 'returns false if node is not in the graph. checks object name' do
298 |           new_node = Abuelo::Node.new('node 4')
299 |           expect(undirected_graph.has_node?(new_node)).to be false
300 |         end
301 |       end
302 | 
303 |       describe '#has_node_with_name?(name)' do
304 |         it 'returns true if a node with the given name is in the graph' do
305 |           expect(undirected_graph.has_node_with_name?('node 1')).to be true
306 |         end
307 | 
308 |         it 'returns false if no node with the given name is in the graph' do
309 |           expect(undirected_graph.has_node_with_name?('foo')).to be false
310 |         end
311 |       end
312 |     end
313 | 
314 |     context 'edges' do
315 |       describe '#edges' do
316 |         it 'returns the edges of the graph' do
317 |           edges = [[edge_1, edge_1.symmetric], [edge_2, edge_2.symmetric]]
318 |           expect(undirected_graph.edges).to match_array edges
319 |         end
320 |       end
321 | 
322 |       describe '#add_edge(edge)' do
323 |         it 'adds the edge to the graph' do
324 |           new_edge = Abuelo::Edge.new(node_1, node_3, 23)
325 | 
326 |           expect do
327 |             undirected_graph.add_edge(new_edge)
328 |           end.to change { undirected_graph.edges.count }.by 1
329 | 
330 |           expect(undirected_graph.has_edge?(new_edge)).to be true
331 |           expect(undirected_graph.has_edge?(new_edge.symmetric)).to be true
332 |         end
333 | 
334 |         it 'raises an error if an edge with the same name nodes in the graph exists' do
335 |           new_edge = Abuelo::Edge.new(node_1, node_2, 23)
336 | 
337 |           expect do
338 |             undirected_graph.add_edge(new_edge)
339 |           end.to raise_error(Abuelo::Exceptions::EdgeAlreadyExistsError)
340 |         end
341 |       end
342 | 
343 |       describe '#edges_for_node(node)' do
344 |         it 'returns all edges that start from the given node' do
345 |           expect(undirected_graph.edges_for_node(node_1)).to eq [edge_1]
346 |           expect(undirected_graph.edges_for_node(node_2)).to eq [edge_1.symmetric, edge_2]
347 |           expect(undirected_graph.edges_for_node(node_3)).to eq [edge_2.symmetric]
348 |         end
349 |       end
350 | 
351 |       describe '#has_edge?(edge)' do
352 |         it 'returns true if there is an edge with similiar nodes in the graph' do
353 |           expect(undirected_graph.has_edge?(edge_1)).to be true
354 |           expect(undirected_graph.has_edge?(edge_1.symmetric)).to be true
355 |         end
356 | 
357 |         it 'returns false if there is no edge with similiar nodes in the graph' do
358 |           other_edge = Abuelo::Edge.new(node_1, node_3, 23)
359 |           expect(undirected_graph.has_edge?(other_edge)).to be false
360 |         end
361 |       end
362 | 
363 |       describe '#find_edge(node_1, node_2)' do
364 |         it 'returns the edge if it can be found in the graph' do
365 |           expect(undirected_graph.find_edge(node_1, node_2)).to eq edge_1
366 |           expect(undirected_graph.find_edge(node_2, node_1)).to eq edge_1.symmetric
367 |         end
368 | 
369 |         it 'returns nil if the edge cannot be found in the graph' do
370 |           expect(undirected_graph.find_edge(node_1, node_3)).to be nil
371 |         end
372 |       end
373 |     end
374 |   end
375 | end
376 | 


--------------------------------------------------------------------------------