abuelo 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56d6315d3eafd194ee45e20bfa60eff9b68548c6
-  data.tar.gz: a15a915a0c83f075c4a67495dce09628fab155f4
+  metadata.gz: 5fec3a84e6365d1dabdbb0a97dfaae5c5f616dfe
+  data.tar.gz: d687748513f8e7aabb0eae7fbfc186949dc61334
 SHA512:
-  metadata.gz: ce7fdf584034fbe02e378dadd644c6e16dc617e3d50c7130cd97011f44bb9c9170af759b11be232f8b53d24b958ad286dda5a5a0b057075dc93d42daa619b8b5
-  data.tar.gz: 463ff60c87536021e450664c9a9749818bf4381a1b9db69f004e8f651ca0f3fe73421eee25af210b66b843425a34a48bc1f96160f67912c880c7e1cc303add43
+  metadata.gz: edca527570d0e4775ebaf20458dfdfb393c3ba54e0d250eaccae09d9476d68e249c62dd7620458824d4030b0d1956e4eb09b7da4d30d7704240116d20d8b2c3f
+  data.tar.gz: d7bc96b07f9ded38385e0a24a1201edc4f7ce6788596c79bbf3ee7ce99c580e274c916ad972a98e2e12940f47c2f9195e8615ec3cc2e7f2ae06756c106ef71ab

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.2.4
+  - 2.1.8
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,8 @@
+# 0.0.2 - 2016-02-21
+* new possibility to build a graph: adjacency matrix
+* added code of conduct
+* refactoring to better meet community standards
+* dropped support for Ruby < 2.0.0
+
+# 0.0.1 - 2016-01-17
+hello world

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at [INSERT EMAIL ADDRESS]. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in abuelo.gemspec
-gemspec
+gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    abuelo (0.0.1)
+    abuelo (0.0.2)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,7 +1,14 @@
 # Abuelo
