dag 0.0.4 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0902242dbbc24972c53aff3dff22f001f7db4f9d
+  data.tar.gz: 42d773c5d7036e62f8727bdbbe6b63e8f97dcee1
+SHA512:
+  metadata.gz: a15741d978e1d0e89a19af621342a786acabf96e28a820bb7582ad619e87641c052d6667553d4f3f2da8e68588073e9b4cc0750a83b8849b3537c44f2483fe78
+  data.tar.gz: a43973369d8803cf5948683c7e3a86b0fbc5d7cf624c565de8cc294d11b00139c38d1ac4118c2d921175ac45322ec4c8c0693931b36c26148eb95946989f4066

data/Gemfile

@@ -1,9 +1,2 @@
-source :rubygems
+source 'https://rubygems.org'
 gemspec
-
-group :test do
-  gem 'rspec', '~> 2.12'
-  gem 'rake', '~> 10.0.1'
-  gem 'simplecov', :require => false
-end
-

data/Gemfile.lock

@@ -1,32 +1,30 @@
 PATH
   remote: .
   specs:
-    dag (0.0.3)
+    dag (0.0.5)
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    diff-lcs (1.2.2)
-    multi_json (1.7.2)
-    rake (10.0.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.0)
-    simplecov (0.7.1)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
+    diff-lcs (1.2.5)
+    rake (10.4.2)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   dag!
-  rake (~> 10.0.1)
-  rspec (~> 2.12)
-  simplecov
+  rake (~> 10)
+  rspec (~> 3)

data/lib/dag/vertex.rb

@@ -39,7 +39,7 @@ class DAG
     #
     def has_path_to?(other)
       raise ArgumentError.new('You must supply a vertex in this DAG') unless
-        other && Vertex === other && other.dag == self.dag
+        is_vertex_in_my_dag?(other)
       successors.include?(other) || successors.any? {|v| v.has_path_to?(other) }
     end
 
@@ -54,7 +54,7 @@ class DAG
     #
     def has_ancestor?(other)
       raise ArgumentError.new('You must supply a vertex in this DAG') unless
-        other && Vertex === other && other.dag == self.dag
+        is_vertex_in_my_dag?(other)
       predecessors.include?(other) || predecessors.any? {|v| v.has_ancestor?(other) }
     end
 
@@ -71,6 +71,31 @@ class DAG
       @payload[key]
     end
 
+    def ancestors(result_set = Set.new)
+      predecessors.each do |v|
+        unless result_set.include? v
+          result_set.add(v)
+          v.ancestors(result_set)
+        end
+      end
+      return result_set
+    end
+
+    def descendants(result_set = Set.new)
+      successors.each do |v|
+        unless result_set.include? v
+          result_set.add(v)
+          v.descendants(result_set)
+        end
+      end
+      return result_set
+    end
+
+    private
+
+    def is_vertex_in_my_dag?(v)
+      v.kind_of?(Vertex) and v.dag == self.dag
+    end
   end
 
 end

data/lib/dag.rb

@@ -2,7 +2,7 @@ require_relative 'dag/vertex'
 
 class DAG
 
-  Edge = Struct.new(:origin, :destination)
+  Edge = Struct.new(:origin, :destination, :properties)
 
   attr_reader :vertices, :edges
 
@@ -28,13 +28,64 @@ class DAG
   def add_edge(attrs)
     origin = attrs[:origin] || attrs[:source] || attrs[:from] || attrs[:start]
     destination = attrs[:destination] || attrs[:sink] || attrs[:to] || attrs[:end]
+    properties = attrs[:properties] || {}
     raise ArgumentError.new('Origin must be a vertex in this DAG') unless
-      origin && Vertex === origin && origin.dag == self
+      is_my_vertex?(origin)
     raise ArgumentError.new('Destination must be a vertex in this DAG') unless
-     destination && Vertex === destination && destination.dag == self
+      is_my_vertex?(destination)
     raise ArgumentError.new('A DAG must not have cycles') if origin == destination
     raise ArgumentError.new('A DAG must not have cycles') if destination.has_path_to?(origin)
-    Edge.new(origin, destination).tap {|e| @edges << e }
+    Edge.new(origin, destination, properties).tap {|e| @edges << e }
+  end
+
+  def subgraph(predecessors_of = [], successors_of = [])
+
+
+    (predecessors_of + successors_of).each { |v|
+      raise ArgumentError.new('You must supply a vertex in this DAG') unless
+        is_my_vertex?(v)
+      }
+
+    result = DAG.new({mixin: @mixin})
+    vertex_mapping = {}
+
+    # Get the set of predecessors verticies and add a copy to the result
+    predecessors_set = Set.new(predecessors_of)
+    predecessors_of.each { |v| v.ancestors(predecessors_set) }
+
+    predecessors_set.each do |v|
+      vertex_mapping[v] = result.add_vertex(payload=v.payload)
+    end
+
+    # Get the set of successor vertices and add a copy to the result
+    successors_set = Set.new(successors_of)
+    successors_of.each { |v| v.descendants(successors_set) }
+
+    successors_set.each do |v|
+      vertex_mapping[v] = result.add_vertex(payload=v.payload) unless vertex_mapping.include? v
+    end
+
+    # get the unique edges
+    edge_set = (
+      predecessors_set.flat_map(&:incoming_edges) +
+      successors_set.flat_map(&:outgoing_edges)
+    ).uniq
+
+    # Add them to the result via the vertex mapping
+    edge_set.each do |e|
+      result.add_edge(
+        from: vertex_mapping[e.origin],
+        to: vertex_mapping[e.destination],
+        properties: e.properties)
+    end
+
+    return result
+  end
+
+  private
+
+  def is_my_vertex?(v)
+    v.kind_of?(Vertex) and v.dag == self
   end
 
 end

data/spec/lib/dag/vertex_spec.rb

@@ -31,18 +31,18 @@ describe DAG::Vertex do
     subject { dag.add_vertex(name: 'Fred', size: 34) }
 
     it 'allows the payload to be accessed' do
-      subject[:name].should == 'Fred'
-      subject[:size].should == 34
-      subject.payload.should == {name: 'Fred', size: 34}
+      expect(subject[:name]).to eq('Fred')
+      expect(subject[:size]).to eq(34)
+      expect(subject.payload).to eq({name: 'Fred', size: 34})
     end
 
     it 'returns nil for missing payload key' do
-      subject[56].should be_nil
+      expect(subject[56]).to be_nil
     end
 
     it 'allows the payload to be changed' do
       subject.payload[:another] = 'ha'
-      subject[:another].should == 'ha'
+      expect(subject[:another]).to eq('ha')
     end
   end
 
@@ -52,25 +52,30 @@ describe DAG::Vertex do
       dag.add_edge from: v2, to: subject
     end
 
-    its(:predecessors) { should =~ [v1, v2] }
-    its(:successors) { should == [] }
+    it 'has the correct predecessors' do
+      expect(subject.predecessors).to eq([v1, v2])
+    end
+
+    it 'has no successors' do
+      expect(subject.successors).to be_empty
+    end
 
     it 'has no paths to its predecessors' do
-      subject.has_path_to?(v1).should be_false
-      subject.has_path_to?(v2).should be_false
+      expect(subject.has_path_to?(v1)).to be_falsey
+      expect(subject.has_path_to?(v2)).to be_falsey
     end
 
     context 'with multiple paths' do
       it 'lists each predecessor only once' do
         dag.add_edge from: v1, to: subject
-        subject.predecessors.should == [v1, v2]
+        expect(subject.predecessors).to eq([v1, v2])
       end
     end
 
     it 'has the correct ancestors' do
-      subject.has_ancestor?(v1).should be_true
-      subject.has_ancestor?(v2).should be_true
-      subject.has_ancestor?(v3).should be_false
+      expect(subject.has_ancestor?(v1)).to be_truthy
+      expect(subject.has_ancestor?(v2)).to be_truthy
+      expect(subject.has_ancestor?(v3)).to be_falsey
     end
   end
 
@@ -80,24 +85,29 @@ describe DAG::Vertex do
       dag.add_edge from: subject, to: v2
     end
 
-    its(:predecessors) { should == [] }
-    its(:successors) { should =~ [v1, v2] }
+    it 'has no predecessors' do
+      expect(subject.predecessors).to be_empty
+    end
+
+    it 'has the correct successors' do
+      expect(subject.successors).to eq([v1, v2])
+    end
 
     it 'has paths to its successors' do
-      subject.has_path_to?(v1).should be_true
-      subject.has_path_to?(v2).should be_true
+      expect(subject.has_path_to?(v1)).to be_truthy
+      expect(subject.has_path_to?(v2)).to be_truthy
     end
 
     context 'with multiple paths' do
       it 'lists each successor only once' do
         dag.add_edge from: subject, to: v1
-        subject.successors.should == [v1, v2]
+        expect(subject.successors).to eq([v1, v2])
       end
     end
 
     it 'has no ancestors' do
-      subject.has_ancestor?(v1).should be_false
-      subject.has_ancestor?(v2).should be_false
+      expect(subject.has_ancestor?(v1)).to be_falsey
+      expect(subject.has_ancestor?(v2)).to be_falsey
     end
   end
 
@@ -108,17 +118,29 @@ describe DAG::Vertex do
     end
 
     it 'has a deep path to v2' do
-      subject.has_path_to?(v2).should be_true
+      expect(subject.has_path_to?(v2)).to be_truthy
     end
 
     it 'has no path to v3' do
-      subject.has_path_to?(v3).should be_false
+      expect(subject.has_path_to?(v3)).to be_falsey
     end
 
     it 'recognises that it is an ancestor of v2' do
-      v2.has_ancestor?(subject).should be_true
+      expect(v2.has_ancestor?(subject)).to be_truthy
+    end
+
+    it 'is known to all descendants' do
+      expect(v2.ancestors).to eq(Set.new([v1, subject]))
+    end
+
+    it 'knows has no ancestors' do
+      expect(subject.ancestors).to eq(Set.new())
     end
+
+    it 'knows has all descendants' do
+      expect(subject.descendants).to eq(Set.new([v1, v2]))
+    end
+
   end
 
 end
-

data/spec/lib/dag_spec.rb

@@ -2,21 +2,21 @@ require 'spec_helper'
 
 describe DAG do
 
-  context 'when new' do
-    its(:vertices) { should be_empty }
-    its(:edges) { should be_empty }
+  it 'when new' do
+    expect(subject.vertices).to be_empty
+    expect(subject.edges).to be_empty
   end
 
   context 'with one vertex' do
     it 'has only that vertex' do
       v = subject.add_vertex
-      subject.vertices.should == [v]
+      expect(subject.vertices).to eq([v])
     end
 
     it 'has no edges' do
       v = subject.add_vertex
-      v.outgoing_edges.should be_empty
-      v.incoming_edges.should be_empty
+      expect(v.outgoing_edges).to be_empty
+      expect(v.incoming_edges).to be_empty
     end
   end
 
@@ -31,11 +31,11 @@ describe DAG do
     end
 
     it 'mixes the module into evey vertex' do
-      (Thing === v).should be_true
+      expect((Thing === v)).to be_truthy
     end
 
     it 'allows the module to access the payload' do
-      v.my_name.should == 'Fred'
+      expect(v.my_name).to eq('Fred')
     end
   end
 
@@ -47,21 +47,30 @@ describe DAG do
       let!(:e1) { subject.add_edge(origin: v1, destination: v2) }
 
       it 'leaves the origin vertex' do
-        v1.outgoing_edges.should == [e1]
+        expect(v1.outgoing_edges).to eq([e1])
       end
 
       it 'arrives at the destination vertex' do
-        v2.incoming_edges.should == [e1]
+        expect(v2.incoming_edges).to eq([e1])
       end
 
       it 'adds no other edges' do
-        v1.incoming_edges.should be_empty
-        v2.outgoing_edges.should be_empty
+        expect(v1.incoming_edges).to be_empty
+        expect(v2.outgoing_edges).to be_empty
+      end
+
+      it 'it has no properties' do
+        expect(e1.properties).to be_empty
       end
 
       it 'allows multiple edges between a pair of vertices' do
         expect { subject.add_edge(origin: v1, destination: v2) }.to_not raise_error
       end
+
+      it 'can specify properties' do
+        e2 = subject.add_edge(origin: v1, destination: v2, properties: {foo: 'bar'})
+        expect(e2.properties[:foo]).to eq('bar')
+      end
     end
 
     context 'when invalid' do
