mementus 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a13c8d4774fbdfad2b26d1180ae51cf1befb116
-  data.tar.gz: c58bafb8b1aeb71e7179bc64947809537e7c90e7
+  metadata.gz: ea57a98cf767959744e32832bb22a99d7c24bca7
+  data.tar.gz: ab44885dd4005e78bc6638fc7bd2e82b4cc09df6
 SHA512:
-  metadata.gz: a4973b6f437b39fbbd0d01dbc9a296ed26cb60e4d18554c9c78fc41d4cc6140edc6847e117afcd690b2088485e08e6c4d7c74c688f1162e19654c850568240f4
-  data.tar.gz: 43cb0c147dbaebb0964b5896432915aec14b16f34f64b25e6e55b678345adfcba016e4648a06c4c2a8fecb439b17b8964c22783d959fded2340599984fafc023
+  metadata.gz: b82452696af8da7cd562a3e664689707bf0cb065d977ee33e1741845d9e1cc73fcb44d0d08d899eeb7de9362e9294b52c97274b524327d1b680be211c11d6c28
+  data.tar.gz: a52150325b2783d8e925010e8184329d219a6c15d0766ad3fa83e00a5b98f0776441013e527bdfd3f84804fdacaf304be9b53c148621e0adce85ad90a7a3f7b9

data/lib/mementus/graph.rb

@@ -10,10 +10,6 @@ module Mementus
       @structure = builder.graph
     end
 
-    def query
-      Query::Source.new(self)
-    end
-
     def nodes_count
       @structure.nodes_count
     end
@@ -27,7 +23,7 @@ module Mementus
     end
 
     def n(id)
-      Processor.new(self, Pipes::Node.new(id))
+      Pipeline::Step.new([node(id)], Pipeline::Pipe.new(self), self)
     end
 
     def has_node?(node)
@@ -54,6 +50,10 @@ module Mementus
       @structure.adjacent(id)
     end
 
+    def adjacent_edges(id)
+      @structure.adjacent_edges(id)
+    end
+
     def each_node(&blk)
       @structure.each_node(&blk)
     end

data/lib/mementus/library/herschel_graph.rb

@@ -1,22 +1,22 @@
-# The Herschel graph is a bipartite undirected graph with 11 vertices and
-# 18 edges, the smallest non-Hamiltonian polyhedral graph.
-#
-#         __________(blue-1)__________
-#        /          /      \          \
-#       /          /        \          \
-#      /       (red-1)    (red-2)       \
-#     /         /  \        /  \         \
-#    /         /    \      /    \         \
-# (red-3)--(blue-2) (blue-3) (blue-4)---(red-4)
-#    \         \    /      \    /         /
-#     \         \  /        \  /         /
-#      \       (red-5)    (red-6)       /
-#       \          \        /          /
-#        \          \      /          /
-#         \_________(blue-5)_________/
-#
 module Mementus
   module Library
+    # The Herschel graph is a bipartite undirected graph with 11 vertices and
+    # 18 edges, the smallest non-Hamiltonian polyhedral graph.
+    #
+    #         __________(blue-1)__________
+    #        /          /      \          \
+    #       /          /        \          \
+    #      /       (red-1)    (red-2)       \
+    #     /         /  \        /  \         \
+    #    /         /    \      /    \         \
+    # (red-3)--(blue-2) (blue-3) (blue-4)---(red-4)
+    #    \         \    /      \    /         /
+    #     \         \  /        \  /         /
+    #      \       (red-5)    (red-6)       /
+    #       \          \        /          /
+    #        \          \      /          /
+    #         \_________(blue-5)_________/
+    #
     class HerschelGraph < Graph
       def self.instance
         self.new do

data/lib/mementus/library/story_graph.rb

