coactive 0.1.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 770c5f64ad5b2032eb3adcc65af596be49364f39fa75de5febc4ee3213ce9f9b
-  data.tar.gz: f8efaa56a30c4f4eabcb22b7c4a0d14f9753c4f982a79f5ec9d5a697c86181a6
+  metadata.gz: cc658ad8e03f5de6bb345b90606d45be83e91ec260e39abcdf4008f2890d6505
+  data.tar.gz: bbe87c6271b5a42b4f4a08fc4c095d1f2078d9d4d9a4e6b8c8d0d7e05b771725
 SHA512:
-  metadata.gz: 6b9f507b0e3c8f2a55e9151ea868d14a314ef017157746375b068c99ded7803bb8c39295fe880b95523eb8d6a054a5ab0646f17a90362e86dd5616d9277bafd3
-  data.tar.gz: e8e5146497628c5de49e7d45797dfa377d209053d3a1ba5195ab7425bdef3092ba1721006ae3ffbefc721c152526d11ccef3068acde178a2ec5b308a01235b10
+  metadata.gz: 6f48fcf54084e267df1533eefe6569fca5ee5d36181c8e4ed36ab6327b1cd94b81d1a163f0dfdbe54058c061bc58410d10e925b7fa3d180a95bb0ebe740fe6c5
+  data.tar.gz: f4f2339513f0292800d5d65862b631c989a0ccd0ae8d3aad3ad9e2f906692b71c1eca0df4684ffbb9e61475d3f1b80c6ed815758949de472da3ff4f6694d14e3

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,23 @@
 # CHANGELOG
 
+## 0.2.2
+
+* Allow overwrite context variables.
+
+## 0.2.1
+
+* Truncate string for context.
+
+## 0.2.0
+
+* Add context feature.
+* Add priority to coaction.
+
+## 0.1.2
+
+* Clear lookup cache when reloaded.
+* Use require_dependency instead of require.
+
 ## 0.1.1
 
 * Reassign config data when configured.

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,44 @@
+# 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.to_s.truncate(300)}" }.join(', ')
+      "#<#{self.class} #{attrs}>"
+    end
+
+    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,23 @@
+# 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 = _contexts.reject { |var| names.include?(var.name) }
+          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/loader.rb

@@ -11,7 +11,7 @@ module Coactive
         engines = [Rails] + Rails::Engine.subclasses.map(&:instance)
         engines.each do |engine|
           Dir["#{engine.root}/{#{Array(paths).join(',')}}/**/*.rb"].each do |file|
-            require file
+            require_dependency file
           end
         end
       end

data/lib/coactive/lookup.rb

@@ -13,19 +13,19 @@ module Coactive
       class_attribute :cache
       self.cache = {}
 
-      def call(klass, coactivation)
-        with_cache(klass, coactivation) do
-          lookup = lookups.detect { |lookup| lookup.callable?(coactivation) }
-          lookup.new(klass, coactivation).call if lookup
+      def call(klass, coactant)
+        with_cache(klass, coactant) do
+          lookup = lookups.detect { |lookup| lookup.callable?(coactant) }
+          lookup.new(klass, coactant).call if lookup
         end
       end
 
       private
 
-      def with_cache(klass, coactivation)
+      def with_cache(klass, coactant)
         if klass.coactive_config.use_cache
           self.cache[klass] ||= {}
-          self.cache[klass][coactivation] ||= yield
+          self.cache[klass][coactant] ||= yield
         else
           yield
         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/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Coactive
+  module Railtie
+    ActiveSupport::Reloader.to_prepare do
+      Coactive::Lookup.cache.clear
+    end
+  end
+end

data/lib/coactive/version.rb

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

data/lib/coactive.rb

@@ -2,3 +2,4 @@ require 'active_support'
 
 require 'coactive/version'
 require 'coactive/base'
+require 'coactive/railtie' if defined?(Rails)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: coactive
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Yoshikazu Kaneta
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-29 00:00:00.000000000 Z
+date: 2022-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -117,18 +117,28 @@ 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
 - lib/coactive/lookups/name.rb
 - lib/coactive/lookups/object.rb
+- lib/coactive/railtie.rb
 - lib/coactive/version.rb
 homepage: https://github.com/kanety/coactive
 licenses: []

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