mementus 0.5.5 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72100572fe7d20e4135b4663a269a8d2bd73cc80
-  data.tar.gz: 0b337f00327f6090a323f91eb5450f4f80c692c6
+  metadata.gz: 3d0e0ff3ecc407016774cd2c78afd992296f7a4a
+  data.tar.gz: 0a9d6fcedc13f06dbec244662182cfa0a319fcab
 SHA512:
-  metadata.gz: 271a2b5486669883f8ea63c1cd615418195628481dcc1e939511e218bed016032a03b66cc19d03bb2bb856d603223c5a70fc43d45f0f2e7a9e22eeb76f10b063
-  data.tar.gz: b641562129543c2db046c924ad6fbcabc3cc033bdebe3f127c819ddec5af18ab8d907921f59ac505b20fb66456067b6c65ba67d54aa6125e7914ff31cd6b2a02
+  metadata.gz: 3c8c9a6a494b072019580ad80edf5ddcdf15781b0269e747bf615e9c8eb90235c59d7453daf4b90323ae0bd588565d09b7bbfa742459952f6c8f47a7e8c8ce7a
+  data.tar.gz: 93e7943eca3b04fb38eb957a0cc6c453e6065fefc7137c895279117ff1d8f66920ff18de51582cd920392424895852a0aa017a9007d74efa0917450370b37588

data/lib/mementus/depth_first_search.rb

@@ -13,7 +13,7 @@ module Mementus
     private
 
     def visit(id, &block)
-      @graph.each_adjacent(id) do |adj_node|
+      @graph.adjacent(id).each do |adj_node|
         next if @visited[adj_node.id]
 
         @visited[adj_node.id] = true

data/lib/mementus/edge_proxy.rb

@@ -0,0 +1,32 @@
+module Mementus
+  class EdgeProxy
+    def initialize(edge, graph)
+      @edge = edge
+      @graph = graph
+    end
+
+    def id
+      @edge.id
+    end
+
+    def label
+      @edge.label
+    end
+
+    def [](prop)
+      @edge[prop]
+    end
+
+    def props
+      @edge.props
+    end
+
+    def from
+      @graph.node(@edge.from.id)
+    end
+
+    def to
+      @graph.node(@edge.to.id)
+    end
+  end
+end

data/lib/mementus/graph.rb

@@ -52,20 +52,24 @@ module Mementus
       @structure.nodes(match)
     end
 
-    def adjacent(id)
-      @structure.adjacent(id)
+    def adjacent(id, match=nil)
+      @structure.adjacent(id, match)
     end
 
-    def adjacent_edges(id)
-      @structure.adjacent_edges(id)
+    def incoming(id, match=nil)
+      @structure.incoming(id, match)
     end
 
-    def each_node(&blk)
-      @structure.each_node(&blk)
+    def adjacent_edges(id, match=nil)
+      @structure.adjacent_edges(id, match)
+    end
+
+    def incoming_edges(id, match=nil)
+      @structure.incoming_edges(id, match)
     end
 
-    def each_adjacent(node, &blk)
-      @structure.each_adjacent(node, &blk)
+    def each_node(&blk)
+      @structure.each_node(&blk)
     end
 
     def each_edge(&blk)

data/lib/mementus/node_proxy.rb

@@ -21,20 +21,28 @@ module Mementus
       @node.props
     end
 
+    def out
+      Pipeline::Step.new([self], Pipeline::Pipe.new(@graph), @graph).out_e
+    end
+
     def out_e
-      Pipeline::Step.new(adjacent_edges, Pipeline::Pipe.new(@graph), @graph)
+      Pipeline::Step.new([self], Pipeline::Pipe.new(@graph), @graph).out_e
     end
 
     def each_adjacent(&block)
       @graph.each_adjacent(@node.id, &block)
     end
 
-    def adjacent
-      @graph.adjacent(@node.id)
+    def adjacent(match=nil)
+      @graph.adjacent(@node.id, match)
+    end
+
+    def incoming(match=nil)
+      @graph.incoming(@node.id, match)
     end
 
