opera 0.2.15 → 0.2.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da6a185f664746509764441abdce1f7ff3b429c0fac119e9442271fe1f19f357
-  data.tar.gz: 898591cfbf92efa85c9c8b3e2b69ee7ca958a3eda0029ac019ca85562f4e3db1
+  metadata.gz: c6b4eeef70ec90ace2eab7861bb9e9801f1e986354a411f2ca426f1380c3a0f7
+  data.tar.gz: b2264478656ffab0e08ae0e50b7b54a4dffdf81d64bb53bb2a27365151700351
 SHA512:
-  metadata.gz: a22fba3cca583d561f2dade3de23246293ca0acadcbf2f60ef5ab41efb6325a49addda52cb3948a12c74c07674a64289aa1e3e500014eb380fa2919648dfffd0
-  data.tar.gz: 2c74a116d21859c048f5c52eef2760806184d8793f569262e22a846ca11c5557f010005cf6e110197258a3f43d1d8fa62551c9ca3c80cd7624ef660d928c58c2
+  metadata.gz: efb5db089f99b26ab2f085e62a064dcaf31adc46632fccc9e51ab73f22dc611d9341f7f3ddb5b4d1bdf5d1c8b598aab54af5071df891f0696f5b8357bcd1960b
+  data.tar.gz: 0c5e84d50fa8f0a0b5f4a839b97e208925420de362ed42ab60e0731aadfe4b7a25462a6927078feb185dd03c2621aa09562a13d5893b3fdba3bd9de171e01fd6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Opera Changelog
 
+### 0.2.17 - July 8, 2024
+
+- minor fix `mode` configuration option.
+
+### 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/executor.rb

@@ -62,6 +62,10 @@ module Opera
         operation.config
       end
 
+      def production_mode?
+        config.mode == Config::PRODUCTION_MODE
+      end
+
       def context
         operation.context
       end

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

@@ -18,7 +18,9 @@ module Opera
             end
 
             execution = result.executions.pop
-            result.executions << { execution => operation_result.executions }
+            result.add_execution(execution => operation_result.executions) unless production_mode?
+
+            operation_result
           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))  unless production_mode?
           end
 
           def raise_error

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

@@ -8,7 +8,7 @@ module Opera
           def call(instruction)
             method = instruction[:method]
 
-            operation.result.add_execution(method)
+            operation.result.add_execution(method) unless production_mode?
             operation.send(method)
           rescue StandardError => exception
             reporter&.error(exception)

data/lib/opera/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opera
 version: !ruby/object:Gem::Version
-  version: 0.2.15
+  version: 0.2.17
 platform: ruby
 authors:
 - ProFinda Development Team
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-06 00:00:00.000000000 Z
+date: 2024-07-08 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