active_module 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1473d88ff3d53e8948747dc7827ad2836478a0c6db139c54e11f2a96df58e758
-  data.tar.gz: 045e7b7689734cf7c98654ec1283a747063d1defba78c47e3efbd115c5046675
+  metadata.gz: b80aaae788c312746df8dcaba68bfda8f881fc2c22d7642b509546bdab198bc0
+  data.tar.gz: 84674ab108e9b639327f7531f678a12b8dbf31ab25c01088f8839458b71d1cac
 SHA512:
-  metadata.gz: 67321659d14a0aff48e5917e2242d42773dbc6f86a8fa8cef935956bbda4717858128a405264ff39cde9bd06e223ee266b08a4f4b07a62f600ee3b6de8c54714
-  data.tar.gz: bf7305eabb2c4d81e0514542c7172e440aaf5b17ea5d4bf732705100f8a92cc01f772aae9b3ba0f864c575f1040626d7730f5831d7d7889aec0ed88980f5271a
+  metadata.gz: a89843336735a230e13691069fd3a2e919403a140712476bb5176862fd0bb72df6ff069fa9d3ca9635c2dadc1a602863122a2ec384f8414754a560da02561698
+  data.tar.gz: f7b03c281aafba2a1bf187f7ed9b049c9dd3798bafdf411c3710964e2cbc087dedd72937c897925bdcbb9f4887e625f5d893b69640df853f738324b12b955e7d

data/README.md

@@ -1,19 +1,21 @@
-# ActiveModule
 
-*"Let's turn modules and classes into first-class active record values!"*
+# active_module 
+![alt text](https://img.shields.io/badge/coverage-100%25-brightgreen)
+
+#### *Modules and Classes as first-class active record values!*
 
 ActiveModel/ActiveRecord implementation of the Module attribute type.
 
-- Allows storing a reference to a `Module` or `Class` (because they are modules) in a `:string` 
-database field in a safe and efficient way.
-- It automatically casts strings and symbols into modules when creating and querying objects.
-- Symbols or strings refer to the modules using unqualified names.
+- Allows storing a reference to a `Module` or `Class` in a `:string` database field
+- Automatically casts strings and symbols into modules when creating and querying objects
+- Symbols or strings refer to the modules using unqualified names
+- It is safe and efficient
 
 This is a very generic mechanism that enables many possible utilizations, for instance:
-- Strategy Pattern (composition-based polymorphism)
-- Rapid prototyping static domain objects
-- Static configuration management
-- Rich Java/C#-like enums
+- **Composition-based polymorphism (Strategy design pattern)**
+- **Rapid prototyping static domain objects**
+- **Static configuration management**
+- **Rich Java/C#-like enums**
 
 You can find examples of these in [Usage -> Examples :](#Examples) 
 
@@ -36,8 +38,19 @@ object.module_field = "Module"
 object.module_field #=> Nested::Module:Module
 ```
 
-And compare them like this (optional):
+Query them like this:
+```ruby 
+MyARObject.where(module_field: Nested::Module)
+MyARObject.where(module_field: :Module)
+MyARObject.where(module_field: "Module")
+object.module_field #=> Nested::Module:Module
+```
+
+And compare them like this:
+
 ```ruby 
+object.module_field == Nested::Module
+
 module MyNameSpace
   using ActiveModule::Comparison
 
@@ -51,7 +64,7 @@ end
 Add to your gemfile - and if you are using rails - that's all you need:
 
 ```ruby
-gem 'active_module', "~>0.1"
+gem 'active_module', "~> 0.1"
 ```
 
 If you are not using rails, just issue this command after loading active record
@@ -77,7 +90,7 @@ create_table :my_ar_objects do |t|
 end
 ```
 
-Now given this module structure:
+Now given this random module hierarchy:
 ```ruby
 class MyARObject < ActiveRecord::Base
   module MyModule1; end
@@ -154,13 +167,44 @@ module YourClassOrModuleThatWantsToCompare
 end
 ```
 
+or like this, if you don't want to use the refinement:
+
+```ruby
+ActiveModule::Comparison.compare(my_ar_object.module_field, :MyModule1)
+```
+
+but in this last case it would probably make more sense to simply use a module literal:
+
+```ruby
+my_ar_object.module_field == MyClass::MyModule1
+```
+
+
 ## Examples
 
-### Strategy Pattern (composition-based polymorphism)
+### Composition-based polymorphism (Strategy design pattern)
 
 [The Strategy design pattern](https://en.wikipedia.org/wiki/Strategy_pattern) allows composition based polymorphism. This enables runtime polymorphism (by changing the strategy in runtime), 
 and multiple-polymorphism (by composing an object of multiple strategies).
 
+If you want to use classes this will do: 
+```ruby
+class MyARObject < ActiveRecord::Base
+  attribute :strategy_class, :active_module, possible_modules: StrategySuperclass.subclasses
+
+  def strategy
+    @strategy ||= strategy_class.new(some_args_from_the_instance)
+  end
+
+  def run_strategy!(args)
+    strategy.call(args)
+  end
+end
+```
+
+But if you are not in the mood to define a class hierarchy for it (or if you are performance-savy),
+you may use modules instead:
+
 ```ruby
 class MyARObject < ActiveRecord::Base
   module Strategy1
@@ -179,16 +223,13 @@ class MyARObject < ActiveRecord::Base
             :active_module, 
             possible_modules: [Strategy1, Strategy2]
 
-  def run_strategy!
-    # here we could pass arguments to the strategy, and if 
-    # in this case strategies were classes we could also 
-    # instantiate them
-    strategy.call
+  def run_strategy!(some_args)
+    strategy.call(some_args, other_args)
   end
 end
 
 MyARObject.create!(module_field: :Strategy1).run_strategy! #=> "strategy1 called"
-MyARObject.create!(module_field: :Strategy1).run_strategy! #=> "strategy2 called"
+MyARObject.create!(module_field: :Strategy2).run_strategy! #=> "strategy2 called"
 ```
 
 
@@ -250,6 +291,10 @@ this is how you could do so:
 # Provider domain Object
 module Provider
   # As if the domain model class
+  def self.all
+    [Ebay, Amazon]
+  end
+
   module Base 
     def do_something!
       "do something with #{something_from_an_instance}"
@@ -274,11 +319,6 @@ module Provider
       "the amazon provider config"
     end
   end
-
-  # As if the domain model class
-  def self.all
-    [Ebay, Amazon]
-  end
 end
 ```
 
@@ -345,6 +385,18 @@ Java/C# enums allow defining methods on the enum, which are shared across all en
 
 ```ruby
 module PipelineStage
+  module_function
+
+  def all
+    [InitialContact, InNegotiations, LostDeal, PaidOut]
+  end
+
+  def cast(stage)
+    self.all.map(&:external_provider_code).find{|code| code == stage} ||
+    self.all.map(&:database_representation).find{|code| code == stage} ||
+    self.all.map(&:frontend_representation).find{|code| code == stage} 
+  end
+
   module Base
     def external_provider_code
       @external_provider_code ||= self.name.underscore
@@ -374,18 +426,6 @@ module PipelineStage
   module PaidOut
     extend Base
   end
-
-  module_function
-
-  def all
-    [InitialContact, InNegotiations, LostDeal, PaidOut]
-  end
-
-  def cast(stage)
-    self.all.map(&:external_provider_code).find{|code| code == stage} ||
-    self.all.map(&:database_representation).find{|code| code == stage} ||
-    self.all.map(&:frontend_representation).find{|code| code == stage} 
-  end
 end
 
 class MyARObject < ActiveRecord::Base

data/lib/active_module/comparison.rb

@@ -7,10 +7,10 @@ module ActiveModule
 
       def =~(other)
         case other
-        when ::String
-          (@possible_names ||= possible_names).include?(other)
         when ::Symbol
-          (@possible_names ||= possible_names).include?(other.to_s)
+          possible_symbol_names_set.include?(other)
+        when ::String
+          possible_symbol_names_set.include?(other.to_sym)
         else
           self == other
         end

data/lib/active_module/module_refinement.rb

@@ -14,6 +14,10 @@ module ActiveModule
         end
       end
 
+      def possible_symbol_names_set
+        @possible_symbol_names_set ||= Set.new(possible_names.map(&:to_sym))
+      end
+
       def qualified_name
         "::#{name}"
       end

data/lib/active_module/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveModule
-  VERSION = "0.1.6"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_module
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Pedro Rolo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-17 00:00:00.000000000 Z
+date: 2024-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: '9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '9'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -44,7 +44,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.15.0
-description: Let's turn modules and classes into first-class active record values!
+description: ActiveModel/ActiveRecord module attribute type implementation
 email:
 - pedrorolo@gmail.com
 executables: []
@@ -89,5 +89,5 @@ requirements: []
 rubygems_version: 3.5.7
 signing_key:
 specification_version: 4
-summary: ActiveModel/ActiveRecord module attribute type implementation
+summary: Modules and Classes as first-class active record values
 test_files: []