graph_matching 0.1.0 → 0.1.1

data/spec/graph_matching/graph/bigraph_spec.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe GraphMatching::Graph::Bigraph do
-  let(:g) { described_class.new }
-
-  it 'is a Graph' do
-    expect(g).to be_a(GraphMatching::Graph::Graph)
-  end
-
-  describe '#partition' do
-    context 'empty graph' do
-      it 'returns two empty sets' do
-        p = g.partition
-        expect(p.length).to eq(2)
-        p.each do |set|
-          expect(set).to be_a(Set)
-          expect(set).to be_empty
-        end
-      end
-    end
-
-    context 'graph with single vertex v' do
-      it 'returns two sets, one with v' do
-        v = 0
-        g.add_vertex(v)
-        p = g.partition
-        expect(p[0]).to eq(Set[v])
-        expect(p[1]).to eq(Set[])
-      end
-    end
-
-    context 'graph with single edge' do
-      it 'returns two disjoint sets, each with one vertex' do
-        e = [0, 1]
-        g.add_edge(*e)
-        p = g.partition
-        expect(p.map(&:first)).to match_array(e)
-      end
-    end
-
-    context 'complete graph with three vertexes' do
-      it 'raises a NotBipartite error' do
-        g.add_edge('alice', 'bob')
-        g.add_edge('bob', 'carol')
-        g.add_edge('alice', 'carol')
-        expect { g.partition }.to \
-          raise_error(GraphMatching::NotBipartite)
-      end
-    end
-
-    context 'non-trivial bipartite graph' do
-      it 'returns the expected disjoint sets' do
-        g.add_edge(1, 3)
-        g.add_edge(1, 4)
-        g.add_edge(2, 3)
-        g.add_edge(2, 4)
-        p = g.partition.map(&:sort).sort_by(&:first)
-        expect(p).to match_array([[1, 2], [3, 4]])
-      end
-    end
-
-    context 'disconnected, yet bipartite graph' do
-      it 'returns one of the the expected disjoint sets' do
-        g = described_class[1, 3, 2, 4]
-        p = g.partition.map(&:sort).sort_by(&:first)
-        permutations = [[[1, 2], [3, 4]], [[1, 4], [2, 3]]]
-        expect(permutations).to include(p)
-      end
-    end
-  end
-end

data/spec/graph_matching/graph/graph_spec.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe GraphMatching::Graph::Graph do
-  ERR_MSG_INT_VERTEXES = 'All vertexes must be integers'.freeze
-
-  let(:g) { described_class.new }
-
-  it 'is an RGL::MutableGraph' do
-    expect(g).to be_a(RGL::MutableGraph)
-  end
-
-  describe '.[]' do
-    it 'checks that all vertexes are integers' do
-      expect { described_class['a', 'b'] }.to \
-        raise_error(ArgumentError, ERR_MSG_INT_VERTEXES)
-    end
-  end
-
-  describe '.new' do
-    it 'checks that all vertexes are integers' do
-      g1 = RGL::AdjacencyGraph[1, 'b']
-      g2 = RGL::AdjacencyGraph['a', 2]
-      expect { described_class.new(Set, g1, g2) }.to \
-        raise_error(ArgumentError, ERR_MSG_INT_VERTEXES)
-    end
-  end
-
-  describe '#connected?' do
-    it 'returns true for a connected graph' do
-      g.add_edge('alice', 'bob')
-      expect(g).to be_connected
-    end
-
-    it 'returns false for a disconnected graph' do
-      g.add_edge('alice', 'bob')
-      g.add_edge('yvette', 'zach')
-      expect(g).to_not be_connected
-    end
-  end
-
-  describe '#max_v' do
-    it 'returns the largest vertex number' do
-      g = described_class[1, 3, 3, 7]
-      expect(g.max_v).to eq(7)
-    end
-
-    it 'returns nil when graph is empty' do
-      expect(g.max_v).to eq(nil)
-    end
-  end
-end

data/spec/graph_matching/graph/weighted_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe GraphMatching::Graph::Weighted do
-  # no-doc
-  class MyGraph < RGL::AdjacencyGraph
-    include GraphMatching::Graph::Weighted
-  end
-
-  describe '.[]' do
-    it 'sets weights' do
-      g = MyGraph[[1, 2, 100], [1, 3, 101]]
-      expect(g.w([1, 2])).to eq(100)
-      expect(g.w([1, 3])).to eq(101)
-    end
-  end
-
-  describe '#set_w' do
-    let(:g) { MyGraph[[1, 2, 100]] }
-    let(:edge) { [1, 2] }
-
-    it 'records the assigned weight' do
-      weight = 7
-      g.set_w(edge, weight)
-      expect(g.w(edge)).to eq(weight)
-    end
-  end
-end

data/spec/graph_matching/integer_vertexes_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'rgl/adjacency'
-require 'spec_helper'
-require 'graph_matching/integer_vertexes'
-
-RSpec.describe GraphMatching::IntegerVertexes do
-  describe '.to_integers' do
-    it 'returns new graph with vertexes converted to integers, and a legend' do
-      e = %w(a b)
-      g1 = RGL::AdjacencyGraph[*e]
-      g2, legend = described_class.to_integers(g1)
-      expect(g2.size).to eq(g1.size)
-      expect(g2.vertices).to eq(1.upto(g1.size).to_a)
-      expect(g2.num_edges).to eq(g1.num_edges)
-      legend.keys.map(&:class).uniq.each do |klass|
-        expect(klass).to(be <= ::Integer)
-      end
-    end
-  end
-end

data/spec/graph_matching/matching_spec.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe GraphMatching::Matching do
-  describe '.gabow' do
-    context 'when nil is used as a placeholder' do
-      it 'returns a Matching' do
-        a = [nil, 2, 1, nil, 5, 4]
-        m = described_class.gabow(a)
-        expect(m.edge?([1, 2])).to eq(true)
-        expect(m.edge?([4, 5])).to eq(true)
-        expect(m.vertex?(3)).to eq(false)
-      end
-    end
-
-    context 'when 0 is used as a placeholder' do
-      it 'returns a Matching' do
-        a = [0, 2, 1]
-        m = described_class.gabow(a)
-        expect(m.edge?([1, 2])).to eq(true)
-        expect(m.vertex?(3)).to eq(false)
-      end
-    end
-  end
-
-  describe '#delete' do
-    it 'removes edge' do
-      e = [2, 3]
-      m = described_class[e]
-      expect(m.edge?(e)).to eq(true)
-      m.delete(e)
-      expect(m.edge?(e)).to eq(false)
-    end
-  end
-
-  describe '#empty?' do
-    context 'when initialized' do
-      it 'returns true' do
-        expect(described_class.new.empty?).to eq(true)
-      end
-    end
-
-    context 'with one or more edges' do
-      it 'returns false' do
-        expect(described_class[[1, 2]].empty?).to eq(false)
-      end
-    end
-  end
-
-  describe '#edge?' do
-    it 'returns true if edge found' do
-      m = described_class.new
-      expect(m.edge?([1, 2])).to eq(false)
-      m.add([1, 2])
-      expect(m.edge?([1, 2])).to eq(true)
-      m.add([4, 3])
-      expect(m.edge?([3, 4])).to eq(true)
-    end
-  end
-
-  describe '#vertex?' do
-    it 'returns true if vertex found' do
-      m = described_class.new
-      expect(m.vertex?(1)).to eq(false)
-      expect(m.vertex?(2)).to eq(false)
-      m.add([1, 2])
-      expect(m.vertex?(1)).to eq(true)
-      expect(m.vertex?(2)).to eq(true)
-    end
-  end
-
-  describe '#to_a' do
-    it 'returns edges' do
-      edges = [[1, 2], [3, 4]]
-      m = described_class[*edges]
-      expect(m.to_a).to eq(edges)
-    end
-  end
-
-  describe '#vertexes' do
-    it 'returns array of matched vertexes' do
-      expect(described_class.new.vertexes).to be_empty
-      expect(described_class[[3, 4]].vertexes).to match_array([3, 4])
-      expect(described_class[[1, 2], [3, 4]].vertexes).to \
-        match_array([1, 2, 3, 4])
-    end
-  end
-end

data/spec/graph_matching/visualize_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-require_relative '../spec_helper'
-
-RSpec.describe GraphMatching::Visualize do
-  describe '.new' do
-    it 'initializes with a graph' do
-      g = double
-      v = described_class.new(g)
-      expect(v.graph).to eq(g)
-    end
-  end
-
-  describe '#dot' do
-    let(:g) { GraphMatching::Graph::Graph.new }
-
-    def normalize_ws(str)
-      str.gsub(/\s+/, ' ').strip
-    end
-
-    context 'given a graph with a single edge' do
-      it 'returns a string in .dot format' do
-        g.add_edge('alice', 'bob')
-        str = described_class.new(g).dot
-        expect(normalize_ws(str)).to eq('graph { alice -- bob }')
-      end
-    end
-
-    context 'given a graph with two edges' do
-      it 'returns a string in .dot format' do
-        g.add_edge('alice', 'bob')
-        g.add_edge('tom', 'jerry')
-        str = described_class.new(g).dot
-        expect(normalize_ws(str)).to eq('graph { alice -- bob tom -- jerry }')
-      end
-    end
-  end
-end

data/spec/graph_matching_spec.rb

@@ -1,9 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe GraphMatching do
-  it 'should have a version number' do
-    expect(GraphMatching::VERSION).to_not be_nil
-  end
-end

data/spec/spec_helper.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
-require 'graph_matching'
-require 'pry'
-
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.filter_run_including(focus: true)
-  config.run_all_when_everything_filtered = true
-end
-
-RSpec::Matchers.define(:match_edges) do |expected|
-  match do |matching|
-    raise TypeError unless matching.is_a?(GraphMatching::Matching)
-    raise TypeError unless expected.is_a?(Array)
-    se = Set.new(expected.map { |e| RGL::Edge::UnDirectedEdge.new(*e) })
-    sa = Set.new(matching.undirected_edges)
-    se == sa
-  end
-
-  failure_message do |matching|
-    edges_desc = to_sentence(expected)
-    "expected #{matching.edges} to equal" + edges_desc
-  end
-end