opera 0.2.15 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da6a185f664746509764441abdce1f7ff3b429c0fac119e9442271fe1f19f357
-  data.tar.gz: 898591cfbf92efa85c9c8b3e2b69ee7ca958a3eda0029ac019ca85562f4e3db1
+  metadata.gz: dc70b9316e79f9ca5de85afc65ea0ea0f667c8a99aa72d0828f267383b8e76c2
+  data.tar.gz: 8ae3e726adc06851d36fdfd1314f001f678b35b7840be2bb96f833065198497a
 SHA512:
-  metadata.gz: a22fba3cca583d561f2dade3de23246293ca0acadcbf2f60ef5ab41efb6325a49addda52cb3948a12c74c07674a64289aa1e3e500014eb380fa2919648dfffd0
-  data.tar.gz: 2c74a116d21859c048f5c52eef2760806184d8793f569262e22a846ca11c5557f010005cf6e110197258a3f43d1d8fa62551c9ca3c80cd7624ef660d928c58c2
+  metadata.gz: f9cf2f017c1ba44975e3968912d7859514ca6c900c824130922e9d1ab7a537cdc7e0d69b0a014d8d4ceb5eb9250be7246a7671af5ff00919764e734cce333f3f
+  data.tar.gz: 1ee6be5b16d95fd0d9174028e93784f6afa18a249553fcc2d5ef1725ac959733e4eba2598249a53c39314937299a7d55889d1919ea7e7bef670d48c712740331

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Opera Changelog
 
+### 0.2.16 - June 8, 2024
+
+- add `mode` configuration option. When set to `:production` we optimize memory usage by skipping storing executions.
+
 ### 0.2.15 - September 4, 2023
 
 - Make the Transaction executor work with the keyword arguments

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    opera (0.2.15)
+    opera (0.2.16)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -36,6 +36,7 @@ Opera::Operation::Config.configure do |config|
   config.transaction_class = ActiveRecord::Base
   config.transaction_method = :transaction
   config.transaction_options = { requires_new: true }
