mini_graph 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f2793e4516fdd7679b69f8ab390e290de4cf03e3dcfb08e483d6aee3c09f6b68
+  data.tar.gz: 4399462a5da0cc58eae86e45922a5909cbecf338987f6739b48c67623a62ff82
+SHA512:
+  metadata.gz: 328ccffe20e07a980dfd62052a293d759e8ce3b92bed28d941b09e3bbbff8724dcfcd20d6d2c83684f63a620ee8e0383d4ed9bc8b75b432a4907ab7ba79b7ffb
+  data.tar.gz: 0b85f02cb695a8d7e5ee5e81cd61ad36dc96917fbbabc91f2517672d039f530ff15d83845d884a32e82107981066be6bd3056f77aba94222a0b7f7b24a79cf5e

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-version

@@ -0,0 +1 @@
+2.7.1

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.5
+before_install: gem install bundler -v 1.17.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in mini_graph.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    mini_graph (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.1)
+    rake (12.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.1)
+  mini_graph!
+  minitest (~> 5.0)
+  rake (~> 12.3.3)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Coroutine LLC
+
+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,144 @@
+# MiniGraph
+
+[![Build Status](https://travis-ci.org/coroutine/mini_graph.svg?branch=master)](https://travis-ci.org/coroutine/mini_graph)
+
+Hi!  MiniGraph is a Ruby gem who's name says it all: it is mini--in functionality
+and user experience--and it's a graph implementation.  Imagine that!
+
+MiniGraph provides a small DSL for defining and searching graphs.  Behind the scenes,
+MiniGraph uses a core set of classes to support the DSL.  Of course, you are free
+to directly use these classes for defining and searching graphs, if that better
+suits your taste.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mini_graph'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mini_graph
+
+## Usage
+
+Honestly, there's not a lot to cover here, so we'll keep it brief.
+
+First, let's have a look at the DSL.  The DSL covers two concerns:
+
+1. Defining graphs: these can be directed or undirected
+2. Searching graphs: we provide depth-first and breadth-first search functionality, feel free to extend this.
+
+Now, let's take a closer look at the graph definition DSL.
+
+### DSL: Defining graphs
+
+By default, all graphs created using the graph DSL are undirected.  Here's an
+example of a new, undirected graph as created with the DSL:
+
+```ruby
+jim   = { name: 'Jim',  likes: %w(bears quilts buttermilk) }
+john  = { name: 'John', likes: %w(tires mailboxes wombats marshmallows) }
+jill  = { name: 'Jill', likes: %w(wind wrappers socks clay) }
+jane  = { name: 'Jane', likes: %w(cds parachutes corndogs living) }
+
+# Create a new undirected graph, with the 4 vertices: jim, john, jill, jane.
+friends = MiniGraph.create(jim, john, jill, jane) do
+
+  # create edges from jim, to john, jill and jane.
+  edge from: jim,   to: [john, jill, jane]
+
+  # create edges from john, to jill and jane
+  edge from: john,  to: [jill, jane]
+
+  # create an edge from jane to jill
+  edge from: jane,  to: jill
+end
+```
+
+In the previous example, we create our graph to contain a know set of vertices.  
+Vertices can only be added to a graph during creation.  At no other point in the
+lifecycle of the graph may vertices be added or deleted.
+
+Also notice the ability to define edges from a vertex to one or more vertices.
+This is one of the nice little shortcuts provided by the DSL.  But wait, there's more!
+We can also easily define edges from many vertices to many vertices.  Take, for
+example, this complete, undirected graph:
+
+```ruby
+poker_friends = MiniGraph.create(jim, john, jill, jane) do
+  edge from: [jim, john, jill, jane], to: [jim, john, jill, jane]
+end
+```
+
+Dang! That was easy!  Ok, enough feigning astonishment!
+
+We've now seen undirected graphs, as defined using the MiniGraph DSL, let's
+now take a look at directed graphs.  Let's use our first example, but this time
+we'll make the edges directed.  Here we go!
+
+```ruby
+# Create a new undirected graph, with the 4 vertices: jim, john, jill, jane.
+friends = MiniGraph.create(jim, john, jill, jane) do
+
+  # Make this a directed graph.
+  directed!
+
+  # create edges from jim, to john, jill and jane.
+  edge from: jim,   to: [john, jill, jane]
+
+  # create edges from john, to jill and jane
+  edge from: john,  to: [jill, jane]
+
+  # create an edge from jane to jill
+  edge from: jane,  to: jill
+end
+```
+
+Did you see that?!  We just added `directed!`, and that was it!  Smooth and declarative.
+
+Did I hear you say you wanted the same declarative syntax for undirected graphs? Boom!
+Just use the `undirected!` declaration, and you're set!
+
+Now, let's move on to searching.
+
+### DSL: Searching graphs
+
+Now that we know how to define graphs, we should probably be able to find stuff
+in them, right?
+
+The MiniGraph search DSL is pretty minimal.  You wanna do a depth-first search?
+Check it:
+
+```ruby
+# Searching our previously defined friends graph, and starting our search at the 'john' vertex:
+results = MiniGraph.dfs friends, start_at: john
+
+# results implements Enumerable
+results.entries # => [john, jim, jill, jane]
+```
+
+...and here's breadth-first search on the same graph:
+
+```ruby
+results = MiniGraph.bfs friends, start_at: jill
+results.entries # => [jill, jim, john, jane]
+```
+
+That's it for the DSL!  Not much to it, right?  You might even call it _Mini_.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/coroutine/mini_graph.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mini_graph"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mini_graph.rb

@@ -0,0 +1,36 @@
+require "mini_graph/version"
+require "mini_graph/dsl/graph_context"
+require "mini_graph/dsl/search_context"
+
+module MiniGraph
+
+  # Used to construct a new graph.
+  #
+  # Example usage:
+  #
+  #   jim   = Person.new
+  #   john  = Person.new
+  #   jill  = Person.new
+  #   jane  = Person.new
+  #
+  #   friends = MiniGraph.create(jim, john, jill, jane) do
+  #     # Creates a directed graph
+  #     directed!
+  #
+  #     edge from: jim,   to: [john, jill, jane]
+  #     edge from: john,  to: [jill, jane]
+  #     edge from: jane,  to: jill
+  #   end
+  #
+  def self.create(*vertices, &block)
+    MiniGraph::DSL::GraphContext.evaluate(*vertices, &block)
+  end
+
+  def self.dfs(graph, start_at: nil)
+    MiniGraph::DSL::SearchContext.evaluate(graph, start_at, algorithm: :dfs)
+  end
+
+  def self.bfs(graph, start_at: nil)
+    MiniGraph::DSL::SearchContext.evaluate(graph, start_at, algorithm: :bfs)
+  end
+end

data/lib/mini_graph/core/edge.rb

@@ -0,0 +1,65 @@
+require 'mini_graph/core/error'
+
+module MiniGraph
+  module Core
+    module Edge
+
+      # -----------------------------------------------------
+      # Directed Edge
+      # -----------------------------------------------------
+
+      class Directed
+        attr_reader :origin, :destination
+
+        def initialize(origin, destination)
+          @origin       = origin
+          @destination  = destination
+        end
+
+        def eql?(edge)
+          origin == edge.origin && destination == edge.destination
+        end
+
+        # cannot use alias or alias_method for this, as subclasses (e.g. UndirectedEdge)
+        # do not behave as expected.  We'll be explicit.
+        def ==(edge)
+          eql?(edge)
+        end
+
+        def to_s
+          "(#{origin} -> #{destination})"
+        end
+
+        # Another case of not using alias to allow subclasses to behave as expected.
+        def inspect
+          to_s
+        end
+
+        # Reverses the direction of the edge
+        def reverse
+          self.class.new(destination, origin)
+        end
+
+        # Indicates a self-looping edge; i.e., an edge that connects a vertex to
+        # itself.
+        def self_loop?
+          origin == destination
+        end
+      end
+
+      # -----------------------------------------------------
+      # Undirected
+      # -----------------------------------------------------
+
+      class Undirected < Directed
+        def eql?(edge)
+          super || (origin == edge.destination && destination == edge.origin)
+        end
+
+        def to_s
+          "(#{origin} <-> #{destination})"
+        end
+      end
+    end
+  end
+end

data/lib/mini_graph/core/error.rb

@@ -0,0 +1,14 @@
+module MiniGraph
+  module Core
+    module Error
+      class GraphError < StandardError; end
+
+      class SelfLoopError < GraphError; end
+      class ParallelEdgeError < GraphError; end
+      class InvalidIndexError < GraphError; end
+      class InvalidEdgeError < GraphError; end
+      class InvalidEdgeTypeError < GraphError; end
+      class InvalidSearchAlgorithmError < GraphError; end
+    end
+  end
+end

data/lib/mini_graph/core/graph.rb

@@ -0,0 +1,119 @@
+require 'forwardable'
+require 'mini_graph/core/edge'
+require 'mini_graph/core/error'
+
+module MiniGraph
+  module Core
+    class Graph
+
+      include Enumerable
+      extend  Forwardable
+
+      def_delegators :@vertices, :each, :size, :[]
+
+      attr_reader :vertices
+
+      # Initialize a directed or undirected graph with a list of vertices
+      def initialize(vertices, directed: false)
+        @directed = !!directed
+        @vertices = [vertices].flatten.freeze
+        @edges    = []
+      end
+
+      def edge_class
+        if directed?
+          MiniGraph::Core::Edge::Directed
+        else
+          MiniGraph::Core::Edge::Undirected
+        end
+      end
+
+      # Adds an edge from the vertex at origin_index to the vertex at
+      # destination_index
+      def add_edge(*args)
+        edge = args_to_edge(args)
+
+        # origin must reference a valid index within the graph
+        if edge.origin >= size
+          raise ::MiniGraph::Core::Error::InvalidIndexError,
+                'origin_index invalid'
+        end
+
+        # destination must reference a valid index within the graph
+        if edge.destination >= size
+          raise ::MiniGraph::Core::Error::InvalidIndexError,
+                'destination_index invalid'
+        end
+
+        edges << edge
+      end
+
+      def directed?
+        @directed
+      end
+
+      def undirected?
+        !directed?
+      end
+
+      # Returns an array of vertex indices that have an inbound edge from the vertex
+      # at the supplied index
+      def adjacent_vertices(index)
+        edges.reduce([]) do |adj, edge|
+          adj << edge.destination if edge.origin == index
+          adj << edge.origin      if undirected? && edge.destination == index
+          adj
+        end
+        .uniq
+      end
+
+      # Returns a reversed copy of the digraph.
+      def reverse
+        self.class.new(vertices, directed: @directed).tap do |dg|
+          dg.edges = edges.map(&:reverse)
+        end
+      end
+
+      def to_s
+        edges.join
+      end
+
+      # -----------------------------------------------------
+      # Protected
+      # -----------------------------------------------------
+
+      protected
+
+      def edges
+        @edges
+      end
+
+      def edges=(edges)
+        @edges = edges
+      end
+
+      # -----------------------------------------------------
+      # Private
+      # -----------------------------------------------------
+
+      private
+
+      def args_to_edge(args)
+        case args.length
+        when 1
+          args.first.tap do |edge|
+            if edge.class != edge_class
+              raise MiniGraph::Core::Error::InvalidEdgeTypeError,
+                    "edge must be instance of #{edge_class.name}"
+            end
+          end
+        when 2
+          edge_class.new(*args)
+        else
+          raise ArgumentError,
+                "wrong number of arguments.  #{args.length} args were provided. 1 or 2 arguments were expected."
+        end
+      end
+    end
+  end
+end

data/lib/mini_graph/core/search.rb

@@ -0,0 +1,73 @@
+module MiniGraph
+  module Core
+    module Search
+
+      # -----------------------------------------------------
+      # Base Search Implementation
+      # -----------------------------------------------------
+
+      class Base
+        include Enumerable
+
+        attr_reader :graph, :vertex_index
+
+        def initialize(graph, vertex_index)
+          @graph        = graph
+          @vertex_index = vertex_index
+        end
+
+        def each
+          return enum_for(:each) unless block_given?
+
+          visit(vertex_index) do |vi|
+            yield graph[vi]
+          end
+        end
+
+        def visit(index, visited=Array.new(graph.size, false), &block)
+          raise NotImplementedError, "#visit must be implemented"
+        end
+      end
+
+      # -----------------------------------------------------
+      # Depth-First Search
+      # -----------------------------------------------------
+
+      class DFS < Base
+        def visit(index, visited=Array.new(graph.size, false), &block)
+          visited[index] = true
+          yield index
+
+          graph.adjacent_vertices(index).each do |vi|
+            visit(vi, visited, &block) unless visited[vi]
+          end
+        end
+      end
+
+      # -----------------------------------------------------
+      # Breadth-First Search
+      # -----------------------------------------------------
+
+      class BFS < Base
+        def visit(index, visited=Array.new(graph.size, false), &block)
+          queue           = []
+          visited[index]  = true
+
+          queue.push(index)
+
+          while !queue.empty?
+            next_index = queue.shift
+            yield next_index
+
+            graph.adjacent_vertices(next_index).each do |vi|
+              unless visited[vi]
+                visited[vi] = true
+                queue.push(vi)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mini_graph/dsl/graph_context.rb

@@ -0,0 +1,79 @@
+require 'mini_graph/core/edge'
+require 'mini_graph/core/graph'
+
+module MiniGraph
+  module DSL
+    class GraphContext
+      def self.evaluate(*vertices, &block)
+        unless block_given?
+          raise ArgumentError, "cannot call .create without a block"
+        end
+
+        graph_context = new(vertices)
+        graph_context.instance_eval(&block)
+        graph_context.resolve
+      end
+
+      # -----------------------------------------------------
+      # Public Methods
+      # -----------------------------------------------------
+
+      def resolve
+        if @edges.any? { |edge| edge.any?(&:nil?) }
+          raise MiniGraph::Core::Error::InvalidEdgeError,
+                'One or more invalid edges were specified'
+        end
+
+        MiniGraph::Core::Graph.new(@vertices, directed: @directed).tap do |g|
+          @edges.each do |edge|
+            g.add_edge(*edge)
+          end
+        end
+      end
+
+      # -----------------------------------------------------
+      # Protected Methods
+      # -----------------------------------------------------
+
+      protected
+
+      attr_reader :vertex_index
+
+      def initialize(vertices)
+        @vertices     = [vertices].flatten
+        @vertex_index = @vertices.map.with_index { |v, i| [v, i] }.to_h
+        @directed     = false
+        @edges        = []
+      end
+
+      def undirected!
+        @directed = false
+      end
+
+      def directed!
+        @directed = true
+      end
+
+      def edge(from:, to:)
+        from_indices  = vertices_to_indices(from)
+        to_indices    = vertices_to_indices(to)
+
+        @edges += from_indices.flat_map do |origin|
+          to_indices.map do |destination|
+            [origin, destination]
+          end
+        end
+      end
+
+      # -----------------------------------------------------
+      # Private Methods
+      # -----------------------------------------------------
+
+      private
+
+      def vertices_to_indices(vertices)
+        [vertices].flatten.map { |v| vertex_index[v] }
+      end
+    end
+  end
+end

data/lib/mini_graph/dsl/search_context.rb

@@ -0,0 +1,28 @@
+require 'mini_graph/core/error'
+require 'mini_graph/core/search'
+
+module MiniGraph
+  module DSL
+    class SearchContext
+
+      ALGORITHM_IMPL = {
+        dfs: MiniGraph::Core::Search::DFS,
+        bfs: MiniGraph::Core::Search::BFS
+      }
+
+      def self.evaluate(graph, start_at, algorithm:)
+        algorithm_impl = ALGORITHM_IMPL[algorithm]
+
+        unless algorithm_impl
+          raise MiniGraph::Core::Error::InvalidSearchAlgorithmError,
+                "An unknown algorithm was provided to SearchContext: #{algorithm}"
+        end
+
+        vertex_index  = graph.vertices.map.with_index { |v, i| [v, i] }.to_h
+        start_index   = start_at.nil? ? 0 : vertex_index[start_at]
+
+        algorithm_impl.new(graph, start_index)
+      end
+    end
+  end
+end

data/lib/mini_graph/version.rb

@@ -0,0 +1,3 @@
+module MiniGraph
+  VERSION = "0.1.0"
+end

data/mini_graph.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "mini_graph/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "mini_graph"
+  spec.version       = MiniGraph::VERSION
+  spec.authors       = ["Tim Lowrimore"]
+  spec.email         = ["tlowrimore@coroutine.com"]
+
+  spec.summary       = %q{A mini graph library + DSL}
+  spec.description   = %q{A mini graph library + DSL}
+  spec.homepage      = "https://github.com/coroutine/mini_graph"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"]     = spec.homepage
+    spec.metadata["source_code_uri"]  = spec.homepage
+    spec.metadata["changelog_uri"]    = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 12.3.3"
+  spec.add_development_dependency "minitest", "~> 5.0"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: mini_graph
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tim Lowrimore
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A mini graph library + DSL
+email:
+- tlowrimore@coroutine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mini_graph.rb
+- lib/mini_graph/core/edge.rb
+- lib/mini_graph/core/error.rb
+- lib/mini_graph/core/graph.rb
+- lib/mini_graph/core/search.rb
+- lib/mini_graph/dsl/graph_context.rb
+- lib/mini_graph/dsl/search_context.rb
+- lib/mini_graph/version.rb
+- mini_graph.gemspec
+homepage: https://github.com/coroutine/mini_graph
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/coroutine/mini_graph
+  source_code_uri: https://github.com/coroutine/mini_graph
+  changelog_uri: https://github.com/coroutine/mini_graph
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: A mini graph library + DSL
+test_files: []