core-extension 0.0.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a71a7e994976d0d1541932017b638a74dc3403686c8c49f517e3c019d7ad656
-  data.tar.gz: 6edfca3b01dbaa1c52df86e9a1cd024395772abf1438e3d6b0845785972a70b4
+  metadata.gz: 36cc50171a9abdf4bcc66e06d50de8b882ca63c4e0abcde6e8a0a3c788e18d1b
+  data.tar.gz: 1ba5eb71c9c127531de40821d2b6f3edaf4e9f3a3324769cdc0053eb2f3c5c6c
 SHA512:
-  metadata.gz: 13c7cfc9dce149e23b940830cce4e9e45d8e8b03cfd43e56030638267514f614271d4ba9979a58800df6dec8a70a33a92bdb46cd783513b3f0c8f4df9174cd51
-  data.tar.gz: '04704682e6f059cd22b6f4c7f68590ed59b2c4a0be43bbc003cac5f77fd27ee54a481a1251f51c1004e3c1c10078ec0bb47b9e5891e079d9d432b5d4b81269af'
+  metadata.gz: 60133541a193b46b53e2e727219f4c23ba778bca20e0a7c3d2c3b650b3eca8c4eeaa27510b9b3fbb2e55260543002d63a220b0597308706752eed1994eaa61b6
+  data.tar.gz: f64b2074f69a38d694a7de22e6ea42c3cae2cc454f31b5146146031f4b43fcc3626e247c182acbb80b2e7c4bc7fa503eafd9b6928a5231783200d7bedb0fe810

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [v0.4.0](https://github.com/metabahn/corerb/releases/tag/2021-10-24)
+
+*released on 2021-10-24*
+
+  * `add` [#86](https://github.com/metabahn/corerb/pull/86) Copy instance variables when cloning an extension ([bryanp](https://github.com/bryanp))
+
+## [v0.3.0](https://github.com/metabahn/corerb/releases/tag/2021-07-15)
+
+*released on 2021-07-15*
+
+  * `chg` [#72](https://github.com/metabahn/corerb/pull/72) Rename extension dependency flags ([bryanp](https://github.com/bryanp))
+  * `chg` [#71](https://github.com/metabahn/corerb/pull/71) Rename Is::Extension::applied to applies ([bryanp](https://github.com/bryanp))
+  * `chg` [#68](https://github.com/metabahn/corerb/pull/68) Pass the extension scope to apply blocks ([bryanp](https://github.com/bryanp))
+  * `chg` [#67](https://github.com/metabahn/corerb/pull/67) Refactor extend support for extensions ([bryanp](https://github.com/bryanp))
+  * `chg` [#66](https://github.com/metabahn/corerb/pull/66) Support extending classes with extensions ([bryanp](https://github.com/bryanp))
+
+## [v0.2.0](https://github.com/metabahn/corerb/releases/tag/2021-07-07)
+
+*released on 2021-07-07*
+
+  * `chg` [#40](https://github.com/metabahn/corerb/pull/40) Drop Ruby 2.6 support from core-extension ([bryanp](https://github.com/bryanp))
+
+## [v0.1.0](https://github.com/metabahn/corerb/releases/tag/2021-02-10)
+
+*released on 2021-02-10*
+
+  * `chg` [#3](https://github.com/metabahn/corerb/pull/3) Apply extension dependencies before behavior ([bryanp](https://github.com/bryanp))
+
 ## [v0.0.0](https://github.com/metabahn/corerb/releases/tag/2020-12-29)
 
 *released on 2020-12-29*

data/lib/core/extension/behavior.rb

@@ -2,7 +2,7 @@
 
 module Core
   module Extension
-    # [public] Defines behavior that can be applied to objects. Behavior will only be applied to each object once.
+    # [public] Defines behavior that can be applied to objects. Behavior will only be applied to each object once by default.
     #
     # force - If true, behavior will be applied even if it has already been applied to the including object.
     #
@@ -12,9 +12,17 @@ module Core
         @module = build_module(&block)
       end
 
-      # [public] Applies this behavior to an object.
+      # [public] Applies this behavior to an object via extend.
       #
-      def apply(object)
+      def apply_extend(object)
+        if force? || unapplied?(object)
+          object.extend(@module)
+        end
+      end
+
+      # [public] Applies this behavior to an object via include.
+      #
+      def apply_include(object)
         if force? || unapplied?(object)
           object.include(@module)
         end
@@ -34,11 +42,35 @@ module Core
 
       private def build_module(&block)
         Module.new {
+          define_singleton_method(:extended) do |base|
+            arguments = {
+              extended: true,
+              included: false
+            }
+
+            base.class_exec(**Behavior.conditional_keyword_arguments(arguments, block), &block)
+          end
+
           define_singleton_method(:included) do |base|
-            base.class_eval(&block)
+            arguments = {
+              extended: false,
+              included: true
+            }
+
+            base.class_exec(**Behavior.conditional_keyword_arguments(arguments, block), &block)
           end
         }
       end
+
+      class << self
+        def conditional_keyword_arguments(arguments, callable)
+          arguments.keep_if { |key, _value|
+            callable.parameters.any? { |type, name|
+              (type == :key || type == :keyreq || type == :keyrest) && name == key
+            }
+          }
+        end
+      end
     end
   end
 end

data/lib/core/extension/dependency.rb

@@ -6,69 +6,71 @@ module Core
     #
     # flags - Changes how the dependencies are applied. Possible values include:
     #
-    #     * `:class` - Extends the including object, making methods available at the class level.
+    #     * `:definition` - Extends the definition of the including object.
     #
-    #     * `:instance` - Includes the methods into the object, making them available at the instance level.
+    #     * `:implementation` - Extends the implementation of the including object.
     #
-    #   Dependencies are applied with the `:instance` flag by default.
+    #   Dependencies are applied with the `:implementation` flag by default.
     #
-    # modules - Modules to be applied to objects, following the rules defined by flags.
+    # dependency - The dependency to be applied to objects, following the rules defined by flags.
     #
-    # prepend - If `true`, methods will be prepended rather than appended.
-    #
-    # block - If passed, defines an anonymous module as a dependency.
+    # prepend - If `true`, methods will be prepended.
     #
     class Dependency
-      ALLOWED_FLAGS = %i[class instance].freeze
+      ALLOWED_FLAGS = %i[definition implementation].freeze
+      ALLOWED_FLAGS_STRING = ALLOWED_FLAGS.map { |allowed_flag|
+        "`#{allowed_flag.inspect}'"
+      }.join(", ").freeze
 
-      def initialize(*flags, modules: [], prepend: false, &block)
+      def initialize(*flags, dependency:, prepend: false)
+        flags = flags.map(&:to_sym)
         enforce_allowed_flags(flags)
 
-        @flags = flags.map(&:to_sym)
-        @modules = modules.to_a
+        @flags = flags
+        @dependency = dependency
         @prepend = prepend
-
-        @modules << build_module(&block) if block
+        @definition = @flags.include?(:definition)
+        @implementation = @flags.include?(:implementation) || (!definition? && !prepend?)
       end
 
-      # [public] Apply the defined dependencies to an object.
+      # [public] Apply the defined dependencies to an object via extend.
       #
-      def apply(object)
-        including = include?
-        extending = extend?
-        prepending = prepend?
+      def apply_extend(object)
+        if prepend?
+          object.singleton_class.prepend(@dependency) if implementation? || definition?
+        elsif definition? || implementation?
+          object.extend(@dependency)
+        end
+      end
 
-        @modules.each do |each_module|
-          if prepending
-            object.prepend(each_module) if including
-            object.singleton_class.prepend(each_module) if extending
-          else
-            object.include(each_module) if including
-            object.extend(each_module) if extending
-          end
+      # [public] Apply the defined dependencies to an object via include.
+      #
+      def apply_include(object)
+        if prepend?
+          object.prepend(@dependency) if implementation?
+          object.singleton_class.prepend(@dependency) if definition?
+        else
+          object.include(@dependency) if implementation?
+          object.extend(@dependency) if definition?
         end
       end
 
-      private def include?
-        @flags.include?(:instance) || (!extend? && !prepend?)
+      private def implementation?
+        @implementation == true
       end
 
-      private def extend?
-        @flags.include?(:class)
+      private def definition?
+        @definition == true
       end
 
       private def prepend?
         @prepend == true
       end
 
-      private def build_module(&block)
-        Module.new(&block)
-      end
-
       private def enforce_allowed_flags(flags)
         flags.each do |flag|
           unless allowed_flag?(flag)
-            raise ArgumentError, "Expected flag `#{flag.inspect}' to be one of: #{allowed_flags_string}"
+            raise ArgumentError, "Expected flag `#{flag.inspect}' to be one of: #{ALLOWED_FLAGS_STRING}"
           end
         end
       end
@@ -76,12 +78,6 @@ module Core
       private def allowed_flag?(flag)
         ALLOWED_FLAGS.include?(flag)
       end
-
-      private def allowed_flags_string
-        ALLOWED_FLAGS.map { |allowed_flag|
-          "`#{allowed_flag.inspect}'"
-        }.join(", ")
-      end
     end
   end
 end

data/lib/core/extension/version.rb

@@ -2,7 +2,7 @@
 
 module Core
   module Extension
-    VERSION = "0.0.0"
+    VERSION = "0.4.0"
 
     def self.version
       VERSION

data/lib/core/extension.rb

@@ -6,3 +6,5 @@ module Core
     require_relative "extension/version"
   end
 end
+
+require_relative "../is/extension"

data/lib/is/extension.rb

@@ -7,6 +7,101 @@ module Is
   # [public] Turn a module into a mixin with superpowers.
   #
   module Extension
+    # Adding core-copy as a dependency creates a recursive dependency, so just bundle it.
+    #
+    module Copy
+      DEFAULT = ::Object.new
+
+      refine ::Object do
+        if RbConfig::CONFIG["RUBY_PROGRAM_VERSION"] < "3"
+          def copy(freeze: DEFAULT)
+            should_freeze = resolve_freeze_argument(freeze)
+
+            value = clone(freeze: should_freeze)
+            value.freeze if should_freeze
+            value
+          end
+        else
+          def copy(freeze: DEFAULT)
+            clone(freeze: resolve_freeze_argument(freeze))
+          end
+        end
+
+        private def resolve_freeze_argument(value)
+          case value
+          when DEFAULT
+            frozen?
+          else
+            !!value
+          end
+        end
+      end
+
+      refine Array do
+        def copy(freeze: DEFAULT)
+          unless Extension.copying?(self)
+            Extension.prevent_recursion(self) do
+              array = map { |value|
+                value.copy(freeze: freeze)
+              }
+
+              array.freeze if resolve_freeze_argument(freeze)
+
+              array
+            end
+          end
+        end
+      end
+
+      refine Hash do
+        def copy(freeze: DEFAULT)
+          unless Extension.copying?(self)
+            Extension.prevent_recursion(self) do
+              hash = {}
+
+              each_pair do |key, value|
+                hash[key.copy(freeze: freeze)] = value.copy(freeze: freeze)
+              end
+
+              hash.freeze if resolve_freeze_argument(freeze)
+
+              hash
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      def prevent_recursion(object)
+        object_id = object.object_id
+        copied_objects[object_id] = true
+        yield
+      ensure
+        copied_objects.delete(object_id)
+      end
+
+      def copying?(object)
+        copied_objects[object.object_id]
+      end
+
+      def copied_objects
+        # We can't use core-local because it would create a recursive dependency.
+        #
+        Thread.current["__corerb_localized_#{object_id}__corerb_copied_objects"] ||= {}
+      end
+    end
+
+    using Copy
+
+    def initialize_copy(...)
+      super
+
+      instance_variables.each do |instance_variable|
+        instance_variable_set(instance_variable, instance_variable_get(instance_variable).copy)
+      end
+    end
+
     # [public] Restrict the extension to one or more object types.
     #
     def restrict(*types)
@@ -14,24 +109,35 @@ module Is
     end
 
     # [public] Define a module to be extended or included into objects that include this extension.
-    # See [Core::Extension::Dependency] for argument details.
     #
     def extends(*flags, dependencies: [], prepend: false, &block)
-      defined_methods << Core::Extension::Dependency.new(*flags, modules: dependencies, prepend: prepend, &block)
+      dependencies.each do |dependency|
+        defined_dependencies << Core::Extension::Dependency.new(*flags, dependency: dependency, prepend: prepend)
+      end
+
+      if block
+        defined_dependencies << Core::Extension::Dependency.new(*flags, dependency: Module.new(&block), prepend: prepend)
+      end
     end
 
     # [public] Define behavior to be evaled on objects that include this extension.
-    # See [Core::Extension::Behavior] for argument details.
     #
-    def applied(force: false, &block)
+    def applies(force: false, &block)
       defined_behaviors << Core::Extension::Behavior.new(force: force, &block)
     end
 
-    # @api private
+    def extended(base)
+      enforce_allowed_types(base)
+      extend_defined_dependencies(base)
+      extend_defined_behaviors(base)
+
+      super
+    end
+
     def included(base)
       enforce_allowed_types(base)
-      apply_defined_behaviors(base)
-      apply_defined_methods(base)
+      include_defined_dependencies(base)
+      include_defined_behaviors(base)
 
       super
     end
@@ -54,15 +160,27 @@ module Is
       }
     end
 
-    private def apply_defined_behaviors(object)
+    private def extend_defined_behaviors(object)
+      defined_behaviors.each do |behavior|
+        behavior.apply_extend(object)
+      end
+    end
+
+    private def extend_defined_dependencies(object)
+      defined_dependencies.each do |dependency|
+        dependency.apply_extend(object)
+      end
+    end
+
+    private def include_defined_behaviors(object)
       defined_behaviors.each do |behavior|
-        behavior.apply(object)
+        behavior.apply_include(object)
       end
     end
 
-    private def apply_defined_methods(object)
-      defined_methods.each do |methods|
-        methods.apply(object)
+    private def include_defined_dependencies(object)
+      defined_dependencies.each do |dependency|
+        dependency.apply_include(object)
       end
     end
 
@@ -74,8 +192,8 @@ module Is
       @__defined_behaviors ||= []
     end
 
-    private def defined_methods
-      @__defined_methods ||= []
+    private def defined_dependencies
+      @__defined_dependencies ||= []
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: core-extension
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-29 00:00:00.000000000 Z
+date: 2021-10-24 00:00:00.000000000 Z
 dependencies: []
 description: Create mixins with superpowers.
 email: bryan@metabahn.com
@@ -35,14 +35,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Create mixins with superpowers.