-    def adjacent_edges
-      @graph.adjacent_edges(@node.id)
+    def adjacent_edges(match=nil)
+      @graph.adjacent_edges(@node.id, match)
     end
   end
 end

data/lib/mementus/pipeline/step.rb

@@ -58,51 +58,36 @@ module Mementus
       end
 
       # Traverse to the outgoing nodes adjacent to the source elements.
-      def out
+      def out(match=nil)
         outgoing_nodes = source.inject([]) do |result, node|
-          result.concat(node.adjacent)
+          result.concat(node.adjacent(match))
         end
 
         Step.new(outgoing_nodes)
       end
 
       # Traverse to the incoming nodes pointing to the source elements.
-      def in
-        incoming_nodes = []
-
-        source.each do |node|
-          graph.each_node do |graph_node|
-            graph.each_adjacent(graph_node.id) do |adj_node|
-              incoming_nodes << graph_node if adj_node.id == node.id
-            end
-          end
+      def in(match=nil)
+        incoming_nodes = source.inject([]) do |result, node|
+          result.concat(node.incoming(match))
         end
 
         Step.new(incoming_nodes)
       end
 
       # Traverse to the outgoing edges from the source elements.
-      def out_e
-        outgoing_edges = []
-
-        source.each do |node|
-          outgoing_edges = graph.each_adjacent(node.id).map do |id|
-            Mementus::Edge.new(from: node, to: id)
-          end
+      def out_e(match=nil)
+        outgoing_edges = source.inject([]) do |result, node|
+          result.concat(graph.adjacent_edges(node.id, match))
         end
 
         Step.new(outgoing_edges)
       end
 
       # Traverse to the incoming edges pointing to the source elements.
-      def in_e
-        ids = source.map(&:id)
-        incoming_edges = []
-
-        graph.each_node do |graph_node|
-          graph.each_adjacent(graph_node.id) do |adj_node|
-            incoming_edges << Mementus::Edge.new(from: graph_node, to: adj_node) if ids.include?(adj_node.id)
-          end
+      def in_e(match=nil)
+        incoming_edges = source.inject([]) do |result, node|
+          result.concat(graph.incoming_edges(node.id, match))
         end
 
         Step.new(incoming_edges)

data/lib/mementus/structure/adjacency_list.rb

@@ -52,19 +52,11 @@ module Mementus
         @index[id].to_a
       end
 
-      def each_node(&blk)
-        nodes.each(&blk)
-      end
-
-      def each_adjacent(id, &blk)
-        @index[id].each(&blk)
-      end
-
       def each_edge(&blk)
         if directed?
-          each_node do |from|
-            each_adjacent(from.id) do |to|
-              yield Edge.new(from: from, to: to)
+          nodes.each do |from|
+            adjacent(from.id).each do |to|
+              yield EdgeProxy.new(Edge.new(from: from, to: to), self)
             end
           end
         else

data/lib/mementus/structure/incidence_list.rb

@@ -43,7 +43,7 @@ module Mementus
         set_node(edge.from) unless has_node?(edge.from)
         set_node(edge.to) unless has_node?(edge.to)
 
-        @edges[edge.id] = edge
+        @edges[edge.id] = EdgeProxy.new(edge, self)
         @outgoing[edge.from.id] << edge.to.id
         @incoming[edge.to.id] << edge.from.id
         @outgoing_e[edge.from.id] << edge.id
@@ -58,10 +58,6 @@ module Mementus
         @nodes[id]
       end
 
-      def each_node(&block)
-        @nodes.values.each(&block)
-      end
-
       def nodes(match=nil)
         return @nodes.values unless match
 
@@ -94,16 +90,62 @@ module Mementus
         end
       end
 
-      def adjacent(id)
-        @nodes.values_at(*@outgoing[id])
+      def adjacent(id, match=nil, direction=:out)
+        directional_index = case direction
+        when :out then @outgoing
+        when :in then @incoming
+        end
+
+        return @nodes.values_at(*directional_index[id]) unless match
+
+        if match.is_a?(Hash)
+          @nodes.values_at(*directional_index[id]).select do |node|
+            key = match.first.first
+            val = match.first.last
+            node[key] == val
+          end
+        elsif match.is_a?(Symbol)
+          @nodes.values_at(*directional_index[id]).select do |node|
+            node.label == match
+          end
+        end
+      end
+
+      def outgoing(id, match=nil)
+        adjacent(id, match, :out)
+      end
+
+      def incoming(id, match=nil)
+        adjacent(id, match, :in)
+      end
+
+      def adjacent_edges(id, match=nil, direction=:out)
+        directional_index = case direction
+        when :out then @outgoing_e
+        when :in then @incoming_e
+        end
+
+        return @edges.values_at(*directional_index[id]) unless match
+
+        if match.is_a?(Hash)
+          @edges.values_at(*directional_index[id]).select do |edge|
+            key = match.first.first
+            val = match.first.last
+            edge[key] == val
+          end
+        elsif match.is_a?(Symbol)
+          @edges.values_at(*directional_index[id]).select do |edge|
+            edge.label == match
+          end
+        end
       end
 
-      def each_adjacent(id, &blk)
-        adjacent(id).each(&blk)
+      def outgoing_edges(id, match=nil)
+        adjacent_edges(id, match, :out)
       end
 
-      def adjacent_edges(id)
-        @edges.values_at(*@outgoing_e[id])
+      def incoming_edges(id, match=nil)
+        adjacent_edges(id, match, :in)
       end
     end
   end

data/lib/mementus/version.rb

@@ -1,3 +1,3 @@
 module Mementus
-  VERSION = '0.5.5'.freeze
+  VERSION = '0.5.6'.freeze
 end

data/lib/mementus.rb

@@ -5,6 +5,7 @@ require 'mementus/structure/incidence_list'
 require 'mementus/node'
 require 'mementus/edge'
 require 'mementus/node_proxy'
+require 'mementus/edge_proxy'
 require 'mementus/pipeline/pipe'
 require 'mementus/pipeline/filter'
 require 'mementus/pipeline/transform'

data/spec/edge_proxy_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Mementus::EdgeProxy do
+  let(:graph) do
+    Mementus::Graph.new do
+      set_edge(edge_1_2)
+      set_edge(edge_1_3)
+    end
+  end
+
+  specify '#from' do
+    edge_proxy = Mementus::EdgeProxy.new(edge_1_2, graph)
+    expect(edge_proxy.from.id).to eq(node_1.id)
+  end
+
+  specify '#to' do
+    edge_proxy = Mementus::EdgeProxy.new(edge_1_2, graph)
+    expect(edge_proxy.to.id).to eq(node_2.id)
+  end
+end

data/spec/pipeline_spec.rb

@@ -26,6 +26,7 @@ describe 'pipeline api' do
         edge.from = 1
         edge.to = 2
         edge.label = :choice
+        edge.props[:name] = 'e3'
       end
 
       create_edge do |edge|
@@ -33,55 +34,114 @@ describe 'pipeline api' do
         edge.from = 2
         edge.to = 4
         edge.label = :choice
+        edge.props[:name] = 'e5'
       end
     end
   end
 
-  it 'traverses from the given node id' do
-    pipeline = graph.n(1)
-    expect(pipeline.id).to eq(1)
-    expect(pipeline.first.id).to eq(1)
-  end
+  describe '#n' do
+    it 'traverses from the given node id' do
+      pipeline = graph.n(1)
+      expect(pipeline.id).to eq(1)
+      expect(pipeline.first.id).to eq(1)
+    end
 
-  it 'traverses from the given node match' do
-    pipeline = graph.n(name: 'one')
-    expect(pipeline.id).to eq(1)
-    expect(pipeline.first.id).to eq(1)
-  end
+    it 'traverses from the given label match' do
+      pipeline = graph.n(:passage)
+      expect(pipeline.id).to eq([1, 2, 4])
+      expect(pipeline.first.id).to eq(1)
+    end
 
