clomp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e100e9861f2a2b799e088d4d4ac31d5e17fd376
-  data.tar.gz: 156d3e65b3b7664ef2f2d1273d0d93967058fff8
+  metadata.gz: 3274c97946362d96e713004853c32790b28282bc
+  data.tar.gz: d1647e5d1bee604c2875ec40a6dbe974091935be
 SHA512:
-  metadata.gz: 13c87f30b50cf897d32b06ebe9dbd6281227d6c58bde6169711f9e3627d3f005b3efe9ce0507440f050d2cdaa52a36bf77eebcc010a5108a67fe2ac4138507b0
-  data.tar.gz: 7ef600eaa8d98c726da464d79dfef75391c8134051f6bb6f14b593db1cbadd2e6977c8f4551223bb9e9486d6ee9096bb4f3081ea0972e7076d938cc41b25a6c2
+  metadata.gz: b20d6816638ca8b9530df827610d3277538623b7f7ca95d09458d42341de994854e65e2033c9b3982eda326066ceedae9f9b6469aab8a71fed697e6c03497099
+  data.tar.gz: 2f7304738d7bc18c62ed79617119e7fd68af14b3e8b2cc42be7743c747747661d47158e0a9916877b296a48167d1ec8b5143c41b9494d7c0fddacab741609e90

data/.byebug_history

@@ -1,3 +1,11 @@
+exit
 c
-break
-_track.failure?
+_callable_object = Callable[result, track, options, _self]
+track.name
+track
+track.track_name
+_callable_object
+c
+n
+track.track_from
+_callable_object

data/.gitignore

@@ -10,3 +10,5 @@
 
 # rspec failure tracking
 .rspec_status
+.clomp-0.0.3.gem
+/*.gem

data/README.md

@@ -1,4 +1,4 @@
-# Clomp [![CircleCI](https://circleci.com/gh/rubyrider/Clomp.svg?style=svg)](https://circleci.com/gh/rubyrider/Clomp)
+# Clomp [![CircleCI](https://circleci.com/gh/rubyrider/clomp.svg?style=svg)](https://circleci.com/gh/rubyrider/clomp)
 
 **Clomp gem provides a smooth, lightweight, productive and reusable way to build an operation using Railway oriented programing paradigm.**
 Clomp will give you an easy interface to complete your service operation. You can use it with any framework 
@@ -27,11 +27,27 @@ specific step.
 
 Consider the following class:
 ```ruby
+class AnotherOperation < Clomp::Operation
+  track :track_from_another_operation
+
+  def track_from_another_operation(options)
+    options[:hello_from_another_operation] = true
+  end
+end
+    
 class SingingOperation < Clomp::Operation
-    # this block only executes on successful steps! 
+    # Configure your operation for common tracks,
+    # configuration can be overridden from individual tracks 
+    setup do |config|
+      config.pass_fast = true
+      config.fail_fast = true
+      config.optional = true
+     end
+      
+    # this block only executes on failure step! 
     # pass options to receive the operation states!   
     add_track :get_lyrics do |options|
-      # we call this a success state based block!
+      # we call this a failure state based block!
       options[:do_some_thing] = 10
     end
     
@@ -39,6 +55,10 @@ class SingingOperation < Clomp::Operation
     
     add_track :start_signing
     
+    # We can now share specific step from 
+    # outsider operation
+    share :track_from_another_operation, from: AnotherOperation # Or 'AnotherOperation'
+    
     finally :receive_price #final step, wont execute after this step!
     
     def get_instruments_ready(options, mutable_data: , **)
@@ -60,7 +80,7 @@ end
 ```
 
 ```ruby
-@result = SingingOperation.({singer_name: 'Base Baba'})
+@result = SingingOperation[singer_name: 'Base Baba']
 @result.success? # => true
 @result.failure? # => false
 ```

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
-require "the_railway"
+require "clomp"
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/clomp/callable.rb

@@ -0,0 +1,14 @@
+module Clomp
+  class Callable
+    class << self
+      def [](track, options, _self)
+        if track.track_from
+          #FIXME: stop executing! we will call it from our context
+          track.track_from.new(track_builders: [track], options: options, exec: false)
+        else
+          _self
+        end
+      end
+    end
+  end
+end

data/lib/clomp/configuration.rb

@@ -0,0 +1,12 @@
+module Clomp
+  class Configuration
+    attr_accessor :fail_fast, :pass_fast, :optional
+    
+    # Constructor for Configuration file
+    def initialize
+      @pass_fast = false
+      @fail_fast = false
+      @optional  = false
+    end
+  end
+end

data/lib/clomp/errors.rb

@@ -3,5 +3,6 @@ module Clomp
     NoTrackProvided  = Class.new(ArgumentError)
     TrackNotDefined  = Class.new(NotImplementedError)
     UnknownTrackType = Class.new(ArgumentError)
+    UnknownOperation = Class.new(NotImplementedError)
   end
 end

data/lib/clomp/executor.rb

@@ -0,0 +1,23 @@
+require 'pp'
+
+module Clomp
+  class Executor
+    class << self
+      def [](result = {}, options, _self: )
+        result['tracks'].each do |track|
+          next unless track.track?
+          
+          _callable_object = Callable[track, options, _self]
+
+          raise Errors::TrackNotDefined, "Please define the track in your operation/service: #{track.name} in #{_callable_object.class}" unless _callable_object.respond_to?(track.name)
+
+          _track = track.exec!(_callable_object, options)
+    
+          break if _track.failure?
+        end
+  
+        _self
+      end
+    end
+  end
+end

data/lib/clomp/operation.rb

@@ -1,79 +1,116 @@
 module Clomp
   class Operation
-    attr_accessor :input, :options
+    attr_reader :result, :configs
     
-    def call(track_builders: [], mutable_data: {}, immutable_data: {})
-      @track_builders           = track_builders
-      @mutable_data             = mutable_data
-      @immutable_data           = immutable_data
-      @options                  ||= {}
-      @options[:mutable_data]   = mutable_data
-      @options[:immutable_data] = immutable_data
+    # Constructor for operation object
+    #
+    # @param track_builders [Array] the list of tracks we define
+    # @param options [Hash] of options to be provided by .[] call/method
+    # @return [self]
+    def initialize(track_builders: [], options: {}, exec: true)
+      @options = options
+      # Setup result object!
+      @result = Result.new(
+          operation: self,
+          tracks:    track_builders || [],
+          options:   options || {}
+      )
       
-      exec_steps!
+      @configs = self.class.setup_configuration
+      
+      exec_steps! if exec
     end
     
     # Execute all the steps! Execute all the tracks!
     def exec_steps!
-      @track_builders.each do |track|
-        raise Errors::TrackNotDefined, "Please define track: #{track.name}" unless self.respond_to?(track.name)
-        
-        _track = track.exec!(self, @options)
-        
-        break if _track.failure?
-      end
-      
-      @result = Result.new(@options, @track_builders, self)
+      Executor[result, @options, _self: self]
     end
     
     def executed_steps
-      @track_builders.collect { |track| track.name if track.success? }.compact
+      @result['tracks'].collect {|track| track.name if track.success?}.compact
     end
     
     # Name of the steps defined in the operation class
     def steps
-      @track_builders.collect { |track| track.name }
+      @result['tracks'].collect {|track| track.name}
     end
     
     class << self
       
       # To store and read all the tracks!
-      attr_accessor :track_builders
+      attr_accessor :track_builders, :configs
+      
+      # Operation wise configuration to control state
+      # All operation may not require fail fast
+      # All operation may not require pass fast
+      # Operation wise optional value could be different
+      #
+      # @yield [config] to mutate new configuration
+      #
+      # @return [Configuration] @config
+      def setup
+        @configs ||= Configuration.new
+        
+        yield(@configs) if block_given?
+        
+        @configs
+      end
+      
+      alias_method :setup_configuration, :setup
+      
+      # Share track from other operation
+      def share(track_name, from:, track_options: {}, &block)
+        @track_builders ||= []
+  
+        _callable_class = from && from.kind_of?(String) ? Object.const_get(from) : from
+        
+        raise UnknownOperation, 'Please provide a valid operation to share the steps for' unless _callable_class
+        
+        @track_builders << build_track(track_name, track_options, :track, track_for: _callable_class , &block)
+      end
       
       # get track name and options!
       def track(track_name, track_options: {}, &block)
         @track_builders ||= []
         
-        @track_builders << build_track(track_name, track_options, :track, &block)
+        @track_builders << build_track(track_name, track_options, :track, track_for: nil, &block)
       end
-
+      
       # get the track name for the failure case!
       def failure(track_name, track_options: {}, &block)
         @track_builders ||= []
         
-        @track_builders << build_track(track_name, track_options, :failed_track, &block)
+        @track_builders << build_track(track_name, track_options, :failed_track, track_for: nil, &block)
       end
-
+      
       # get the track name for the final step! Only one step will be executed!
       def finally(track_name, track_options: {}, &block)
         @track_builders ||= []
-  
-        @track_builders << build_track(track_name, track_options, :finally, &block)
+        
+        @track_builders << build_track(track_name, track_options, :finally, track_for: nil, &block)
+      end
+      
+      def [](mutable_data = {}, immutable_data = {})
+        self.(mutable_data, immutable_data)
       end
       
       def call(mutable_data = {}, immutable_data = {})
-        self.new.call(
+        new(
             track_builders: @track_builders,
-            mutable_data:   mutable_data,
-            immutable_data: immutable_data
-        )
+            options:        {
+                mutable_data:   mutable_data,
+                immutable_data: immutable_data
+            },
+            ).result
       end
       
       private
       
-      def build_track(track_name, track_options = {}, track_type , &block)
-        Track.new(name: track_name, track_options: track_options, track_type: track_type, &block)
+      def build_track(track_name, track_options = {}, track_type, track_for: nil, &block)
+        @configs ||= Configuration.new
+        
+        TrackBuilder[track_name: track_name, track_options: track_options, track_type: track_type, track_for: track_for, &block]
       end
     end
   end
-end
+end

data/lib/clomp/result.rb

@@ -1,18 +1,58 @@
 module Clomp
   class Result
-    include CommonStates
-    extend Forwardable
+    attr_reader :options, :operation, :state
     
-    attr_reader :options, :state, :operation
+    def initialize(options: {}, tracks: [], operation: nil)
+      @report = {}
+      
+      @operation      = set_prop :operation, operation || Operation.new
+      @tracks         = set_prop :tracks, tracks || []
+      @options        ||= {}
+      @immutable_data = set_prop :options, options
+      @state          = ->(tracks) { tracks.select {|track| track.failure?}.count.zero? }
+    end
+    
+    def success?
+      @state.(self[:tracks]) === true
+    end
+    
+    def failure?
+      @state.(self[:tracks]) === false
+    end
+    
+    def method_missing(method, *args)
+      if @operation.respond_to?(method)
+        @operation.send(method, *args)
+      else
+        super
+      end
+    end
+    
+    def [](key)
+      sym_key = to_sym_key(key)
+      
+      self.instance_variable_get(sym_key)
+    end
+    
+    def []=(key, value)
+      sym_key = to_sym_key(key)
+      self.instance_variable_set(sym_key, value)
+    end
+    
+    def set_prop(key, value)
+      sym_key = to_sym_key(key)
+      
+      self.instance_variable_set(sym_key, value)
+    end
     
-    def_delegators :@operation, :steps, :executed_steps
+    private
     
-    def initialize(options, tracks = [], operation)
-      @options   = options
-      @tracks    = tracks
-      @error     = nil
-      @state     = @tracks.select {|track| track.failure?}.count.zero? ? SUCCESS : FAILURE
-      @operation = operation
+    def to_sym_key(key)
+      if key.is_a? Symbol
+        ('@' + key.to_s).to_sym
+      else
+        ('@' + key.to_s.delete('@')).to_sym
+      end
     end
   end
 end

data/lib/clomp/track.rb

@@ -2,14 +2,15 @@ module Clomp
   class Track
     include Clomp::CommonStates
     
-    attr_reader :name, :block, :track_options, :state, :error
+    attr_reader :name, :block, :track_options, :state, :error, :track_from
     
     VALID_TRACK_TYPES = %I(track failed_track finally catch)
     
-    def initialize(name: (raise Errors::NoTrackProvided), track_options: {}, track_type: VALID_TRACK_TYPES.first, &block)
+    def initialize(name: (raise Errors::NoTrackProvided), track_options: {}, track_type: VALID_TRACK_TYPES.first, track_from: nil, &block)
       raise UnknownTrackType, 'Please provide a valid track type' unless VALID_TRACK_TYPES.include?(track_type)
       
       @name          = name
+      @track_from    = track_from
       @block         = block
       @track_options = track_options
       @type          = track_type
@@ -17,6 +18,20 @@ module Clomp
       @error         = nil
     end
     
+    def type
+      @type
+    end
+    
+    VALID_TRACK_TYPES.each do |track_type|
+      define_method "#{track_type}?" do
+        @type == track_type
+      end
+    end
+    
+    def track?
+      @type == :track
+    end
+    
     # Track#exec! executes the steps defined in the operation class
     def exec!(object, options)
       mark_as_failure! # going to execute! set to failure initially
@@ -27,7 +42,7 @@ module Clomp
         mark_as_success! if object.public_send(name.to_sym, options) != false
       end
       
-      @block.(options) if success? && @block
+      @block.(options) if failure? && @block
       
       self
     

data/lib/clomp/track_builder.rb

@@ -0,0 +1,9 @@
+module Clomp
+  class TrackBuilder < Array
+    class << self
+      def [](track_name:, track_options: {}, track_for: nil, track_type:, &block)
+        Track.new(name: track_name, track_options: track_options, track_type: track_type, track_from: track_for, &block)
+      end
+    end
+  end
+end

data/lib/clomp/version.rb

@@ -1,3 +1,3 @@
 module Clomp
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/clomp.rb

@@ -1,10 +1,14 @@
 require 'clomp/version'
 require 'clomp/common_states'
+require 'clomp/track_builder'
 require 'clomp/operation'
 require 'clomp/track'
 require 'clomp/context'
 require 'clomp/errors'
 require 'clomp/result'
+require 'clomp/configuration'
+require 'clomp/callable'
+require 'clomp/executor'
 
 module Clomp
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clomp
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Irfan Ahmed
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-04 00:00:00.000000000 Z
+date: 2018-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -89,12 +89,16 @@ files:
 - bin/setup
 - clomp.gemspec
 - lib/clomp.rb
+- lib/clomp/callable.rb
 - lib/clomp/common_states.rb
+- lib/clomp/configuration.rb
 - lib/clomp/context.rb
 - lib/clomp/errors.rb
+- lib/clomp/executor.rb
 - lib/clomp/operation.rb
 - lib/clomp/result.rb
 - lib/clomp/track.rb
+- lib/clomp/track_builder.rb
 - lib/clomp/version.rb
 homepage: https://github.com/rubyrider/clomp
 licenses: