coactive 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec350eb0f4e954f1fa493547fcea1bbc8bef66b7968ae5cc56c8d4028136d84a
-  data.tar.gz: fb1fd1da81b027631dea81b1a03ee4295837c06bd1ef8332fb355529cf4120cd
+  metadata.gz: be01c5f37abbfc9ccf4a885e3eefdaf6416bdf2f04c08e29194acd4253a6a222
+  data.tar.gz: f65e89cca406a0d1a34ee056f3bbf3e8fb2dc4e12d0710007fd31c5c8d249b03
 SHA512:
-  metadata.gz: 8b5238f3adc94100d21684d3fbec31d917e1ff69a08931a2b7fb11a9380f07b9257a0c17f958633f2cdd0477d3c3b2aa9de3cd97ca3aaa95d0aeac9ee10895f0
-  data.tar.gz: d71895d84b2ee93ddc5778e1406b8c3b1aee756eb31f0d01d84c2d4e84f1134595812dc34ab21e4c22ee7868c23e4a6134076ce236b9b04554b51b0002cd4943
+  metadata.gz: a1290b6da95ab7806fa2eabd3bf1bd904bfb7536a7bb7d9b8ffa7d70e66e593ad91f211cb247d37f8a291d21fe98fb890c835b6a2a4a9d09057da8b5ff59f738
+  data.tar.gz: 6db5aad85ac64b5a398e892fdfe652448cecbf56a30f3c2352929ac7d138348d69afb109621ee7e105058c43d82649e53c32787d224eab8244bdb83e251b4381

data/.github/workflows/ci.yml

@@ -4,21 +4,29 @@ on: [push, pull_request]
 
 jobs:
   test:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     strategy:
       fail-fast: false
       matrix:
-        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, 3.0]
-        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61']
+        ruby: [2.3, 2.4, 2.5, 2.6, 2.7, '3.0']
+        gemfile: ['rails50', 'rails51', 'rails52', 'rails60', 'rails61', 'rails70']
         exclude:
           - ruby: 2.3
             gemfile: rails60
           - ruby: 2.3
             gemfile: rails61
+          - ruby: 2.3
+            gemfile: rails70
           - ruby: 2.4
             gemfile: rails60
           - ruby: 2.4
             gemfile: rails61
+          - ruby: 2.4
+            gemfile: rails70
+          - ruby: 2.5
+            gemfile: rails70
+          - ruby: 2.6
+            gemfile: rails70
           - ruby: 3.0
             gemfile: rails50
           - ruby: 3.0

data/.gitignore

@@ -1,6 +1,7 @@
 .bundle/
 Gemfile.lock
 coverage/
+gemfiles/*.lock
 pkg/
 tmp/
 spec/dummy/db/*.sqlite3

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.2.0
+
+* Add context feature.
+* Add priority to coaction.
+
 ## 0.1.2
 
 * Clear lookup cache when reloaded.

data/README.md

@@ -21,6 +21,8 @@ Then execute:
 
 ## Usage
 
+### Coactors
+
 Include `Coactive::Base` to your base class:
 
 ```ruby
@@ -51,7 +53,7 @@ C.new.coactors
 # => [A, B]
 ```
 
-### Named coactors
+#### Named coactors
 
 You can also define coactive classes by using specific name:
 
@@ -88,30 +90,30 @@ class Base
 end
 ```
 
-### Object-based coactors
+#### Object-based coactors
 
 You can also define coactive classes by using object:
 
 ```ruby
-class ModelA
+class ItemA
 end
 
-class ModelB
+class ItemB
 end
 
-class Base::ModelA < Base
+class Base::ItemA < Base
 end
 
-class Base::ModelB < Base
+class Base::ItemB < Base
 end
 
 class Base::C < Base
-  coact ModelA
-  coact ModelB
+  coact ItemA
+  coact ItemB
 end
 
 Base::C.new.coactors
-#=> [Base::ModelA, Base::ModelB]
+#=> [Base::ItemA, Base::ItemB]
 ```
 
 Coactors are looked up from the namespace corresponding with caller classes.
@@ -130,7 +132,7 @@ class Base
 end
 ```
 
-### Dynamic coactors
+#### Dynamic coactors
 
 You can also dynamically lookup coactors by using block or instance method:
 
@@ -184,7 +186,7 @@ D.new('B').coactors
 #=> [B]
 ```
 
-### Nested coactors
+#### Nested coactors
 
 You can define nested coactors. For example:
 
@@ -212,6 +214,110 @@ C.new.coactors.map { |klass| [klass] + klass.new.coactors }.flatten
 #=> [A, NestedA, B, NestedB]
 ```
 
+### Context
+
+You can define variables used in a coactor as a context by including `Coactive::Initializer`.
+The variables are stored in `context` as follows:
+
+```ruby
+class Base
+  include Coactive::Base
+  include Coactive::Initializer
+end
+
+class A < Base
+  context :input
+end
+
+coactor = A.new(input: 'something')
+coactor.context.input
+#=> something
+```
+
+#### Required context
+
+You can also define required context as follows:
+
+```ruby
+class A < Base
+  context :input, required: true
+end
+
+A.new
+#=> Coactive::MissingContextError (missing required context: input)
+```
+
+#### Default value
+
+You can also define default value as follows:
+
+```ruby
+class A < Base
+  context :input, default: 'something'
+end
+
+coactor = A.new
+coactor.context.input
+#=> something
+```
+
+### Contextualizer
+
+You can copy context variables to a coactor by calling `contextualize`:
+
+```ruby
+class Base
+  include Coactive::Base
+  include Coactive::Initializer
+  include Coactive::Contextualizer
+end
+
+class A < Base
+  context :input
+end
+
+coactor = A.new(input: 'something')
+coactor.contextualize
+coactor.input
+#=> something
+coactor.instance_variable_get(:@input)
+#=> something
+```
+
+#### Output
+
+You can also set context when finished `contextualize` block:
+
+```ruby
+class A < Base
+  context :result, output: true
+
+  def call
+    @result = 'something'
+  end
+end
+
+coactor = A.new
+coactor.contextualize { coactor.call }
+coactor.context.result
+#=> something
+```
+
+#### Output return value
+
+You can also set context from return value of `contextualize` block:
+
+```ruby
+class A < Base
+  context :result, output: :return
+end
+
+coactor = A.new
+coactor.contextualize { 'return value' }
+coactor.context.result
+#=> return value
+```
+
 ### Configuration
 
 You can set configurations in your base class as follows:

data/gemfiles/rails70.gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem "rails", "~> 7.0.0"
+
+gemspec path: "../"

data/lib/coactive/base.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'configure'
-require_relative 'coact'
-require_relative 'coaction'
-require_relative 'coactors'
-require_relative 'loader'
+require_relative 'coactor'
+require_relative 'interface'
+require_relative 'errors'
 
 module Coactive
   module Base
@@ -12,9 +11,7 @@ module Coactive
 
     included do
       include Configure
-      include Coact
-      include Coaction
-      include Coactors
+      include Coactor
     end
   end
 end

data/lib/coactive/{coactors.rb → coactor.rb}

@@ -1,10 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'loader'
 require_relative 'lookup'
+require_relative 'coactors/coactants'
+require_relative 'coactors/coactions'
 
 module Coactive
-  module Coactors
+  module Coactor
     extend ActiveSupport::Concern
+    include Coactors::Coactants
+    include Coactors::Coactions
 
     def coactors
       self.class._coactants.map do |coactant|

data/lib/coactive/coactors/coactants.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Coactive
+  module Coactors
+    module Coactants
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_coactants
+        self._coactants = []
+      end
+
+      class_methods do
+        def coact(*coactants, **options, &block)
+          if block
+            self._coactants = _coactants + [block]
+          elsif options[:before]
+            index = self._coactants.index { |coactant| coactant == options[:before] }
+            self._coactants = self._coactants.insert(index, *coactants)
+          else
+            self._coactants = _coactants + coactants
+          end
+        end
+
+        def coactants
+          self._coactants
+        end
+
+        def clear_coactants
+          self._coactants = []
+        end
+      end
+    end
+  end
+end

data/lib/coactive/coactors/coaction.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Coactive
+  module Coactors
+    class Coaction < Struct.new(:name, :options)
+      def priority
+        options[:priority]
+      end
+    end
+  end
+end

data/lib/coactive/coactors/coactions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'coaction'
+
+module Coactive
+  module Coactors
+    module Coactions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_coactions
+        self._coactions = []
+      end
+
+      class_methods do
+        def coaction(*names, **options)
+          self._coactions = _coactions + names.map { |name| Coaction.new(name, options) }
+        end
+
+        def coactions
+          self._coactions
+        end
+
+        def clear_coactions
+          self._coactions = []
+        end
+      end
+    end
+  end
+end

data/lib/coactive/context.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Coactive
+  class Context
+    attr_reader :_data
+
+    def initialize(data = {}, &block)
+      data = data.to_h if data.respond_to?(:to_h)
+      @_data = data
+    end
+
+    def [](key)
+      @_data[key]
+    end
+
+    def []=(key, value)
+      @_data[key] = value
+    end
+
+    def key?(key)
+      @_data.key?(key)
+    end
+
+    def to_h
+      @_data
+    end
+
+    def to_s
+      attrs = @_data.map { |k, v| "#{k}=#{v.inspect}" }.join(', ')
+      "#<#{self.class} #{attrs}>"
+    end
+    alias :inspect :to_s
+
+    def define_accessors!(keys)
+      Array(keys).each do |key|
+        define_singleton_method key do
+          @_data[key]
+        end
+        define_singleton_method "#{key}=" do |value|
+          @_data[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/coactive/contextualizer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Coactive
+  module Contextualizer
+    extend ActiveSupport::Concern
+
+    def contextualize
+      self.class._contexts.each do |var|
+        instance_variable_set("@#{var.name}", @context[var.name])
+        define_singleton_method var.name do
+          instance_variable_get("@#{var.name}")
+        end
+      end
+
+      return_value = yield if block_given?
+
+      self.class._contexts.each do |var|
+        if var.output_return?
+          @context[var.name] = return_value
+        elsif var.output? && instance_variable_defined?("@#{var.name}")
+          @context[var.name] = instance_variable_get("@#{var.name}")
+        end
+      end
+
+      return_value
+    end
+  end
+end

data/lib/coactive/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Coactive
+  class MissingContextError < StandardError
+  end
+end

data/lib/coactive/initializer.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative 'context'
+require_relative 'initializers/contexts'
+
+module Coactive
+  module Initializer
+    extend ActiveSupport::Concern
+    include Initializers::Contexts
+
+    included do
+      class_attribute :context_class
+      self.context_class = Context
+      attr_reader :context
+    end
+
+    def initialize(args = {}, &block)
+      @context = self.class.context_class.new(args, &block)
+      @context.define_accessors!(self.class._contexts.map(&:name))
+
+      self.class._contexts.each do |var|
+        if var.required? && !@context.key?(var.name)
+          raise MissingContextError.new("missing required context: #{var.name}")
+        end
+        if var.default && !@context.key?(var.name)
+          @context[var.name] = Initializer.resolve(self, var.default)
+        end
+      end
+    end
+
+    class << self
+      def resolve(instance, value)
+        if value.respond_to?(:call)
+          instance.instance_exec(&value)
+        elsif value.is_a?(Symbol) && instance.respond_to?(value, true)
+          instance.send(value)
+        else
+          value.deep_dup
+        end
+      end
+    end
+  end
+end

data/lib/coactive/initializers/contexts.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'variable'
+
+module Coactive
+  module Initializers
+    module Contexts
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_contexts
+        self._contexts = []
+      end
+
+      class_methods do
+        def context(*names, **options)
+          self._contexts = self._contexts + names.map { |name| Variable.new(name, options) }
+        end
+      end
+    end
+  end
+end

data/lib/coactive/initializers/variable.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Coactive
+  module Initializers
+    class Variable < Struct.new(:name, :options)
+      def default
+        options[:default] if options
+      end
+
+      def required?
+        options[:required] if options
+      end
+
+      def output?
+        options[:output] if options
+      end
+
+      def output_return?
+        options[:output] == :return if options
+      end
+    end
+  end
+end

data/lib/coactive/interface.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'initializer'
+require_relative 'contextualizer'
+
+module Coactive
+  module Interface
+    extend ActiveSupport::Concern
+
+    included do
+      include Initializer
+      include Contextualizer
+    end
+  end
+end

data/lib/coactive/lookups/name.rb

@@ -15,9 +15,10 @@ module Coactive
       end
 
       def lookup
-        @klass.coactive_config.base_class.descendants.select do |coactor|
-          coactor._coactions.any? { |coaction| coaction == @coactant }
-        end
+        @klass.coactive_config.base_class.descendants.each_with_object({}).with_index do |(coactor, hash), i|
+          coaction = coactor.coactions.detect { |coaction| coaction.name == @coactant }
+          hash[[coaction.priority || 1 << 63, i]] = coactor if coaction
+        end.sort.map { |x| x[1] }
       end
 
       class << self

data/lib/coactive/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Coactive
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coactive
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-13 00:00:00.000000000 Z
+date: 2022-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -117,13 +117,22 @@ files:
 - gemfiles/rails52.gemfile
 - gemfiles/rails60.gemfile
 - gemfiles/rails61.gemfile
+- gemfiles/rails70.gemfile
 - lib/coactive.rb
 - lib/coactive/base.rb
-- lib/coactive/coact.rb
-- lib/coactive/coaction.rb
-- lib/coactive/coactors.rb
+- lib/coactive/coactor.rb
+- lib/coactive/coactors/coactants.rb
+- lib/coactive/coactors/coaction.rb
+- lib/coactive/coactors/coactions.rb
 - lib/coactive/config.rb
 - lib/coactive/configure.rb
+- lib/coactive/context.rb
+- lib/coactive/contextualizer.rb
+- lib/coactive/errors.rb
+- lib/coactive/initializer.rb
+- lib/coactive/initializers/contexts.rb
+- lib/coactive/initializers/variable.rb
+- lib/coactive/interface.rb
 - lib/coactive/loader.rb
 - lib/coactive/lookup.rb
 - lib/coactive/lookups/base.rb
@@ -149,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Make classes coactive

data/lib/coactive/coact.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Coactive
-  module Coact
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_coactants
-      self._coactants = []
-    end
-
-    class_methods do
-      def coact(*coactants, **options, &block)
-        if block
-          self._coactants = _coactants + [block]
-        elsif options[:before]
-          index = self._coactants.index { |coactant| coactant == options[:before] }
-          self._coactants = self._coactants.insert(index, *coactants)
-        else
-          self._coactants = _coactants + coactants
-        end
-      end
-
-      def coactants
-        self._coactants
-      end
-
-      def clear_coactants
-        self._coactants = []
-      end
-    end
-  end
-end

data/lib/coactive/coaction.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Coactive
-  module Coaction
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_coactions
-      self._coactions = []
-    end
-
-    class_methods do
-      def coaction(*coactions)
-        self._coactions = _coactions + coactions
-      end
-
-      def coactions
-        self._coactions
-      end
-
-      def clear_coactions
-        self._coactions = []
-      end
-    end
-  end
-end