-  it 'traverses from the given label match' do
-    pipeline = graph.n(:passage)
-    expect(pipeline.id).to eq([1, 2, 4])
-    expect(pipeline.first.id).to eq(1)
+    it 'traverses from the given prop match' do
+      pipeline = graph.n(name: 'one')
+      expect(pipeline.id).to eq(1)
+      expect(pipeline.first.id).to eq(1)
+    end
   end
 
-  it 'traverses to outgoing nodes' do
-    pipeline = graph.n(1).out
-    expect(pipeline.all.count).to eq(1)
-    expect(pipeline.all.first.id).to eq(2)
-  end
+  describe '#out' do
+    it 'traverses to outgoing nodes' do
+      pipeline = graph.n(1).out
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(2)
+    end
 
-  it 'traverses to second-degree outgoing nodes' do
-    pipeline = graph.n(1).out.out
-    expect(pipeline.all.count).to eq(1)
-    expect(pipeline.all.first.id).to eq(4)
+    it 'traverses to outgoing nodes matching label' do
+      pipeline = graph.n(1).out(:passage)
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(2)
+    end
+
+    it 'traverses to outgoing nodes matching filter' do
+      pipeline = graph.n(1).out(name: 'two')
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(2)
+    end
+
+    it 'traverses to second-degree outgoing nodes' do
+      pipeline = graph.n(1).out.out
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(4)
+    end
   end
 
-  it 'traverses to outgoing edges' do
-    pipeline = graph.n(1).out_e
-    expect(pipeline.all.count).to eq(1)
-    expect(pipeline.all.first.to.id).to eq(2)
+  describe '#out_e' do
+    it 'traverses to outgoing edges' do
+      pipeline = graph.n(1).out_e
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.to.id).to eq(2)
+    end
+
+    it 'traverses to outgoing edges matching label' do
+      pipeline = graph.n(1).out_e(:choice)
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.to.id).to eq(2)
+    end
+
+    it 'traverses to outgoing edges matching filter' do
+      pipeline = graph.n(1).out_e(name: 'e3')
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.to.id).to eq(2)
+    end
   end
 
-  it 'traverses to incoming nodes' do
-    pipeline = graph.n(2).in
-    expect(pipeline.all.count).to eq(1)
-    expect(pipeline.all.first.id).to eq(1)
+  describe '#in' do
+    it 'traverses to incoming nodes' do
+      pipeline = graph.n(2).in
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(1)
+    end
+
+    it 'traverses to incoming nodes matching label' do
+      pipeline = graph.n(2).in(:passage)
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(1)
+    end
+
+    it 'traverses to incoming nodes matching filter' do
+      pipeline = graph.n(2).in(name: 'one')
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.id).to eq(1)
+    end
   end
 
-  it 'traverses to incoming edges' do
-    pipeline = graph.n(2).in_e
-    expect(pipeline.all.count).to eq(1)
-    expect(pipeline.all.first.from.id).to eq(1)
+  describe '#in_e' do
+    it 'traverses to incoming edges' do
+      pipeline = graph.n(2).in_e
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.from.id).to eq(1)
+    end
+
+    it 'traverses to incoming edges matching label' do
+      pipeline = graph.n(2).in_e(:choice)
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.from.id).to eq(1)
+    end
+
+    it 'traverses to incoming edges matching filter' do
+      pipeline = graph.n(2).in_e(name: 'e3')
+      expect(pipeline.all.count).to eq(1)
+      expect(pipeline.all.first.from.id).to eq(1)
+    end
   end
 end

data/spec/structure/adjacency_list_spec.rb

@@ -0,0 +1,9 @@
+require_relative 'indexed_graph_example'
+
+describe Mementus::Structure::AdjacencyList do
+  let(:structure) do
+    Mementus::Structure::AdjacencyList.new
+  end
+
+  it_behaves_like 'an indexed graph data structure'
+end

data/spec/structure/directed_graph_example.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+shared_examples_for 'a directed graph data structure' do
+  it 'enumerates outgoing nodes from the given node' do
+    edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+    structure.set_edge(edge)
+
+    expect(structure.outgoing(1).first.id).to eq(2)
+  end
+
+  it 'enumerates outgoing edges from the given node' do
+    edge = Mementus::Edge.new(id: 3, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+    structure.set_edge(edge)
+
+    expect(structure.outgoing_edges(1).first.id).to eq(3)
+  end
+
+  it 'enumerates incoming nodes from the given node' do
+    edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+    structure.set_edge(edge)
+
+    expect(structure.incoming(2).first.id).to eq(1)
+  end
+
+  it 'enumerates incoming edges from the given node' do
+    edge = Mementus::Edge.new(id: 3, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+    structure.set_edge(edge)
+
+    expect(structure.incoming_edges(2).first.id).to eq(3)
+  end
+end

data/spec/structure/incidence_list_spec.rb

@@ -0,0 +1,13 @@
+require_relative 'indexed_graph_example'
+require_relative 'directed_graph_example'
+require_relative 'property_graph_example'
+
+describe Mementus::Structure::IncidenceList do
+  let(:structure) do
+    Mementus::Structure::IncidenceList.new
+  end
+
+  it_behaves_like 'an indexed graph data structure'
+  it_behaves_like 'a directed graph data structure'
+  it_behaves_like 'a property graph data structure'
+end

data/spec/structure/indexed_graph_example.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+shared_examples_for "an indexed graph data structure" do
+  describe '#new' do
+    it 'starts with empty node list' do
+      expect(structure.nodes_count).to eq(0)
+    end
+
+    it 'starts with empty edge list' do
+      expect(structure.edges_count).to eq(0)
+    end
+  end
+
+  describe '#set_node' do
+    it 'assigns a node object to the graph' do
+      structure.set_node(Mementus::Node.new(id: 1))
+
+      expect(structure.nodes_count).to eq(1)
+      expect(structure.edges_count).to eq(0)
+    end
+  end
+
+  describe '#set_edge' do
+    it 'adds an edge object to the graph' do
+      structure.set_edge(Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2)))
+
+      expect(structure.nodes_count).to eq(2)
+      expect(structure.edges_count).to eq(1)
+    end
+  end
+
+  describe '#has_node?' do
+    it 'tests for the presence of a given node' do
+      node = Mementus::Node.new(id: 1)
+      structure.set_node(node)
+
+      expect(structure.has_node?(node)).to be true
+    end
+  end
+
+  describe '#has_edge?' do
+    it 'tests for the presence of a given edge' do
+      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      expect(structure.has_edge?(edge)).to be true
+    end
+  end
+
+  describe '#node(id)' do
+    it 'finds a node by id' do
+      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      expect(structure.node(1).id).to eq(edge.from.id)
+    end
+  end
+
+  describe '#nodes' do
+    it 'lists all nodes in the graph' do
+      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      expect(structure.nodes.first.id).to eq(edge.from.id)
+      expect(structure.nodes.last.id).to eq(edge.to.id)
+    end
+  end
+end