+  config.mode = :development # Can be set to production too
   config.reporter = defined?(Rollbar) ? Rollbar : Rails.logger
 end
 ```
@@ -885,9 +886,147 @@ Opera::Operation::Result.new(output: 'success')
     - add_exceptions(Hash)     - Adds multiple exceptions
     - add_information(Hash)    - Adss new information - Useful informations for developers
 
+## Opera::Operation::Base - Instance Methods
+>
+    - context [Hash]          - used to pass information between steps - only for internal usage
+    - params [Hash]           - immutable and received in call method
+    - dependencies [Hash]     - immutable and received in call method
+    - finish!                 - this method interrupts the execution of steps after is invoked
+
 ## Opera::Operation::Base - Class Methods
+
+#### `context_reader`
+
+The `context_reader` helper method is designed to facilitate easy access to specified keys within a `context` hash. It dynamically defines a method that acts as a getter for the value associated with a specified key, simplifying data retrieval.
+
+#### Parameters
+**key (Symbol):** The key(s) for which the getter and setter methods are to be created. These symbols should correspond to keys in the context hash.
+
+**default (Proc, optional):** A lambda or proc that returns a default value for the key if it is not present in the context hash. This proc is lazily evaluated only when the getter is invoked and the key is not present in the hash.
+
+#### Usage
+
+**GOOD**
+
+```ruby
+# USE context_reader to read steps outputs from the context hash
+
+context_reader :schema_output
+
+validate :schema # context = { schema_output: { id: 1 } }
+step :do_something
+
+def do_something
+  puts schema_output  # outputs: { id: 1 }
+end
+```
+
+```ruby
+# USE context_reader with 'default' option to provide default value when key is missing in the context hash
+
+context_reader :profile, default: -> { Profile.new }
+
+step :fetch_profile
+step :do_something
+
+def fetch_profile
+  return if App.http_disabled?
+
+  context[:profile] = ProfileFetcher.call
+end
+
+def update_profile
+  profile.name = 'John'
+  profile.save!
+end
+```
+
+**BAD**
+
+```ruby
+# Using `context_reader` to create read-only methods that instantiate objects,
+# especially when these objects are not stored or updated in the `context` hash, is not recommended.
+# This approach can lead to confusion and misuse of the context hash,
+# as it suggests that the object might be part of the persistent state.
+context_reader :serializer, default: -> { ProfileSerializer.new }
+
+step :output
+
+def output
+  self.result = serializer.to_json({...})
+end
+
+
+# A better practice is to use private methods to define read-only access to resources
+# that are instantiated on the fly and not intended for storage in any state context.
+
+step :output
+
+def output
+  self.result = serializer.to_json({...})
+end
+
+private
+
+def serializer
+  ProfileSerializer.new
+end
+```
+**Conclusion**
+
+For creating instance methods that are meant to be read-only and not stored within a context hash, defining these methods as private is a more suitable and clear approach compared to using context_reader with a default. This method ensures that transient dependencies remain well-encapsulated and are not confused with persistent application state.
+
+#### `context_writer`
+
+The `context_writer` helper method is designed to enable setting of values for specified keys within a `context` hash. This method dynamically defines a method that acts as a setter, allowing for the direct modification of the value associated with a given key.
+
+#### Usage
+```ruby
+context_writer :profile
+
+step :fetch_profile
+
+def fetch_profile
+  self.profile = ProfileFetcher.call # sets context[:profile]
+end
+```
+
+#### `context_accessor`
+
+The `context_accessor` helper method is designed to enable easy access to and modification of values for specified keys within a `context` hash. This method dynamically defines both getter and setter methods for the designated keys, facilitating straightforward retrieval and update of values.
+
+#### Parameters
+
+**key (Symbol):** The key(s) for which the getter and setter methods are to be created. These symbols will correspond to keys in the context hash.
+
+**default (Proc, optional):** A lambda or proc that returns a default value for the key if it is not present in the context hash. This proc is lazily evaluated only when the getter is invoked and the key is not present in the hash.
+
+#### Usage
+```ruby
+context_accessor :profile
+
+step :fetch_profile
+step :update_profile
+
+def fetch_profile
+  self.profile = ProfileFetcher.call # sets context[:profile]
+end
+
+def update_profile
+  profile.update!(name: 'John') # reads profile from context[:profile]
+end
+```
+
+```ruby
+context_accessor :profile, default: -> { Profile.new }
+```
+
+```ruby
+context_accessor :profile, :account
+```
+
+#### Other methods
 >
-    - context_[reader|writer|accessor] - predefined methods for easy access
     - [params|dependencies]_reader     - predefined readers for immutable arguments
     - step(Symbol)             - single instruction
       - return [Truthly]       - continue operation execution
@@ -903,13 +1042,6 @@ Opera::Operation::Result.new(output: 'success')
     - call(params: Hash, dependencies: Hash?)
       - return [Opera::Operation::Result] - never raises an exception
 
-## Opera::Operation::Base - Instance Methods
->
-    - context [Hash]          - used to pass information between steps - only for internal usage
-    - params [Hash]           - immutable and received in call method
-    - dependencies [Hash]     - immutable and received in call method
-    - finish!                 - this method interrupts the execution of steps after is invoked
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/opera/operation/base.rb

@@ -14,6 +14,7 @@ module Opera
         @result = Result.new
         @params = params.freeze
         @dependencies = dependencies.freeze
+        config
       end
 
       def config

data/lib/opera/operation/config.rb

@@ -3,13 +3,19 @@
 module Opera
   module Operation
     class Config
-      attr_accessor :transaction_class, :transaction_method, :transaction_options, :reporter
+      DEVELOPMENT_MODE = :development
+      PRODUCTION_MODE = :production
+
+      attr_accessor :transaction_class, :transaction_method, :transaction_options, :reporter, :mode
 
       def initialize
         @transaction_class = self.class.transaction_class
         @transaction_method = self.class.transaction_method || :transaction
         @transaction_options = self.class.transaction_options
+        @mode = self.class.mode || DEVELOPMENT_MODE
         @reporter = custom_reporter || self.class.reporter
+
+        validate!
       end
 
       def configure
@@ -20,12 +26,28 @@ module Opera
         Rails.application.config.x.reporter.presence if defined?(Rails)
       end
 
+      private
+
+      def validate!
+        unless [DEVELOPMENT_MODE, PRODUCTION_MODE].include?(mode)
+          raise ArgumentError, 'Mode is incorrect. Can be either: development or production' 
+        end
+      end
+
       class << self
-        attr_accessor :transaction_class, :transaction_method, :transaction_options, :reporter
+        attr_accessor :transaction_class, :transaction_method, :transaction_options, :reporter, :mode
 
         def configure
           yield self
         end
+
+        def development_mode?
+          mode == DEFAULT_MODE
+        end
+
+        def production_mode?
+          mode == PRODUCTION_MODE
+        end
       end
     end
   end

data/lib/opera/operation/instructions/executors/operation.rb

@@ -18,7 +18,7 @@ module Opera
             end
 
             execution = result.executions.pop
-            result.executions << { execution => operation_result.executions }
+            result.add_execution(execution => operation_result.executions)
           end
 
           private

data/lib/opera/operation/instructions/executors/operations.rb

@@ -45,7 +45,7 @@ module Opera
           def add_results(instruction, results)
             add_instruction_output(instruction, results.map(&:output))
             execution = result.executions.pop
-            result.executions << { execution => results.map(&:executions) }
+            result.add_execution(execution => results.map(&:executions))
           end
 
           def raise_error

data/lib/opera/operation/result.rb

@@ -71,8 +71,16 @@ module Opera
       end
 
       def add_execution(step)
+        return if config.production_mode?
+
         @executions << step
       end
+
+      private
+
+      def config
+        Config
+      end
     end
   end
 end

data/lib/opera/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Opera
-  VERSION = '0.2.15'
+  VERSION = '0.2.16'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opera
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.16
 platform: ruby
 authors:
 - ProFinda Development Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-06 00:00:00.000000000 Z
+date: 2024-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-validation
@@ -115,7 +115,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: Use simple DSL language to keep your Operations clean and maintainable