@@ -0,0 +1,45 @@
+module Mementus
+  module Library
+    # Demo of an interactive fiction story with passages represented as nodes
+    # and choices represented as edges.
+    class StoryGraph < Graph
+      def self.instance
+        self.new do
+          create_node do |node|
+            node.id = "start"
+            node.label = :passage
+            node.props[:text] = "The start of a story."
+          end
+
+          create_node do |node|
+            node.id = "happy-ending"
+            node.label = :passage
+            node.props[:text] = "A happy ending."
+          end
+
+          create_node do |node|
+            node.id = "tragic-ending"
+            node.label = :passage
+            node.props[:text] = "A tragic ending."
+          end
+
+          create_edge do |edge|
+            edge.id = "happy-choice"
+            edge.label = :choice
+            edge.from = "start"
+            edge.to = "happy-ending"
+            edge.props[:text] = "Choose wisely."
+          end
+
+          create_edge do |edge|
+            edge.id = "tragic-choice"
+            edge.label = :choice
+            edge.from = "start"
+            edge.to = "tragic-ending"
+            edge.props[:text] = "Choose poorly."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mementus/node.rb

@@ -1,6 +1,6 @@
 module Mementus
   class Node
-    attr_reader :id, :label
+    attr_reader :id, :label, :props
 
     def initialize(id: nil, label: nil, props: {})
       @id = id

data/lib/mementus/node_proxy.rb

@@ -17,6 +17,14 @@ module Mementus
       @node[prop]
     end
 
+    def props
+      @node.props
+    end
+
+    def out_e
+      Pipeline::Step.new(adjacent_edges, Pipeline::Pipe.new(@graph), @graph)
+    end
+
     def each_adjacent(&block)
       @graph.each_adjacent(@node.id, &block)
     end
@@ -24,5 +32,9 @@ module Mementus
     def adjacent
       @graph.adjacent(@node.id)
     end
+
+    def adjacent_edges
+      @graph.adjacent_edges(@node.id)
+    end
   end
 end

data/lib/mementus/pipeline/filter.rb

@@ -0,0 +1,9 @@
+module Mementus
+  module Pipeline
+    class Filter < Pipe
+      def call(element)
+        Fiber.yield(element) if process(element)
+      end
+    end
+  end
+end

data/lib/mementus/pipeline/pipe.rb

@@ -0,0 +1,23 @@
+module Mementus
+  module Pipeline
+    # Base class for pipes to inherit from.
+    class Pipe
+      def initialize(graph)
+        @graph = graph
+      end
+
+      attr_reader :graph
+      private :graph
+
+      # Basic passthrough.
+      def process(element)
+        element
+      end
+
+      # Basic passthrough.
+      def call(element)
+        Fiber.yield(element)
+      end
+    end
+  end
+end

data/lib/mementus/pipeline/step.rb

@@ -0,0 +1,127 @@
+module Mementus
+  module Pipeline
+    # Represents a step in a pipeline chain.
+    #
+    # New steps are constructed from a `source` enumerable (usually the previous
+    # step in the chain) and an optional `pipe` which provides the strategy
+    # for generating output values.
+    #
+    # Each step has an internal `Fiber` context which is used to yield control
+    # to the next step in the chain on each value in the iteration, rather than
+    # cycle through the entire list of values before forwarding control.
+    #
+    # This avoids the problem of iterating over a huge set of nodes and edges
+    # which are then discarded by a later step.
+    #
+    # The approach here is roughly similar to the way that Ruby chains together
+    # `Enumerator::Lazy` objects.
+    class Step
+      # Initialize a pipeline step from the given source.
+      #
+      # @param source [#each]
+      # @param pipe [Mementus::Pipeline::Pipe]
+      def initialize(source, pipe=nil, graph=nil)
+        @source = source
+        @pipe = pipe || Pipe.new(graph)
+        @graph = graph
+      end
+
+      attr_reader :source, :pipe, :graph
+      private :source, :pipe, :graph
+
+      # Loop through each value in the sequence, yielding control to the next
+      # step if necessary.
+      #
+      # If a block is provided, it is called with the value. Otherwise, a lazy
+      # enumerator representing the wrapped source is returned.
+      def each
+        return to_enum unless block_given?
+
+        context = Fiber.new do
+          source.each do |element|
+            pipe.call(element)
+          end
+
+          raise StopIteration
+        end
+
+        loop do
+          yield context.resume
+        end
+      end
+
+      # Dereference ids from the source elements.
+      def id
+        ids = to_enum.map { |element| element.id }
+        return ids.first if ids.length == 1
+        ids
+      end
+
+      # Traverse to the outgoing nodes adjacent to the source elements.
+      def out
+        outgoing_nodes = source.inject([]) do |result, node|
+          result.concat(node.adjacent)
+        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
+        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
+        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
+        end
+
+        Step.new(incoming_edges)
+      end
+
+      # Returns the first value in the sequence.
+      def first
+        to_enum.first
+      end
+
+      # Returns all values in the sequence
+      def all
+        to_enum.to_a
+      end
+
+      # Returns the given number of values from the sequence.
+      def take(num)
+        to_enum.take(num)
+      end
+    end
+  end
+end

