core-operation 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ddabc5be1c80df0049c0d02c04a9c96c30a3ec91da7c91393398902fd41f3d4
-  data.tar.gz: d0c92a5a7f27b5b23265a44551cd913395f40908b97045bf0cf823598ec16402
+  metadata.gz: 31a0abdb122d6ca1ad5fcad68fedfa7f2286d11840d080db2daf54f45b6b153b
+  data.tar.gz: 2c472a84ff410b278d9f13344dcd386cb71c92d31987f6a2639bc9ad16379a16
 SHA512:
-  metadata.gz: adc0ef08a62a4c989676186ec37bfa50ccc8fd04ed7ee55ccc84279144ea44b5a26cfe6fa99cc45e83ade8319b768ca3b0ed1c705ad07f9998ffa131c3f49a1c
-  data.tar.gz: ae9eb2fe7239ed8c46d5db781c69d844145da7563c81d45bfc55da9e85cf95dc6b16ed41e9c8357879c27d992414d7899d78f4a35d5ec4d19eecaf5224056f18
+  metadata.gz: 272370d98179fc6e361e8ffb1ff226ae457922b7a74e32f68026e5db30000b8d95cafd3168c78df0a51424401d019f850c471894d0cdf8870dd74be0af91cf20
+  data.tar.gz: '0188b166e710ade916bf0ac9b7b74fafb686c665943d45ec17730be0fcccccadfcd141335c02d82dd5ddfe493e1688963ecb23f7add7f5f48b33e0b554c14828'

data/CHANGELOG.md

