standard_procedure_operations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9cfaaef3f5470debfff84e64763fd703752ae0c70a7c62c2926468aa9b897c83
+  data.tar.gz: 2af99adbc94c3c6f734e9272b909d42d199ddc7d7f18a866f4d14bd2ad78b9ff
+SHA512:
+  metadata.gz: 40ba366b5f54cfd1d376ac34731f1d8e462afffef0512b9011603734a3c45319e40994b7790f556e6bfd27923b0cf67aadd521bebf98f004b71d7aad5956c53f
+  data.tar.gz: 833099833d7ef03773530f4301ee5b66434c26c94af54508e0c006aa082e6d4c812b84fd621dd9e5d9cb9a300be17292bf4be7c46679f5429c50937d5362a94b

data/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,261 @@
+# Operations
+Build your business logic operations in an easy to understand format.  
+
+Most times when I'm adding a feature to a complex application, I tend to end up drawing a flowchart.  
+
+"We start here, then we check that option and if it's true then we do this, if it's false then we do that"
+
+In effect, that flowchart is a state machine - with "decision states" and "action states".  And Operations is intended to be a way of designing your ruby class so that flowchart becomes easy to follow.  
+
+## Usage
+Here's a simplified example from [Collabor8Online](https://www.collabor8online.co.uk) - in C8O when you download a document, we need to check your access rights, as well as ensuring that the current user has not breached their monthly download limit.  In addition, some accounts have a "filename scrambler" switched on - where the original filename is replaced (which is a feature used by some of our clients on their customers' trial accounts).  
+
+### Defining an operation
+The flowchart, for this simplified example, is something like this: 
+
+```
+START -> CHECK AUTHORISATION
+         Is this user authorised?
+         NO -> FAIL
+         YES -> CHECK DOWNLOAD LIMITS
+
+         CHECK DOWNLOAD LIMITS
+         Is this user within their monthly download limit?
+         NO -> FAIL
+         YES -> CHECK FILENAME SCRAMBLER
+
+         CHECK FILENAME SCRAMBLER
+         Is the filename scrambler switched on for this account?
+         NO -> PREPARE DOWNLOAD
+         YES -> SCRAMBLE FILENAME
+
+         SCRAMBLE FILENAME
+         Replace the filename with a scrambled one
+         THEN -> PREPARE DOWNLOAD
+
+         PREPARE DOWNLOAD
+         Return the document's filename so it can be used when sending the document to the end user
+         DONE
+```
+
+We have five states - three of which are decisions, one is an action and one is a result.  
+
+Here's how this would be represented using Operations.  
+
+```ruby
+class PrepareDocumentForDownload < Operations::Task
+  starts_with :authorised?
+
+  decision :authorised? do
+    if_true :within_download_limits?
+    if_false { fail_with "unauthorised" }
+  end
+
+  decision :within_download_limits? do
+    if_true :use_filename_scrambler?
+    if_false { fail_with "download_limit_reached" }
+  end
+
+  decision :use_filename_scrambler? do
+    condition { use_filename_scrambler }
+    if_true :scramble_filename
+    if_false :return_filename
+  end
+
+  action :scramble_filename do
+    self.filename = "#{Faker::Lorem.word}#{File.extname(document.filename.to_s)}"
+    go_to :return_filename
+  end
+
+  result :return_filename do |results|
+    results.filename = filename || document.filename.to_s
+  end
+
+  private def authorised?(data) = data.user.can?(:read, data.document)
+  private def within_download_limits?(data) = data.user.within_download_limits?
+end
+```
+
+The five states are represented as three [decision](#decisions) handlers, one [action](#actions) handler and a [result](#results) handler.  
+
+### Decisions
+A decision handler evaluates a condition, then changes state depending upon if the result is true or false. 
+
+It's up to you whether you define the condition as a block, as part of the decision handler, or as a method on the task object.  
+
+```ruby
+decision :is_it_the_weekend? do 
+  condition { Date.today.wday.in? [0, 6] }
+  if_true :have_a_party 
+  if_false :go_to_work
+end
+```
+Or
+```ruby
+decision :is_it_the_weekend? do 
+  if_true :have_a_party 
+  if_false :go_to_work
+end
+
+def is_it_the_weekend?(data)
+  Date.today.wday.in? [0, 6]
+end
+```
+A decision can also mark a failure, which will terminate the task.  
+```ruby
+decision :authorised? do 
+  condition { user.administrator? }
+  if_true :do_some_work 
+  if_false { fail_with "Unauthorised" }
+end
+```
+
+### Actions
+An action handler does some work, then moves to another state.  
+
+```ruby 
+action :have_a_party do
+  self.food = task.buy_some_food_for(number_of_guests)
+  self.beer = task.buy_some_beer_for(number_of_guests)
+  self.music = task.plan_a_party_playlist
+  go_to :send_invitations
+end
+```
+Again, instead of using a block in the action handler, you could provide a method to do the work.
+
+```ruby
+action :have_a_party
+
+def have_a_party(data)
+  data.food = buy_some_food_for(data.number_of_guests)
+  data.beer = buy_some_beer_for(data.number_of_guests)
+  data.music = plan_a_party_playlist
+  go_to :send_invitations
+end
+```
+Note that when using a method you need to refer to the `data` parameter directly, when using a block, you need to refer to the `task` - see the section on "[Data](#data-and-results)" for more information.
+
+Do not forget to call `go_to` from your action handler, otherwise the operation will just stop whilst still being marked as in progress.  
+
+### Results
+A result handler marks the end of an operation, optionally returning some results.  You need to copy your desired results from your [data](#data-and-results) to your results object.  This is so only the information that matters to you is stored in the database (as many operations may have a large set of working data).  
+
+```ruby
+action :send_invitations do 
+  self.invited_friends = (0..number_of_guests).collect do |i|
+    friend = friends.pop
+    FriendsMailer.with(recipient: friend).party_invitation.deliver_later
+    friend 
+  end
+  go_to :ready_to_party
+end
+
+result :ready_to_party do |results|
+  results.invited_friends = invited_friends
+end
+```
+After this result handler has executed, the task will then be marked as `completed?`, the task's state will be `ready_to_party` and `results.invited_friends` will contain an array of the people you sent invitations to.  
+
+If you don't have any meaningful results, you can omit the block on your result handler.  
+```ruby
+result :go_to_work
+```
+In this case, the task will be marked as `completed?`, the task's state will be `go_to_work` and `results` will be empty.  
+
+### Calling an operation
+You would use the earlier [PrepareDocumentForDownload](spec/examples/prepare_document_for_download_spec.rb) operation in a controller like this:
+
+```ruby
+class DownloadsController < ApplicationController 
+  def show 
+    @document = Document.includes(:account).find(params[:id])
+    @task = PrepareDocumentForDownload.call(user: Current.user, document: @document, use_filename_scrambler: @document.account.use_filename_scrambler?)
+    if @task.completed?
+      @filename = @task.results.filename
+      send_data @document.contents, filename: @filename, disposition: "attachment"
+    else
+      render action: "error", message: @task.results.failure_message, status: 401
+    end
+  end
+end
+```
+
+OK - so that's a pretty longwinded way of performing a simple task.  But, in Collabor8Online, the actual operation for handling downloads has over twenty states, with half of them being decisions (as there are a number of feature flags and per-account configuration options).  When you get to complex decision trees like that, being able to lay them out as state transitions becomes invaluable.  
+
+### Data and results
+Each operation carries its own, mutable, data for the duration of the operation.  This is provided when you `call` the operation to start it and is passed through to each decision, action and result.  This data is transient and not stored in the database. If you modify the data then that modification is passed on to the next handler.  
+
+For example, in the [DownloadsController](#calling-an-operation) shown above, the `user`, `document` and `use_filename_scrambler` are set within the data object when the operation is started.  But if the `scramble_filename` action is called, it generates a new filename and adds that to the data object as well.  Finally the `return_filename` result handler then returns either the scrambled or the original filename to the caller. 
+
+Within handlers implemented as blocks, you can read the data directly - for example, `condition { use_filename_scrambler }` from the `use_filename_scrambler?` decision shown earlier.  If you want to modify a value, or add a new one, you must use `self` - `self.my_data = "something important"`.  This is because the data is carried using a [DataCarrier](/app/models/operations/task/data_carrier.rb) object and `instance_eval` is used within your block handlers.  This also means that block handlers must use `task.method` to access methods or data on the task object itself (as you are not actually within the context of the task object itself).  The exceptions are the `go_to` and `fail_with` methods which the data carrier forwards to the task.  
+
+Handlers can alternatively be implemented as methods on the task itself.  This means that they are executed within the context of the task and can methods and variables belonging to the task.  Each handler method receives a `data` parameter which is the data carrier for that task.  Individual items can be accessed as a hash - `data[:my_item]` - or as an attribute - `data.my_item`.  
+
+The final `results` data from any `result` handlers is stored, along with the task, in the database, so it can be examined later.  It is accessed as an OpenStruct that is encoded into JSON.  But any ActiveRecord models are translated using a [GlobalID](https://github.com/rails/globalid) using [ActiveJob::Arguments](https://guides.rubyonrails.org/active_job_basics.html#supported-types-for-arguments).  Be aware that if you do store an ActiveRecord model into your `results` and that model is later deleted from the database, your task's `results` will be unavailable, as the `GlobalID::Locator` will fail when it tries to load the record.  The data is not lost though - if the deserialisation fails, the routine will return the JSON string as `results.raw_data`.
+
+### Failures and exceptions
+
+If any handlers raise an exception, the task will be terminated. It will be marked as `failed?` and the `results` hash will contain `results.exception_message`, `results.exception_class` and `results.exception_backtrace` for the exception's message, class name and backtrace respectively.  
+
+You can also stop a task at any point by calling `fail_with message`.  This will mark the task as `failed?` and the `reeults` has will contain `results.failure_message`.
+
+### Task life-cycle and the database
+
+There is an ActiveRecord migration that creates the `operations_tasks` table.  Use `bin/rails app:operations:install:migrations` to copy it to your application.  
+
+When you `call` a task, it is written to the database.  Then whenever a state transition occurs, the task record is updated.  
+
+This gives you a number of possibilities: 
+- you can access the results (or error state) of a task after it has completed
+- you can use [TurboStream broadcasts](https://turbo.hotwired.dev/handbook/streams) to update your user-interface as the state changes - see "[status messages](#status-messages)" below
+- tasks can run in the background (using ActiveJob) and other parts of your code can interact with them whilst they are in progress - see "[background operations](#background-operations-and-pauses)" below
+- the tasks table acts as an audit trail or activity log for your application
+
+However, it also means that your database table could fill up with junk that you're no longer interested in.  Therefore you can specify the maximum age of a task and, periodically, clean old tasks away.  Every task has a `delete_at` field that, by default, is set to `90.days.from_now`.  This can be changed by calling `Operations::Task.delete_after 7.days` (or whatever value you prefer).  Then, run a cron job (once per day) that calls `Operations::Task.delete_expired`, removing any tasks whose `deleted_at` date has passed.  
+
+### Status messages
+
+Documentation coming soon.  
+
+### Child tasks
+
+Coming soon.  
+
+### Background operations and pauses
+
+Coming soon.  
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem "standard_procedure_operations"
+```
+
+Run `bundle install`, copy and run the migrations to add the tasks table to your database:
+
+```sh
+bin/rails app:operations:install:migrations 
+bin/rails db:migrate
+```
+
+Then create your own operations by inheriting from `Operations::Task`.
+
+```ruby
+class DailyLife < Operations::Task
+  starts_with :am_i_awake?
+
+  decision :am_i_awake? do 
+    if_true :live_like_theres_no_tomorrow 
+    if_false :rest_and_recuperate
+  end 
+
+  result :live_like_theres_no_tomorrow 
+  result :rest_and_recuperate
+
+  def am_i_awake? = (7..23).include?(Time.now.hour)
+end
+```
+
+## License
+The gem is available as open source under the terms of the [LGPL License](/LICENSE).  This may or may not make it suitable for your needs.

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("spec/test_app/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+require "rspec/core"
+require "rspec/core/rake_task"
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(spec: "app:db:test:prepare")
+
+task default: :spec

data/app/models/operations/task/data_carrier.rb

@@ -0,0 +1,5 @@
+class Operations::Task::DataCarrier < OpenStruct
+  def go_to(state, message = nil) = task.go_to(state, self, message)
+
+  def fail_with(message) = task.fail_with(message)
+end

data/app/models/operations/task/deletion.rb

@@ -0,0 +1,17 @@
+module Operations::Task::Deletion
+  extend ActiveSupport::Concern
+
+  included do
+    scope :for_deletion, -> { where(delete_at: ..Time.now.utc) }
+    attribute :delete_at, :datetime, default: -> { deletes_after.from_now.utc }
+    validates :delete_at, presence: true
+  end
+
+  class_methods do
+    def delete_after(value) = @@deletes_after = value
+
+    def deletes_after = @@deletes_after ||= 90.days
+
+    def delete_expired = for_deletion.destroy_all
+  end
+end

data/app/models/operations/task/state_management.rb

@@ -0,0 +1,80 @@
+module Operations::Task::StateManagement
+  extend ActiveSupport::Concern
+
+  included do
+    attribute :state, :string
+    validate :state_is_valid
+  end
+
+  class_methods do
+    def starts_with(value) = @initial_state = value.to_sym
+
+    def initial_state = @initial_state
+
+    def decision(name, &config) = state_handlers[name.to_sym] = DecisionHandler.new(name, &config)
+
+    def action(name, &handler) = state_handlers[name.to_sym] = ActionHandler.new(name, &handler)
+
+    def result(name, &results) = state_handlers[name.to_sym] = CompletionHandler.new(name, &results)
+
+    def state_handlers = @state_handlers ||= {}
+
+    def handler_for(state) = state_handlers[state.to_sym]
+  end
+
+  private def handler_for(state) = self.class.handler_for(state.to_sym)
+  private def process_current_state(data)
+    handler_for(state).call(self, data)
+  rescue => ex
+    update! status: "failed", results: OpenStruct.new(exception_message: ex.message, exception_class: ex.class.name, exception_backtrace: ex.backtrace)
+  end
+  private def state_is_valid
+    errors.add :state, :invalid if state.blank? || handler_for(state.to_sym).nil?
+  end
+
+  class ActionHandler
+    def initialize name, &action
+      @name = name.to_sym
+      @action = action
+    end
+
+    def call(task, data)
+      @action.nil? ? task.send(@name, data) : data.instance_exec(&@action)
+    end
+  end
+
+  class DecisionHandler
+    def initialize name, &config
+      @name = name.to_sym
+      @condition = nil
+      @true_state = nil
+      @false_state = nil
+      instance_eval(&config)
+    end
+
+    def condition(&condition) = @condition = condition
+
+    def if_true(state = nil, &handler) = @true_state = state || handler
+
+    def if_false(state = nil, &handler) = @false_state = state || handler
+
+    def call(task, data)
+      result = @condition.nil? ? task.send(@name, data) : data.instance_exec(&@condition)
+      next_state = result ? @true_state : @false_state
+      next_state.respond_to?(:call) ? data.instance_eval(&next_state) : task.go_to(next_state, data)
+    end
+  end
+
+  class CompletionHandler
+    def initialize name, &handler
+      @name = name.to_sym
+      @handler = handler
+    end
+
+    def call(task, data)
+      results = OpenStruct.new
+      data.instance_exec(results, &@handler) unless @handler.nil?
+      task.send :complete, results
+    end
+  end
+end

data/app/models/operations/task.rb

@@ -0,0 +1,20 @@
+module Operations
+  class Task < ApplicationRecord
+    include StateManagement
+    include Deletion
+    enum :status, in_progress: 0, completed: 1, failed: -1
+    composed_of :results, class_name: "OpenStruct", constructor: ->(results) { results.to_h }, converter: ->(hash) { OpenStruct.new(hash) }
+    serialize :results, coder: Operations::GlobalIDSerialiser, type: Hash, default: {}
+
+    def self.call(data = {}) = create!(state: initial_state).tap { |task| task.send(:process_current_state, DataCarrier.new(data.merge(task: task))) }
+
+    def go_to(state, data = {}, message = nil)
+      update!(state: state, status_message: message || state.to_s)
+      process_current_state(data)
+    end
+
+    def fail_with(message) = update! status: "failed", results: {failure_message: message.to_s}
+
+    private def complete(results) = update!(status: "completed", results: results)
+  end
+end

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/db/migrate/20250127160616_create_operations_tasks.rb

@@ -0,0 +1,17 @@
+class CreateOperationsTasks < ActiveRecord::Migration[8.0]
+  def change
+    create_table :operations_tasks do |t|
+      t.string :type
+      t.integer :status, default: 0, null: false
+      t.string :state, null: false
+      t.string :status_message, default: "", null: false
+      t.text :data, default: "{}"
+      t.text :results, default: "{}"
+      t.boolean :background, default: false, null: false
+      t.datetime :delete_at, null: false, index: true
+      t.timestamps
+    end
+
+    add_index :operations_tasks, [:type, :status]
+  end
+end

data/lib/operations/engine.rb

@@ -0,0 +1,11 @@
+module Operations
+  class Engine < ::Rails::Engine
+    isolate_namespace Operations
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/operations/global_id_serialiser.rb

@@ -0,0 +1,21 @@
+module Operations
+  # Serialise and deserialise data to and from JSON
+  # Unlike the standard JSON coder, this coder uses the ActiveJob::Arguments serializer.
+  # This means that if the data contains an ActiveRecord model, it will be serialised as a GlobalID string
+  #
+  # Usage:
+  # class MyModel < ApplicationRecord
+  #   serialize :data, coder: GlobalIDSerialiser, type: Hash, default: {}
+  # end
+  # @my_model = MyModel.create! data: {hello: "world", user: User.first}
+  # puts @my_model[:data] # => {hello: "world", user: #<User id: 1>}
+  class GlobalIDSerialiser
+    def self.dump(data) = ActiveSupport::JSON.dump(ActiveJob::Arguments.serialize([data]))
+
+    def self.load(json)
+      ActiveJob::Arguments.deserialize(ActiveSupport::JSON.decode(json)).first
+    rescue => ex
+      {exception_message: ex.message, exception_class: ex.class.name, raw_data: json.to_s}
+    end
+  end
+end

data/lib/operations/version.rb

@@ -0,0 +1,3 @@
+module Operations
+  VERSION = "0.1.0"
+end

data/lib/operations.rb

@@ -0,0 +1,7 @@
+require "ostruct"
+
+module Operations
+  require "operations/version"
+  require "operations/engine"
+  require "operations/global_id_serialiser"
+end

data/lib/standard_procedure_operations.rb

@@ -0,0 +1 @@
+require_relative "operations"

data/lib/tasks/operations_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :operations do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: standard_procedure_operations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rahoul Baruah
+bindir: bin
+cert_chain: []
+date: 2025-01-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.1.3
+description: Pipelines and State Machines for composable, trackable business logic
+email:
+- rahoulb@echodek.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- app/models/operations/task.rb
+- app/models/operations/task/data_carrier.rb
+- app/models/operations/task/deletion.rb
+- app/models/operations/task/state_management.rb
+- config/routes.rb
+- db/migrate/20250127160616_create_operations_tasks.rb
+- lib/operations.rb
+- lib/operations/engine.rb
+- lib/operations/global_id_serialiser.rb
+- lib/operations/version.rb
+- lib/standard_procedure_operations.rb
+- lib/tasks/operations_tasks.rake
+homepage: https://theartandscienceofruby.com/
+licenses:
+- LGPL
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://theartandscienceofruby.com/
+  source_code_uri: https://github.com/standard-procedure/operations
+  changelog_uri: https://github.com/standard-procedure/operations/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Operations
+test_files: []