data/lib/mementus/pipeline/transform.rb

@@ -0,0 +1,9 @@
+module Mementus
+  module Pipeline
+    class Transform < Pipe
+      def call(element)
+        Fiber.yield(process(element))
+      end
+    end
+  end
+end

data/lib/mementus/pipes/node.rb

@@ -1,12 +1,9 @@
 module Mementus
   module Pipes
-    class Node
-      def initialize(id)
-        @id = id
-      end
-
-      def process(graph, id)
-        graph.node(id || @id)
+    class Node < Pipeline::Transform
+      def process(id)
+        #@graph.node(id)
+        puts id
       end
     end
   end

data/lib/mementus/pipes/outgoing_edges.rb

@@ -1,8 +1,8 @@
 module Mementus
   module Pipes
     class OutgoingEdges
-      def process(graph, node)
-        graph.each_adjacent(node.id).map do |id|
+      def process(node)
+        @graph.each_adjacent(node.id).map do |id|
           Mementus::Edge.new(from: node, to: id)
         end
       end

data/lib/mementus/structure/incidence_list.rb

@@ -4,6 +4,8 @@ module Mementus
       def initialize(is_directed=true)
         @outgoing = {}
         @incoming = {}
+        @outgoing_e = {}
+        @incoming_e = {}
         @nodes = {}
         @edges = {}
         @is_directed = is_directed
@@ -33,6 +35,8 @@ module Mementus
         @nodes[node.id] = NodeProxy.new(node, self)
         @outgoing[node.id] ||= []
         @incoming[node.id] ||= []
+        @outgoing_e[node.id] ||= []
+        @incoming_e[node.id] ||= []
       end
 
       def set_edge(edge)
@@ -42,6 +46,8 @@ module Mementus
         @edges[edge.id] = edge
         @outgoing[edge.from.id] << edge.to.id
         @incoming[edge.to.id] << edge.from.id
+        @outgoing_e[edge.from.id] << edge.id
+        @incoming_e[edge.to.id] << edge.id
       end
 
       def edge(id)
@@ -67,6 +73,10 @@ module Mementus
       def each_adjacent(id, &blk)
         adjacent(id).each(&blk)
       end
+
+      def adjacent_edges(id)
+        @edges.values_at(*@outgoing_e[id])
+      end
     end
   end
 end

data/lib/mementus/version.rb

@@ -1,3 +1,3 @@
 module Mementus
-  VERSION = '0.5.1'.freeze
+  VERSION = '0.5.2'.freeze
 end

data/lib/mementus.rb

@@ -1,3 +1,4 @@
+require 'fiber'
 require 'mementus/graph'
 require 'mementus/structure/adjacency_list'
 require 'mementus/structure/incidence_list'
@@ -5,6 +6,10 @@ require 'mementus/node'
 require 'mementus/edge'
 require 'mementus/node_proxy'
 require 'mementus/processor'
+require 'mementus/pipeline/pipe'
+require 'mementus/pipeline/filter'
+require 'mementus/pipeline/transform'
+require 'mementus/pipeline/step'
 require 'mementus/pipes/incoming_edges'
 require 'mementus/pipes/incoming'
 require 'mementus/pipes/node'
@@ -12,10 +17,6 @@ require 'mementus/pipes/outgoing_edges'
 require 'mementus/pipes/outgoing'
 require 'mementus/depth_first_search'
 require 'mementus/breadth_first_search'
-require 'mementus/query/traversal'
-require 'mementus/query/source'
-require 'mementus/query/step'
-require 'mementus/query/traversal'
 require 'mementus/integer_id'
 require 'mementus/element_builder'
 require 'mementus/graph_builder'

data/spec/node_proxy_spec.rb

@@ -10,4 +10,14 @@ describe Mementus::NodeProxy do
     node_proxy = Mementus::NodeProxy.new(node_1, graph)
     expect(node_proxy.adjacent.map { |node| node.id }).to eq([node_2.id, node_3.id])
   end
+
+  specify '#adjacent_edges' do
+    graph = Mementus::Graph.new do
+      set_edge(edge_1_2)
+      set_edge(edge_1_3)
+    end
+
+    node_proxy = Mementus::NodeProxy.new(node_1, graph)
+    expect(node_proxy.adjacent_edges.map { |edge| edge.to.id }).to eq([node_2.id, node_3.id])
+  end
 end

data/spec/node_spec.rb

@@ -26,12 +26,18 @@ describe Mementus::Node do
     expect(node[:title]).to be_nil
   end
 
-  it 'initializes with props hash' do
+  it 'initializes with props keys' do
     node = Mementus::Node.new(props: { title: 'Vertex' })
 
     expect(node[:title]).to eq('Vertex')
   end
 
+  it 'initializes with props hash' do
+    node = Mementus::Node.new(props: { title: 'Vertex', count: 10 })
+
+    expect(node.props).to eq({ title: 'Vertex', count: 10 })
+  end
+
   it 'does not allow mutation of props' do
     node = Mementus::Node.new(props: { title: 'Vertex' })
 

data/spec/pipeline/step_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Mementus::Pipeline::Step do
+  describe '#each' do
+    it 'iterates with an enumerator' do
+      enum = Mementus::Pipeline::Step.new([:a, :b, :c]).each
+      expect(enum.next).to eq(:a)
+      expect(enum.next).to eq(:b)
+      expect(enum.next).to eq(:c)
+    end
+
+    it 'iterates with a block' do
+      Mementus::Pipeline::Step.new([:a]).each do |value|
+        expect(value).to eq(:a)
+      end
+    end
+
+    it 'raises StopIteration when no more values can be yielded' do
+      enum = Mementus::Pipeline::Step.new([]).each
+      expect { enum.next }.to raise_error(StopIteration)
+    end
+
+    it 'creates an isolated iteration context with each enumerator' do
+      step = Mementus::Pipeline::Step.new([:a, :b, :c])
+      expect(step.to_enum.next).to eq(:a)
+      expect(step.to_enum.next).to eq(:a)
+    end
+  end
+
+  describe '#first' do
+    it 'returns the first element in the source sequence' do
+      step = Mementus::Pipeline::Step.new([:a, :b, :c])
+      expect(step.first).to eq(:a)
+    end
+  end
+
+  describe '#all' do
+    it 'returns all values in the source sequence' do
+      step = Mementus::Pipeline::Step.new([:a, :b, :c])
+      expect(step.all).to eq([:a, :b, :c])
+    end
+  end
+
+  describe '#take' do
+    it 'returns the given number of values from the source sequence' do
+      step = Mementus::Pipeline::Step.new([:a, :b, :c])
+      expect(step.take(2)).to eq([:a, :b])
+    end
+  end
+
+  describe '#new' do
+    it 'treats steps as enumerable sources to other steps' do
+      step = Mementus::Pipeline::Step.new(Mementus::Pipeline::Step.new([:a, :b, :c]))
+      expect(step.all).to eq([:a, :b, :c])
+    end
+
+    it 'transforms output values based on the given pipe' do
+      transform = -> (value) { Fiber.yield(value.to_s.upcase) }
+      step = Mementus::Pipeline::Step.new([:a, :b, :c], transform)
+      expect(step.all).to eq(['A', 'B', 'C'])
+    end
+
+    it 'filters output values based on the given pipe' do
+      filter = -> (value) { Fiber.yield(value) if value == :a }
+      step = Mementus::Pipeline::Step.new([:a, :b, :c], filter)
+      expect(step.all).to eq([:a])
+    end
+
+    it 'transforms and filters output values based on the given pipes' do
+      filter = -> (value) { Fiber.yield(value) if value == :a }
+      transform = -> (value) { Fiber.yield(value.to_s.upcase) }
+      prev = Mementus::Pipeline::Step.new([:a, :b, :c], filter)
+      step = Mementus::Pipeline::Step.new(prev, transform)
+      expect(step.all).to eq(['A'])
+    end
+  end
+end

data/spec/pipeline_spec.rb

@@ -37,7 +37,7 @@ describe 'pipeline api' do
   it 'traverses from the given node' do
     pipeline = graph.n(1)
     expect(pipeline.id).to eq(1)
-    expect(pipeline.one.id).to eq(1)
+    expect(pipeline.first.id).to eq(1)
   end
 
   it 'traverses to outgoing nodes' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mementus
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - maetl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-26 00:00:00.000000000 Z
+date: 2016-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -76,18 +76,20 @@ files:
 - lib/mementus/integer_id.rb
 - lib/mementus/library.rb
 - lib/mementus/library/herschel_graph.rb
+- lib/mementus/library/story_graph.rb
 - lib/mementus/node.rb
 - lib/mementus/node_builder.rb
 - lib/mementus/node_proxy.rb
+- lib/mementus/pipeline/filter.rb
+- lib/mementus/pipeline/pipe.rb
+- lib/mementus/pipeline/step.rb
+- lib/mementus/pipeline/transform.rb
 - lib/mementus/pipes/incoming.rb
 - lib/mementus/pipes/incoming_edges.rb
 - lib/mementus/pipes/node.rb
 - lib/mementus/pipes/outgoing.rb
 - lib/mementus/pipes/outgoing_edges.rb
 - lib/mementus/processor.rb
-- lib/mementus/query/source.rb
-- lib/mementus/query/step.rb
-- lib/mementus/query/traversal.rb
 - lib/mementus/structure/adjacency_list.rb
 - lib/mementus/structure/incidence_list.rb
 - lib/mementus/version.rb
@@ -99,8 +101,8 @@ files:
 - spec/integer_id_spec.rb
 - spec/node_proxy_spec.rb
 - spec/node_spec.rb
+- spec/pipeline/step_spec.rb
 - spec/pipeline_spec.rb
-- spec/query_spec.rb
 - spec/spec_helper.rb
 - spec/structure_spec.rb
 - spec/traversal_spec.rb
@@ -136,8 +138,8 @@ test_files:
 - spec/integer_id_spec.rb
 - spec/node_proxy_spec.rb
 - spec/node_spec.rb
+- spec/pipeline/step_spec.rb
 - spec/pipeline_spec.rb
-- spec/query_spec.rb
 - spec/spec_helper.rb
 - spec/structure_spec.rb
 - spec/traversal_spec.rb

data/lib/mementus/query/source.rb

@@ -1,13 +0,0 @@
-module Mementus
-  module Query
-    class Source
-      def initialize(graph)
-        @traversal = Traversal.new(graph)
-      end
-
-      def node(id)
-        @traversal.add_step(Step.new(@traversal, id))
-      end
-    end
-  end
-end

data/lib/mementus/query/step.rb

@@ -1,14 +0,0 @@
-module Mementus
-  module Query
-    class Step
-      def initialize(traversal, id)
-        @traversal = traversal
-        @id = id
-      end
-
-      def to_node
-        @traversal.graph.node(@id)
-      end
-    end
-  end
-end

data/lib/mementus/query/traversal.rb

@@ -1,25 +0,0 @@
-module Mementus
-  module Query
-    class Traversal
-      attr_reader :graph
-
-      def initialize(graph)
-        @graph = graph
-        @steps = []
-      end
-
-      def add_step(step)
-        @steps << step
-        self
-      end
-
-      def adjacent
-        @steps.last.to_node.adjacent
-      end
-
-      def id
-        @steps.last.to_node.id
-      end
-    end
-  end
-end

data/spec/query_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Mementus::Query do
-  let(:graph) do
-    Mementus::Graph.new do
-      set_edge(Mementus::Edge.new(from: Mementus::Node.new(id: 1),to: Mementus::Node.new(id: 2)))
-    end
-  end
-
-  specify '#node' do
-    expect(graph.query.node(1).id).to eq(1)
-  end
-
-  specify '#node#adjacent' do
-    expect(graph.query.node(1).adjacent.first.id).to eq(2)
-  end
-end