transactable 0.0.0

data/lib/transactable/pipeable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "dry/monads/result"
+
+module Transactable
+  # Allows any object to pipe sequential steps together which can be composed into a single result.
+  class Pipeable < Module
+    def initialize steps = Steps::Container
+      super()
+      @steps = steps
+      @instance_module = Class.new(Module).new
+    end
+
+    def included klass
+      super
+      define_pipe
+      define_steps
+      klass.include instance_module
+    end
+
+    private
+
+    attr_reader :steps, :instance_module
+
+    def define_pipe
+      instance_module.define_method :pipe do |input, *steps|
+        fail ArgumentError, "Transaction must have at least one step." if steps.empty?
+
+        result = input.is_a?(Dry::Monads::Result) ? input : Dry::Monads::Success(input)
+
+        steps.reduce(&:>>).call result
+      rescue NoMethodError
+        raise TypeError, "Step must be functionally composable and answer a monad."
+      end
+    end
+
+    def define_steps
+      instance_module.class_exec steps do |container|
+        container.each_key do |name|
+          define_method name do |*positionals, **keywords, &block|
+            step = container[name]
+            step.is_a?(Proc) ? step : step.new(*positionals, **keywords, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/transactable/steps/abstract.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "dry/monads"
+
+module Transactable
+  module Steps
+    # Provides the blueprint for a step to used in function composition.
+    class Abstract
+      DEPENDENCIES = %i[instrument marameters].freeze
+
+      # rubocop:todo Layout/ClassStructure
+      include Import[*DEPENDENCIES]
+      # rubocop:enable Layout/ClassStructure
+      include Dry::Monads[:result]
+      include Composable
+
+      def initialize *positionals, **keywords, &block
+        super(**keywords.slice(*DEPENDENCIES))
+        @base_positionals = positionals
+        @base_keywords = keywords.except(*DEPENDENCIES)
+        @base_block = block
+      end
+
+      protected
+
+      attr_reader :base_positionals, :base_keywords, :base_block
+    end
+  end
+end

data/lib/transactable/steps/as.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Allows result to be messaged as a callable.
+    class As < Abstract
+      prepend Instrumentable
+
+      def call result
+        result.fmap { |operation| operation.public_send(*base_positionals, **base_keywords) }
+      end
+    end
+  end
+end

data/lib/transactable/steps/bind.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Wraps Dry Monads `#bind` method as a step.
+    class Bind < Abstract
+      prepend Instrumentable
+
+      def call(result) = result.bind { |input| base_block.call input }
+    end
+  end
+end

data/lib/transactable/steps/check.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Checks if operation is true and then answers success (passthrough) or failure (with argument).
+    class Check < Abstract
+      prepend Instrumentable
+
+      def initialize operation, message, **dependencies
+        super(**dependencies)
+        @operation = operation
+        @message = message
+      end
+
+      def call result
+        result.bind do |arguments|
+          answer = question arguments
+          answer == true || answer.is_a?(Success) ? result : Failure(arguments)
+        end
+      end
+
+      private
+
+      attr_reader :operation, :message
+
+      def question arguments
+        splat = marameters.categorize operation.method(message).parameters, arguments
+        operation.public_send(message, *splat.positionals, **splat.keywords, &splat.block)
+      end
+    end
+  end
+end

data/lib/transactable/steps/container.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "dry/container"
+
+module Transactable
+  module Steps
+    # Registers all default steps.
+    module Container
+      extend Dry::Container::Mixin
+
+      register(:as) { As }
+      register(:bind) { Bind }
+      register(:check) { Check }
+      register(:fmap) { Fmap }
+      register(:insert) { Insert }
+      register(:map) { Map }
+      register(:merge) { Merge }
+      register(:orr) { Or }
+      register(:tee) { Tee }
+      register(:to) { To }
+      register(:try) { Try }
+      register(:use) { Use }
+      register(:validate) { Validate }
+    end
+  end
+end

data/lib/transactable/steps/fmap.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Wraps Dry Monads `#fmap` method as a step.
+    class Fmap < Abstract
+      prepend Instrumentable
+
+      def call(result) = result.fmap { |input| base_block.call input }
+    end
+  end
+end

data/lib/transactable/steps/insert.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Inserts elements before, after, or around input.
+    class Insert < Abstract
+      prepend Instrumentable
+
+      LAST = -1
+
+      def initialize *positionals, at: LAST, **dependencies
+        super(*positionals, **dependencies)
+        @value = positionals.empty? ? base_keywords : positionals.flatten
+        @at = at
+      end
+
+      def call result
+        result.fmap do |input|
+          cast = input.is_a?(Array) ? input : [input]
+          value.is_a?(Array) ? cast.insert(at, *value) : cast.insert(at, value)
+        end
+      end
+
+      private
+
+      attr_reader :value, :at
+    end
+  end
+end

data/lib/transactable/steps/map.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Maps over a collection, processing each element, and answering a new result.
+    class Map < Abstract
+      prepend Instrumentable
+
+      def call(result) = result.fmap { |collection| collection.map(&base_block) }
+    end
+  end
+end

data/lib/transactable/steps/merge.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Merges initialized attributes with step argument for use by a subsequent step.
+    class Merge < Abstract
+      prepend Instrumentable
+
+      def initialize as: :step, **keywords
+        super(**keywords)
+        @as = as
+      end
+
+      def call result
+        result.fmap do |input|
+          if input.is_a? Hash
+            input.merge! base_keywords
+          else
+            {as => input}.merge!(base_keywords)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :as
+    end
+  end
+end

data/lib/transactable/steps/or.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Wraps Dry Monads `#or` method as a step.
+    class Or < Abstract
+      prepend Instrumentable
+
+      def call(result) = result.or { |input| base_block.call input }
+    end
+  end
+end

data/lib/transactable/steps/tee.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Messages operation, without any response checks, while passing input through as output.
+    class Tee < Abstract
+      prepend Instrumentable
+
+      def initialize operation, *positionals, **dependencies
+        super(*positionals, **dependencies)
+        @operation = operation
+      end
+
+      def call result
+        operation.public_send(*base_positionals, **base_keywords)
+        result
+      end
+
+      private
+
+      attr_reader :operation
+    end
+  end
+end

data/lib/transactable/steps/to.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Delegates to a non-callable operation which automatically wraps the result if necessary.
+    class To < Abstract
+      prepend Instrumentable
+
+      def initialize operation, message, **dependencies
+        super(**dependencies)
+        @operation = operation
+        @message = message
+      end
+
+      def call result
+        result.bind do |arguments|
+          splat = marameters.categorize operation.method(message).parameters, arguments
+          wrap operation.public_send(message, *splat.positionals, **splat.keywords, &splat.block)
+        end
+      end
+
+      private
+
+      attr_reader :operation, :message
+
+      def wrap(result) = result.is_a?(Dry::Monads::Result) ? result : Success(result)
+    end
+  end
+end

data/lib/transactable/steps/try.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Messages a risky operation which may pass or fail.
+    class Try < Abstract
+      prepend Instrumentable
+
+      def initialize *positionals, catch:, **keywords
+        super(*positionals, **keywords)
+        @catch = catch
+      end
+
+      def call result
+        result.fmap { |operation| operation.public_send(*base_positionals, **base_keywords) }
+      rescue *Array(catch) => error
+        Failure error.message
+      end
+
+      private
+
+      attr_reader :catch
+    end
+  end
+end

data/lib/transactable/steps/use.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Use another transaction -- or any command -- which answers a result.
+    class Use < Abstract
+      prepend Instrumentable
+
+      def initialize operation, **dependencies
+        super(**dependencies)
+        @operation = operation
+      end
+
+      def call(result) = result.bind { |input| operation.call input }
+
+      private
+
+      attr_reader :operation
+    end
+  end
+end

data/lib/transactable/steps/validate.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Transactable
+  module Steps
+    # Validates a result via a callable operation.
+    class Validate < Abstract
+      prepend Instrumentable
+
+      def initialize operation, as: :to_h, **dependencies
+        super(**dependencies)
+        @operation = operation
+        @as = as
+      end
+
+      def call result
+        result.bind do |payload|
+          value = operation.call payload
+
+          return Failure value if value.failure?
+
+          Success(as ? value.public_send(as) : value)
+        end
+      end
+
+      private
+
+      attr_reader :operation, :as
+    end
+  end
+end

data/lib/transactable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+Zeitwerk::Loader.for_gem.setup
+
+# Main namespace.
+module Transactable
+  def self.included(klass) = klass.include Pipeable.new
+
+  def self.with(...) = Pipeable.new(...)
+end

data/transactable.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "transactable"
+  spec.version = "0.0.0"
+  spec.authors = ["Brooke Kuhlmann"]
+  spec.email = ["brooke@alchemists.io"]
+  spec.homepage = "https://www.alchemists.io/projects/transactable"
+  spec.summary = "A DSL for transactional workflows built atop function composition."
+  spec.license = "Hippocratic-2.1"
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/bkuhlmann/transactable/issues",
+    "changelog_uri" => "https://www.alchemists.io/projects/transactable/versions",
+    "documentation_uri" => "https://www.alchemists.io/projects/transactable",
+    "funding_uri" => "https://github.com/sponsors/bkuhlmann",
+    "label" => "Transactable",
+    "rubygems_mfa_required" => "true",
+    "source_code_uri" => "https://github.com/bkuhlmann/transactable"
+  }
+
+  spec.signing_key = Gem.default_key_path
+  spec.cert_chain = [Gem.default_cert_path]
+
+  spec.required_ruby_version = "~> 3.1"
+
+  spec.add_dependency "dry-container", "~> 0.10"
+  spec.add_dependency "dry-events", "~> 0.3"
+  spec.add_dependency "dry-monads", "~> 1.4"
+  spec.add_dependency "infusible", "~> 0.0"
+  spec.add_dependency "marameters", "~> 0.9"
+  spec.add_dependency "refinements", "~> 9.6"
+  spec.add_dependency "zeitwerk", "~> 2.6"
+
+  spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
+  spec.files = Dir["*.gemspec", "lib/**/*"]
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: transactable
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Brooke Kuhlmann
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIC/jCCAeagAwIBAgIBBTANBgkqhkiG9w0BAQsFADAlMSMwIQYDVQQDDBpicm9v
+  a2UvREM9YWxjaGVtaXN0cy9EQz1pbzAeFw0yMjAzMTkxNzI0MzJaFw0yMzAzMTkx
+  NzI0MzJaMCUxIzAhBgNVBAMMGmJyb29rZS9EQz1hbGNoZW1pc3RzL0RDPWlvMIIB
+  IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6l1qpXTiomH1RfMRloyw7MiE
+  xyVx/x8Yc3EupdH7uhNaTXQGyORN6aOY//1QXXMHIZ9tW74nZLhesWMSUMYy0XhB
+  brs+KkurHnc9FnEJAbG7ebGvl/ncqZt72nQvaxpDxvuCBHgJAz+8i5wl6FhLw+oT
+  9z0A8KcGhz67SdcoQiD7qiCjL/2NTeWHOzkpPrdGlt088+VerEEGf5I13QCvaftP
+  D5vkU0YlAm1r98BymuJlcQ1qdkVEI1d48ph4kcS0S0nv1RiuyVb6TCAR3Nu3VaVq
+  3fPzZKJLZBx67UvXdbdicWPiUR75elI4PXpLIic3xytaF52ZJYyKZCNZJhNwfQID
+  AQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU0nzow9vc
+  2CdikiiE3fJhP/gY4ggwDQYJKoZIhvcNAQELBQADggEBAJbbNyWzFjqUNVPPCUCo
+  IMrhDa9xf1xkORXNYYbmXgoxRy/KyNbUr+jgEEoWJAm9GXlcqxxWAUI6pK/i4/Qi
+  X6rPFEFmeObDOHNvuqy8Hd6AYsu+kP94U/KJhe9wnWGMmGoNKJNU3EkW3jM/osSl
+  +JRxiH5t4WtnDiVyoYl5nYC02rYdjJkG6VMxDymXTqn7u6HhYgZkGujq1UPar8x2
+  hNIWJblDKKSu7hA2d6+kUthuYo13o1sg1Da/AEDg0hoZSUvhqDEF5Hy232qb3pDt
+  CxDe2+VuChj4I1nvIHdu+E6XoEVlanUPKmSg6nddhkKn2gC45Kyzh6FZqnzH/CRp
+  RFE=
+  -----END CERTIFICATE-----
+date: 2022-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: dry-events
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: dry-monads
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: infusible
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: marameters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: refinements
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.6'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description:
+email:
+- brooke@alchemists.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.adoc
+- LICENSE.adoc
+files:
+- LICENSE.adoc
+- README.adoc
+- lib/transactable.rb
+- lib/transactable/composable.rb
+- lib/transactable/container.rb
+- lib/transactable/import.rb
+- lib/transactable/instrument.rb
+- lib/transactable/instrumentable.rb
+- lib/transactable/pipeable.rb
+- lib/transactable/steps/abstract.rb
+- lib/transactable/steps/as.rb
+- lib/transactable/steps/bind.rb
+- lib/transactable/steps/check.rb
+- lib/transactable/steps/container.rb
+- lib/transactable/steps/fmap.rb
+- lib/transactable/steps/insert.rb
+- lib/transactable/steps/map.rb
+- lib/transactable/steps/merge.rb
+- lib/transactable/steps/or.rb
+- lib/transactable/steps/tee.rb
+- lib/transactable/steps/to.rb
+- lib/transactable/steps/try.rb
+- lib/transactable/steps/use.rb
+- lib/transactable/steps/validate.rb
+- transactable.gemspec
+homepage: https://www.alchemists.io/projects/transactable
+licenses:
+- Hippocratic-2.1
+metadata:
+  bug_tracker_uri: https://github.com/bkuhlmann/transactable/issues
+  changelog_uri: https://www.alchemists.io/projects/transactable/versions
+  documentation_uri: https://www.alchemists.io/projects/transactable
+  funding_uri: https://github.com/sponsors/bkuhlmann
+  label: Transactable
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/bkuhlmann/transactable
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.22
+signing_key:
+specification_version: 4
+summary: A DSL for transactional workflows built atop function composition.
+test_files: []