active_module 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31dff5b0baa89fa4624fc7b974f5261d483cdaf48f7b7fe9a5d1f0a7f256d7fa
-  data.tar.gz: fbb6655e9de6c118ee99e199ed4ce78441cd55d151d839f7bf0040fa48519df5
+  metadata.gz: 191f7c2deb3a07261247a4302436cc734541ab62c3db9dd742974d58320dd763
+  data.tar.gz: bd20cb4d1aa7b6437facfaefc8213485571497df5e9e607ce19d16b81db246b8
 SHA512:
-  metadata.gz: 0ed009054605141713db46f3d768dc044f42d5bc8ac479ae8004408eaa9ad4657694d661299ba600868975bf7f254da00315d64564d1dfcd96a942ad6622dada
-  data.tar.gz: 4053a0f71c9b2b8db76c1f7637a989646c7b8ad531fa5da680c9795e61ec967fe9db13c74b566350039c13cdaf16d1a0c80f58e04944650e5e2c2f78d73a017f
+  metadata.gz: bc48c3f11e8f71321ab4abece1b5d58f671c96de7e494a5f2f7a8e55b9946c6e88af9e61970bdd2332eba12ee74dadec13485555dff0f05a4f74209c1327fd96
+  data.tar.gz: 126c9c4a2d885cadbe472dc23caa5025415f2806411e9eecce37a5b40c28ce990c5956246646292e9780b6f30d6f77705ab681899a7532940dbe0cfe59f2a471

data/README.md

@@ -17,6 +17,35 @@ This is a very generic mechanism that enables many possible utilizations, for in
 
 You can find examples of these in [Usage -> Examples :](#Examples) 
 
+## TL;DR
+
+Declare module attributes like this:
+```ruby
+class MyARObject < ActiveRecord::Base
+  attribute :module_field, 
+            :active_module, 
+            possible_modules: [MyModule1, MyClass, Nested::Module]
+end
+```
+
+Assign them like this:
+```ruby 
+object.module_field = Nested::Module
+object.module_field = :Module
+object.module_field = "Module"
+object.module_field #=> Nested::Module:Module
+```
+
+And compare them like this (optional):
+```ruby 
+module MyNameSpace
+  using ActiveModule::Comparison
+
+  object.module_field =~ :Module1
+  object.module_field =~ "Module1"
+end
+```
+
 ## Installation
 
 Add to your gemfile - and if you are using rails - that's all you need:
@@ -54,7 +83,7 @@ class MyARObject < ActiveRecord::Base
   module MyModule1; end
   module MyModule2; end
   class MyClass; 
-    module Module1; end
+    module MyModule1; end
   end
 end
 ```
@@ -63,13 +92,13 @@ You can make the field refer to one of these modules/classes like this:
 class MyARObject < ActiveRecord::Base
   attribute :module_field, 
             :active_module, 
-            possible_modules: [MyModule1, MyModule2, MyClass, MyClass::Module1]
+            possible_modules: [MyModule1, MyModule2, MyClass, MyClass::MyModule1]
 end
 ```
 And this is it! Easy!<br>
 
 ### Assigning and querying module attributes
-Now you can use this attribute in many handy ways:
+Now you can use this attribute in many handy ways!
 <br>
 <br>
 For instance, you may refer to it using module literals:
@@ -118,10 +147,25 @@ only available within the namespace that includes the refinement.
 ```ruby
 module YourClassOrModuleThatWantsToCompare
   using ActiveModule::Comparison
+
   def method_that_compares
     my_ar_object.module_field =~ :MyModule1
   end
 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
 
@@ -130,6 +174,19 @@ end
 [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, :active_module, possible_modules: StrategySuperclass.subclasses
+
+  def run_strategy!(args)
+    strategy.new(some_args).call(other_args)
+  end
+end
+```
+
+But if you are not in the mood to define a class hierarchy for it, you can use modules instead:
+
 ```ruby
 class MyARObject < ActiveRecord::Base
   module Strategy1
@@ -148,16 +205,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"
 ```
 
 
@@ -219,6 +273,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}"
@@ -243,11 +301,6 @@ module Provider
       "the amazon provider config"
     end
   end
-
-  # As if the domain model class
-  def self.all
-    [Ebay, Amazon]
-  end
 end
 ```
 
@@ -314,6 +367,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
@@ -343,18 +408,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,16 +7,12 @@ module ActiveModule
 
       def =~(other)
         case other
-        when nil
-          false
-        when ::Module
-          super(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
-          false
+          self == other
         end
       end
     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.5"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_module
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Pedro Rolo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-17 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord