abuelo 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 56d6315d3eafd194ee45e20bfa60eff9b68548c6
+  data.tar.gz: a15a915a0c83f075c4a67495dce09628fab155f4
+SHA512:
+  metadata.gz: ce7fdf584034fbe02e378dadd644c6e16dc617e3d50c7130cd97011f44bb9c9170af759b11be232f8b53d24b958ad286dda5a5a0b057075dc93d42daa619b8b5
+  data.tar.gz: 463ff60c87536021e450664c9a9749818bf4381a1b9db69f004e8f651ca0f3fe73421eee25af210b66b843425a34a48bc1f96160f67912c880c7e1cc303add43

data/.gitignore

@@ -0,0 +1,7 @@
+*~
+.bundle
+.yardoc
+doc/*
+pkg
+log
+test/tmp/*

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    abuelo (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    method_source (0.8.2)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  abuelo!
+  bundler (~> 1.7)
+  pry
+  rake
+  rspec

data/MIT-LICENSE

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

data/README.md

@@ -0,0 +1,52 @@
+# Abuelo
+Abuelo is a graph theory library that allows you to build a representation of a directed graph with its nodes and edges.
+
+## Examples
+```ruby
+graph  = Abuelo::Graph.new
+
+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.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]
+```
+
+## Future
+* Implement graph algorithms
+  * [Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm)
+  * [Prim's algorithm](https://en.wikipedia.org/wiki/Prim%27s_algorithm)
+  * [Dijkstra's algorithm](https://en.wikipedia.org/wiki/Dijkstra%27s_algorithm)
+* Implement visualization of graph
+
+## Installation
+Abuelo is a gem which you can install with:
+```
+gem install abuelo
+```
+
+In Rails 3+, add the following to your ```Gemfile```:
+```
+gem 'abuelo'
+```
+
+## Credits
+Dirk Holzapfel
+
+[cachezero.net](http://cachezero.net)
+
+[bitcrowd.net](http://bitcrowd.net)

data/Rakefile

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

data/abuelo.gemspec

@@ -0,0 +1,28 @@
+$:.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.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"]
+
+  # Development
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'pry'
+
+  # Testing
+  spec.add_development_dependency 'rspec'
+end

data/lib/abuelo/edge.rb

@@ -0,0 +1,71 @@
+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>
+  #
+  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
+
+    #
+    # Initialiazises the edge with its two nodes and its weight.
+    #
+    # @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)
+      @node_1 = node_1
+      @node_2 = node_2
+      @weight = weight
+    end
+
+    #
+    # @return [Abuelo::Edge] a new edge with same weight but reversed start- and end-node.
+    # 
+    def opposite
+      Abuelo::Edge.new(node_2, node_1, weight)
+    end
+
+    #
+    # Comparison based on weight.
+    #
+    # @param [Abuelo::Edge] other_edge
+    #
+    # @return [-1, 0, +1 or ni]
+    # 
+    def <=>(other_edge)
+      self.weight <=> other_edge.weight
+    end
+
+    #
+    # Equality check.
+    #
+    # @param [Abuelo::Edge] other_edge
+    #
+    # @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
+    end
+
+    #
+    # @return [String] human readable representation of edge
+    # 
+    def to_s
+      "#{node_1.to_s} -> #{node_2.to_s} with weight #{weight}"
+    end
+
+  end
+end

data/lib/abuelo/exceptions/exceptions.rb

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

data/lib/abuelo/graph.rb

@@ -0,0 +1,127 @@
+module Abuelo
+  #
+  # Class Graph provides a representation of a directed graph.
+  # A graph consists of nodes (= vertices, points) and edges (= lines, arcs).
+  #
+  # @author Dirk Holzapfel <dirk@bitcrowd.net>
+  #
+  class Graph
+
+    def initialize
+      @nodes = {} # @nodes = { node_name => node_object }
+      @edges = {} # @edges = { node_object => { node_object => edge }}
+    end
+
+
+    #
+    # @return [Array<Abuelo::Node>] list of nodes of the graph
+    #
+    def nodes
+      @nodes.values
+    end
+
+    #
+    # Adds a node to the graph.
+    #
+    # @param [Abuelo::Node] node to add
+    #
+    # @return [Abuelo::Graph] the graph
+    #
+    # @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
+
+    #
+    # Checks if the given node is contained in the graph.
+    #
+    # @param [Abuelo::Node] node
+    #
+    # @return [Boolean]
+    # 
+    def has_node?(node)
+      has_node_with_name?(node.name)
+    end
+
+    #
+    # Checks if a node with the given name is contained in the graph.
+    #
+    # @param [String] name of the node
+    #
+    # @return [Boolean]
+    # 
+    def has_node_with_name?(name)
+      @nodes[name] ? true : false
+    end
+
+
+    #
+    # @return [Array<Abuelo::Edge>] list of edges of the graph
+    # 
+    def edges
+      edges = @edges.keys.map { |key| @edges[key].values }
+      edges.flatten
+    end
+
+    #
+    # Adds an edge to the graph.
+    #
+    # @param [Abuelo::Edge] edge to add
+    #
+    # @return [Abuelo::Graph] the graph
+    #
+    # @raise [Abuelo::Exceptions::EdgeAlreadyExistsError] if the edge is
+    #   already contained in the graph
+    # 
+    def add_edge(edge)
+      raise Abuelo::Exceptions::EdgeAlreadyExistsError if has_edge?(edge)
+
+      @edges[edge.node_1] ||= {}
+      @edges[edge.node_1][edge.node_2] = edge
+      self
+    end
+
+    #
+    # Checks if the given edge is contained in the graph.
+    #
+    # @param [Abuelo::Edge] edge
+    #
+    # @return [Boolean]
+    # 
+    def has_edge?(edge)
+      find_edge(edge.node_1, edge.node_2) ? true : false
+    end
+
+    #
+    # Checks if there is an edge 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
+
+    #
+    # Returns all edges that start from the given node.
+    #
+    # @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
+    end
+
+  end
+end

data/lib/abuelo/node.rb

@@ -0,0 +1,55 @@
+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>
+  #
+  class Node
+    # @return [String] name
+    attr_reader :name
+
+    # @return [Object] attached object
+    attr_reader :object
+
+    # @return [Abuelo::Graph] associated graph
+    attr_accessor :graph
+
+    #
+    # Initialiazises the node with its name.
+    #
+    # @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
+    end
+
+    #
+    # @return [Array<Abuelo::Edge>] list of edges starting from the node
+    # 
+    def edges
+      graph.edges_for_node(self) if graph
+    end
+
+    #
+    # @return [String] human readable representation of node
+    # 
+    def to_s
+      @name
+    end
+
+    #
+    # Equality check.
+    #
+    # @param [Abuelo::Node] other_node
+    #
+    # @return [Boolean] true if name is equal
+    # 
+    def ==(other_node)
+      self.name == other_node.name
+    end
+  end
+end

data/lib/abuelo/version.rb

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

data/lib/abuelo.rb

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

data/spec/edge_spec.rb

@@ -0,0 +1,67 @@
+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
+    end
+  end
+
+  context 'accessors' do
+    it 'has following getters' do
+      expect(edge.respond_to?(:node_1)).to be true
+      expect(edge.respond_to?(:node_2)).to be true
+      expect(edge.respond_to?(:weight)).to be true
+    end
+  end
+
+  describe '#opposite' 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
+    end
+  end
+
+  describe '#to_s' do
+    it 'is human readable' do
+      expect(edge.to_s).to eq 'node 1 -> node 2 with weight 3'
+    end
+  end
+
+  describe '#==(other)' do
+    it 'is true when the nodes and weight match' do
+      other = Abuelo::Edge.new(node_1, node_2, 3)
+      expect(edge == other).to be true
+    end
+
+    it 'is false when the nodes do not match' do
+      other = Abuelo::Edge.new(node_2, node_1, 3)
+      expect(edge == other).to be false
+    end
+
+    it 'is false when the weight does not match' do
+      other = Abuelo::Edge.new(node_1, node_2, 1)
+      expect(edge == other).to be false
+    end
+  end
+
+  context 'order' do
+    it 'is sorted by its weight' do
+      edge_1 = described_class.new(node_1, node_2, 1)
+      edge_2 = described_class.new(node_1, node_2, 2)
+      edge_3 = described_class.new(node_1, node_2, 3)
+
+      edges = [edge_3, edge_1, edge_2]
+
+      expect(edges.sort).to eq [edge_1, edge_2, edge_3]
+    end
+  end
+end

data/spec/graph_spec.rb

@@ -0,0 +1,130 @@
+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(:graph) do 
+    graph = described_class.new
+    graph.add_node(node_1)
+    graph.add_node(node_2)
+    graph.add_edge(edge)
+  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]
+      end
+    end
+
+    describe '#add_node(node)' do
+      it 'adds the node to the graph' do
+        new_node = Abuelo::Node.new('node 3')
+
+        expect{
+          graph.add_node(new_node)
+        }.to change{ graph.nodes.count }.by 1
+
+        expect(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 raise_error(Abuelo::Exceptions::NodeAlreadyExistsError)
+      end
+
+      it 'sets the graph of the node to itself' do
+        new_node = Abuelo::Node.new('node 3')
+
+        expect{
+          graph.add_node(new_node)
+        }.to change{ new_node.graph }.to(graph)
+      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
+      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
+      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
+      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
+      end
+    end
+  end
+
+
+  context 'edges' do
+    describe '#edges' do
+      it 'returns the edges of the graph' do
+        expect(graph.edges).to match_array [edge]
+      end
+    end
+
+    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.add_edge(new_edge)
+        }.to change{ graph.edges.count }.by 1
+
+        expect(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{
+          graph.add_edge(new_edge)
+        }.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(graph.edges_for_node(node_1)).to eq [edge]
+        expect(graph.edges_for_node(node_2)).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(graph.has_edge?(edge)).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_2, node_1, 23)
+        expect(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(graph.find_edge(node_1, node_2)).to eq edge
+      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
+      end
+    end
+  end
+
+end

data/spec/node_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe Abuelo::Node do
+
+  let(:node) { described_class.new('node 1') }
+
+  context 'initialization' do
+    it 'sets object to nil if not given' do
+      expect(node.object).to be nil
+    end
+  end
+
+  context 'accessors' do
+    it 'has following getters' do
+      expect(node.respond_to?(:name)).to be true
+      expect(node.respond_to?(:object)).to be true
+      expect(node.respond_to?(:graph)).to be true
+    end
+
+    it 'has following setters' do
+      expect(node.respond_to?(:graph=)).to be true
+    end
+  end
+
+  describe '#edges' do
+    it 'calls edges_for_node on its graph' do
+      graph = Abuelo::Graph.new
+      node.graph = graph
+      expect(graph).to receive(:edges_for_node).with(node)
+      node.edges
+    end
+
+    it 'responds with nil if the node has no associated graph' do
+      expect(node.edges).to be nil
+    end
+  end
+
+  describe '#to_s' do
+    it 'responds with its name' do
+      expect(node.to_s).to eq 'node 1'
+    end
+  end
+
+  describe '#==(other)' do
+    it 'is true when the names match' do
+      other = Abuelo::Node.new('node 1')
+      expect(node == other).to be true
+    end
+
+    it 'is false when the names do not match' do
+      other = Abuelo::Node.new('node 2')
+      expect(node == other).to be false
+    end
+  end
+end

data/spec/spec_helper.rb

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

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: abuelo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dirk Holzapfel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Abuelo is a graph theory library.
+email: dirk@bitcrowd.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- abuelo.gemspec
+- lib/abuelo.rb
+- lib/abuelo/edge.rb
+- lib/abuelo/exceptions/exceptions.rb
+- lib/abuelo/graph.rb
+- lib/abuelo/node.rb
+- lib/abuelo/version.rb
+- spec/edge_spec.rb
+- spec/graph_spec.rb
+- spec/node_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/dirkholzapfel/abuelo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Abuelo
+test_files:
+- spec/edge_spec.rb
+- spec/graph_spec.rb
+- spec/node_spec.rb
+- spec/spec_helper.rb