@@ -1,19 +1,29 @@
-## [v0.1.1](https://github.com/metabahn/corerb/releases/tag/2022-01-13)
+## [v0.2.0](https://github.com/bryanp/corerb/releases/tag/2023-12-24)
+
+*released on 2023-12-24*
+
+  * `fix` [#149](https://github.com/bryanp/corerb/pull/149) Fix operations that don't define a default action ([bryanp](https://github.com/bryanp))
+  * `fix` [#148](https://github.com/bryanp/corerb/pull/148) Fix an issue with subclassed operations ([bryanp](https://github.com/bryanp))
+  * `dep` [#143](https://github.com/bryanp/corerb/pull/143) Deprecate `Is::*` and `Refine::*` namespaces ([bryanp](https://github.com/bryanp))
+  * `chg` [#140](https://github.com/bryanp/corerb/pull/140) Refactor operations to be single-action returning a result object ([bryanp](https://github.com/bryanp))
+  * `dep` [#135](https://github.com/bryanp/corerb/pull/135) Remove Ruby 2 support ([bryanp](https://github.com/bryanp))
+
+## [v0.1.1](https://github.com/bryanp/corerb/releases/tag/2022-01-13)
 
 *released on 2022-01-13*
 
-  * `fix` [#120](https://github.com/metabahn/corerb/pull/120) Explicitly require a dependency ([bryanp](https://github.com/bryanp))
+  * `fix` [#120](https://github.com/bryanp/corerb/pull/120) Explicitly require a dependency ([bryanp](https://github.com/bryanp))
 
-## [v0.1.0](https://github.com/metabahn/corerb/releases/tag/2021-11-03)
+## [v0.1.0](https://github.com/bryanp/corerb/releases/tag/2021-11-03)
 
 *released on 2021-11-03*
 
-  * `add` [#104](https://github.com/metabahn/corerb/pull/104) Let operation result be turned into a hash ([bryanp](https://github.com/bryanp))
+  * `add` [#104](https://github.com/bryanp/corerb/pull/104) Let operation result be turned into a hash ([bryanp](https://github.com/bryanp))
 
-## [v0.0.0](https://github.com/metabahn/corerb/releases/tag/2021-11-02)
+## [v0.0.0](https://github.com/bryanp/corerb/releases/tag/2021-11-02)
 
 *released on 2021-11-02*
 
-  * `add` [#90](https://github.com/metabahn/corerb/pull/90) Initial implementation of the core-operation gem ([bryanp](https://github.com/bryanp))
+  * `add` [#90](https://github.com/bryanp/corerb/pull/90) Initial implementation of the core-operation gem ([bryanp](https://github.com/bryanp))
 
 

data/lib/core/operation/action.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "core/inspect"
+require "core/state"
+require "securerandom"
+
+module Core
+  module Operation
+    # [public] An operation action.
+    #
+    class Action
+      include Core::State
+      state :__used_random_suffixes__, default: []
+
+      class << self
+        # [public] Builds an action for a given target.
+        #
+        def build(target = nil, *args, &block)
+          raise ArgumentError, "actions must be defined with a block" unless block
+
+          Actions::Block.new(target, &block)
+        end
+
+        def build_reference
+          suffix = generate_random_suffix
+          if __used_random_suffixes__.include?(suffix)
+            build_reference
+          else
+            __used_random_suffixes__ << suffix
+            "action_#{suffix}"
+          end
+        end
+
+        def generate_random_suffix
+          SecureRandom.hex(8)
+        end
+      end
+
+      include Core::Inspect
+
+      def initialize(name)
+        @name = (name || :call).to_sym
+        @reference = self.class.build_reference.to_sym
+      end
+
+      # [public] The action name.
+      #
+      attr_reader :name
+
+      # [public] The action reference.
+      #
+      attr_reader :reference
+
+      # [public] Finalizes the action for the given context.
+      #
+      def finalize(context)
+        raise "not implemented"
+      end
+
+      require_relative "actions/block"
+    end
+  end
+end

data/lib/core/operation/actions/block.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "core/inspect"
+
+module Core
+  module Operation
+    module Actions
+      # [public] An operation action defined as a block.
+      #
+      class Block < Action
+        include Core::Inspect
+
+        def initialize(name = nil, &block)
+          @block = block
+
+          super(name)
+        end
+
+        # [public]
+        #
+        def finalize(context)
+          context.define_method(@reference, &@block)
+
+          @reference
+        end
+      end
+    end
+  end
+end

data/lib/core/operation/callable.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "action"
+require_relative "compiler"
+
+module Core
+  module Operation
+    class Callable
+      def initialize(object)
+        @object = object
+        @actions = []
+        @compiled = false
+        @compiler = Compiler
+      end
+
+      def initialize_copy(...)
+        @actions = @actions.clone
+        super
+      end
+
+      attr_reader :actions
+
+      # [public] Relocates to another object context.
+      #
+      def relocate(object)
+        @object = object
+      end
+
+      # [public] Defines an action.
+      #
+      def action(...)
+        @actions << Action.build(...)
+        recompile if compiled?
+      end
+
+      # [public]
+      #
+      def action?(name)
+        @actions.any? { |action| action.name == name.to_sym }
+      end
+
+      # [public] Calls the default operation action with the given arguments.
+      #
+      def call(object, ...)
+        finalize.call(object, ...)
+      end
+
+      # [public]
+      #
+      def invoke(object, name, ...)
+        finalize.invoke(object, name, ...)
+      end
+
+      # [public] Finalizes the operation.
+      #
+      def finalize
+        compile
+
+        self
+      end
+
+      private def compile
+        return if compiled?
+
+        instance_eval(@compiler.compile(self, @object), __FILE__, __LINE__ - 1)
+        @compiled = true
+      end
+
+      private def recompile
+        remove_compiled_methods
+        compile
+      end
+
+      private def compiled?
+        @compiled == true
+      end
+
+      private def remove_compiled_methods
+        return unless compiled?
+
+        singleton_class.remove_method(:call)
+        singleton_class.remove_method(:invoke)
+        @compiled = false
+      end
+    end
+  end
+end

data/lib/core/operation/compiler.rb

@@ -1,24 +1,72 @@
 # frozen_string_literal: true
 
-require "core/pipeline/compiler"
-
-require_relative "result"
+require_relative "errors/undefined_action_error"
 
 module Core
   module Operation
-    class Compiler < Pipeline::Compiler
+    # [public] Compiles an operation into evalable code.
+    #
+    class Compiler
       class << self
-        private def compile_call(callable, object)
-          code = +"result = Core::Operation::Result.new\n"
-          code += "object.localize(:result, result) do\n"
-          code += super
-          code += "end\n"
-          code += "result.finalize\n"
-          code
+        # [public] Compiles a callable operation in context of an object.
+        #
+        def compile(callable, object)
+          compiled = <<~CODE
+            #{compile_actions(callable, object)}
+            def invoke(object, name, ...)
+              __send__(name, object, ...)
+            end
+          CODE
+
+          unless callable.actions.any? { |action| action.name == :call }
+            compiled << <<~CODE
+              def call(...)
+                raise UndefinedActionError, "undefined action `call`"
+              end
+            CODE
+          end
+
+          compiled
+        end
+
+        # [public]
+        #
+        private def compile_actions(callable, object)
+          compiled = +""
+          finalized_actions(callable, object).each_value do |action|
+            compiled << compile_action(action, object)
+          end
+
+          compiled
         end
 
+        # [public]
+        #
         private def compile_action(action, object)
-          "result.set(#{action[:object].name.inspect}, #{super})\n"
+          action_body = case action[:finalized]
+          when Symbol
+            "object.#{action[:finalized]}(...)"
+          end
+
+          <<~CODE
+            def #{action[:object].name}(object, ...)
+              #{action_body}
+            end
+          CODE
+        end
+
+        private def finalized_actions(callable, object)
+          finalized_actions = build_finalized_actions(callable, object)
+          callable.instance_variable_set(:@__finalized_actions__, finalized_actions)
+        end
+
+        private def build_finalized_actions(callable, object)
+          callable.actions.map { |action|
+            finalized = action.finalize(object)
+            {object: action, finalized: finalized, object_id: finalized.object_id}
+          }.each_with_object({}) { |action, lookup|
+            lookup[action[:object_id]] = action
+          }
         end
       end
     end

data/lib/core/operation/errors/undefined_action_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Core
+  module Operation
+    class UndefinedActionError < NameError
+    end
+  end
+end

data/lib/core/operation/failed.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Core
+  module Operation
+    # [public]
+    #
+    class Failed < RuntimeError
+      def initialize(value)
+        @value = value
+      end
+
+      # [public]
+      #
+      attr_reader :value
+    end
+  end
+end

data/lib/core/operation/result.rb

@@ -1,34 +1,66 @@
 # frozen_string_literal: true
 
+require_relative "failed"
+
 module Core
   module Operation
+    # [public]
+    #
     class Result
+      include Core::Inspect
+      inspects :value, :failure
+
       def initialize
-        @values = {}
-        @latest = nil
+        @value = nil
+        @failure = nil
+        @succeeded = false
+        @failed = false
       end
 
-      def finalize
-        @values.freeze
-        freeze
-        self
-      end
+      # [public]
+      #
+      attr_reader :failure
 
+      # [public]
+      #
       def value
-        @latest
+        raise Failed.new(@failure) if failure?
+        @value
       end
 
-      def set(name, value)
-        @values[name.to_sym] = value
-        @latest = value
+      # [public]
+      #
+      def succeeded(value)
+        @value = value
+        @succeeded = true
+        finalize
       end
 
-      def get(name)
-        @values[name.to_sym]
+      # [public]
+      #
+      def failed(value)
+        @failure = value
+        @failed = true
+        finalize
       end
 
-      def to_hash
-        @values.dup
+      # [public]
+      #
+      def success?
+        @succeeded == true
+      end
+
+      # [public]
+      #
+      def failure?
+        @failed == true
+      end
+
+      # [public]
+      #
+      def finalize
+        freeze
+        self
       end
     end
   end

data/lib/core/operation/version.rb

@@ -2,7 +2,7 @@
 
 module Core
   module Operation
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
 
     # [public]
     #

data/lib/core/operation.rb

@@ -1,7 +1,99 @@
 # frozen_string_literal: true
 
+require "core/extension"
+require "core/local"
+require "core/state"
+
 module Core
+  # [public]
+  #
   module Operation
+    require_relative "operation/callable"
+    require_relative "operation/result"
     require_relative "operation/version"
+
+    extend Core::Extension
+
+    applies do |extended:|
+      # [public] The callable operation.
+      #
+      state :operation, default: Core::Operation::Callable.new(extended ? singleton_class : self)
+    end
+
+    extends dependencies: [
+      Core::Local,
+      Core::State
+    ]
+
+    extends :definition do
+      # [public] Defines an action.
+      #
+      def action(...)
+        operation.action(...)
+      end
+
+      def inherited(subclass)
+        super
+
+        subclass.operation.relocate(subclass)
+      end
+    end
+
+    extends :implementation do
+      # [public] Calls the default action with arguments.
+      #
+      def call(...)
+        call_operation do
+          @operation.call(self, ...)
+        end
+      end
+
+      # [public] Defines an action, isolated to the instance.
+      #
+      def action(...)
+        operation.relocate(singleton_class)
+        operation.action(...)
+      end
+
+      # [public]
+      #
+      def failed(...)
+        localized(:__core_operation_result__).failed(...)
+      end
+
+      def method_missing(name, ...)
+        if @operation.action?(name)
+          call_operation do
+            @operation.invoke(self, name, ...)
+          end
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, ...)
+        @operation.action?(name) || super
+      end
+
+      private def call_operation
+        localize(:__core_operation_result__, Core::Operation::Result.new) { |result|
+          value = yield
+          unless result.failure?
+            result.succeeded(value)
+          end
+          result
+        }
+      end
+    end
+
+    extends :implementation, prepend: true do
+      # [public]
+      #
+      def finalize(...)
+        super if defined?(super)
+        operation.finalize
+        self
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: core-operation
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-14 00:00:00.000000000 Z
+date: 2023-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: core-extension
@@ -16,30 +16,44 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.4'
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: core-inspect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: core-local
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
-  name: core-pipeline
+  name: core-state
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.2'
 description: Turns Ruby objects into operations.
-email: bryan@metabahn.com
+email: bryan@bryanp.org
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -61,11 +75,15 @@ files:
 - CHANGELOG.md
 - LICENSE
 - lib/core/operation.rb
+- lib/core/operation/action.rb
+- lib/core/operation/actions/block.rb
+- lib/core/operation/callable.rb
 - lib/core/operation/compiler.rb
+- lib/core/operation/errors/undefined_action_error.rb
+- lib/core/operation/failed.rb
 - lib/core/operation/result.rb
 - lib/core/operation/version.rb
-- lib/is/operation.rb
-homepage: https://github.com/metabahn/corerb/
+homepage: https://github.com/bryanp/corerb/
 licenses:
 - MPL-2.0
 metadata: {}
@@ -77,14 +95,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: Turns Ruby objects into operations.

data/lib/is/operation.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "is/extension"
-require "is/localized"
-require "is/pipeline"
-
-require_relative "../core/operation/compiler"
-require_relative "../core/operation/result"
-
-module Is
-  # [public]
-  #
-  module Operation
-    extend Is::Extension
-
-    applies do
-      pipeline.compiler = Core::Operation::Compiler
-    end
-
-    extends dependencies: [Is::Localized, Is::Pipeline]
-
-    extends :definition, :implementation do
-      # [public]
-      #
-      def action(*args, curry: true, **kwargs, &block)
-        super(*args, curry: curry, **kwargs)
-      end
-    end
-
-    extends :implementation do
-      # [public]
-      #
-      def get(name)
-        localized(:result).get(name)
-      end
-
-      # [public]
-      #
-      def set(name, value)
-        localized(:result).set(name, value)
-      end
-    end
-  end
-end