ogr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 83cf5471104a54bfb6ed4f87203f21af7b6c0dc1
+  data.tar.gz: ecf312736e5b4a2a950fed9157d563625ff2d266
+SHA512:
+  metadata.gz: 7c6a05934278805233e4a72479bd1aa6e1f8d172a25a5498da9c714acf61b9391723205d7a105a2910b87821408d3b9fc9c909ed1bb56fc2d72c23c463c7a5dc
+  data.tar.gz: 1c56b4b496bb8c60b237599c7c8d06597f5620fda246804f9b097114997ff1a4662b19d0d8e519252c750d6e9f3ddf51e3e2647cc09a6c00d0ecbfafc99253d3

data/.gitignore

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

data/.rubocop.yml

@@ -0,0 +1,3 @@
+Metrics/LineLength:
+  Max: 100
+

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.2.2
+  - 2.2.3
+  - 2.3.0
+  - jruby-head
+script:
+  - bundle exec rake
+before_install:
+  - gem install bundler
+  - gem update bundler

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 knife
+
+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,141 @@
+# Ogr
+
+General graph library for Ruby. Provides sparse(or dense), directed(or undirected) and weighted graphs for Ruby.
+
+## Installation
+
+```ruby
+  gem install ogr
+```
+
+## Usage
+
+```ruby
+  require 'ogr'
+  graph = Ogr::Graph.new
+```
+
+To not have to type "Ogr::" before each class, use:
+
+```ruby
+  include Ogr
+  graph = Graph.new
+```
+
+
+## Graph
+
+Creating new Graph
+
+First define edges:
+
+```ruby
+  edges = []
+  edges << Edge.new('Jim','Bob')
+  edges << Edge.new('Jim','Tom')
+  edges << Edge.new('Bob','Jack')
+  edges << Edge.new('Tom','Bob')
+```
+or
+
+```ruby
+  edges = [
+      ['Jim','Bob'],
+      ['Jim','Tom'],
+      ['Bob','Jack'],
+      ['Tom','Bob']
+  ]
+```
+
+New undirected graph (implemented as adjency list)
+
+```ruby
+  graph = Graph.new(edges)
+```
+
+New undirected dense graph (implemented as triangular matrix)
+
+```ruby
+  graph = Graph.create(edges)
+```
+or
+
+```ruby
+  graph = Graph.new(edges, :tri_matrix)
+
+```
+
+Examples:
+```ruby
+  graph.vertex_size #=> 4
+  graph.degree("Bob") #=> 3
+  graph.edge?("Bob", "Tom") #=> true
+  graph.edge?("Tom", "Jack") #=> false
+  graph.add_edge(Edge.new("Bob", "Kate"))
+  graph.remove("Bob", "Jack")
+  graph.neighbors('Tom') #=> ["Bob", "Jim"]
+```
+
+Iterating
+
+```ruby
+  graph.each_edge{ |e| p e }
+  graph.each_vertex{ |v| p v }
+```
+
+
+## Digraph
+
+Directed Weighted Graph
+
+```ruby
+  edges = []
+  edges << Edge.new(:A, :C, 5)
+  edges << Edge.new(:A, :D, 3)
+  edges << Edge.new(:A, :G, 14)
+  edges << Edge.new(:C, :E, 3)
+  edges << Edge.new(:C, :F, 2)
+  edges << Edge.new(:D, :C, 11)
+  edges << Edge.new(:D, :E, 7)
+  edges << Edge.new(:D, :G, 6)
+  edges << Edge.new(:G, :E, 7)
+  edges << Edge.new(:E, :B, 5)
+  edges << Edge.new(:G, :B, 6)
+  edges << Edge.new(:F, :B, 7)
+```
+
+New directed graph (implemented as adjency list)
+
+```ruby
+  wdigraph = Digraph.new(edges)
+```
+
+New directed dense graph (implemented as matrix)
+```ruby
+  wdigraph = Digraph.create(edges)
+```
+or
+```ruby
+  wdigraph = Digraph.new(edges, :matrix)
+```
+
+Examples
+```ruby
+  wdigraph.get_edge(:D, :C).weight #=> 11
+  wdigraph.degree(:E) #=> 4
+  wdigraph.in_degree(:E) #=> 3
+  wdigraph.out_degree(:E) #=> 1
+```
+
+## Searching
+
+Breadth First Search:
+```ruby
+  BreadthFirstSearch.new(wdigraph).search(:A) #=> [:A, :C, :D, :G, :E, :F, :B]
+```
+
+Depth First Search:
+```ruby
+  DepthFirstSearch.new(wdigraph).search(:A) #=> [:A, :G, :B, :E, :D, :C, :F]
+`
+

data/Rakefile

