discriminable 2.2.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b497fdb2a24f47cb09e211407bb91fb07fd02c7566702e64ed7d02609d430ec
-  data.tar.gz: 8dd4464ff4cad4e6235e02bc8dde5eefe3f0ea4f9b0b32e94624e25188aa3f0a
+  metadata.gz: 3f3be0fa32d9828b9d37795c4f04974db45b399b1b729701cc3466bc5136ac2a
+  data.tar.gz: 5e0039a3a78058800f9ae0924146eba632ad3784457c13b448d98cc174b73466
 SHA512:
-  metadata.gz: 87c3f76d275be7dc83ed812fd06fa5f9b302b2709920342a17ec7cdcff24a688be648fe29f7c7b1f426270119f5350ec74f7feb09eca684ecb8f2b30000cefde
-  data.tar.gz: 8f8367a33ce5bd14c11664bc08dac19d6bc32614f355a69aafd0c7c67a1de164e93f3890ff99f2933e284761ce797adfbf757b66ace722685a6308d364c6e44f
+  metadata.gz: ea6a3450967d34c3e275ba4da051463bd1ca9d5a2f79d483edaad6bb5b284bb76bcc498b1ad54b87df62f79728bf1665112a7409c1b621716b813d02201b8c54
+  data.tar.gz: 9cfbe503697d09f795ff4477031ed3afd66e67fc53f01c2a7a226ec6b335eb16ea655fe821ffc4a828afab1c8f2964b16674c47db37491a9619e6a4f3be6720f

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+## [3.0.0](https://github.com/gregorw/discriminable/compare/v2.2.5...v3.0.0) (2022-08-21)
+
+
+### ⚠ BREAKING CHANGES
+
+* get rid of legacy hash notation
+
+### Features
+
+* Alternate syntax using attribute/value instead of prepositions ([d0843e4](https://github.com/gregorw/discriminable/commit/d0843e4fdf7d9721c29d7259f5c8f0746d345d9b))
+
+
+### Bug Fixes
+
+* coverage ([bd862a8](https://github.com/gregorw/discriminable/commit/bd862a835fc0239f0ac59cac1e051293b4b547bc))
+* get rid of legacy hash notation ([4feda16](https://github.com/gregorw/discriminable/commit/4feda16be37df14dd159b321d3e45a16127fa922))
+
 ### [2.2.5](https://github.com/gregorw/discriminable/compare/v2.2.4...v2.2.5) (2022-04-29)
 
 

data/README.md

@@ -9,7 +9,9 @@
 
 This is a Ruby gem that implements single-table inheritance (STI) for ActiveRecord models using string, integer and boolean column types.
 
-In other words, use any (existing) model attribute to discriminate between different classes in your class hierarchy. This makes storing class names in a `type` column redundant.
+In other words, it allows to use any (existing) model attribute to discriminate between different subclasses in your class hierarchy. This makes storing class names in a `type` column redundant.
+
+Also, it supports aliased attributes and _multiple_ values per subclass.
 
 ## Installation
 
@@ -25,11 +27,11 @@ or
 class Order < ActiveRecord::Base
   include Discriminable
 
-  discriminable_by :state
+  discriminable_attribute :state
 end
 
 class Cart < Order
-  discriminable_as :open
+  discriminable_value :open
 end
 
 Cart.create
@@ -48,21 +50,21 @@ class Order < ActiveRecord::Base
 
   enum state: { open: 0, processing: 1, invoiced: 2 }
 
-  discriminable_by :state
+  discriminable_attribute :state
 end
 
 class Cart < Order
-  discriminable_as :open
+  discriminable_value :open
 end
 
 class Invoice < Order
-  discriminable_as :invoiced
+  discriminable_value :invoiced
 end
 ```
 
 ### Aliased attributes
 
-In case you are working with a legacy database and cannot change the column name easily it’s easy to reference an aliased attribute in the `discriminable_by` definition.
+In case you are working with a legacy database and cannot change the column name easily it’s easy to reference an aliased attribute in the `discriminable_attribute` definition.
 
 ```ruby
 class Property < ActiveRecord::Base
@@ -71,11 +73,11 @@ class Property < ActiveRecord::Base
   alias_attribute :kind, :kind_with_legacy_postfix
 
   # Aliased attributes are supported when specifying the discriminable attribute
-  discriminable_by :kind
+  discriminable_attribute :kind
 end
 
 class NumberProperty < Property
-  discriminable_as 1
+  discriminable_value 1
 end
 ```
 
@@ -86,12 +88,37 @@ Sometimes, in a real project, you may want to map a number of values to a single
 ```ruby
 class OptionProperty < Property
   # The first mention becomes the default value
-  discriminable_as 2, 3, 4
+  discriminable_values 2, 3, 4
 end
 ```
 
 Note that when creating new records with e.g. `OptionProperty.create` a _default_ value needs to be set in the database for this discriminable class. The Discriminable gem uses the _first_ value in the list as the default.
 
+
+## Comparison with standard Rails
+
+
+### Rails STI
+
+| *values* | string | integer | boolean | enum | decimal | … |
+|--|--|--|--|--|--|--|
+| single | 🟡 `class.name` only | 🔴 |  🔴 |  🔴 |  🔴 |  🔴 |
+| multiple | 🔴 | 🔴 |  🔴 |  🔴 |  🔴 |  🔴 |
+
+### Discriminable Gem
+
+| *values* | string | integer | boolean | enum | decimal | … |
+|--|--|--|--|--|--| --|
+| single | 🟢 | 🟢 |  🟢 |  🟢 |  🟢 | 🟢 |
+| multiple | 🟢 | 🟢 |  🟢 |  🟢 |  🟢 | 🟢 |
+
+“Multiple” means that more than one value can map to a single subclass. This may or may not be useful for your use case. In standard Rails, the a single class name obviously maps to a single class.
+
+## Prerequisits
+
+Rails 5+ is required.
+
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gregorw/discriminable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/gregorw/discriminable/blob/main/CODE_OF_CONDUCT.md).

data/lib/discriminable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Discriminable
-  VERSION = "2.2.5"
+  VERSION = "3.0.0"
 end

data/lib/discriminable.rb

@@ -17,74 +17,78 @@ require "active_support"
 # class Customer < ActiveRecord::Base
 #   include Discriminable
 #
-#   discriminable state: { lead: "Lead" }
+#   discriminable_by :state
 # end
 #
 module Discriminable
   extend ActiveSupport::Concern
 
   included do
-    class_attribute :discriminable_map, instance_writer: false
-    class_attribute :discriminable_inverse_map, instance_writer: false
-    class_attribute :discriminable_values, instance_writer: false
+    class_attribute :_discriminable_map, instance_writer: false
+    class_attribute :_discriminable_inverse_map, instance_writer: false
+    class_attribute :_discriminable_values, instance_writer: false
   end
 
-  # Specify the column to use for discrimination.
+  # This adds
+  # - `discriminable_attribute` and
+  # - `discriminalbe_value`
+  # class methods (plus some aliases).
   module ClassMethods
-    def discriminable(**options)
-      raise "Subclasses should not override .discriminable" unless base_class?
-
-      attribute, map = options.first
-
-      # E.g. { value: "ClassName" }
-      self.discriminable_map = map.with_indifferent_access
+    # Specify the attribute/column at the root class to use for discrimination.
+    def discriminable_by(attribute)
+      raise "Subclasses should not override .discriminable_by" unless base_class?
 
-      # Use first key as default discriminator
-      # { a: "C", b: "C" }.invert => { "C" => :b }
-      # { a: "C", b: "C" }.to_a.reverse.to_h.invert => { "C" => :a }
-      # E.g. { "ClassName" => :value }
-      self.discriminable_inverse_map = map.to_a.reverse.to_h.invert
+      self._discriminable_map ||= _discriminable_map_memoized
+      self._discriminable_inverse_map ||= _discriminable_inverse_map_memoized
 
       attribute = attribute.to_s
       self.inheritance_column = attribute_aliases[attribute] || attribute
     end
 
-    def discriminable_by(attribute)
-      raise "Subclasses should not override .discriminable_by" unless base_class?
-
-      self.discriminable_map ||= discriminable_map_memoized
-      self.discriminable_inverse_map ||= discriminable_inverse_map_memoized
+    # “Aliases” for discriminable_by
+    def discriminable_attribute(attribute)
+      discriminable_by(attribute)
+    end
 
-      attribute = attribute.to_s
-      self.inheritance_column = attribute_aliases[attribute] || attribute
+    def discriminable_on(attribute)
+      discriminable_by(attribute)
     end
 
+    # Specify the values the subclass corresponds to.
     def discriminable_as(*values)
       raise "Only subclasses should specify .discriminable_as" if base_class?
 
-      self.discriminable_values = values.map do |value|
+      self._discriminable_values = values.map do |value|
         value.instance_of?(Symbol) ? value.to_s : value
       end
     end
 
+    def discriminable_value(*values)
+      discriminable_as(*values)
+    end
+
+    def discriminable_values(*values)
+      discriminable_as(*values)
+    end
+
     # This is the value of the discriminable attribute
     def sti_name
-      discriminable_inverse_map[name]
+      _discriminable_inverse_map[name]
     end
 
     def sti_names
-      ([self] + descendants).flat_map(&:discriminable_values)
+      ([self] + descendants).flat_map(&:_discriminable_values)
     end
 
     def type_condition(table = arel_table)
-      return super unless discriminable_values.present?
+      return super unless _discriminable_values.present?
 
       sti_column = table[inheritance_column]
       predicate_builder.build(sti_column, sti_names)
     end
 
     def sti_class_for(value)
-      return self unless (type_name = discriminable_map[value])
+      return self unless (type_name = _discriminable_map[value])
 
       super type_name
     end
@@ -96,23 +100,23 @@ module Discriminable
       attrs = attrs.to_h if attrs.respond_to?(:permitted?)
       return unless attrs.is_a?(Hash)
 
-      value = discriminable_value(attrs)
+      value = _discriminable_value(attrs)
       sti_class_for(value)
     end
 
-    def discriminable_map_memoized
+    def _discriminable_map_memoized
       Hash.new do |map, value|
-        map[value] = descendants.detect { |d| d.discriminable_values.include? value }&.name
+        map[value] = descendants.detect { |d| d._discriminable_values.include? value }&.name
       end
     end
 
-    def discriminable_inverse_map_memoized
+    def _discriminable_inverse_map_memoized
       Hash.new do |map, value|
-        map[value] = value.constantize.discriminable_values&.first
+        map[value] = value.constantize._discriminable_values&.first
       end
     end
 
-    def discriminable_value(attrs)
+    def _discriminable_value(attrs)
       attrs = attrs.with_indifferent_access
       value = attrs[inheritance_column]
       value ||= attrs[attribute_aliases.invert[inheritance_column]]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: discriminable
 version: !ruby/object:Gem::Version
-  version: 2.2.5
+  version: 3.0.0
 platform: ruby
 authors:
 - Gregor Wassmann
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-29 00:00:00.000000000 Z
+date: 2022-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord