depth_first 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 639dafea3e41c28485b5363b5bc9b8840b2fbee26b034409b6823fe41cd5db14
-  data.tar.gz: 98ec27e41c2b8d4385c3fe246ca31377e56995659a57de678b150de195ab95be
+  metadata.gz: f458b23b4e11951bfe32ce363890c693ad436c02a8a01c06d7a63f1e1d1310db
+  data.tar.gz: a5fbd2c177fd85f4fe5edf6b0dd46e1354ee94fd4de2a72cdb6c3f9a18b1c0f9
 SHA512:
-  metadata.gz: c19b6195c6600b41d3499a3df177430d5c82d134657929843a46de3aeaedd1d160bf238d8c01bf91209f94190945bf58728088c93a58ec87319098ebaad773a3
-  data.tar.gz: 6358f250ae799e01c778649af1fef18d320f93091f16b7c1447df9ad89967e677ecb0a736b8e2873a2980729dfc82d1bab788feb5428573be3788e9e6ca56e15
+  metadata.gz: 32f4030a7a3cc8e214fbe1ae02a60ac77de467ae87725afc62cc3756cf39778d8c1719f92e813fe0cacfd99551ef8fc4745bee8f4cc160dbc7dbf48f2b00ad5f
+  data.tar.gz: a7e2ea90b8b5246d22352e75d94a78f354a15e9b686019dbab1206c95594b3750853818b25ef30cac01527ee714a4360f5e7a2b319bb839c5581e7e5fb29e8ea

data/README.md

@@ -1,2 +1,73 @@
 # depth_first
-Depth-first search code organization
+Depth-first search code organization gem allowing for sequential and concurrent code execution using [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby).
+
+## Tasks
+A task accepts an input hash and merges in a results hash.
+
+### Examples
+```
+class A < DepthFirst::Task
+  def perform
+    { a: 1 }
+  end
+end
+
+class B < DepthFirst::Task
+  def perform
+    { b: 2 }
+  end
+end
+
+class C < DepthFirst::Task
+  def perform
+    { c: 3 }
+  end
+end
+```
+
+### Usage
+```
+> A.new(test: true).perform
+ => { test: true, a: 1 }
+
+> B.new(test: true).perform
+ => { test: true, b: 2 }
+```
+
+## Organizers
+An organizer chains together tasks, piping a hash through each subtask.
+
+## SequentialOrganizer
+Data is passed through `A`, `B`, and `C` sequentially. The input hash `{ testing: true }` is piped through A. The resulting hash `{ testing: true, a: 1 }` is then piped through B. And so on.
+
+### Example
+```
+class SequentialAbc < DepthFirst::SequentialOrganizer
+  TASKS = [A, B, C].freeze
+end
+```
+
+### Usage
+```
+> SequentialAbc.new(testing: true).perform
+ => { testing: true, a: 1, b: 2, c: 3 }
+```
+
+## ParallelOrganizer
+Data is passed through `A`, `B`, and `C` concurrently. All three classes execute in parallel. The input hash `{ testing: true }` is passed to all three classes and all three intermediate result hashes are merged into the final result hash once their promises are resolved.
+
+### Example
+```
+class ParallelAbc < DepthFirst::ParallelOrganizer
+  TASKS = [A, B, C].freeze
+end
+```
+
+### Usage
+```
+> ParallelAbc.new(testing: true).perform
+ => { testing: true, a: 1, b: 2, c: 3}
+```
+
+## Note
+An organizer can have a subtask which is itself another organizer. In this manner, code can be organized in an arbitrarily-deep tree structure with order of execution roughly matching a Depth First Search algorithm.

data/lib/depth_first/parallel_organizer.rb

@@ -1,6 +1,13 @@
 module DepthFirst
   # Base parallel organizer class
   class ParallelOrganizer < SequentialOrganizer
+    DEPENDENCIES = [].freeze
+
+    def initialize(options)
+      super(options)
+      load_dependencies
+    end
+
     def perform
       tasks.map { |task| execute_promise(task) }
            .reduce(options) { |a, e| resolve_promise(a, e) }
@@ -8,6 +15,16 @@ module DepthFirst
 
     private
 
+    # Load dependencies before concurrency to get
+    # around lazy-loading race condition.
+    def load_dependencies
+      dependencies.each { |dependency| dependency }
+    end
+
+    def dependencies
+      self.class::DEPENDENCIES
+    end
+
     def execute_promise(task)
       Concurrent::Promise.new { task.new(options).perform }.execute
     end

data/lib/depth_first/version.rb

@@ -1,3 +1,3 @@
 module DepthFirst
-  VERSION = '1.0.2'.freeze
+  VERSION = '1.1.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: depth_first
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Isaac Anthony