@@ -0,0 +1,19 @@
+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']
+  t.verbose = true
+end
+
+Rake::TestTask.new do |t|
+  t.name = 'test:performance'
+  t.libs << 'test'
+  t.test_files = FileList['test/performance/*test.rb']
+  t.verbose = true
+end
+
+desc 'Run tests'
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ogr'
+
+# 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

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/ogr/graphs/breadth_first_search.rb

@@ -0,0 +1,66 @@
+module Ogr
+  # Class implements Breadth First Search in graphs
+  class BreadthFirstSearch
+    attr_accessor :parents, :visited, :distance
+    private :parents=, :visited=, :distance=
+
+    def initialize(graph)
+      @graph = graph
+      @colors = {}
+      @parents = {}
+      @visited = []
+      @distance = {}
+      @to_visit = SimpleQueue.new
+    end
+
+    def search(s)
+      # TODO: Check if source exists in graph
+      reset!
+      visit_source(s)
+      until to_visit.empty?
+        v = to_visit.dequeue
+        visit_neighbors(v)
+        colors[v] = :black
+        visited << (block_given? ? yield(v) : v)
+      end
+      visited
+    end
+
+    private
+
+    attr_accessor :graph, :to_visit, :colors
+
+    def reset!
+      self.visited = []
+      graph.each_vertex do |v|
+        colors[v] = :white
+        parents[v] = nil
+        distance[v] = Float::INFINITY
+      end
+    end
+
+    def visit_source(s)
+      colors[s] = :white
+      parents[s] = nil
+      distance[s] = 0
+      to_visit.enqueue s
+    end
+
+    def visit_node(v, from)
+      colors[v] = :grey
+      parents[v] = from
+      distance[v] = distance[from] + 1
+      to_visit.enqueue v
+    end
+
+    def visit_neighbors(u)
+      graph.neighbors(u).each do |v|
+        visit_node(v, u) if not_visited?(v)
+      end
+    end
+
+    def not_visited?(v)
+      colors[v] == :white
+    end
+  end
+end

data/lib/ogr/graphs/depth_first_search.rb

@@ -0,0 +1,40 @@
+module Ogr
+  # Class implements Breadth First Search in graphs
+  class DepthFirstSearch
+    attr_accessor :parents, :visited, :distance, :marked
+    private :parents=, :visited=, :distance=, :marked=
+
+    def initialize(graph)
+      @graph = graph
+      @parents = {}
+      @marked = {}
+      @visited = []
+      @distance = {}
+    end
+
+    def search(u, &block)
+      reset!
+      dfs(u, &block)
+      visited
+    end
+
+    def dfs(v, from = nil, &block)
+      marked[v] = true
+      visited << (block_given? ? yield(v) : v)
+      parents[v] = from
+      graph.neighbors(v).reverse_each do |u|
+        dfs(u, v, &block) unless marked[u]
+      end
+    end
+
+    private
+
+    attr_reader :graph
+
+    def reset!
+      self.visited = []
+      self.parents = {}
+      self.marked = {}
+    end
+  end
+end

data/lib/ogr/graphs/digraph.rb

@@ -0,0 +1,29 @@
+module Ogr
+  # Class implements directed graph
+  class Digraph < Graph
+    def initialize(edges, store = :list)
+      @map = IndexedSet.new
+      case store
+      when :list
+        @g = GraphAsList.new
+      when :matrix
+        @g = GraphAsMatrix.new
+      end
+      add_edges(edges)
+    end
+
+    def self.new_dense(args)
+      new(args, :matrix)
+    end
+
+    # Returns number of incoming edges to given vertex.
+    def in_degree(x)
+      @g.degree index(x), :in
+    end
+
+    # Returns number of outcoming edges to given vertex.
+    def out_degree(x)
+      @g.degree index(x), :out
+    end
+  end
+end

data/lib/ogr/graphs/edge.rb

@@ -0,0 +1,13 @@
+module Ogr
+  # Class implements graph edge
+  class Edge
+    attr_accessor :from, :to, :weight
+
+    # Create new edge.
+    def initialize(from, to, weight = 1)
+      @from = from
+      @to = to
+      @weight = weight
+    end
+  end
+end

data/lib/ogr/graphs/edge_bag.rb

@@ -0,0 +1,29 @@
+module Ogr
+  # Bag for Edge objects
+  class EdgeBag
+    include Enumerable
+    def initialize
+      @store = []
+    end
+
+    def add(x, weight)
+      @store.push v: x, weight: weight
+    end
+
+    def remove(x)
+      @store.delete_if { |edge| edge[:v] == x }
+    end
+
+    def get(x)
+      @store.find { |edge| edge[:v] == x }
+    end
+
+    def each(&block)
+      @store.each(&block)
+    end
+
+    def size
+      @store.size
+    end
+  end
+end

data/lib/ogr/graphs/graph.rb

@@ -0,0 +1,105 @@
+module Ogr
+  # Graph class
+  class Graph
+    # Create new graph from array of edges. Second parameter determines
+    # graph internal implementation: :list (Adjency List), :tri_matrix (Triangular
+    # Matrix), :matrix (Matrix).
+    def initialize(edges = nil, store = :list)
+      @map = IndexedSet.new
+      case store
+      when :list
+        @g = GraphAsList.new(directed: false)
+      when :matrix
+        @g = GraphAsMatrix.new
+      when :tri_matrix
+        @g = GraphAsTriMatrix.new
+      end
+
+      add_edges(edges) if edges
+    end
+
+    # Create new graph from array of edges. Internally graph will be represented
+    # by Triangular Matrix.
+    def self.new_dense(edges)
+      new(edges, :tri_matrix)
+    end
+
+    # Adds new edge to graph.
+    def add(x, y, weight = 1)
+      @g.add(push(x), push(y), weight)
+    end
+
+    # Adds new edges to graph.
+    def add_edges(edges)
+      if edges[0].is_a? Array
+        edges.each { |e| add(e[0], e[1]) }
+      else
+        edges.each { |e| add(e.from, e.to, e.weight) }
+      end
+    end
+
+    # Adds new edge to graph.
+    def add_edge(edge)
+      add_edges([edge])
+    end
+
+    # Removes connection between vertex x and y.
+    def remove(x, y)
+      @g.remove(index(x), index(y))
+    end
+
+    # Returns all neighbors for given vertex.
+    def neighbors(x)
+      @g.neighbors(index(x)).map { |i| vertexes[i] }
+    end
+
+    # Returns vertex degree.
+    def degree(x)
+      @g.degree index(x)
+    end
+
+    # Checks if two elements are connected.
+    def edge?(x, y)
+      @g.edge?(index(x), index(y))
+    end
+
+    # Returns Edge(x,y) if exist.
+    def get_edge(x, y)
+      return nil unless edge?(x, y)
+      w = @g.get_edge(index(x), index(y))
+      Edge.new(x, y, w) if w
+    end
+
+    def vc
+      (0...vertexes.size)
+    end
+
+    def vertexes
+      @map.to_a
+    end
+
+    def vertex_size
+      vertexes.size
+    end
+
+    # Vertex iterator
+    def each_vertex
+      vc.each { |v| yield vertexes[v] }
+    end
+
+    # Edge iterator
+    def each_edge(&block)
+      @g.each_edge(vertexes, &block)
+    end
+
+    private
+
+    def index(x)
+      @map.index(x)
+    end
+
+    def push(x)
+      @map.push(x)
+    end
+  end
+end

data/lib/ogr/graphs/graph_as_list.rb

@@ -0,0 +1,78 @@
+module Ogr
+  # Graph implemented as Adjency List
+  class GraphAsList
+    def initialize(opts = {})
+      @store = []
+      @directed = opts[:directed].nil? ? true : false
+    end
+
+    def undirected?
+      !@directed
+    end
+
+    # Adds new edges to graph.
+    def add(x, y, weight)
+      @store[x] ||= EdgeBag.new
+      @store[x].add(y, weight)
+      @store[y] ||= EdgeBag.new if undirected?
+      @store[y].add(x, weight) if undirected?
+    end
+
+    # Removes conection between vertex x and y.
+    def remove(x, y)
+      @store[x].remove(y)
+      @store[y].remove(x) if undirected?
+    end
+
+    # Checks if two elements are connected.
+    def edge?(x, y)
+      connected?(x, y)
+    end
+
+    # Returns Edge(x,y) if exist.
+    def get_edge(x, y)
+      edge = get(x, y)
+      edge[:weight] if edge
+    end
+
+    # Returns all neighbors for given vertex.
+    def neighbors(x)
+      @store[x].map { |edge| edge[:v] }
+    end
+
+    # Returns vertex degree. Second parameter determines direction - :in incoming
+    # edges, :out - outcoming edges, :all - incoming and outcoming edges.
+    def degree(x, direction = :all)
+      r = Hash.new(0)
+      vc = (0..@store.size)
+      vc.each do |i|
+        r[:in] += 1 if  connected?(i, x)
+        r[:out] += 1 if connected?(x, i)
+      end
+      r[:all] = r[:in] + r[:out]
+      return r[direction] / 2 if undirected?
+      r[direction]
+    end
+
+    def each_edge(vertexes)
+      @store.each_with_index do |list, i|
+        list.each do |vertex|
+          j = vertex[:v]
+          next if i > j && undirected?
+          w = get_edge(i, j)
+          yield Edge.new(vertexes[i], vertexes[j], w) if w
+        end
+      end
+    end
+
+    private
+
+    def get(x, y)
+      @store[x] && @store[x].get(y)
+    end
+
+    def connected?(x, y)
+      !get(x, y).nil?
+    end
+  end
+end

data/lib/ogr/graphs/graph_as_matrix.rb

@@ -0,0 +1,67 @@
+module Ogr
+  # Graph implemented as Matrix
+  class GraphAsMatrix
+    def initialize
+      @store = Array2D.new
+    end
+
+    def add(x, y, weight)
+      @store[x, y] = weight
+    end
+
+    # Removes conection between vertex x and y.
+    def remove(x, y)
+      @store[x, y] = 0
+    end
+
+    # Checks if two elements are connected.
+    def edge?(x, y)
+      connected?(x, y)
+    end
+
+    # Returns Edge(x,y) if exist.
+    def get_edge(x, y)
+      @store[x, y]
+    end
+
+    # Returns all neighbors for given vertex.
+    def neighbors(v)
+      n = []
+      vertexes.each { |i| n << i if connected?(v, i) }
+      n
+    end
+
+    # Returns vertex degree. Second parameter determines direction - :in incoming
+    # edges, :out - outcoming edges, :all - incoming and outcoming edges.
+    def degree(x, direction = :all)
+      r = Hash.new(0)
+      vertexes.each do |i|
+        r[:in] += 1 if connected?(i, x)
+        r[:out] += 1 if connected?(x, i)
+      end
+      r[:all] = r[:in] + r[:out]
+      r[direction]
+    end
+
+    # Edge iterator
+    def each_edge(vertexes)
+      size = vertexes.size
+      (0...size).each do |v0|
+        (0...size).each do |v1|
+          weight = @store[v0, v1]
+          yield Edge.new(vertexes[v0], vertexes[v1], weight) if weight
+        end
+      end
+    end
+
+    private
+
+    def connected?(x, y)
+      @store[x, y] > 0
+    end
+
+    def vertexes
+      (0..@store.size)
+    end
+  end
+end

data/lib/ogr/graphs/graph_as_tri_matrix.rb

@@ -0,0 +1,28 @@
+module Ogr
+  # Graph implemented as Triangular Matrix
+  class GraphAsTriMatrix < GraphAsMatrix
+    def initialize
+      @store = TriMatrix.new(0)
+    end
+
+    # Returns vertex degree.
+    def degree(x)
+      sum = 0
+      vc = (0..@store.size)
+      vc.each do |i|
+        sum += @store[x, i] if @store[x, i]
+      end
+      sum
+    end
+
+    # Edge iterator
+    def each_edge(vertexes)
+      size = vertexes.size
+      (0...size).each do |v0|
+        (0...v0).each do |v1|
+          yield Edge.new(vertexes[v0], vertexes[v1], @store[v0, v1]) if connected?(v0, v1)
+        end
+      end
+    end
+  end
+end

data/lib/ogr/version.rb

@@ -0,0 +1,3 @@
+module Ogr
+  VERSION = '0.1.0'.freeze
+end

data/lib/ogr.rb

@@ -0,0 +1,18 @@
+require 'ds'
+
+require 'ogr/version'
+
+require 'ogr/graphs/edge'
+require 'ogr/graphs/graph_as_matrix'
+require 'ogr/graphs/graph_as_list'
+require 'ogr/graphs/graph_as_tri_matrix'
+require 'ogr/graphs/edge_bag'
+require 'ogr/graphs/graph'
+require 'ogr/graphs/digraph'
+require 'ogr/graphs/breadth_first_search'
+require 'ogr/graphs/depth_first_search'
+
+# Main module namespace
+module Ogr
+  include DS
+end

data/ogr.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ogr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ogr'
+  spec.version       = Ogr::VERSION
+  spec.authors       = ['knife']
+  spec.email         = ['satre@o2.pl']
+
+  spec.summary       = 'Graphs implemented in Ruby'
+  spec.description   = 'Graphs library for Ruby'
+  spec.homepage      = 'https://github.com/knife/ogr'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host',
+  # or delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  # end
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |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_runtime_dependency 'ds', '~> 0.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: ogr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- knife
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ds
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: 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: Graphs library for Ruby
+email:
+- satre@o2.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ogr.rb
+- lib/ogr/graphs/breadth_first_search.rb
+- lib/ogr/graphs/depth_first_search.rb
+- lib/ogr/graphs/digraph.rb
+- lib/ogr/graphs/edge.rb
+- lib/ogr/graphs/edge_bag.rb
+- lib/ogr/graphs/graph.rb
+- lib/ogr/graphs/graph_as_list.rb
+- lib/ogr/graphs/graph_as_matrix.rb
+- lib/ogr/graphs/graph_as_tri_matrix.rb
+- lib/ogr/version.rb
+- ogr.gemspec
+homepage: https://github.com/knife/ogr
+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.8
+signing_key: 
+specification_version: 4
+summary: Graphs implemented in Ruby
+test_files: []
+has_rdoc: