operational 0.1.0

data/lib/operational/form.rb

@@ -0,0 +1,72 @@
+module Operational
+  class Form
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include ActiveModel::Dirty
+
+    def self.inherited(subclass)
+      super
+      subclass.instance_variable_set(:@_operational_sync_check_pending, true)
+    end
+
+    def self.method_added(method_name)
+      super
+      if method_name == :sync && @_operational_sync_check_pending
+        raise MethodCollision,
+          "#{self} defines #sync, which collides with Operational::Form#sync. " \
+          "Rename your method to #on_sync — it will be called automatically during sync."
+      end
+    end
+
+    def self.build(model: nil, model_persisted: nil, state: {}, build_method: :on_build)
+      form = new
+
+      if model
+        raise InvalidContractModel unless model.respond_to?(:attributes)
+        valid_form_attrs = form.attribute_names
+        valid_params = model.attributes.slice(*valid_form_attrs).compact
+        form.assign_attributes(valid_params)
+      end
+
+      form.instance_variable_set(:@_operational_model_persisted, (model_persisted.nil? ? model&.persisted? || false : !!model_persisted))
+      form.instance_variable_set(form.send(:_operational_state_variable), state.dup.freeze)
+      form.send(build_method, state) if form.respond_to?(build_method)
+      form.changes_applied if form.respond_to?(:changes_applied)
+      form
+    end
+
+    def validate(params = {})
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+      params = params.with_indifferent_access if params.respond_to?(:with_indifferent_access)
+      valid_params = params.slice(*attribute_names)
+      assign_attributes(valid_params)
+      valid?
+    end
+
+    def sync(model: nil, state: {}, sync_method: :on_sync)
+      if model
+        raise InvalidContractModel unless model.respond_to?(:attributes)
+        valid_model_attrs = model.attribute_names
+        valid_params = attributes.slice(*valid_model_attrs)
+        model.assign_attributes(valid_params)
+      end
+
+      send(sync_method, state) if respond_to?(sync_method)
+      true
+    end
+
+    def persisted?
+      @_operational_model_persisted
+    end
+
+    def other_validators_have_passed?
+      errors.blank?
+    end
+
+    protected
+
+    def _operational_state_variable
+      :@state
+    end
+  end
+end

data/lib/operational/operation/contract.rb

@@ -0,0 +1,42 @@
+module Operational
+  class Operation
+    module Contract
+      def self.Build(contract:, name: :contract, model_key: :model, model_persisted: nil, build_method: :on_build)
+        lambda do |state|
+          model = state.key?(model_key) ? state[model_key] : nil
+          raise InvalidContractModel if state.key?(model_key) && model.nil?
+
+          state[name] = contract.build(
+            model: model,
+            model_persisted: model_persisted,
+            state: state,
+            build_method: build_method
+          )
+          true
+        end
+      end
+
+      def self.Validate(name: :contract, params_path: nil)
+        lambda do |state|
+          valid_path = case
+            when params_path.nil? then [:params]
+            when params_path.is_a?(Symbol) then [:params, params_path]
+            when params_path.is_a?(Array) then params_path
+          end
+
+          raw_params = state.dig(*valid_path) || {}
+          state[name].validate(raw_params)
+        end
+      end
+
+      def self.Sync(name: :contract, model_key: :model, sync_method: :on_sync)
+        lambda do |state|
+          model = state.key?(model_key) ? state[model_key] : nil
+          raise InvalidContractModel if state.key?(model_key) && model.nil?
+
+          state[name].sync(model: model, state: state, sync_method: sync_method)
+        end
+      end
+    end
+  end
+end

data/lib/operational/operation/nested.rb

@@ -0,0 +1,13 @@
+module Operational
+  class Operation
+    module Nested
+      def self.Operation(operation:)
+        lambda do |state|
+          nested_result = operation.call(state)
+          state.merge!(nested_result.state)
+          nested_result.succeeded?
+        end
+      end
+    end
+  end
+end

data/lib/operational/operation.rb

@@ -0,0 +1,66 @@
+module Operational
+  class Operation
+    def self.step(action)
+      add_step(:step, action)
+    end
+
+    def self.pass(action)
+      add_step(:pass, action)
+    end
+
+    def self.fail(action)
+      add_step(:fail, action)
+    end
+
+    def self.call(state={})
+      instance = self.new
+      instance.instance_variable_set(:@_operational_state, state)
+      instance.instance_variable_set(:@_operational_path, [])
+      instance.instance_variable_set(:@_operational_succeeded, true)
+
+      failure_circuit = false
+
+      instance.send(:_operational_steps).each do |railway_step|
+        type, action = railway_step
+
+        next if !failure_circuit && type == :fail
+        next if failure_circuit && type != :fail
+
+        result = if action.is_a?(Symbol)
+          instance.send(action, instance.send(:_operational_state))
+        elsif action.respond_to?(:call)
+          action.call(instance.send(:_operational_state))
+        else
+          raise UnknownStepType
+        end
+
+        result = true if type == :pass
+        instance.instance_variable_set(:@_operational_succeeded, result ? true : false)
+        instance.instance_variable_get(:@_operational_path) << (result ? true : false)
+
+        failure_circuit = !instance.instance_variable_get(:@_operational_succeeded) && type != :pass
+      end
+
+      return Result.new(
+        succeeded: (instance.instance_variable_get(:@_operational_succeeded) ? true : false),
+        state: instance.instance_variable_get(:@_operational_state),
+        operation: instance)
+    end
+
+    private
+
+    def self.add_step(type, action)
+      railway = class_variable_defined?(:@@_operational_steps) ? class_variable_get(:@@_operational_steps) : []
+      railway << [type, action]
+      class_variable_set(:@@_operational_steps, railway)
+    end
+
+    def _operational_steps
+      self.class.class_variable_defined?(:@@_operational_steps) ? self.class.class_variable_get(:@@_operational_steps) : []
+    end
+
+    def _operational_state
+      @_operational_state
+    end
+  end
+end

data/lib/operational/result.rb

@@ -0,0 +1,29 @@
+module Operational
+  class Result
+    def initialize(succeeded:, state:, operation:)
+      @succeeded = succeeded
+      @state = state.dup.freeze
+      @operation = operation
+    end
+
+    def succeeded?
+      @succeeded
+    end
+
+    def failed?
+      !@succeeded
+    end
+
+    def operation
+      @operation
+    end
+
+    def state
+      @state
+    end
+
+    def [](i)
+      @state[i]
+    end
+  end
+end

data/lib/operational/version.rb

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

data/lib/operational.rb

@@ -0,0 +1,14 @@
+require 'active_model'
+
+require "operational/version"
+require "operational/error"
+require "operational/operation"
+require "operational/result"
+require "operational/form"
+require "operational/controller"
+
+require "operational/operation/contract"
+require "operational/operation/nested"
+
+module Operational
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: operational
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bryan Rite
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Operational wraps your business logic into operations — small classes
+  with a railway of steps that succeed or fail. Pair them with form objects and contracts
+  to decouple your UI and APIs from your models.
+email:
+- bryan@bryanrite.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- AI_README.md
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/operational.rb
+- lib/operational/controller.rb
+- lib/operational/error.rb
+- lib/operational/form.rb
+- lib/operational/operation.rb
+- lib/operational/operation/contract.rb
+- lib/operational/operation/nested.rb
+- lib/operational/result.rb
+- lib/operational/version.rb
+homepage: https://github.com/bryanrite/operational
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/bryanrite/operational/blob/master/CHANGELOG.md
+  source_code_uri: https://github.com/bryanrite/operational
+  documentation_uri: https://github.com/bryanrite/operational#readme
+  bug_tracker_uri: https://github.com/bryanrite/operational/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Lightweight, railway-oriented operation and form objects for business logic
+test_files: []