strategic 0.9.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4031c3d360c08e12ac58e42d6e56b97c177c342e64a1680275f50ad0add7e08
-  data.tar.gz: 5b4b783eca5301aa05f6043729531c7458b40806ed3b768c7b341b283d77ccda
+  metadata.gz: 60db744a19fb4a7e6ac36c0fc5d36a6868a801d296c9331b4e865e087dd93c31
+  data.tar.gz: a88167c7f3a97fe47be46abef4ccd840597e237bc84812a1da586db501cc7868
 SHA512:
-  metadata.gz: b5edee9e7e0f491e5ecda04465372bb9e45274ecc906d07798e627a4485f8776f1625c8175ff403b3f8a25a8e16781f20dd6d02c76b0600cc41b7a9c4354b920
-  data.tar.gz: 1c7ebfb4ce224c80d3181b55e4c9137ac7d1015733211592ec95218a581cedafd56abe235fab07de92c2cdf2343873eb2ad5a7789ebc18d97f05f84b88528c13
+  metadata.gz: a0dd52c3176aa17bab03d9de1affdfbd8b90156278277ad3b2ade3a5d4401982a83208b5d04b54c9df39faf66845bd374f0eff9cd71cc6977382382fc7f4138a
+  data.tar.gz: 966b2e8d07234cf47e0d6da3c622628d777970d99f7c5b6725760b53f7958e013b206aa6eb287d1da2c30a869373648a004db528d40647b89422cf812a4e7a90

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Change Log
 
+## 1.1.0
+
+- Generate `strategy_name` attribute on `Strategic` class if it does not already exist like in the case of a Rails migration column
+- Automatically set `strategy_name` attribute when setting `strategy` attribute (either `strategy_name` attribute in Ruby or column in Rails)
+- Load `strategy` attribute from `strategy_name` attribute on `after_initialize` in Rails
+
+## 1.0.1
+
+- Fix error "undefined method `new' for Strategic::Strategy:Module" that occurs when setting an empty string strategy (must return nil or default strategy)
+- Fix issue with `ancestors` method not available on all constants (only ones that are classes/modules)
+
+## 1.0.0
+
+- Improve design to better match the authentic Gang of Four Strategy Pattern with `Strategic::Strategy` module, removing the need for inheritance.
+- `#strategy=`/`#strategy` enable setting/getting strategy on model
+- `#context` enables getting strategic model instance on strategy just as per the GOF Design Pattern
+- `default_strategy` class body method to set default strategy
+- Filter strategies by ones ending with `Strategy` in class name
+
+## 0.9.1
+
+- `strategy_name` returns parsed strategy name of current strategy class
+- `strategy_matcher` ignores a strategy if it found another strategy already matching by strategy_alias
+
 ## 0.9.0
 
 - `strategy_matcher` block support that enables any strategy to specify a custom matcher (or the superclass of all strategies instead)

data/README.md

@@ -1,16 +1,14 @@
-# Strategic 0.9.0
+# Strategic 1.1.0
 ## Painless Strategy Pattern in Ruby and Rails
 [![Gem Version](https://badge.fury.io/rb/strategic.svg)](http://badge.fury.io/rb/strategic)
-[![Build Status](https://travis-ci.com/AndyObtiva/strategic.svg?branch=master)](https://travis-ci.com/AndyObtiva/strategic?branch=master)
+[![rspec](https://github.com/AndyObtiva/strategic/actions/workflows/ruby.yml/badge.svg)](https://github.com/AndyObtiva/strategic/actions/workflows/ruby.yml)
 [![Coverage Status](https://coveralls.io/repos/github/AndyObtiva/strategic/badge.svg?branch=master)](https://coveralls.io/github/AndyObtiva/strategic?branch=master)
-
-(Note: this gem is a very early alpha work in progress and may change API in the future)
+[![Maintainability](https://api.codeclimate.com/v1/badges/0e638e392c21500c4fbe/maintainability)](https://codeclimate.com/github/AndyObtiva/strategic/maintainability)
 
 `if`/`case` conditionals can get really hairy in highly sophisticated business domains.
 Object-oriented inheritance helps remedy the problem, but dumping all
-logic variations in subclasses can cause a maintenance nightmare.
-Thankfully, the Strategy Pattern as per the [Gang of Four book](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) solves the problem by externalizing logic to
-separate classes outside the domain models.
+logic variations in domain model subclasses can cause a maintenance nightmare.
+Thankfully, the Strategy Pattern as per the [Gang of Four book](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612) solves the problem by externalizing logic via composition to separate classes outside the domain models.
 
 Still, there are a number of challenges with "repeated implementation" of the Strategy Pattern:
 - Making domain models aware of newly added strategies without touching their
@@ -28,7 +26,9 @@ code (Open/Closed Principle).
 
 `Strategic` enables you to make any existing domain model "strategic",
 externalizing all logic concerning algorithmic variations into separate strategy
-classes that are easy to find, maintain and extend while honoring the Open/Closed Principle.
+classes that are easy to find, maintain and extend while honoring the Open/Closed Principle and avoiding conditionals.
+
+In summary, if you make a class called `TaxCalculator` strategic by including the `Strategic` mixin module, now you are able to drop strategies under the `tax_calculator` directory sitting next to the class (e.g. `tax_calculator/us_strategy.rb`, `tax_calculator/canada_strategy.rb`) while gaining extra [API](#api) methods to grab strategy names to present in a user interface (`.strategy_names`), set a strategy (`#strategy=(strategy_name)` or `#strategy_name=(strategy_name)`), and/or instantiate `TaxCalculator` directly with a strategy from the get-go (`.new_with_strategy(strategy_name, *initialize_args)`). Finally, you can simply invoke strategy methods on the main strategic model (e.g. `tax_calculator.tax_for(39.78)`).
 
 ### Example
 
@@ -41,71 +41,80 @@ alt="Strategic Example" />
 class TaxCalculator
   include Strategic
 
-  def tax_for(amount)
-    amount * 0.09
-  end
+  # strategies may implement a tax_for(amount) method
 end
 ```
 
 2. Now, you can add strategies under this directory without having to modify the original class: `tax_calculator`
 
-3. Add strategy classes under the namespace matching the original class name (`TaxCalculator`) and extending the original class (`TaxCalculator`) just to take advantage of default logic in it:
+3. Add strategy classes having names ending with `Strategy` by convention (e.g. `UsStrategy`) under the namespace matching the original class name (`TaxCalculator::` as in `tax_calculator/us_strategy.rb` representing `TaxCalculator::UsStrategy`) and including the module (`Strategic::Strategy`):
+
+All strategies get access to their context (strategic model instance), which they can use in their logic.
 
 ```ruby
-class TaxCalculator::UsStrategy < TaxCalculator
-  def initialize(state)
-    @state = state
-  end
+class TaxCalculator::UsStrategy
+  include Strategic::Strategy
+  
   def tax_for(amount)
-    amount * state_rate
+    amount * state_rate(context.state)
   end
-  # ... more code follows
+  # ... other strategy methods follow
 end
 
-class TaxCalculator::CanadaStrategy < TaxCalculator
-  def initialize(province)
-    @province = province
-  end
+class TaxCalculator::CanadaStrategy
+  include Strategic::Strategy
+
   def tax_for(amount)
-    amount * (gst + qst)
+    amount * (gst(context.province) + qst(context.province))
   end
-  # ... more code follows
+  # ... other strategy methods follow
 end
 ```
 
-4. In client code, obtain the needed strategy by underscored string reference minus the word strategy (e.g. UsStrategy becomes simply 'us'):
+(note: if you use strategy inheritance hierarchies, make sure to have strategy base classes end with `StrategyBase` to avoid getting picked up as strategies)
+
+4. In client code, set the strategy by underscored string reference minus the word strategy (e.g. UsStrategy becomes simply 'us'):
 
 ```ruby
-tax_calculator_strategy_class = TaxCalculator.strategy_class_for('us')
+tax_calculator = TaxCalculator.new(args)
+tax_calculator.strategy = 'us'
 ```
 
-5. Instantiate the strategy object:
+4a. Alternatively, instantiate the strategic model with a strategy to begin with:
 
 ```ruby
-tax_calculator_strategy = strategy_class.new('IL')
+tax_calculator = TaxCalculator.new_with_strategy('us', args)
 ```
 
-6. Invoke the strategy overridden method:
+4b. Alternatively in Rails, instantiate or create an ActiveRecord model with `strategy_name` column attribute included in args (you may generate migration for `strategy_name` column via `rails g migration add_strategy_name_to_resources strategy_name:string`):
 
 ```ruby
-tax = tax_calculator_strategy.tax_for(39.78)
+tax_calculator = TaxCalculator.create(args) # args include strategy_name
 ```
 
-**Alternative approach using `new_strategy(strategy_name, *initializer_args)`:**
+5. Invoke the strategy implemented method:
 
 ```ruby
-tax_calculator_strategy = TaxCalculator.new_strategy('US', 'IL')
-tax = tax_calculator_strategy.tax_for(39.78)
+tax = tax_calculator.tax_for(39.78)
 ```
 
-**Default strategy for a strategy name that has no strategy class is the superclass: `TaxCalculator`**
+Default strategy for a strategy name that has no strategy class is `nil`
+
+You may set a default strategy on a strategic model via class method `default_strategy`
 
 ```ruby
-tax_calculator_strategy_class = TaxCalculator.strategy_class_for('France')
-tax_calculator_strategy = tax_calculator_strategy_class.new
-tax = tax_calculator_strategy.tax_for(100.0) # returns 9.0 from TaxCalculator
+class TaxCalculator
+  include Strategic
+  
+  default_strategy 'canada'
+end
+
+tax_calculator = TaxCalculator.new(args)
+tax = tax_calculator.tax_for(39.78)
 ```
 
+If no strategy is selected and you try to invoke a method that belongs to strategies, Ruby raises an amended method missing error informing you that no strategy is set to handle the method (in case it was a strategy method).
+
 ## Setup
 
 ### Option 1: Bundler
@@ -113,7 +122,7 @@ tax = tax_calculator_strategy.tax_for(100.0) # returns 9.0 from TaxCalculator
 Add the following to bundler's `Gemfile`.
 
 ```ruby
-gem 'strategic', '~> 0.9.0'
+gem 'strategic', '~> 1.1.0'
 ```
 
 ### Option 2: Manual
@@ -121,7 +130,7 @@ gem 'strategic', '~> 0.9.0'
 Or manually install and require library.
 
 ```bash
-gem install strategic -v0.9.0
+gem install strategic -v1.1.0
 ```
 
 ```ruby
@@ -131,33 +140,87 @@ require 'strategic'
 ### Usage
 
 Steps:
-1. Have the original class you'd like to strategize include Strategic
-2. Create a directory matching the class underscored file name minus the '.rb' extension
-3. Create a strategy class under that directory, which:
+1. Have the original class you'd like to strategize include `Strategic` (e.g. `def TaxCalculator; include Strategic; end`
+2. Create a directory matching the class underscored file name minus the '.rb' extension (e.g. `tax_calculator/`)
+3. Create a strategy class under that directory (e.g. `tax_calculator/us_strategy.rb`), which:
  - Lives under the original class namespace
- - Extends the original class to strategize
+ - Includes the `Strategic::Strategy` module
  - Has a class name that ends with `Strategy` suffix (e.g. `NewCustomerStrategy`)
-4. Get needed strategy class using `strategy_class_for` class method taking strategy name (any case) or related object/type (can call `strategy_names` class method to obtain strategy names)
-5. Instantiate strategy with needed constructor parameters
+4. Set strategy on strategic model using `strategy=` attribute writer method or instantiate with `new_with_strategy` class method, which takes a strategy name string (any case), strategy class, or mirror object (having a class matching strategy name minus the word `Strategy`) (note: you can call `::strategy_names` class method to obtain available strategy names or `::stratgies` to obtain available strategy classes)
+5. Alternatively in Rails, create migration `rails g migration add_strategy_name_to_resources strategy_name:string` and set strategy via `strategy_name` column, storing in database. On load of the model, the right strategy is automatically loaded based on `strategy_name` column.
 6. Invoke strategy method needed
 
-Alternative approach:
+## API
 
-Combine steps 4 and 5 using `new_strategy` method, which takes both strategy name
-and constructor parameters
+### Strategic model
 
-Passing an invalid strategy name to `strategy_class_for` returns original class as the default
-strategy.
+#### Class Body Methods
 
-## API
+These methods can be delcared in a strategic model class body.
+
+- `::default_strategy`: sets default strategy as a strategy name string (e.g. 'us' selects UsStrategy) or alternatively a class/object if you have a mirror hierarchy for the strategy hierarchy
+- `::strategy_matcher`: custom matcher for all strategies (e.g. `strategy_matcher {|string| string.start_with?('C') && string.end_with?('o')}`)
+
+#### Class Methods
+
+- `::strategy_names`: returns list of strategy names (strings) discovered by convention (nested under a namespace matching the superclass name)
+- `::strategies`: returns list of strategies discovered by convention (nested under a namespace matching the superclass name)
+- `::new_with_strategy(string_or_class_or_object, *args, &block)`: instantiates a strategy based on a string/class/object and strategy constructor args
+- `::strategy_class_for(string_or_class_or_object)`: selects a strategy class based on a string (e.g. 'us' selects UsStrategy) or alternatively a class/object if you have a mirror hierarchy for the strategy hierarchy
 
-- `StrategicSuperClass::strategy_class_for(string_or_class_or_object)`: selects a strategy class based on a string (e.g. 'us' selects USStrategy) or alternatively a class/object if you have a mirror hierarchy for the strategy hierarchy
-- `StrategicSuperClass::new_strategy(string_or_class_or_object, *args, &block)`: instantiates a strategy based on a string/class/object and strategy constructor args
-- `StrategicSuperClass::strategies`: returns list of strategies discovered by convention (nested under a namespace matching the superclass name)
-- `StrategicSuperClass::strategy_names`: returns list of strategy names (strings) discovered by convention (nested under a namespace matching the superclass name)
-- `StrategicSuperClass::strategy_matcher`: custom match (e.g. `strategy_matcher {|string| string.start_with?('C') && string.end_with?('o')}`)
-- `StrategicSuperClass::strategy_exclusion`: exclusion from custom matcher (e.g. `strategy_exclusion 'Cio'`)
-- `StrategicSuperClass::strategy_alias`: alias for strategy in addition to strategy's name derived from class name by convention (e.g. `strategy_alias 'USA'` for `UsStrategy`)
+#### Instance Methods
+
+- `#strategy=`: sets strategy
+- `#strategy`: returns current strategy
+
+### Strategy
+
+#### Class Body Methods
+
+- `::strategy_matcher`: custom matcher for a specific strategy (e.g. `strategy_matcher {|string| string.start_with?('C') && string.end_with?('o')}`)
+- `::strategy_exclusion`: exclusion from custom matcher (e.g. `strategy_exclusion 'Cio'`)
+- `::strategy_alias`: alias for strategy in addition to strategy's name derived from class name by convention (e.g. `strategy_alias 'USA'` for `UsStrategy`)
+
+#### Class Methods
+
+- `::strategy_name`: returns parsed strategy name of current strategy class
+
+#### Instance Methods
+
+- `#context`: returns strategy context (the strategic model instance)
+
+### Example with Customizations via Class Body Methods
+
+```ruby
+class TaxCalculator
+  default_strategy 'us'
+
+  # fuzz matcher
+  strategy_matcher do |string_or_class_or_object|
+    class_name = self.name # current strategy class name being tested for matching
+    strategy_name = class_name.split('::').last.sub(/Strategy$/, '').gsub(/([A-Z])/) {|letter| "_#{letter.downcase}"}[1..-1]
+    strategy_name_length = strategy_name.length
+    possible_keywords = strategy_name_length.times.map {|n| strategy_name.chars.combination(strategy_name_length - n).to_a}.reduce(:+).map(&:join)
+    possible_keywords.include?(string_or_class_or_object)
+  end
+  # ... more code follows
+end
+
+class TaxCalculator::UsStrategy
+  include Strategic::Strategy
+
+  strategy_alias 'USA'
+  strategy_exclusion 'U'
+  
+  # ... strategy methods follow
+end
+
+class TaxCalculator::CanadaStrategy
+  include Strategic::Strategy
+  
+  # ... strategy methods follow
+end
+```
 
 ## TODO
 

data/lib/strategic/strategy.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2020-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Strategic
+  module Strategy
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+  
+    module ClassMethods
+      def strategy_alias(alias_string_or_class_or_object)
+        strategy_aliases << alias_string_or_class_or_object
+      end
+      
+      def strategy_aliases
+        @strategy_aliases ||= []
+      end
+    
+      def strategy_exclusion(exclusion_string_or_class_or_object)
+        strategy_exclusions << exclusion_string_or_class_or_object
+      end
+      
+      def strategy_exclusions
+        @strategy_exclusions ||= []
+      end
+      
+      def strategy_matcher(&matcher_block)
+        if block_given?
+          @strategy_matcher = matcher_block
+        else
+          @strategy_matcher
+        end
+      end
+      
+      def strategy_name
+        Strategic.underscore(name.split(':').last).sub(/_strategy$/, '')
+      end
+    end
+    
+    attr_reader :context
+    
+    def initialize(context)
+      @context = context
+    end
+    
+  end
+end

data/lib/strategic.rb

@@ -18,37 +18,58 @@
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
+  
 module Strategic
   def self.included(klass)
     klass.extend(ClassMethods)
     klass.require_strategies
-  end
-
-  module ClassMethods
-    def strategy_alias(alias_string_or_class_or_object)
-      strategy_aliases << alias_string_or_class_or_object
-    end
-    
-    def strategy_aliases
-      @strategy_aliases ||= []
+    rails_mode = klass.respond_to?(:column_names) && klass.column_names.include?('strategy_name')
+    if rails_mode
+      klass.include(ExtraRailsMethods)
+      klass.after_initialize :reload_strategy
+    else
+      klass.include(ExtraRubyMethods)
     end
+  end
   
-    def strategy_exclusion(exclusion_string_or_class_or_object)
-      strategy_exclusions << exclusion_string_or_class_or_object
+  module ExtraRailsMethods
+    def strategy_name=(string)
+      self['strategy_name'] = string
+      strategy_class = self.class.strategy_class_for(string)
+      @strategy = strategy_class&.new(self)
     end
+  end
+  
+  module ExtraRubyMethods
+    attr_reader :strategy_name
     
-    def strategy_exclusions
-      @strategy_exclusions ||= []
+    def strategy_name=(string)
+      @strategy_name = string
+      strategy_class = self.class.strategy_class_for(string)
+      @strategy = strategy_class&.new(self)
     end
-    
+  end
+
+  module ClassMethods
     def strategy_matcher(&matcher_block)
-      if block_given?
+      if matcher_block.nil?
+        @strategy_matcher
+      else
         @strategy_matcher = matcher_block
+      end
+    end
+    
+    def default_strategy(string_or_class_or_object = nil)
+      if string_or_class_or_object.nil?
+        @default_strategy
       else
-        @strategy_matcher
+        @default_strategy = strategy_class_for(string_or_class_or_object)
       end
     end
+    
+    def strategy_matcher_for_any_strategy?
+      !!(strategy_matcher || strategies.any?(&:strategy_matcher))
+    end
   
     def require_strategies
       klass_path = caller[1].split(':').first
@@ -59,47 +80,86 @@ module Strategic
     end
 
     def strategy_class_for(string_or_class_or_object)
-      strategy_class = nil
-      if strategy_matcher
-        strategy_class = strategies.detect do |strategy|
-          match = strategy&.strategy_matcher&.call(string_or_class_or_object)
-          match ||= strategy.instance_exec(string_or_class_or_object, &strategy_matcher)
-          match unless strategy.strategy_exclusions.include?(string_or_class_or_object)
-        end
+      strategy_class = strategy_matcher_for_any_strategy? ? strategy_class_with_strategy_matcher(string_or_class_or_object) : strategy_class_without_strategy_matcher(string_or_class_or_object)
+      strategy_class ||= strategies.detect { |strategy| strategy.strategy_aliases.include?(string_or_class_or_object) }
+      strategy_class ||= default_strategy
+    end
+    
+    def strategy_class_with_strategy_matcher(string_or_class_or_object)
+      strategies.detect do |strategy|
+        match = strategy.strategy_aliases.include?(string_or_class_or_object)
+        match ||= strategy&.strategy_matcher&.call(string_or_class_or_object) || (strategy_matcher && strategy.instance_exec(string_or_class_or_object, &strategy_matcher))
+        # match unless excluded or included by another strategy as an alias
+        match unless strategy.strategy_exclusions.include?(string_or_class_or_object) || (strategies - [strategy]).map(&:strategy_aliases).flatten.include?(string_or_class_or_object)
+      end
+    end
+    
+    def strategy_class_without_strategy_matcher(string_or_class_or_object)
+      if string_or_class_or_object.is_a?(String)
+        strategy_class_name = string_or_class_or_object.downcase
+      elsif string_or_class_or_object.is_a?(Class)
+        strategy_class_name = string_or_class_or_object.name
       else
-        if string_or_class_or_object.is_a?(String)
-          strategy_class_name = string_or_class_or_object.downcase
-        elsif string_or_class_or_object.is_a?(Class)
-          strategy_class_name = string_or_class_or_object.name
-        else
-          strategy_class_name = string_or_class_or_object.class.name
-        end
-        begin
-          class_name = "::#{self.name}::#{Strategic.classify(strategy_class_name)}Strategy"
-          strategy_class = class_eval(class_name)
-        rescue NameError
-          # No Op
-        end
+        strategy_class_name = string_or_class_or_object.class.name
+      end
+      return nil if strategy_class_name.to_s.strip.empty?
+      begin
+        class_name = "::#{self.name}::#{Strategic.classify(strategy_class_name)}Strategy"
+        class_eval(class_name)
+      rescue NameError
+        # No Op
       end
-      strategy_class ||= strategies.detect { |strategy| strategy.strategy_aliases.include?(string_or_class_or_object) }
-      strategy_class ||= self
     end
 
-    def new_strategy(string_or_class_or_object, *args, &block)
-      strategy_class_for(string_or_class_or_object).new(*args, &block)
+    def new_with_strategy(string_or_class_or_object, *args, &block)
+      new(*args, &block).tap do |model|
+        model.strategy = string_or_class_or_object
+      end
     end
 
     def strategies
       constants.map do |constant_symbol|
         const_get(constant_symbol)
       end.select do |constant|
-        constant.respond_to?(:ancestors) && constant.ancestors.include?(self)
-      end
+        constant.respond_to?(:ancestors)
+      end.select do |constant|
+        constant.ancestors.include?(Strategic::Strategy) && constant.name.split('::').last.end_with?('Strategy') && constant.name.split('::').last != 'Strategy' # has to be something like PrefixStrategy
+      end.sort_by(&:strategy_name)
     end
 
     def strategy_names
-      strategies.map(&:name).map { |class_name| Strategic.underscore(class_name.split(':').last).sub(/_strategy$/, '') }
+      strategies.map(&:strategy_name)
     end
+    
+  end
+  
+  def strategy=(string_or_class_or_object)
+    strategy_class = self.class.strategy_class_for(string_or_class_or_object)
+    self.strategy_name = strategy_class&.strategy_name
+  end
+      
+  def strategy
+    @strategy
+  end
+  
+  def reload_strategy
+    self.strategy = strategy_name
+  end
+  
+  def method_missing(method_name, *args, &block)
+    if strategy&.respond_to?(method_name, *args, &block)
+      strategy.send(method_name, *args, &block)
+    else
+      begin
+        super
+      rescue => e
+        raise "No strategy is set to handle the method #{method_name} with args #{args.inspect} and block #{block.inspect} / " + e.message
+      end
+    end
+  end
+    
+  def respond_to?(method_name, *args, &block)
+    strategy&.respond_to?(method_name, *args, &block) || super
   end
 
   private
@@ -112,3 +172,5 @@ module Strategic
     text.chars.reduce('') {|output,c| !output.empty? && c.match(/[A-Z]/) ? output + '_' + c : output + c}.downcase
   end
 end
+
+require_relative 'strategic/strategy'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strategic
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-15 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -42,14 +42,14 @@ dependencies:
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.12'
 - !ruby/object:Gem::Dependency
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.3.0
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.23
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.23
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -109,19 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.16.1
 - !ruby/object:Gem::Dependency
-  name: simplecov-lcov
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.23
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.23
 - !ruby/object:Gem::Dependency
   name: puts_debuggerer
   requirement: !ruby/object:Gem::Requirement
@@ -161,6 +147,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/strategic.rb
+- lib/strategic/strategy.rb
 homepage: http://github.com/AndyObtiva/strategic
 licenses:
 - MIT
@@ -180,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Painless Strategy Pattern for Ruby and Rails