@@ -105,20 +114,82 @@ describe DAG do
       let!(:e1) { subject.add_edge(origin: v1, destination: v2) }
 
       it 'allows :source and :sink' do
-        subject.add_edge(source: v1, sink: v2).should == e1
+        expect(subject.add_edge(source: v1, sink: v2)).to eq(e1)
       end
 
       it 'allows :from and :to' do
-        subject.add_edge(from: v1, to: v2).should == e1
+        expect(subject.add_edge(from: v1, to: v2)).to eq(e1)
       end
 
       it 'allows :start and :end' do
-        subject.add_edge(start: v1, end: v2).should == e1
+        expect(subject.add_edge(start: v1, end: v2)).to eq(e1)
       end
 
     end
 
   end
 
-end
+  context 'given a dag' do
+    subject { DAG.new(mixin: Thing) }
+    module Thing
+      def my_name
+        payload[:name]
+      end
+    end
+
+    let(:joe) { subject.add_vertex(name: "joe") }
+    let(:bob) { subject.add_vertex(name: "bob") }
+    let(:jane) { subject.add_vertex(name: "jane") }
+    let!(:e1) { subject.add_edge(origin: joe, destination: bob, properties: {name: "father of"} ) }
+    let!(:e2) { subject.add_edge(origin: joe, destination: jane) }
+    let!(:e3) { subject.add_edge(origin: bob, destination: jane) }
+
+    describe '.subgraph' do
+      it 'returns a graph' do
+        expect(subject.subgraph()).to be_an_instance_of(DAG)
+      end
+
+      it 'of joe and his ancestors' do
+        subgraph = subject.subgraph([joe,],[])
+        expect(subgraph.vertices.length).to eq(1)
+        expect(subgraph.vertices[0].my_name).to eq("joe")
+        expect(subgraph.edges).to be_empty
+      end
 
+      it 'of joe and his descendants' do
+        subgraph = subject.subgraph([],[joe,])
+        expect(Set.new(subgraph.vertices.map(&:my_name))).to eq(Set.new(["joe","bob","jane"]))
+        expect(subgraph.edges.length).to eq(3)
+      end
+
+      it 'of Jane and her ancestors' do
+        subgraph = subject.subgraph([jane,],[])
+        expect(Set.new(subgraph.vertices.map(&:my_name))).to eq(Set.new(["joe","bob","jane"]))
+        expect(subgraph.edges.length).to eq(3)
+      end
+
+      it 'of jane and her descendants' do
+        subgraph = subject.subgraph([],[jane,])
+        expect(Set.new(subgraph.vertices.map(&:my_name))).to eq(Set.new(["jane"]))
+        expect(subgraph.edges).to be_empty
+      end
+
+      it 'of bob and his descendants' do
+        subgraph = subject.subgraph([],[bob,])
+        expect(Set.new(subgraph.vertices.map(&:my_name))).to eq(Set.new(["bob","jane"]))
+        expect(subgraph.edges.length).to eq(1)
+      end
+
+      it 'there is something incestuous going on here' do
+        subgraph = subject.subgraph([bob,],[bob,])
+        expect(Set.new(subgraph.vertices.map(&:my_name))).to eq(Set.new(["bob","jane","joe"]))
+        expect(subgraph.edges.length).to eq(2)
+        expect(subgraph.edges[0].properties).to eq({name: "father of"})
+        expect(subgraph.edges[1].properties).to eq({})
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -1,9 +1,3 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'simplecov'
-
-SimpleCov.start
-
 require 'dag'
-
-

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dag
 version: !ruby/object:Gem::Version
-  version: 0.0.4
-  prerelease: 
+  version: 0.0.5
 platform: ruby
 authors:
 - Kevin Rutherford
@@ -14,59 +13,39 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.1
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.1
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.12'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.12'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 description: Directed acyclic graphs
 email: kevin@rutherford-software.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .rspec
-- .yardopts
+- ".rspec"
+- ".yardopts"
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -78,27 +57,26 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/kevinrutherford/dag
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Directed acyclic graphs
 test_files:
 - spec/lib/dag/vertex_spec.rb