sleeping_king_studios-tools 1.3.0.rc.0 → 1.3.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddf9748934072d1e7acf8ae748029ed8d616c46fd7d0a502499f0b54bc4e5d1b
-  data.tar.gz: bae72b5b57afe8404d45aab67ee59a5e8643b3656820e915c535b934016ee0d3
+  metadata.gz: 4939601ed132d3b370114ce53c547e220277c715eb1d442dc20566049f041bea
+  data.tar.gz: f5cf620154ef2245749693dc5da447adb6fc0e2644bf3aa1094d289881a32338
 SHA512:
-  metadata.gz: 6de4c073168e77a204afc0a1b4cc7e873619fbb9796df24177b7c2125be120df29e22034a690da73f1998822e10667d473bebfcdfb4adcd4da0a6dbea3f796c5
-  data.tar.gz: 999e795763737b1f79be6d0884f162cf436d116c7319cd6d66d4934e3bbb2048249bf4d7e9c632379d2d2e5aa01525bf0ddcc52318e5d146153af7971fa945e6
+  metadata.gz: 0da898a1ae8bd177700cbd6d3736fe171a534ad2f9b7e3c934f9e033c4b61136e4996dc8d375c98706a83b4ef573531901a3fa4de830a29fc3bff6c39f251307
+  data.tar.gz: 050d5c3e8ae855129dc5aa0d426038bda2bd43706282c3b89e418e56d69973781d9996002168e15bcdc29ae0acd387494dc260402351058d76400c0ee4ace564

data/CHANGELOG.md

@@ -91,6 +91,10 @@ Added keyword support to `ConstantMap.new`.
 
 Corrected the scope of `Mixin#included` and `Mixin#prepended` to be `private`.
 
+#### HeritableData
+
+Added `Toolbox::HeritableData`, which allows for defining `Data` subclasses with inheritable members and methods.
+
 #### Initializer
 
 Added `Toolbox::Initializer`, used for defining a one-time initialization for a library or project.

data/lib/sleeping_king_studios/tools/messages/registry.rb

@@ -22,7 +22,7 @@ module SleepingKingStudios::Tools
     end
 
     # Data class representing a single node in the registry tree.
-    Node = Struct.new(:children, :scope, :strategy, keyword_init: true) do
+    Node = Struct.new(:children, :scope, :strategy) do
       # @param scope [String] the scope for the registry node.
       # @param strategy [SleepingKingStudios::Tools::Messages::Strategy] the
       #   strategy defined for the node, if any.

data/lib/sleeping_king_studios/tools/toolbox/heritable_data.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require 'sleeping_king_studios/tools/toolbox'
+
+module SleepingKingStudios::Tools::Toolbox
+  # Mixin to allow defining subclasses of Data classes.
+  module HeritableData
+    # Methods prepended onto the singleton class when including HeritableData.
+    module ClassMethods
+      # Compares `self` and `other`.
+      #
+      # @param other [Object] the object to compare.
+      #
+      # @return [true] if self is a subclass of other, or if self inherits Data
+      #   members and methods from other.
+      # @return [false] if self and other are the same class, if other is a
+      #   subclass of self, or if other inherits Data members and methods from
+      #   self.
+      # @return [nil] if none of the above is true.
+      def <(other)
+        (self <=> other)&.then { |cmp| cmp == -1 }
+      end
+
+      # Compares `self` and `other`.
+      #
+      # @param other [Object] the object to compare.
+      #
+      # @return [true] if self and other are the same class, if self is a
+      #   subclass of other, or if self inherits Data members and methods from
+      #   other.
+      # @return [false] if other is a subclass of self, or if other inherits
+      #   Data members and methods from self.
+      # @return [nil] if none of the above is true.
+      def <=(other)
+        (self <=> other)&.then { |cmp| cmp < 1 }
+      end
+
+      # Compares `self` and `other`.
+      #
+      # @param other [Object] the object to compare.
+      #
+      # @return [-1] if self is a subclass of other, or if self inherits Data
+      #   members and methods from other.
+      # @return [0] if self and other are the same class.
+      # @return [1] if self is a parent class of other, or if other inherits
+      #   Data members and methods from self.
+      # @return [nil] if none of the above is true.
+      def <=>(other)
+        return super unless other.is_a?(Class)
+
+        return -1 if other.equal?(Data)
+        return 0  if other.equal?(self)
+
+        return nil unless other.const_defined?(:HeritableMethods)
+
+        return -1 if include?(other::HeritableMethods)
+        return 1 if other.include?(self::HeritableMethods)
+
+        nil
+      end
+
+      # @return [true] if the object is an instance of the data class, or if the
+      #   object is an instance of a Data class that inherits members and
+      #   methods from self.
+      def ===(object)
+        return true if super
+
+        (self > object.class) || false
+      end
+
+      # Compares `self` and `other`.
+      #
+      # @param other [Object] the object to compare.
+      #
+      # @return [true] if other is a subclass of other, or if other inherits
+      #   Data members and methods from self.
+      # @return [false] if self and other are the same class, if self is a
+      #   subclass of other, or if self inherits Data members and methods from
+      #   other.
+      # @return [nil] if none of the above is true.
+      def >(other)
+        (self <=> other)&.then { |cmp| cmp == 1 }
+      end
+
+      # Compares `self` and `other`.
+      #
+      # @param other [Object] the object to compare.
+      #
+      # @return [true] if self and other are the same class, if other is a
+      #   subclass of other, or if other inherits Data members and methods from
+      #   self.
+      # @return [false] if self is a subclass of other, or if self inherits Data
+      #   members and methods from other.
+      # @return [nil] if none of the above is true.
+      def >=(other)
+        (self <=> other)&.then { |cmp| cmp > -1 }
+      end
+
+      # Defines a new Data class including the members/methods of this class.
+      #
+      # The defined data class will include HeritableData, and will be able to
+      # define it's own Data types using this method.
+      #
+      # @param symbols [Array<Symbol>] additional Data members to define. Any
+      #   members listed here will be appended to the members defined on the
+      #   parent Data class.
+      #
+      # @yield additional methods to define on the new Data class.
+      def define(*symbols, &)
+        HeritableData.define(*symbols, parent_class: self, &)
+      end
+    end
+
+    # Custom module used to propagate heritable methods across Data classes.
+    #
+    # @private
+    class HeritableMethods < Module
+      # @param parent_class [Class, nil] the parent data class, if any.
+      #
+      # @yield additional methods to define on the Data class.
+      def initialize(parent_class: nil, &methods)
+        super(&nil)
+
+        @parent_class = parent_class
+
+        class_exec(&methods) if methods
+      end
+
+      # @return [Class, nil] the parent data class.
+      attr_reader :parent_class
+
+      private
+
+      def each_ancestor
+        return enum_for(:each_ancestor) unless block_given?
+
+        ancestor = parent_class
+
+        while ancestor
+          yield ancestor::HeritableMethods
+
+          ancestor = ancestor::HeritableMethods.parent_class
+        end
+      end
+
+      def included(other)
+        super
+
+        each_ancestor { |ancestor| other.include(ancestor) }
+      end
+    end
+
+    class << self
+      # Defines a new heritable Data class.
+      #
+      # @param symbols [Array<Symbol>] Data members to define.
+      # @param parent_class [Class] the parent class to inherit members and
+      #   methods from.
+      #
+      # @yield additional methods to define on the new Data class.
+      def define(*symbols, parent_class: nil, &)
+        Data.define(*parent_class&.members, *symbols).tap do |data_class|
+          data_class.include(HeritableData)
+
+          define_mixin_for(data_class, parent_class, &)
+        end
+      end
+
+      private
+
+      def define_mixin_for(data_class, parent_class = nil, &)
+        data_class.const_set(
+          :HeritableMethods,
+          HeritableData::HeritableMethods.new(parent_class:, &)
+        )
+
+        data_class.include(data_class::HeritableMethods)
+      end
+
+      def included(other)
+        super
+
+        other.singleton_class.prepend(ClassMethods)
+      end
+    end
+
+    # Checks if the object class inherits from type.
+    #
+    # @param type [Module] the type to check.
+    #
+    # @return [true] if the object class inherits from type, or if the object
+    #   class inherits members and methods from the given type.
+    def is_a?(type)
+      super || self.class < type || false
+    end
+    alias kind_of? is_a?
+  end
+end

data/lib/sleeping_king_studios/tools/toolbox.rb

@@ -7,6 +7,8 @@ module SleepingKingStudios::Tools
   module Toolbox
     autoload :ConstantMap,
       'sleeping_king_studios/tools/toolbox/constant_map'
+    autoload :HeritableData,
+      'sleeping_king_studios/tools/toolbox/heritable_data'
     autoload :Inflector,
       'sleeping_king_studios/tools/toolbox/inflector'
     autoload :Initializer,

data/lib/sleeping_king_studios/tools/version.rb

@@ -15,7 +15,7 @@ module SleepingKingStudios
       # Prerelease version.
       PRERELEASE = :rc
       # Build metadata.
-      BUILD = 0
+      BUILD = 1
 
       class << self
         # Generates the gem version string from the Version constants.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sleeping_king_studios-tools
 version: !ruby/object:Gem::Version
-  version: 1.3.0.rc.0
+  version: 1.3.0.rc.1
 platform: ruby
 authors:
 - Rob "Merlin" Smith
@@ -42,6 +42,7 @@ files:
 - lib/sleeping_king_studios/tools/toolbelt.rb
 - lib/sleeping_king_studios/tools/toolbox.rb
 - lib/sleeping_king_studios/tools/toolbox/constant_map.rb
+- lib/sleeping_king_studios/tools/toolbox/heritable_data.rb
 - lib/sleeping_king_studios/tools/toolbox/inflector.rb
 - lib/sleeping_king_studios/tools/toolbox/inflector/rules.rb
 - lib/sleeping_king_studios/tools/toolbox/initializer.rb