-Abuelo is a graph theory library that allows you to build a representation of a directed graph with its nodes and edges.
+[![Build Status](https://travis-ci.org/dirkholzapfel/abuelo.svg?branch=master)](https://travis-ci.org/dirkholzapfel/abuelo)
+
+Abuelo is a graph theory library written in Ruby that allows you to build a representation of a graph.
+
+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.
+
+Abuelo supports Ruby >= 2.0.0
 
 ## Examples
+### Undirected graph
 ```ruby
 graph  = Abuelo::Graph.new
 
@@ -17,15 +24,109 @@ graph.add_node(node_1)
      .add_edge(edge_1)
      .add_edge(edge_2)
 
-graph.nodes                      # => [node_1, node_2, node_3]
-graph.has_node?(node_1)          # => true
-graph.has_node_with_name?('foo') # => false
-graph.edges                      # => [edge_1, edge_2]
-graph.has_edge?(edge_1)          # => true
-graph.find_edge(node_1, node_2)  # => edge_1
-graph.edges_for_node(node_2)     # => [edge_2]
+graph.order                       # => 3
+graph.size                        # => 2
+graph.nodes                       # => [node_1, node_2, node_3]
+graph.has_node?(node_1)           # => true
+graph.has_node_with_name?('foo')  # => false
+graph.find_node_by_name('node 1') # => node_1
+graph.edges                       # => [[edge_1, edge_1.symmetric], [edge_2, edge_2.symmetric]]
+graph.has_edge?(edge_1)           # => true
+graph.has_edge?(edge_1.symmetric) # => true
+graph.find_edge(node_1, node_2)   # => edge_1
+graph.find_edge(node_2, node_1)   # => edge_1.symmetric
+graph.edges_for_node(node_2)      # => [edge_1.symmetric, edge_2]
+
+node_1.edges                      # => [edge_1]
+node_1.neighbours                 # => [node_2]
 ```
 
+### Directed graph
+```ruby
+graph  = Abuelo::Graph.new(directed: true)
+
+node_1 = Abuelo::Node.new('node 1')
+node_2 = Abuelo::Node.new('node 2')
+node_3 = Abuelo::Node.new('node 3')
+edge_1 = Abuelo::Edge.new(node_1, node_2, 42)
+edge_2 = Abuelo::Edge.new(node_2, node_3, 23)
+
+graph.add_node(node_1)
+     .add_node(node_2)
+     .add_node(node_3)
+     .add_edge(edge_1)
+     .add_edge(edge_2)
+
+graph.order                       # => 3
+graph.size                        # => 2
+graph.nodes                       # => [node_1, node_2, node_3]
+graph.has_node?(node_1)           # => true
+graph.has_node_with_name?('foo')  # => false
+graph.find_node_by_name('node 1') # => node_1
+graph.edges                       # => [edge_1, edge_2]
+graph.has_edge?(edge_1)           # => true
+graph.has_edge?(edge_1.symmetric) # => false
+graph.find_edge(node_1, node_2)   # => edge_1
+graph.find_edge(node_2, node_1)   # => nil
+graph.edges_for_node(node_2)      # => [edge_2]
+
+node_1.edges                      # => [edge_1]
+node_1.neighbours                 # => [node_2]
+```
+
+### Initialize a graph with an adjacency matrix
+The above, object oriented way to build graphs is the recommended way to work with this library.
+But you can also build a graph with an [adjacency matrix](https://en.wikipedia.org/wiki/Adjacency_matrix).
+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.
+
+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".
+The above example can be built like this:
+
+#### Undirected graphs
+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.
+
+```ruby
+adjacency_matrix = <<-matrix
+   0 42  0
+  42  0 23
+   0 23  0
+  matrix
+
+# The above matrix corresponds to this internal representation
+#
+#          | node 1 | node 2 | node 3 |
+#  ------------------------------------
+#  node 1  | 0      | 42     | 0      |
+#  node 2  | 42     | 0      | 23     |
+#  node 3  | 0      | 23     | 0      |
+
+graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
+node_1 = graph.find_node_by_name('node 1')
+node_2 = graph.find_node_by_name('node 2')
+graph.find_edge(node_1, node_2).weight # => 42
+```
+#### Directed graphs
+```ruby
+adjacency_matrix = <<-matrix
+  0 42  0
+  0  0 23
+  0  0  0
+  matrix
+
+# The above matrix corresponds to this internal representation
+#
+#          | node 1 | node 2 | node 3 |
+#  ------------------------------------
+#  node 1  | 0      | 42     | 0      |
+#  node 2  | 0      | 0      | 23     |
+#  node 3  | 0      | 0      | 0      |
+
+graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix, directed: true)
+```
+
+## Documentation
+[YARD](http://yardoc.org) documentation is available at [rubydoc](http://www.rubydoc.info/gems/abuelo).
+
 ## Future
 * Implement graph algorithms
   * [Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm)
@@ -49,4 +150,9 @@ Dirk Holzapfel
 
 [cachezero.net](http://cachezero.net)
 
-[bitcrowd.net](http://bitcrowd.net)
+[Abuelo](http://www.ronabuelopanama.com)
+
+### Contributors
+[dirkholzapfel](https://github.com/dirkholzapfel),
+[mbirman](https://github.com/mbirman),
+[sergey-kintsel](https://github.com/sergey-kintsel)

data/Rakefile

@@ -1,7 +1,7 @@
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
-task :default => :tests
-task :tests => [:spec]
+task default: :tests
+task tests: [:spec]
 
 RSpec::Core::RakeTask.new(:spec)

data/abuelo.gemspec

@@ -1,22 +1,22 @@
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 require 'abuelo/version'
 
 Gem::Specification.new do |spec|
   spec.name        = 'abuelo'
   spec.version     = Abuelo::VERSION
   spec.date        = '2016-01-10'
-  spec.summary     = "Abuelo"
-  spec.description = "Abuelo is a graph theory library."
-  spec.authors     = ["Dirk Holzapfel"]
-  spec.email       = 'dirk@bitcrowd.net'
+  spec.summary     = 'Abuelo'
+  spec.description = 'Abuelo is a graph theory library.'
+  spec.authors     = ['Dirk Holzapfel']
+  spec.email       = 'cache.zero@mailbox.org'
   spec.homepage    =
     'http://github.com/dirkholzapfel/abuelo'
   spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  spec.require_paths = ['lib']
 
   # Development
   spec.add_development_dependency 'bundler', '~> 1.7'
@@ -25,4 +25,4 @@ Gem::Specification.new do |spec|
 
   # Testing
   spec.add_development_dependency 'rspec'
-end
+end

data/lib/abuelo.rb

@@ -1,4 +1,4 @@
 require 'abuelo/graph'
 require 'abuelo/node'
 require 'abuelo/edge'
-require 'abuelo/exceptions/exceptions'
+require 'abuelo/exceptions/exceptions'

data/lib/abuelo/edge.rb

@@ -3,16 +3,15 @@ module Abuelo
   # Class Edge provides a representation of an edge.
   # An edge connects two nodes(start-node and end-node) and has a weight.
   #
-  # @author Dirk Holzapfel <dirk@bitcrowd.net>
+  # @author Dirk Holzapfel <cache.zero@mailbox.org>
   #
   class Edge
-    
     # @return [Abuelo::Node] start-node
     attr_reader :node_1
 
     # @return [Abuelo::Node] end-node
     attr_reader :node_2
-    
+
     # @return [Numeric] weight
     attr_reader :weight
 
@@ -22,8 +21,8 @@ module Abuelo
     # @param [Abuelo::Node] node_1 start-node
     # @param [Abuelo::Node] node_2 end-node
     # @param [Numeric] weight of the edge
-    # 
-    def initialize(node_1, node_2, weight = 0)
+    #
+    def initialize(node_1, node_2, weight = 1)
       @node_1 = node_1
       @node_2 = node_2
       @weight = weight
@@ -31,41 +30,40 @@ module Abuelo
 
     #
     # @return [Abuelo::Edge] a new edge with same weight but reversed start- and end-node.
-    # 
-    def opposite
+    #
+    def symmetric
       Abuelo::Edge.new(node_2, node_1, weight)
     end
 
     #
     # Comparison based on weight.
     #
-    # @param [Abuelo::Edge] other_edge
+    # @param [Abuelo::Edge] other
+    #
+    # @return [-1, 0, +1]
     #
-    # @return [-1, 0, +1 or ni]
-    # 
-    def <=>(other_edge)
-      self.weight <=> other_edge.weight
+    def <=>(other)
+      weight <=> other.weight
     end
 
     #
     # Equality check.
     #
-    # @param [Abuelo::Edge] other_edge
+    # @param [Abuelo::Edge] other
     #
     # @return [Boolean] true if start-, end-node and weight of both edges are equal
-    # 
-    def ==(other_edge)
-      self.node_1 == other_edge.node_1 &&
-      self.node_2 == other_edge.node_2 &&
-      self.weight == other_edge.weight
+    #
+    def ==(other)
+      node_1 == other.node_1 &&
+        node_2 == other.node_2 &&
+        weight == other.weight
     end
 
     #
     # @return [String] human readable representation of edge
-    # 
+    #
     def to_s
-      "#{node_1.to_s} -> #{node_2.to_s} with weight #{weight}"
+      "#{node_1} -> #{node_2} with weight #{weight}"
     end
-
   end
 end

data/lib/abuelo/exceptions/exceptions.rb

@@ -1,11 +1,9 @@
 module Abuelo
   module Exceptions
-
     class NodeAlreadyExistsError < StandardError
     end
 
     class EdgeAlreadyExistsError < StandardError
     end
-
   end
-end
+end

data/lib/abuelo/graph.rb

@@ -1,17 +1,64 @@
 module Abuelo
   #
   # Class Graph provides a representation of a directed graph.
+  #
   # 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.
   #
-  # @author Dirk Holzapfel <dirk@bitcrowd.net>
+  # @author Dirk Holzapfel <cache.zero@mailbox.org>
   #
   class Graph
-
-    def initialize
+    #
+    # @param [Hash] opts the options to create a graph with
+    # @option opts [Boolean] :directed defines if the graph is directed or undirected.
+    #                        (defaults to false == undirected)
+    # @option opts [String] :adjacency_matrix a representation of the graph in form
+    #                       of an adjacency matrix
+    #
+    # @example Build a graph with the help of an adjacency matrix
+    #  adjacency_matrix = <<-matrix
+    #     0 42  0
+    #    42  0 23
+    #     0 23  0
+    #    matrix
+    #  graph = Abuelo::Graph.new(adjacency_matrix: adjacency_matrix)
+    #
+    def initialize(opts = {})
       @nodes = {} # @nodes = { node_name => node_object }
       @edges = {} # @edges = { node_object => { node_object => edge }}
+      @directed = opts.fetch(:directed, false)
+      init_by_adjacency_matrix(opts[:adjacency_matrix]) if opts[:adjacency_matrix]
     end
 
+    #
+    # @return [Boolean] true if the graph is directed, false if it is undirected
+    #
+    def directed?
+      @directed
+    end
+
+    #
+    # @return [Boolean] true if the graph is undirected, false if it is directed
+    #
+    def undirected?
+      !directed?
+    end
+
+    #
+    # @return [Integer] the order of the graph == the number of nodes
+    #
+    def order
+      nodes.count
+    end
+
+    #
+    # @return [Integer] the size of the graph == the number of edges
+    #
+    def size
+      edges.count
+    end
 
     #
     # @return [Array<Abuelo::Node>] list of nodes of the graph
@@ -29,12 +76,13 @@ module Abuelo
     #
     # @raise [Abuelo::Exceptions::NodeAlreadyExistsError] if the node is
     #   already contained in the graph
-    # 
+    #
     def add_node(node)
       raise Abuelo::Exceptions::NodeAlreadyExistsError if has_node?(node)
 
       @nodes[node.name] = node
       node.graph = self
+
       self
     end
 
@@ -44,7 +92,7 @@ module Abuelo
     # @param [Abuelo::Node] node
     #
     # @return [Boolean]
-    # 
+    #
     def has_node?(node)
       has_node_with_name?(node.name)
     end
@@ -55,22 +103,46 @@ module Abuelo
     # @param [String] name of the node
     #
     # @return [Boolean]
-    # 
+    #
     def has_node_with_name?(name)
-      @nodes[name] ? true : false
+      !find_node_by_name(name).nil?
     end
 
+    #
+    # Returns the node with the given name if it is contained in the graph.
+    #
+    # @param [String] name of the node
+    #
+    # @return [Abuelo::Node, nil] the node if found, otherwise nil
+    #
+    def find_node_by_name(name)
+      @nodes[name]
+    end
 
     #
-    # @return [Array<Abuelo::Edge>] list of edges of the graph
-    # 
+    # @return [Array<Abuelo::Edge>, Array<Array(Abuelo::Edge, Abuelo::Edge)>]
+    #   list of edges of the graph if directed,
+    #   list of list of symmetric pairs of edges of the graph if undirected
+    #
+    # @example directed graph
+    #  "graph.edges" #=> [edge_from_node_1_to_node_2]
+    #
+    # @example undirected graph
+    #  "graph.edges" #=> [[edge_from_node_1_to_node_2, edge_from_node_2_to_node_1]]
+    #
     def edges
-      edges = @edges.keys.map { |key| @edges[key].values }
-      edges.flatten
+      edges = @edges.keys.flat_map { |key| @edges[key].values }
+
+      if directed?
+        edges
+      else
+        edges.each_slice(2).to_a
+      end
     end
 
     #
     # Adds an edge to the graph.
+    # Auto-adds the symmetric counterpart if graph is undirected.
     #
     # @param [Abuelo::Edge] edge to add
     #
@@ -78,12 +150,17 @@ module Abuelo
     #
     # @raise [Abuelo::Exceptions::EdgeAlreadyExistsError] if the edge is
     #   already contained in the graph
-    # 
-    def add_edge(edge)
+    #
+    def add_edge(edge, opts = {})
       raise Abuelo::Exceptions::EdgeAlreadyExistsError if has_edge?(edge)
 
       @edges[edge.node_1] ||= {}
       @edges[edge.node_1][edge.node_2] = edge
+
+      if undirected? && !opts[:symmetric]
+        add_edge(edge.symmetric, symmetric: true)
+      end
+
       self
     end
 
@@ -93,19 +170,19 @@ module Abuelo
     # @param [Abuelo::Edge] edge
     #
     # @return [Boolean]
-    # 
+    #
     def has_edge?(edge)
-      find_edge(edge.node_1, edge.node_2) ? true : false
+      !find_edge(edge.node_1, edge.node_2).nil?
     end
 
     #
-    # Checks if there is an edge between the two given nodes.
+    # Returns the edge if there is one between the two given nodes.
     #
     # @param [Abuelo::Node] node_1
     # @param [Abuelo::Node] node_2
     #
     # @return [Abuelo::Edge, nil] the edge if found, otherwise nil
-    # 
+    #
     def find_edge(node_1, node_2)
       @edges[node_1][node_2] if @edges[node_1]
     end
@@ -116,12 +193,30 @@ module Abuelo
     # @param [Abuelo::Node] node <description>
     #
     # @return [Array<Abuelo::Edge>] list of edges that start from the given node
-    # 
+    #
     def edges_for_node(node)
-      edges = []
-      edges += @edges[node].values.to_a if @edges[node]
-      edges
+      Hash(@edges[node]).values
     end
 
+
+    private
+
+    def init_by_adjacency_matrix(adjacency_matrix)
+      nodes = {}
+      1.upto(adjacency_matrix.lines.count) do |i|
+        node = Abuelo::Node.new("node #{i}")
+        nodes[i] = node
+        add_node(node)
+      end
+
+      adjacency_matrix.split(/\r?\n/).each_with_index do |row, row_index|
+        row.split(' ').map(&:to_i).each_with_index do |weight, column_index|
+          if weight != 0
+            edge = Abuelo::Edge.new(nodes[row_index+1], nodes[column_index+1], weight)
+            add_edge(edge, symmetric: true)
+          end
+        end
+      end
+    end
   end
 end

data/lib/abuelo/node.rb

@@ -3,7 +3,7 @@ module Abuelo
   # Class Node provides a representation of a node.
   # A node has a name. Any object may be attached on initialization.
   #
-  # @author Dirk Holzapfel <dirk@bitcrowd.net>
+  # @author Dirk Holzapfel <cache.zero@mailbox.org>
   #
   class Node
     # @return [String] name
@@ -21,7 +21,7 @@ module Abuelo
     # @param [String] name of the node
     # @param [Object] object to attach to the node.
     #  This is useful on some algorithm implementations.
-    # 
+    #
     def initialize(name, object = nil)
       @name   = name
       @object = object
@@ -29,14 +29,21 @@ module Abuelo
 
     #
     # @return [Array<Abuelo::Edge>] list of edges starting from the node
-    # 
+    #
     def edges
       graph.edges_for_node(self) if graph
     end
 
+    #
+    # @return [Array<Abuelo::Node>] list of nodes that are adjacent to the node
+    #
+    def neighbours
+      edges.map(&:node_2)
+    end
+
     #
     # @return [String] human readable representation of node
-    # 
+    #
     def to_s
       @name
     end
@@ -44,12 +51,12 @@ module Abuelo
     #
     # Equality check.
     #
-    # @param [Abuelo::Node] other_node
+    # @param [Abuelo::Node] other
     #
     # @return [Boolean] true if name is equal
-    # 
-    def ==(other_node)
-      self.name == other_node.name
+    #
+    def ==(other)
+      name == other.name
     end
   end
 end

data/lib/abuelo/version.rb

@@ -1,3 +1,3 @@
 module Abuelo
-  VERSION = "0.0.1".freeze
-end
+  VERSION = '0.0.2'.freeze
+end

data/spec/edge_spec.rb

@@ -1,15 +1,14 @@
 require 'spec_helper'
 
 RSpec.describe Abuelo::Edge do
-
   let(:node_1) { Abuelo::Node.new('node 1') }
   let(:node_2) { Abuelo::Node.new('node 2') }
 
   let(:edge) { described_class.new(node_1, node_2, 3) }
 
   context 'initialization' do
-    it 'sets the weight to 0 if not given' do
-      expect(described_class.new(node_1, node_2).weight).to eq 0
+    it 'sets the weight to 1 if not given' do
+      expect(described_class.new(node_1, node_2).weight).to eq 1
     end
   end
 
@@ -21,12 +20,12 @@ RSpec.describe Abuelo::Edge do
     end
   end
 
-  describe '#opposite' do
+  describe '#symmetric' do
     it 'returns an edge object with the same weight, but reversed nodes' do
-      opposite = edge.opposite
-      expect(opposite.node_1).to eq edge.node_2
-      expect(opposite.node_2).to eq edge.node_1
-      expect(opposite.weight).to eq edge.weight
+      symmetric = edge.symmetric
+      expect(symmetric.node_1).to eq edge.node_2
+      expect(symmetric.node_2).to eq edge.node_1
+      expect(symmetric.weight).to eq edge.weight
     end
   end
 

data/spec/graph_spec.rb

@@ -1,130 +1,375 @@
 require 'spec_helper'
 
 RSpec.describe Abuelo::Graph do
-
   let(:node_1) { Abuelo::Node.new('node 1') }
   let(:node_2) { Abuelo::Node.new('node 2') }
-  let(:edge)   { Abuelo::Edge.new(node_1, node_2, 42) }
+  let(:node_3) { Abuelo::Node.new('node 3') }
+  let(:edge_1) { Abuelo::Edge.new(node_1, node_2, 42) }
+  let(:edge_2) { Abuelo::Edge.new(node_2, node_3, 23) }
+
+  let(:directed_graph) do
+    described_class.new(directed: true)
+                   .add_node(node_1)
+                   .add_node(node_2)
+                   .add_node(node_3)
+                   .add_edge(edge_1)
+                   .add_edge(edge_2)
+  end
 
-  let(:graph) do 
-    graph = described_class.new
-    graph.add_node(node_1)
-    graph.add_node(node_2)
-    graph.add_edge(edge)
+  let(:undirected_graph) do
+    described_class.new
+                   .add_node(node_1)
+                   .add_node(node_2)
+                   .add_node(node_3)
+                   .add_edge(edge_1)
+                   .add_edge(edge_2)
   end
 
-  context 'nodes' do
-    describe '#nodes' do
-      it 'returns the nodes of the graph' do
-        expect(graph.nodes).to match_array [node_1, node_2]
+  context 'directed graph' do
+    describe '#initialize' do
+      it 'can be initialized with an adjacency matrix with weights' do
+        adjacency_matrix = <<-matrix
+          0  7  9  0 0 14
+          7  0 10 15 0  0
+          9 10  0 11 0  2
+          0  0 11  0 6  0
+          0  0  0  6 0  9
+          0  0  2  0 9  0
+          matrix
+
+          graph = described_class.new(adjacency_matrix: adjacency_matrix, directed: true)
+          node_1 = graph.find_node_by_name('node 1')
+          node_2 = graph.find_node_by_name('node 2')
+          node_4 = graph.find_node_by_name('node 4')
+
+          expect(graph.order).to eq 6
+          expect(graph.size).to eq 16
+
+          expect(graph.has_node_with_name?('node 1')).to be true
+          expect(graph.has_node_with_name?('node 0')).to be false
+          expect(graph.has_node_with_name?('node 7')).to be false
+
+          expect(graph.find_edge(node_1, node_4)).to be nil
+
+          edge_1_2 = graph.find_edge(node_1, node_2)
+          expect(edge_1_2.weight).to eq 7
       end
     end
 
-    describe '#add_node(node)' do
-      it 'adds the node to the graph' do
-        new_node = Abuelo::Node.new('node 3')
+    describe '#undirected?' do
+      it 'is false' do
+        expect(directed_graph.undirected?).to be false
+      end
+    end
 
-        expect{
-          graph.add_node(new_node)
-        }.to change{ graph.nodes.count }.by 1
+    describe '#directed?' do
+      it 'is true' do
+        expect(directed_graph.directed?).to be true
+      end
+    end
 
-        expect(graph.has_node?(new_node)).to be true
+    describe 'order' do
+      it 'returns the count of nodes' do
+        expect(directed_graph.order).to eq 3
       end
+    end
 
-      it 'raises an error if a node with the same name in the graph exists' do
-        new_node = Abuelo::Node.new('node 1')
+    describe 'size' do
+      it 'returns the count of edges' do
+        expect(directed_graph.size).to eq 2
+      end
+    end
 
-        expect{
-          graph.add_node(new_node)
-        }.to raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
+    context 'nodes' do
+      describe '#nodes' do
+        it 'returns the nodes of the graph' do
+          expect(directed_graph.nodes).to match_array [node_1, node_2, node_3]
+        end
       end
 
-      it 'sets the graph of the node to itself' do
-        new_node = Abuelo::Node.new('node 3')
+      describe '#add_node(node)' do
+        it 'adds the node to the graph' do
+          new_node = Abuelo::Node.new('node 4')
+
+          expect do
+            directed_graph.add_node(new_node)
+          end.to change { directed_graph.nodes.count }.by 1
+
+          expect(directed_graph.has_node?(new_node)).to be true
+        end
+
+        it 'raises an error if a node with the same name in the graph exists' do
+          new_node = Abuelo::Node.new('node 1')
 
-        expect{
-          graph.add_node(new_node)
-        }.to change{ new_node.graph }.to(graph)
+          expect do
+            directed_graph.add_node(new_node)
+          end.to raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
+        end
+
+        it 'sets the graph of the node to itself' do
+          new_node = Abuelo::Node.new('node 4')
+
+          expect do
+            directed_graph.add_node(new_node)
+          end.to change { new_node.graph }.to(directed_graph)
+        end
       end
-    end
 
-    describe '#has_node?(node)' do
-      it 'returns true if node is in the graph. checks object name' do
-        expect(graph.has_node?(node_1)).to be true
+      describe '#has_node?(node)' do
+        it 'returns true if node is in the graph. checks object name' do
+          expect(directed_graph.has_node?(node_1)).to be true
+        end
+
+        it 'returns false if node is not in the graph. checks object name' do
+          new_node = Abuelo::Node.new('node 99')
+          expect(directed_graph.has_node?(new_node)).to be false
+        end
       end
 
-      it 'returns false if node is not in the graph. checks object name' do
-        new_node = Abuelo::Node.new('node 3')
-        expect(graph.has_node?(new_node)).to be false
+      describe '#has_node_with_name?(name)' do
+        it 'returns true if a node with the given name is in the graph' do
+          expect(directed_graph.has_node_with_name?('node 1')).to be true
+        end
+
+        it 'returns false if no node with the given name is in the graph' do
+          expect(directed_graph.has_node_with_name?('foo')).to be false
+        end
       end
     end
 
-    describe '#has_node_with_name?(name)' do
-      it 'returns true if a node with the given name is in the graph' do
-        expect(graph.has_node_with_name?('node 1')).to be true
+    context 'edges' do
+      describe '#edges' do
+        it 'returns the edges of the graph' do
+          expect(directed_graph.edges).to match_array [edge_1, edge_2]
+        end
       end
 
-      it 'returns fale if no node with the given name is in the graph' do
-        expect(graph.has_node_with_name?('foo')).to be false
+      describe '#add_edge(edge)' do
+        it 'adds the edge to the graph' do
+          new_edge = Abuelo::Edge.new(node_2, node_1, 23)
+
+          expect do
+            directed_graph.add_edge(new_edge)
+          end.to change { directed_graph.edges.count }.by 1
+
+          expect(directed_graph.has_edge?(new_edge)).to be true
+        end
+
+        it 'raises an error if an edge with the same name nodes in the graph exists' do
+          new_edge = Abuelo::Edge.new(node_1, node_2, 23)
+
+          expect do
+            directed_graph.add_edge(new_edge)
+          end.to raise_error(Abuelo::Exceptions::EdgeAlreadyExistsError)
+        end
+      end
+
+      describe '#edges_for_node(node)' do
+        it 'returns all edges that start from the given node' do
+          expect(directed_graph.edges_for_node(node_1)).to eq [edge_1]
+          expect(directed_graph.edges_for_node(node_2)).to eq [edge_2]
+          expect(directed_graph.edges_for_node(node_3)).to eq []
+        end
+      end
+
+      describe '#has_edge?(edge)' do
+        it 'returns true if there is an edge with similiar nodes in the graph' do
+          expect(directed_graph.has_edge?(edge_1)).to be true
+        end
+
+        it 'does not have a symmetric edge automatically' do
+          expect(directed_graph.has_edge?(edge_1.symmetric)).to be false
+        end
+
+        it 'returns false if there is no edge with similiar nodes in the graph' do
+          other_edge = Abuelo::Edge.new(node_2, node_1, 23)
+          expect(directed_graph.has_edge?(other_edge)).to be false
+        end
       end
-    end
-  end
 
+      describe '#find_edge(node_1, node_2)' do
+        it 'returns the edge if it can be found in the graph' do
+          expect(directed_graph.find_edge(node_1, node_2)).to eq edge_1
+        end
 
-  context 'edges' do
-    describe '#edges' do
-      it 'returns the edges of the graph' do
-        expect(graph.edges).to match_array [edge]
+        it 'returns nil if the edge cannot be found in the graph' do
+          expect(directed_graph.find_edge(node_2, node_1)).to be nil
+        end
       end
     end
+  end
+
+  context 'undirected graph' do
+    describe '#initialize' do
+      it 'can be initialized with an adjacency matrix with weights' do
+        adjacency_matrix = <<-matrix
+           0  7  9  0 0 14
+           7  0 10 15 0  0
+           9 10  0 11 0  2
+           0 15 11  0 6  0
+           0  0  0  6 0  9
+          14  0  2  0 9  0
+          matrix
+
+          graph = described_class.new(adjacency_matrix: adjacency_matrix)
+          node_1 = graph.find_node_by_name('node 1')
+          node_2 = graph.find_node_by_name('node 2')
+          node_4 = graph.find_node_by_name('node 4')
 
-    describe '#add_edge(edge)' do
-      it 'adds the edge to the graph' do
-        new_edge = Abuelo::Edge.new(node_2, node_1, 23)
+          expect(graph.order).to eq 6
+          expect(graph.size).to eq 9
 
-        expect{
-          graph.add_edge(new_edge)
-        }.to change{ graph.edges.count }.by 1
+          expect(graph.has_node_with_name?('node 1')).to be true
+          expect(graph.has_node_with_name?('node 0')).to be false
+          expect(graph.has_node_with_name?('node 7')).to be false
 
-        expect(graph.has_edge?(new_edge)).to be true
+          expect(graph.find_edge(node_1, node_4)).to be nil
+
+          edge_1_2 = graph.find_edge(node_1, node_2)
+          expect(edge_1_2.weight).to eq 7
       end
+    end
 
-      it 'raises an error if an edge with the same name nodes in the graph exists' do
-        new_edge = Abuelo::Edge.new(node_1, node_2, 23)
+    describe '#undirected?' do
+      it 'is true' do
+        expect(undirected_graph.undirected?).to be true
+      end
+    end
+
+    describe '#directed?' do
+      it 'is false' do
+        expect(undirected_graph.directed?).to be false
+      end
+    end
 
-        expect{
-          graph.add_edge(new_edge)
-        }.to raise_error(Abuelo::Exceptions::EdgeAlreadyExistsError)
+    describe 'order' do
+      it 'returns the count of nodes' do
+        expect(undirected_graph.order).to eq 3
       end
     end
 
-    describe '#edges_for_node(node)' do
-      it 'returns all edges that start from the given node' do
-        expect(graph.edges_for_node(node_1)).to eq [edge]
-        expect(graph.edges_for_node(node_2)).to eq []
+    describe 'size' do
+      it 'returns the count of edges' do
+        expect(undirected_graph.size).to eq 2
       end
     end
 
-    describe '#has_edge?(edge)' do
-      it 'returns true if there is an edge with similiar nodes in the graph' do
-        expect(graph.has_edge?(edge)).to be true
+    context 'nodes' do
+      describe '#nodes' do
+        it 'returns the nodes of the graph' do
+          expect(undirected_graph.nodes).to match_array [node_1, node_2, node_3]
+        end
       end
 
-      it 'returns false if there is no edge with similiar nodes in the graph' do
-        other_edge = Abuelo::Edge.new(node_2, node_1, 23)
-        expect(graph.has_edge?(other_edge)).to be false
+      describe '#add_node(node)' do
+        it 'adds the node to the graph' do
+          new_node = Abuelo::Node.new('node 4')
+
+          expect do
+            undirected_graph.add_node(new_node)
+          end.to change { undirected_graph.nodes.count }.by 1
+
+          expect(undirected_graph.has_node?(new_node)).to be true
+        end
+
+        it 'raises an error if a node with the same name in the graph exists' do
+          new_node = Abuelo::Node.new('node 1')
+
+          expect do
+            undirected_graph.add_node(new_node)
+          end.to raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
+        end
+
+        it 'sets the graph of the node to itself' do
+          new_node = Abuelo::Node.new('node 4')
+
+          expect do
+            undirected_graph.add_node(new_node)
+          end.to change { new_node.graph }.to(undirected_graph)
+        end
+      end
+
+      describe '#has_node?(node)' do
+        it 'returns true if node is in the graph. checks object name' do
+          expect(undirected_graph.has_node?(node_1)).to be true
+        end
+
+        it 'returns false if node is not in the graph. checks object name' do
+          new_node = Abuelo::Node.new('node 4')
+          expect(undirected_graph.has_node?(new_node)).to be false
+        end
+      end
+
+      describe '#has_node_with_name?(name)' do
+        it 'returns true if a node with the given name is in the graph' do
+          expect(undirected_graph.has_node_with_name?('node 1')).to be true
+        end
+
+        it 'returns false if no node with the given name is in the graph' do
+          expect(undirected_graph.has_node_with_name?('foo')).to be false
+        end
       end
     end
 
-    describe '#find_edge(node_1, node_2)' do
-      it 'returns the edge if it can be found in the graph' do
-        expect(graph.find_edge(node_1, node_2)).to eq edge
+    context 'edges' do
+      describe '#edges' do
+        it 'returns the edges of the graph' do
+          edges = [[edge_1, edge_1.symmetric], [edge_2, edge_2.symmetric]]
+          expect(undirected_graph.edges).to match_array edges
+        end
       end
 
-      it 'returns nil if the edge cannot be found in the graph' do
-        expect(graph.find_edge(node_2, node_1)).to be nil
+      describe '#add_edge(edge)' do
+        it 'adds the edge to the graph' do
+          new_edge = Abuelo::Edge.new(node_1, node_3, 23)
+
+          expect do
+            undirected_graph.add_edge(new_edge)
+          end.to change { undirected_graph.edges.count }.by 1
+
+          expect(undirected_graph.has_edge?(new_edge)).to be true
+          expect(undirected_graph.has_edge?(new_edge.symmetric)).to be true
+        end
+
+        it 'raises an error if an edge with the same name nodes in the graph exists' do
+          new_edge = Abuelo::Edge.new(node_1, node_2, 23)
+
+          expect do
+            undirected_graph.add_edge(new_edge)
+          end.to raise_error(Abuelo::Exceptions::EdgeAlreadyExistsError)
+        end
+      end
+
+      describe '#edges_for_node(node)' do
+        it 'returns all edges that start from the given node' do
+          expect(undirected_graph.edges_for_node(node_1)).to eq [edge_1]
+          expect(undirected_graph.edges_for_node(node_2)).to eq [edge_1.symmetric, edge_2]
+          expect(undirected_graph.edges_for_node(node_3)).to eq [edge_2.symmetric]
+        end
+      end
+
+      describe '#has_edge?(edge)' do
+        it 'returns true if there is an edge with similiar nodes in the graph' do
+          expect(undirected_graph.has_edge?(edge_1)).to be true
+          expect(undirected_graph.has_edge?(edge_1.symmetric)).to be true
+        end
+
+        it 'returns false if there is no edge with similiar nodes in the graph' do
+          other_edge = Abuelo::Edge.new(node_1, node_3, 23)
+          expect(undirected_graph.has_edge?(other_edge)).to be false
+        end
+      end
+
+      describe '#find_edge(node_1, node_2)' do
+        it 'returns the edge if it can be found in the graph' do
+          expect(undirected_graph.find_edge(node_1, node_2)).to eq edge_1
+          expect(undirected_graph.find_edge(node_2, node_1)).to eq edge_1.symmetric
+        end
+
+        it 'returns nil if the edge cannot be found in the graph' do
+          expect(undirected_graph.find_edge(node_1, node_3)).to be nil
+        end
       end
     end
   end
-
 end

data/spec/node_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 RSpec.describe Abuelo::Node do
-
   let(:node) { described_class.new('node 1') }
 
   context 'initialization' do
@@ -35,6 +34,24 @@ RSpec.describe Abuelo::Node do
     end
   end
 
+  describe '#neighbours' do
+    it 'returns an array with all nodes that are connected via an edge to the node' do
+      graph = Abuelo::Graph.new(directed: true, adjacency_matrix: <<-matrix
+        0 1 1
+        0 0 0
+        0 0 0
+        matrix
+      )
+      node_1 = graph.find_node_by_name('node 1')
+      node_2 = graph.find_node_by_name('node 2')
+      node_3 = graph.find_node_by_name('node 3')
+
+      expect(node_1.neighbours).to match_array [node_2, node_3]
+      expect(node_2.neighbours).to eq []
+      expect(node_3.neighbours).to eq []
+    end
+  end
+
   describe '#to_s' do
     it 'responds with its name' do
       expect(node.to_s).to eq 'node 1'

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-$: << File.join(File.dirname(__FILE__), '/../lib')
+$LOAD_PATH << File.join(File.dirname(__FILE__), '/../lib')
 require "#{File.dirname(__FILE__)}/../lib/abuelo"
 require 'pry'
 
@@ -6,4 +6,4 @@ RSpec.configure do |config|
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
   config.order = 'random'
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: abuelo
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Dirk Holzapfel
@@ -67,12 +67,15 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 description: Abuelo is a graph theory library.
-email: dirk@bitcrowd.net
+email: cache.zero@mailbox.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
 - MIT-LICENSE
@@ -118,3 +121,4 @@ test_files:
 - spec/graph_spec.rb
 - spec/node_spec.rb
 - spec/spec_helper.rb
+has_rdoc: