trainworks 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bd0bbc94d01b0526100339105b0e244a47c84286
+  data.tar.gz: e1187451608b2347fe70790753498d9158bd65a3
+SHA512:
+  metadata.gz: 893e1e95c8ba60a8722ddc686587a2bca8edc7a74e05e80d3440c005330ee3b7b629b80676edcd748a78f40c4d4f8061a280711bf2078e9ce9e23f957e34049a
+  data.tar.gz: 10385ce964d3426719dcc6a2acc86f4685fb6e774fb93ed4b0be8f84dd017d0dc81c2b28a59f73b4531d71dfd4979637ed78661af0dc3e58f5c220fd1ae0209f

data/.gitignore

@@ -0,0 +1,7 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/doc/
+/tmp
+.vimrc

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,14 @@
+Metrics/LineLength:
+  Max: 120
+SpaceInsideHashLiteralBraces:
+  Enabled: false
+SpaceInsideBrackets:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: true
+  Exclude:
+    - spec/**/*

data/.ruby-gemset

@@ -0,0 +1 @@
+trainworks

data/.ruby-version

@@ -0,0 +1 @@
+2.3.3

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Andre Herculano
+
+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,112 @@
+# Trainworks 🚂
+[![Build Status](https://semaphoreci.com/api/v1/projects/14ca60dd-4c8c-4c22-a419-b888d253491c/1073642/shields_badge.svg)](https://semaphoreci.com/andresilveirah/trainworks)
+
+## Problem Definition
+
+The local commuter railroad services a number of towns in Kiwiland.  Because of monetary concerns, all of the tracks are 'one-way.'  That is, a route from Kaitaia to Invercargill does not imply the existence of a route from Invercargill to Kaitaia.  In fact, even if both of these routes do happen to exist, they are distinct and are not necessarily the same distance!
+
+The purpose of this problem is to help the railroad provide its customers with information about the routes.  In particular, you will compute the distance along a certain route, the number of different routes between two towns, and the shortest route between two towns.
+
+### Input
+A directed graph where a node represents a town and an edge represents a route between two towns.  The weighting of the edge represents the distance between the two towns.  A given route will never appear more than once, and for a given route, the starting and ending town will not be the same town.
+
+### Output
+
+For test input 1 through 5, if no such route exists, output 'NO SUCH ROUTE'.  Otherwise, follow the route as given; do not make any extra stops!  For example, the first problem means to start at city A, then travel directly to city B (a distance of 5), then directly to city C (a distance of 4).
+
+1. The distance of the route A-B-C.
+2. The distance of the route A-D.
+3. The distance of the route A-D-C.
+4. The distance of the route A-E-B-C-D.
+5. The distance of the route A-E-D.
+6. The number of trips starting at C and ending at C with a maximum of 3 stops.  In the sample data below, there are two such trips: C-D-C (2 stops). and C-E-B-C (3 stops).
+7. The number of trips starting at A and ending at C with exactly 4 stops.  In the sample data below, there are three such trips: A to C (via B,C,D); A to C (via D,C,D); and A to C (via D,E,B).
+8. The length of the shortest route (in terms of distance to travel) from A to C.
+9. The length of the shortest route (in terms of distance to travel) from B to B.
+10. The number of different routes from C to C with a distance of less than 30.  In the sample data, the trips are: CDC, CEBC, CEBCDC, CDCEBC, CDEBC, CEBCEBC, CEBCEBCEBC.
+
+### Test Input
+
+For the test input, the towns are named using the first few letters of the alphabet from A to E. A route between two towns (A to B) with a distance of 5 is represented as AB5.
+
+    Graph: AB5, BC4, CD8, DC8, DE6, AD5, CE2, EB3, AE7
+
+Expected Output:
+
+```
+Output #1: 9
+Output #2: 5
+Output #3: 13
+Output #4: 22
+Output #5: NO SUCH ROUTE
+Output #6: 2
+Output #7: 3
+Output #8: 9
+Output #9: 9
+Output #10: 7
+```
+
+## Installation
+
+**Note:** Since the project is not yet publicly available, there's no way to fork/clone/install it from [Rubygems](https://rubygems.org/). The only way to use the gem is getting its source code and running `rake install`. It will install the local gem so you'll be able to require it in `irb` for example.
+
+First you'll need [Bundler](http://bundler.io/) in order to install the dependencies (which are only necessary for development).
+
+    $ gem install bundler
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'trainworks'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install trainworks
+
+## Usage
+
+```ruby
+require 'trainworks'
+
+railroad = Trainworks::Railroad.new('examples/input.txt')
+
+# assuming you have the following graph
+# AB5, BC4, CD8, DC8, DE6, AD5, CE2, EB3, AE7
+railroad.distance("A-B-C")
+# => 9.0
+
+railroad.distance("A-Z")
+# => "NO SUCH ROUTE"
+
+railroad.shortest_distance(from: "A", to: "C")
+# => 9.0
+
+railroad.trips(from: "C", to: "C", with_max_stops: 3)
+# => [["C","D","C"], ["C","E","B","C"]]
+
+railroad.trips(from: "A", to: "C", with_exact_stops: 4)
+# => [["A", "B", "C", "D", "C"], ["A", "D", "C", "D", "C"], ["A", "D", "E", "B", "C"]]
+
+railroad.trips(from: "C", to: "C", with_max_distance: 30)
+# => [["C","D","C"], ["C","E","B","C"], ["C","E","B","C","D","C"], ["C","D","C","E","B","C"], ["C","D","E","B","C"], ["C","E","B","C","E","B","C"], ["C","E","B","C","E","B","C","E","B","C"]]
+```
+
+## Development & Contribution
+
+**Note:** This section is only valid after the project is publicly available.
+
+1. Fork this repository.
+2. Clone it into your machine and run `bundle install`.
+3. Add your changes.
+4. Make sure the specs are green by running `rspec`.
+5. Make sure the code style is respected by running `rubocop`.
+6. Open a pull request.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/examples/input.txt

@@ -0,0 +1 @@
+AB5, BC4, CD8, DC8, DE6, AD5, CE2, EB3, AE7

data/lib/trainworks.rb

@@ -0,0 +1,10 @@
+require 'trainworks/version'
+require 'trainworks/railroad'
+require 'trainworks/file_parser'
+require 'trainworks/route'
+require 'trainworks/graph_algorithm'
+require 'trainworks/graph_builder'
+
+# Trainworks is used only as a namespace for the trainworks gem
+module Trainworks
+end

data/lib/trainworks/file_parser.rb

@@ -0,0 +1,40 @@
+require 'trainworks/file_parser/invalid_railroad_input_format'
+
+module Trainworks
+  # FileParser is responsible for parsing the input file
+  # @example
+  #   AB5, cd99, LetterLetterPositiveNumbers
+  class FileParser
+    # captures, for example, AB99
+    SINGLE_TUPLE_REGEX = /(?<from>[a-zA-Z])(?<to>[a-zA-Z])(?<distance>\d+)/
+
+    # Converts the object into textual markup given a specific format.
+    # @param file_path [String] the path for input file
+    def initialize(file_path)
+      @raw_content = File.read(file_path)
+    end
+
+    # @return [Array<Route>] array of {Route}s
+    # @raise [InvalidRailroadInputFormat] if the tuple doesn't match SINGLE_TUPLE_REGEX
+    def parse
+      clean_string(@raw_content).split(',').map do |route_string|
+        matched_route_string = route_string.match(SINGLE_TUPLE_REGEX)
+        raise InvalidRailroadInputFormat, route_string if matched_route_string.nil?
+
+        Route.new(
+          from:     matched_route_string[:from],
+          to:       matched_route_string[:to],
+          distance: matched_route_string[:distance]
+        )
+      end
+    end
+
+    private
+
+    # removes special characters from the input except letters, numbers and commas
+    # @private
+    def clean_string(text)
+      text.gsub(/[^0-9A-Za-z\,]/, '')
+    end
+  end
+end

data/lib/trainworks/file_parser/invalid_railroad_input_format.rb

@@ -0,0 +1,18 @@
+module Trainworks
+  class FileParser
+    # When parsing the input file, format of the route is not correct
+    # InvalidRailroadInputFormat will be raised
+    class InvalidRailroadInputFormat < ArgumentError
+      # @param [Object] route_string - must respond to `#to_s`
+      # @return [InvalidRailroadInputFormat]
+      def initialize(route_string)
+        @route_string = route_string
+      end
+
+      # Converts the exception into string
+      def to_s
+        "'#{@route_string}' is not of the form LetterLetterNumber. E.g. AB10"
+      end
+    end
+  end
+end

data/lib/trainworks/graph_algorithm.rb

@@ -0,0 +1,149 @@
+# rubocop:disable MethodLength
+# rubocop:disable ParameterLists
+
+module Trainworks
+  # GraphAlgorithm is used to calculate direct distances,
+  # shortest path and other paths between nodes.
+  # It assumes graph is a hash of adjacencies of a **directed-positively-weighted-possibly-cyclic-graph**
+  # @example Example of a graph
+  #   'A' => { 'B' => 5 },
+  #   'B' => { 'C' => 5 },
+  #   'C' => { 'B' => 4 }
+  #
+  class GraphAlgorithm
+    def initialize(graph)
+      @graph = graph
+    end
+
+    # @param [Array] cities is a set of nodes
+    # @return [Number] the distance traveled from city to city in cities
+    # @return [String] "NO SUCH ROUTE" when one of the citis is not connected to another
+    # @example
+    #   algorithm.distance(['A', 'B', 'C']) => 10
+    def distance(cities)
+      distance = 0
+      begin
+        cities.each_cons(2) do |(from, to)|
+          distance += go(from: from, to: to)
+        end
+      rescue NoSuchRoute => e
+        distance = e.to_s
+      end
+
+      distance
+    end
+
+    # @param [Object] from the starting point
+    # @param [Object] to the goal
+    # @param [Number] stops the maximum number of stops between from and to the algorithm is allowed to travel
+    # @return [Array<Array>] all possible trips from the starting point to the goal with maximum stops equal to `stops`
+    def trips_with_max_stops(from:, to:, stops:, total_paths: [from], solutions: [])
+      routes(from).map do |city, _paths|
+        return solutions if 0 >= stops
+        next_total_paths = [*total_paths, city]
+        solutions.push(next_total_paths) if arrived?(city, to)
+        trips_with_max_stops(from: city, to: to, stops: stops - 1, total_paths: next_total_paths, solutions: solutions)
+      end
+      solutions
+    end
+
+    # @param [Object] from the starting point
+    # @param [Object] to the goal
+    # @param [Number] stops the maximum number of stops between from and to the algorithm is allowed to travel
+    # @return [Array<Array>] all possible trips from the starting point to the goal with maximum stops equal to `stops`
+    # @see GraphAlgorithm#trips_with_max_stops #trips_with_max_stops
+    # it calls {trips_with_max_stops} and filter out the trips that don't have the exact number of stops as `stops`
+    def trips_with_exact_stops(from:, to:, stops:)
+      total_path_size = stops + 1 # a path includes the stops plus the origin
+      trips_with_max_stops(from: from, to: to, stops: stops).select do |path|
+        path.size == total_path_size
+      end
+    end
+
+    # @param [Object] from the starting point
+    # @param [Object] to the goal
+    # @param [Number] max_distance the maximum distance between from and to the algorithm is allowed to travel
+    # @return [Array<Array>] all trips from the starting point to the goal with maximum stops equal to `max_distance`
+    # Since we calculate the distance by adding up the distances between the nodes, the edges must have positive
+    # distances otherwise it's not garateed the algorithm will reach a stop.
+    def trips_with_max_distance(from:, to:, max_distance:, total_paths: [from], solutions: {}, current_distance: 0)
+      routes(from).map do |city, _paths|
+        next_current_distance = current_distance + go(from: from, to: city)
+        return solutions.keys if next_current_distance >= max_distance
+        next_total_paths = [*total_paths, city]
+        solutions[next_total_paths] = next_current_distance if arrived?(city, to)
+        trips_with_max_distance(
+          from: city,
+          to: to,
+          max_distance: max_distance,
+          total_paths: next_total_paths,
+          solutions: solutions,
+          current_distance: next_current_distance
+        )
+      end
+      solutions.keys
+    end
+
+    # @param [Object] from the starting point
+    # @param [Object] to the goal
+    # @return [Hash] all possible trips from the starting point to the goal without repeating loops
+    def trips(from:, to:, current_distance: 0, current_path: [from], all_paths: {})
+      routes(from).map do |city, _paths|
+        next_current_path = [*current_path, city]
+        next_current_distance = current_distance + go(from: from, to: city)
+        all_paths[next_current_path] = next_current_distance if arrived?(city, to)
+        next if arrived?(city, to) || already_visited?(next_current_path, city)
+        trips(
+          from: city,
+          to: to,
+          current_distance: next_current_distance,
+          current_path: next_current_path,
+          all_paths: all_paths
+        )
+      end
+      all_paths
+    end
+
+    # @param [Object] from the starting point
+    # @param [Object] to the goal
+    # @return [Number] the shortest distance from `from` to `to`
+    # @see GraphAlgorithm#trips #trips
+    # @raise NoSuchRoute
+    # It calls {trips} to find all paths between the starting point and the goal and returns
+    # the shortest distance found. If there's no path between `from` and `to` it raises {NoSuchRoute}
+    def shortest_distance(from:, to:)
+      shortest_distance = trips(from: from, to: to).values.min
+      raise NoSuchRoute if shortest_distance.nil?
+      shortest_distance
+    end
+
+    # NoSuchRoute is raised when there are no direct connection between two cities (nodes)
+    class NoSuchRoute < KeyError
+      def to_s
+        'NO SUCH ROUTE'
+      end
+    end
+
+    private
+
+    def arrived?(current, goal)
+      current == goal
+    end
+
+    # if the current_city can be found more than one time in the path
+    # it means we already visited it.
+    def already_visited?(path, current_city)
+      path.count(current_city) > 1
+    end
+
+    # these are helper methods to deal with finding keys in the graph an its value
+    # in case of not finding the keys (`from` and `to`) it raises `NoSuchRoute`
+    def go(from:, to:)
+      routes(from).fetch(to) { raise NoSuchRoute }
+    end
+
+    def routes(city)
+      @graph.fetch(city) { raise NoSuchRoute }
+    end
+  end
+end

data/lib/trainworks/graph_builder.rb

@@ -0,0 +1,31 @@
+module Trainworks
+  # GraphBuilder is responsible to transform tuples (in our case Routes)
+  # into a Hash which represents a list of adjacencies between the nodes.
+  #
+  # @todo: encapsulate the idea of a Graph inside a class instead of relying on Hash class.
+  module GraphBuilder
+    # @param [Array<Route>] routes
+    # @return [Hash]
+    def self.build(routes)
+      routes.reduce({}) do |graph, route|
+        add_edge(graph, route.from, route.to, route.distance)
+      end
+    end
+
+    # @param [Hash] graph
+    # @param [Object] from
+    # @param [Object] to
+    # @param [Object] distance
+    # @return [Hash] graph with the new edge
+    # Adds a new edge to the graph.
+    # It checks if the key `from` (*node*) is present in the graph and adds to it the `to` with its distance.
+    def self.add_edge(graph, from, to, distance)
+      if graph.key?(from)
+        graph[from][to] = distance
+      else
+        graph[from] = Hash[to, distance]
+      end
+      graph
+    end
+  end
+end

data/lib/trainworks/railroad.rb

@@ -0,0 +1,53 @@
+module Trainworks
+  # Railroad is the entry point for Trainworks gem
+  class Railroad
+    # @param [String] file_path is the path for the input file containing the graph definition
+    # @param [Object] file_parser is the class responsible for parsing the input file and return a set of {Route}s
+    # @param [Object] graph_builder receives the set of {Route}s and build a graph for `graph_algorithm`
+    # @param [Object] graph_algorithm is the responsible for calculating the distances between nodes, paths, etc.
+    def initialize(file_path, file_parser: FileParser, graph_builder: GraphBuilder, graph_algorithm: GraphAlgorithm)
+      @file_parser = file_parser.new(file_path)
+      @graph = graph_builder.build(@file_parser.parse)
+      @algorithm = graph_algorithm.new(@graph)
+    end
+
+    # @param [String] route_string represents the route to be followed. E.g. A-B-C
+    # @return [Number] the distance from A to B to C
+    # Calculates the distance traveled between cities in the form of `"A-B-C"`
+    def distance(route_string)
+      @algorithm.distance(route_string.split('-'))
+    end
+
+    # @param [Object] from is the starting point
+    # @param [Object] to is the goal
+    # @param [Number] with_max_stops how many stops at most, the algorithm is allowed to *travel*.
+    # @param [Number] with_exact_stops how many stops exactly, the algorithm is allowed to *travel*.
+    # @param [Number] with_max_distance the maximum distance (non inclusive), the algorithm is allowed to *travel*
+    # @return [Array<Array>] which represents each path found
+    # Notice that only one of the parameters `with_max_stops`, `with_exact_stops` or `with_max_distance` will be taken
+    # into account, in the following order:
+    #
+    # 1. `with_max_stops`
+    # 2. `with_exact_stops`
+    # 3. `with_max_distance`
+    def trips(from:, to:, with_max_stops: nil, with_exact_stops: nil, with_max_distance: nil)
+      if with_max_stops
+        @algorithm.trips_with_max_stops(from: from, to: to, stops: with_max_stops)
+      elsif with_exact_stops
+        @algorithm.trips_with_exact_stops(from: from, to: to, stops: with_exact_stops)
+      elsif with_max_distance
+        @algorithm.trips_with_max_distance(from: from, to: to, max_distance: with_max_distance)
+      else
+        raise "I don't know how to calculate these routes"
+      end
+    end
+
+    # @param [Object] from is the starting point
+    # @param [Object] to is the goal
+    # @return [Number] the shortest distance between `from` and `to`
+    # Calculates the shortest distance between `from` and `to`
+    def shortest_distance(from:, to:)
+      @algorithm.shortest_distance(from: from, to: to)
+    end
+  end
+end

data/lib/trainworks/route.rb

@@ -0,0 +1,28 @@
+module Trainworks
+  # Route is used to group together the information
+  # of an edge of a graph. From and To are two nodes
+  # and distance is the weight between them
+  class Route
+    attr_accessor :from, :to, :distance
+
+    # @param [Object] from is the starting point of the route
+    # @param [Object] to is the end point of the route
+    # @param [Object] distance also known as *weight* between `from` and `to`
+    # @return [Route]
+    # `from` and `to` must respond to `#to_s` and `distance` must respond to `#to_f`
+    def initialize(from:, to:, distance:)
+      self.from     = from.to_s
+      self.to       = to.to_s
+      self.distance = distance.to_f
+    end
+
+    # @param [Object] other
+    # @return [Boolean]
+    # Returns `true` if `other.from`, `other.to` and `other.distance` have the same value as `self`
+    def ==(other)
+      from == other.from &&
+        to == other.to &&
+        distance == other.distance
+    end
+  end
+end

data/lib/trainworks/version.rb

@@ -0,0 +1,4 @@
+module Trainworks
+  # Current version
+  VERSION = '1.0.0'.freeze
+end

data/trainworks.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'trainworks/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'trainworks'
+  spec.version       = Trainworks::VERSION
+  spec.authors       = ['André Herculano']
+  spec.email         = ['andresilveirah@gmail.com']
+  spec.homepage    = 'https://rubygems.org/gems/example'
+  spec.summary       = 'Models a railroad as a graph and offers some traversing methods.'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(spec)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.13'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.45.0'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'redcarpet', '~> 3.3'
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: trainworks
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- André Herculano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.45.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+description: 
+email:
+- andresilveirah@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/input.txt
+- lib/trainworks.rb
+- lib/trainworks/file_parser.rb
+- lib/trainworks/file_parser/invalid_railroad_input_format.rb
+- lib/trainworks/graph_algorithm.rb
+- lib/trainworks/graph_builder.rb
+- lib/trainworks/railroad.rb
+- lib/trainworks/route.rb
+- lib/trainworks/version.rb
+- tmp/.gitkeep
+- trainworks.gemspec
+homepage: https://rubygems.org/gems/example
+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.6.11
+signing_key: 
+specification_version: 4
+summary: Models a railroad as a graph and offers some traversing methods.
+test_files: []