brace_comb 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41d35900d437fbd8fb7020a89d72244682bfb255
-  data.tar.gz: b4be3187728524431a2b33cfef64006660cc638d
+  metadata.gz: 225cef0fa8aeb8117ae666819ecbbba48205e45a
+  data.tar.gz: c722dc8360a165d39a6f569429dae35ce4d5b05b
 SHA512:
-  metadata.gz: 17ace335998349832f61efc1671d773a862ef0bc84f99ca5ae4a85aa7fba29b2d23154ab33fee9deadfcf760be56a171b685a4bdd2ca2c0cc0ba6af01f9fd94e
-  data.tar.gz: '09fae34d26d65f50119710fec7cb7704ab5d2b5b0c3a174caafc67bf3d5e4ee4c5cd5c237dcfa514608a0b197ef66f740fdd8af92a1b5fa9554b937b62658406'
+  metadata.gz: 95197f8bc990fe35f9cb641a24b38e9b546344e4763aaee3c86c2d28078f1e608fa5ed10584c4b246a80012dc7d20e03705854bd7584d56a7eecabd33c4ddcf1
+  data.tar.gz: dec014b2be336b8624f960d7890430d190cb92816e07ea02b6e7f3d4cdca1dfb1db50657ba7568fd1c4259ee0d4877fa1ba1155c33b21b48b7075b21a041772d

data/README.md

@@ -9,18 +9,18 @@ This is akin to how workflows are connected to each other with dependencies.
 In workflow management systems, there is often a need to define that certain tasks should only begin when another task(s) is complete. BraceComb can be used to define multiple types of workflows and handle each workflow consistently.
 
 ## Example
-A factory production line sytem uses pre-defined workflows with strict dependencies between tasks. In a simplified scenario, let's say we need to define a workflow in which an item on the conveyor belt must be packed before it is dispatched. In this case:
+A factory production line system uses pre-defined workflows with strict dependencies between tasks. In a simplified scenario, let's say we need to define a workflow in which an item on the conveyor belt must be packed before it is dispatched. In this case:
 
 - Dependents/Tasks are the actions such as packing and dispatching
 - Dependencies are links that define that packing must finish before dispatching
 
-In this system we can create a dependent entity called `entity1` for `packing` and another dependent entity called `entity2` for `dispatching`. A new dependency between the two entities can be created using the following command:
+In this system we can create a dependent entity called `tasks` of type `packing` and another dependent entity `tasks` of type `dispatching`. A new `task_dependency` entity between the two entities can be created using the following command:
 
   ```
-    initialize_dependency! from: entity1.id, to: entity2.id, type: 'dispatch'
+    initialize_dependency! from: task1.id, to: task2.id, dependency_type: 'dispatch'
   ```
 
-This will create a dependency in `pending` state. In this case `packing` is a strict prerequisite for `dispatching`, hence `entity2` should not start unless the dependency is in `resolved` state. This is also the case for any dependencies of type `dispatch`. This can be defined by declaring a dependency characteristics using:
+`dependency_type` is used to categorize the dependency. This will create a `task_dependency` entity in `pending` state. In this case `packing` task is a strict prerequisite for `dispatching` task, hence `dispatching` should not start unless `packing` is complete. Therefore the `task_dependency` between them should be in `resolved` state. This is also the case for any dependencies of dependency_type `dispatch`. This relationship can be defined by declaring a dependency characteristics on the `task_dependency` class using:
 
 ```
   declare_dependency type: :dispatch,
@@ -29,13 +29,13 @@ This will create a dependency in `pending` state. In this case `packing` is a st
                      after_resolution: [:send_dispatch_notification]
 ```
 
-This declaration will ensure that for all dependencies of type `dispatch`, all `before_resolution` hooks are first run. If any `before_resolution` functions returns false, then the operation is aborted. If all `before_resolution` functions return true, then the resolver code inside `send_packing_complete_confirmation` will be executed, and then all functions inside `after_resolution` would be executed.
+This declaration will ensure that for all dependencies of type `dispatch`, when the `task_dependency` is marked as resolved, all `before_resolution` hooks are first run. If any `before_resolution` functions returns false, then the operation is aborted. If all `before_resolution` functions return true, then the resolver code inside `send_packing_complete_confirmation` will be executed, and then all functions inside `after_resolution` would be executed.
 
-To kick-off this flow just call `dependency.resolve` and the before and after hooks will be invoked in the manner as described above.
+To kick-off this flow just call `task_dependency.resolve` and the before and after hooks will be invoked in the manner as described above.
 
 ## Installation
 
-1. Add JobDependencies to your `Gemfile`.
+1. Add to your `Gemfile`.
 
     `gem 'brace_comb'`
 
@@ -56,12 +56,11 @@ To kick-off this flow just call `dependency.resolve` and the before and after ho
 
 Entity names for dependencies and dependents are configurable and can be set in `config/initializers/brace_comb.rb` before creating the migrations.
 
-1. Declare a dependency type by adding in the following to the dependency class:
+1. Declare a dependency type by adding in the following to the dependency (`task_dependency`) class:
    ```
-     include BraceComb::Helper
-     enum type: { shopping: 0 }
+     include BraceComb::Model
    ```
-2. Declare a dependency by typing in the following in any ActiveRecord class. Only `resolver` is compulsory whereas `before_resolution` and `after_resolution` are optional.
+2. Declare a dependency by typing in the following in any ActiveRecord class. Only `resolver` is compulsory whereas `before_resolution` and `after_resolution` are optional. `type` is a unique string and is used to identify the resolution behaviour for all dependents with `dependency_type` the same as that defined in `type`. 
 
    a. Using a method name in the resolver
    ```
@@ -84,11 +83,11 @@ Entity names for dependencies and dependents are configurable and can be set in
 3. Create dependencies between the dependent class by using the following helper in any instance method of a model class:
 
    - When an exception needs to be raised:
-   `initialize_dependency! from: entity1.id, to: entity2.id, type: 'shopping'`
+   `initialize_dependency! from: task1.id, to: task2.id, type: 'shopping'`
 
    or
    - When a boolean needs to be returned:
-   `initialize_dependency from: entity1.id, to: entity2.id, type: 'shopping'`
+   `initialize_dependency from: task1.id, to: task2.id, type: 'shopping'`
 
 5. Resolve dependencies from any active record model by using:
 
@@ -107,7 +106,6 @@ Entity names for dependencies and dependents are configurable and can be set in
 
 ## Under consideration
    - Allowing dependency declaration to accept multiple resolvers, and allowing resolve to accept the name of the resolver. This could possibly by done in `resolve` method itself instead of `declare_dependency`
-   - Automatically including the concern for `resolve` inside the dependency class
    - Combining the installation steps into 1-2 steps
    - And more...
 ## Contributing

data/lib/brace_comb.rb

@@ -3,7 +3,6 @@ require 'dry-configurable'
 require 'brace_comb/version'
 require 'brace_comb/config'
 require 'brace_comb/dependency_model'
-require 'brace_comb/dependency_helper'
 
 module BraceComb
   class << self

data/lib/brace_comb/dependency_model.rb

@@ -1,4 +1,5 @@
 require 'brace_comb/exceptions/callback_failure'
+require 'brace_comb/dependency_helper'
 
 module BraceComb
   module Model
@@ -28,7 +29,7 @@ module BraceComb
 
       def execute_after_callbacks(after_callbacks)
         return unless after_callbacks
-        after_callbacks.each do |after_callback|
+        after_callbacks.map do |after_callback|
           execute_callback(after_callback)
         end
       end
@@ -63,6 +64,8 @@ module BraceComb
 
     def self.included(base)
       base.send :include, InstanceMethods
+      base.send :include, BraceComb::Helper::InstanceMethods
+      base.send :extend, BraceComb::Helper::ClassMethods
     end
   end
 end

data/lib/brace_comb/version.rb

@@ -1,3 +1,3 @@
 module BraceComb
-  VERSION = '0.1.3'
+  VERSION = '0.2.0'
 end

data/spec/brace_comb/dependency_model_spec.rb

@@ -23,7 +23,7 @@ describe BraceComb::Model do
 
   before do
     dependency_class.constantize.class_eval do
-      include BraceComb::Helper
+      include BraceComb::Model
 
       enum dependency_type: { shopping: 0 }
       enum status: { pending: 0, resolved: 1 }
@@ -122,10 +122,10 @@ describe BraceComb::Model do
       end
 
       it 'resolves dependency if all before resolve hooks are satisfied' do
-        result = dependency.resolve
+        result = dependency.resolve!
         expect(dependency).not_to receive(:complete_job).and_call_original
         expect(dependency).to be_resolved
-        expect(result).to be true
+        expect(result).to eq [true]
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: brace_comb
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Ankita Gupta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-18 00:00:00.000000000 Z
+date: 2019-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord