strategic 0.9.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d5c5c2a7b15c1c3e826a37c64b0b4b90f8b4a1dd8d93aaeb5f6c81c796faa93
-  data.tar.gz: ef054a37db19f752d92e2344f7da9f6269732bcf897babcce4c756e426ca90e2
+  metadata.gz: d76d0987f4534352de4fb52f025547a0ef37cad16a9452f1fd78da71606a3bae
+  data.tar.gz: 389a399d74c94352cf2165a8975b0b8d5886c782d08614c8b674ae0bd329c2a3
 SHA512:
-  metadata.gz: 18fe37a88abab52119d44e03402ea2c005c3235d8709b3802dca8cebaf863af712bbc62c68bed47940ca7846d310135a685e416bc94c4c4f7d6984094ab5071b
-  data.tar.gz: 959739994722aa145afa46180cad9ef556fe27e57f39e9b49b631074dd788b2cfcc60dda26f564f8d09a2ce94c1100dc6d5994718d3b1421599dbc0665c1bbee
+  metadata.gz: 5aa4d886c61f6daf162ac9a7dbd19635fb20cb0c9c9cef437998d8496e0e75f4c0381a7abe2c887ba794398ca4522489702cfa644cd18d180bb9cf95813a8725
+  data.tar.gz: 2243df9a574cbf09d708f16ef5d6c2bbc2d621e1932c50e68b081402ad19c49ab341dfdd07b5fd5461cbe1ad0ed17cf1898546d62e09b4e254b4ed3d9fbf8d89

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Change Log
 
+## 1.2.0
+
+- `default_strategy` default value will be `'default'`, assuming a `model_namespace/default_strategy.rb` file with `DefaultStrategy` class
+- `new_with_default_strategy` class method (instantiating with `'default'` strategy if not configured or `default_strategy` class method value if configured)
+
+## 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

data/README.md

@@ -1,4 +1,4 @@
-# Strategic 0.9.1
+# Strategic 1.2.0
 ## Painless Strategy Pattern in Ruby and Rails
 [![Gem Version](https://badge.fury.io/rb/strategic.svg)](http://badge.fury.io/rb/strategic)
 [![rspec](https://github.com/AndyObtiva/strategic/actions/workflows/ruby.yml/badge.svg)](https://github.com/AndyObtiva/strategic/actions/workflows/ruby.yml)
@@ -7,9 +7,8 @@
 
 `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
@@ -27,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 (`.new(*initialize_args)`), with default strategy (`.new_with_default_strategy(*initialize_args)`), or 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
 
@@ -40,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` unless `DefaultStrategy` class exists under the model class namespace or `default_strategy` class attribute is set.
+
+This is how to 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
@@ -112,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.1'
+gem 'strategic', '~> 1.2.0'
 ```
 
 ### Option 2: Manual
@@ -120,7 +130,7 @@ gem 'strategic', '~> 0.9.1'
 Or manually install and require library.
 
 ```bash
-gem install strategic -v0.9.1
+gem install strategic -v1.2.0
 ```
 
 ```ruby
@@ -130,34 +140,89 @@ 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`) (default is assumed as `tax_calculator/default_strategy.rb` unless customized with `default_strategy` class method):
  - 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(strategy_name)`: 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
+- `::default_strategy`: returns default strategy (default: `'default'` as in `DefaultStrategy`)
+- `::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
+- `::new_with_default_strategy(*args, &block)`: instantiates with default strategy
+- `::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
 
-- `StrategicClass::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
-- `StrategicClass::new_strategy(string_or_class_or_object, *args, &block)`: instantiates a strategy based on a string/class/object and strategy constructor args
-- `StrategicClass::strategies`: returns list of strategies discovered by convention (nested under a namespace matching the superclass name)
-- `StrategicClass::strategy_names`: returns list of strategy names (strings) discovered by convention (nested under a namespace matching the superclass name)
-- `StrategicClass::strategy_name`: returns parsed strategy name of current strategy class
-- `StrategicClass::strategy_matcher`: custom match (e.g. `strategy_matcher {|string| string.start_with?('C') && string.end_with?('o')}`)
-- `StrategicClass::strategy_exclusion`: exclusion from custom matcher (e.g. `strategy_exclusion 'Cio'`)
-- `StrategicClass::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,35 +18,53 @@
 # 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
+    klass.default_strategy 'default'
+  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
     
@@ -65,7 +83,7 @@ module Strategic
     def strategy_class_for(string_or_class_or_object)
       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 ||= self
+      strategy_class ||= default_strategy
     end
     
     def strategy_class_with_strategy_matcher(string_or_class_or_object)
@@ -85,6 +103,7 @@ module Strategic
       else
         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)
@@ -93,26 +112,62 @@ module Strategic
       end
     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_default_strategy(*args, &block)
+      new(*args, &block).tap do |model|
+        model.strategy = nil
+      end
+    end
+
+    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(&:strategy_name)
     end
     
-    def strategy_name
-      Strategic.underscore(name.split(':').last).sub(/_strategy$/, '')
+  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
 
@@ -124,3 +179,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.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Andy Maleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-17 00:00:00.000000000 Z
+date: 2022-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -122,6 +122,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: rake-tui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   if/case conditionals can get really hairy in highly sophisticated business domains.
   Domain model inheritance can help remedy the problem, but you don't want to dump all
@@ -147,6 +161,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/strategic.rb
+- lib/strategic/strategy.rb
 homepage: http://github.com/AndyObtiva/strategic
 licenses:
 - MIT
@@ -166,7 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.3.1
 signing_key:
 specification_version: 4
 summary: Painless Strategy Pattern for Ruby and Rails