core-extension 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95231fea0fd981dbd609b053f8a334003490a1a90805c9168665b5d7574a66b1
-  data.tar.gz: 510b7bb6e4efbf527431cc178a5229b0482ab3280ebc1d4d2c9c9a0290051278
+  metadata.gz: 4ed9558c9300ae7945b4d23f9082dfdde7a531e4fa70a95c0b43086d945d51ad
+  data.tar.gz: 48ce184ff00a9b7c9432c348a63b273be732271aeee476376a7592500cef53a0
 SHA512:
-  metadata.gz: a543f05bbebd33a68b9ad4fdf9d0c91d213d9423790edaefb59a60be4b39496f8b3a83174f9f7592bcd638f2a875cf1830128c139515076ff90955213f4f28c4
-  data.tar.gz: 2cc2758b3c0589e5130c873623de64d8777e5bd3d7959ee2eb7d7446fd9bf3ca8061847d01b91030f374a90a0d45ff077090130d19db9976aedc54d539c75bd0
+  metadata.gz: 83d18619a6e0e458aa03955b852d6930de8612812f9ea07eeeab96005a31d2befe8220c5ed0ca4a50e38e8f7ebcb620f285d74bd42842d1eb40bc9a29771e2c6
+  data.tar.gz: c39ca3469c55b68fafe12fc4461ffb7493a4955a3b75482bc972f184ad0c0ebae0f95d02539d4c3d84e1fdc3138c7816eaaed96dd1a4fcfcbf26a688346b8d87

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+## [v0.4.1](https://github.com/metabahn/corerb/releases/tag/2021-11-02)
+
+*released on 2021-11-02*
+
+  * `chg` [#97](https://github.com/metabahn/corerb/pull/97) Designate internal state with leading and trailing double underscores ([bryanp](https://github.com/bryanp))
+
+## [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*

data/lib/core/extension/behavior.rb

@@ -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.1.0"
+    VERSION = "0.4.1"
 
     def self.version
       VERSION

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)
@@ -16,19 +111,33 @@ module Is
     # [public] Define a module to be extended or included into objects that include this extension.
     #
     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.
     #
-    def applied(force: false, &block)
+    def applies(force: false, &block)
       defined_behaviors << Core::Extension::Behavior.new(force: force, &block)
     end
 
+    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_methods(base)
-      apply_defined_behaviors(base)
+      include_defined_dependencies(base)
+      include_defined_behaviors(base)
 
       super
     end
@@ -51,28 +160,40 @@ 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
 
     private def allowed_types
-      @__allowed_types ||= []
+      @__allowed_types__ ||= []
     end
 
     private def defined_behaviors
-      @__defined_behaviors ||= []
+      @__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.1.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-10 00:00:00.000000000 Z
+date: 2021-11-02 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.2.4
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Create mixins with superpowers.