core-extension 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7e64f65a82f9721e0a0a39f85d8593e6b57e295d6cb8eb6c8febcc798c8497b
-  data.tar.gz: e4d1dd2fea0b66d39a4c258c296a763c8d512b6404300a58c5f9d1dab66b67f0
+  metadata.gz: 02a2bc3087e71c3fc19d9f0c20210833a2a8bd88cf76f6187fade6e389eadf14
+  data.tar.gz: 8e38b249e3e3e5badcd6f9e6658d967f96f63ab837d563ca5e97f0cc408ee7a8
 SHA512:
-  metadata.gz: d9c8dc64956983a80358ec5ed0dc8d7122029a2fc59750e1bacb3c84da0e81d44bec2958b82c2ae3f506a3c068e9e63b49cec8000e1ff0a9f7d021692b409bbc
-  data.tar.gz: 1601c7edd515bd085ee5890ca0b4e3ce46b7920d594dbb9a806808da8c73549582ce7287926fa73de7abd4e662b87281a7c31a6b0ab22357fb52e09caf7f2502
+  metadata.gz: 38f391788aef874938c0e69dd95eaa24fee62737dbd5744a3bfafe0813e52189266ef079808a61d29c93688963b8eef1ef4bad9c38dbe2fcd38fb4ea468a3174
+  data.tar.gz: a41f51ba2b22432e4cd8505065f3e44fa57d1ba5c38cbc5c7b7fb362698cf47580dca2515b0b35fc0a2d2bd2fa5c498ab7faf1e7a67ada66f5591fb551d32954

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [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*

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,70 +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
-        @modules = modules.to_a
+        @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
@@ -77,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.2.0"
+    VERSION = "0.3.0"
 
     def self.version
       VERSION

data/lib/is/extension.rb

@@ -15,20 +15,39 @@ module Is
 
     # [public] Define a module to be extended or included into objects that include this extension.
     #
+    # TODO: These flags almost need different names, since instance extensions could technically end up on a class.
+    # Name them by their intended use? Like a definition and usage lifecycle or something.
+    #
+    # Maybe `definition` and `implementation`?
+    #
     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,15 +70,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
 
@@ -71,8 +102,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.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Bryan Powell
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-07-07 00:00:00.000000000 Z
+date: 2021-07-15 00:00:00.000000000 Z
 dependencies: []
 description: Create mixins with superpowers.
 email: bryan@metabahn.com