data/spec/structure/property_graph_example.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+shared_examples_for 'a property graph data structure' do
+  describe '#nodes(match)' do
+    it 'matches all nodes with the given prop' do
+      structure.set_node(Mementus::Node.new(id: 1, props: { tag: 'point'}))
+      structure.set_node(Mementus::Node.new(id: 2, props: { tag: 'point'}))
+      structure.set_node(Mementus::Node.new(id: 3))
+
+      structure.nodes(tag: 'point').tap do |matched|
+        expect(matched.first.id).to eq(1)
+        expect(matched.last.id).to eq(2)
+      end
+    end
+
+    it 'matches all nodes with the given label' do
+      structure.set_node(Mementus::Node.new(id: 1, label: :point))
+      structure.set_node(Mementus::Node.new(id: 2, label: :point))
+      structure.set_node(Mementus::Node.new(id: 3))
+
+      structure.nodes(:point).tap do |matched|
+        expect(matched.first.id).to eq(1)
+        expect(matched.last.id).to eq(2)
+      end
+    end
+  end
+
+  describe '#edges' do
+    it 'lists all edges in the graph' do
+      edge = Mementus::Edge.new(id: 3, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      structure.edges.tap do |matched|
+        expect(matched.first.id).to eq(edge.id)
+        expect(matched.first.from.id).to eq(edge.from.id)
+        expect(matched.first.to.id).to eq(edge.to.id)
+      end
+    end
+  end
+
+  describe '#edges(match)' do
+    it 'matches all edges with the given prop' do
+      edge = Mementus::Edge.new(props: { tag: 'link' }, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      structure.edges(tag: 'link').tap do |matched|
+        expect(matched.first.id).to eq(edge.id)
+        expect(matched.first.from.id).to eq(edge.from.id)
+        expect(matched.first.to.id).to eq(edge.to.id)
+      end
+    end
+
+    it 'matches all edges with the given label' do
+      edge = Mementus::Edge.new(label: :link, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
+      structure.set_edge(edge)
+
+      structure.edges(:link).tap do |matched|
+        expect(matched.first.id).to eq(edge.id)
+        expect(matched.first.from.id).to eq(edge.from.id)
+        expect(matched.first.to.id).to eq(edge.to.id)
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mementus
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.5.6
 platform: ruby
 authors:
 - maetl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-10 00:00:00.000000000 Z
+date: 2016-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - lib/mementus/direction.rb
 - lib/mementus/edge.rb
 - lib/mementus/edge_builder.rb
+- lib/mementus/edge_proxy.rb
 - lib/mementus/element_builder.rb
 - lib/mementus/graph.rb
 - lib/mementus/graph_builder.rb
@@ -94,6 +95,7 @@ files:
 - lib/mementus/version.rb
 - mementus.gemspec
 - spec/direction_spec.rb
+- spec/edge_proxy_spec.rb
 - spec/edge_spec.rb
 - spec/graph_spec.rb
 - spec/herschel_spec.rb
@@ -103,7 +105,11 @@ files:
 - spec/pipeline/step_spec.rb
 - spec/pipeline_spec.rb
 - spec/spec_helper.rb
-- spec/structure_spec.rb
+- spec/structure/adjacency_list_spec.rb
+- spec/structure/directed_graph_example.rb
+- spec/structure/incidence_list_spec.rb
+- spec/structure/indexed_graph_example.rb
+- spec/structure/property_graph_example.rb
 - spec/traversal_spec.rb
 homepage: https://github.com/maetl/mementus
 licenses:
@@ -125,12 +131,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Graph data structure toolkit for Ruby applications.
 test_files:
 - spec/direction_spec.rb
+- spec/edge_proxy_spec.rb
 - spec/edge_spec.rb
 - spec/graph_spec.rb
 - spec/herschel_spec.rb
@@ -140,5 +147,9 @@ test_files:
 - spec/pipeline/step_spec.rb
 - spec/pipeline_spec.rb
 - spec/spec_helper.rb
-- spec/structure_spec.rb
+- spec/structure/adjacency_list_spec.rb
+- spec/structure/directed_graph_example.rb
+- spec/structure/incidence_list_spec.rb
+- spec/structure/indexed_graph_example.rb
+- spec/structure/property_graph_example.rb
 - spec/traversal_spec.rb

data/spec/structure_spec.rb

@@ -1,145 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "a mutable graph data structure" do
-  describe '#new' do
-    it 'starts with empty node list' do
-      expect(structure.nodes_count).to eq(0)
-    end
-
-    it 'starts with empty edge list' do
-      expect(structure.edges_count).to eq(0)
-    end
-  end
-
-  describe '#set_node' do
-    it 'assigns a node object to the graph' do
-      structure.set_node(Mementus::Node.new(id: 1))
-
-      expect(structure.nodes_count).to eq(1)
-      expect(structure.edges_count).to eq(0)
-    end
-  end
-
-  describe '#set_edge' do
-    it 'adds an edge object to the graph' do
-      structure.set_edge(Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2)))
-
-      expect(structure.nodes_count).to eq(2)
-      expect(structure.edges_count).to eq(1)
-    end
-  end
-
-  describe '#has_node?' do
-    it 'tests for the presence of a given node' do
-      node = Mementus::Node.new(id: 1)
-      structure.set_node(node)
-
-      expect(structure.has_node?(node)).to be true
-    end
-  end
-
-  describe '#has_edge?' do
-    it 'tests for the presence of a given edge' do
-      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      expect(structure.has_edge?(edge)).to be true
-    end
-  end
-
-  describe '#node(id)' do
-    it 'finds a node by id' do
-      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      expect(structure.node(1).id).to eq(edge.from.id)
-    end
-  end
-
-  describe '#nodes' do
-    it 'lists all nodes in the graph' do
-      edge = Mementus::Edge.new(from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      expect(structure.nodes.first.id).to eq(edge.from.id)
-      expect(structure.nodes.last.id).to eq(edge.to.id)
-    end
-  end
-end
-
-describe Mementus::Structure::AdjacencyList do
-  let(:structure) do
-    Mementus::Structure::AdjacencyList.new
-  end
-
-  it_behaves_like "a mutable graph data structure"
-end
-
-describe Mementus::Structure::IncidenceList do
-  let(:structure) do
-    Mementus::Structure::IncidenceList.new
-  end
-
-  it_behaves_like "a mutable graph data structure"
-
-  describe '#nodes(match)' do
-    it 'matches all nodes with the given prop' do
-      structure.set_node(Mementus::Node.new(id: 1, props: { tag: 'point'}))
-      structure.set_node(Mementus::Node.new(id: 2, props: { tag: 'point'}))
-      structure.set_node(Mementus::Node.new(id: 3))
-
-      structure.nodes(tag: 'point').tap do |matched|
-        expect(matched.first.id).to eq(1)
-        expect(matched.last.id).to eq(2)
-      end
-    end
-
-    it 'matches all nodes with the given label' do
-      structure.set_node(Mementus::Node.new(id: 1, label: :point))
-      structure.set_node(Mementus::Node.new(id: 2, label: :point))
-      structure.set_node(Mementus::Node.new(id: 3))
-
-      structure.nodes(:point).tap do |matched|
-        expect(matched.first.id).to eq(1)
-        expect(matched.last.id).to eq(2)
-      end
-    end
-  end
-
-  describe '#edges' do
-    it 'lists all edges in the graph' do
-      edge = Mementus::Edge.new(id: 3, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      structure.edges.tap do |matched|
-        expect(matched.first.id).to eq(edge.id)
-        expect(matched.first.from.id).to eq(edge.from.id)
-        expect(matched.first.to.id).to eq(edge.to.id)
-      end
-    end
-  end
-
-  describe '#edges(match)' do
-    it 'matches all edges with the given prop' do
-      edge = Mementus::Edge.new(props: { tag: 'link' }, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      structure.edges(tag: 'link').tap do |matched|
-        expect(matched.first.id).to eq(edge.id)
-        expect(matched.first.from.id).to eq(edge.from.id)
-        expect(matched.first.to.id).to eq(edge.to.id)
-      end
-    end
-
-    it 'matches all edges with the given label' do
-      edge = Mementus::Edge.new(label: :link, from: Mementus::Node.new(id: 1), to: Mementus::Node.new(id: 2))
-      structure.set_edge(edge)
-
-      structure.edges(:link).tap do |matched|
-        expect(matched.first.id).to eq(edge.id)
-        expect(matched.first.from.id).to eq(edge.from.id)
-        expect(matched.first.to.id).to eq(edge.to.id)
-      end
-    end
-  end
-end