strategic 0.8.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5b79636eeccc8c6b813d95c05e0aba4e864d8cbc
-  data.tar.gz: 4fb40967c29ffa5c788db5432c0a80444ab5c3db
+SHA256:
+  metadata.gz: 5d1b5e48f559fa9befbe74660a5894d73aa99e9acb9ab31daf6d592e50d5200e
+  data.tar.gz: b0064808d6119cd5e860762c82483d457c30c4a5d22b703060fbef323a781086
 SHA512:
-  metadata.gz: 654d0e603dbe10f748ba3025664bf0480a4833d62be091ffb3f6b807754487a8284f2687f7f9c40658d499e99342f408c2c282c8590962664c16cf6504453aa9
-  data.tar.gz: 74f1272d40abb8e22520914614bf99a80455f99480007f4b7bc54b0b785065afcf8762822cf34bae977108e42895971c4bf9ac822d18f81620f9914925f461bd
+  metadata.gz: 351e5f342baf23c732723b97e0040f85d65378bf4e5fdfcde2385a9b16870a303f638da34765569d0392180295997088e1f7730b3a970210ebdd22bb388b712a
+  data.tar.gz: b5b269f698ae134d412dc9d8ff5e16d397da76480c88f9b92e984079f5edbaed3002f409e71ac4686e010fbd0a0bdcc460b70a42a7c503ea95e2001b665dd7a5

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Change Log
+
+## 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)
+- `strategy_exclusion` class method support that enables any strategy to specify exclusions from the custom `strategy_matcher`
+- `strategy_alias` class method support that enables any strategy to specify extra aliases (used by superclass's `strategy_class_for` method)
+
+## 0.8.0
+
+- Initial version with `strategy_class_for`, `new_strategy`, `strategies`, and `strategy_names`

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2017 Andy Maleh
+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

data/README.md

@@ -1,18 +1,21 @@
-# Strategic (Painless Strategy Pattern in Ruby and Rails)
+# Strategic 1.0.1
+## 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)
+[![Coverage Status](https://coveralls.io/repos/github/AndyObtiva/strategic/badge.svg?branch=master)](https://coveralls.io/github/AndyObtiva/strategic?branch=master)
+[![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.
-Domain model inheritance can help remedy the problem, but dumping all
-logic variations in the same domain models can cause a maintenance nightmare.
-Thankfully, Strategy Pattern as per the Gang of Four solves the problem by externalizing logic variations to
-separate classes outside the domain models.
+`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 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 Strategy Pattern:
+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
 code (Open/Closed Principle).
-- Fetching the right strategy without use of conditionals.
+- Fetching the right strategy without the use of conditionals.
 - Avoiding duplication of strategy dispatch code for multiple domain models
-- Have different strategies mirror an existing domain model hierarchy
+- Have strategies mirror an existing domain model inheritance hierarchy
 
 `strategic` solves these problems by offering:
 - Strategy Pattern support through a Ruby mixin and strategy path/name convention
@@ -21,18 +24,99 @@ code (Open/Closed Principle).
 - Ability to fetch a strategy by name or by object type to mirror
 - Plain Ruby and Ruby on Rails support
 
-`strategic` enables you to make any existing domain model "strategic",
+`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.
+classes that are easy to find, maintain and extend while honoring the Open/Closed Principle and avoiding conditionals.
 
-## Instructions
+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)`), 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
+
+<img src="strategic-example.png"
+alt="Strategic Example" />
+
+1. Include `Strategic` module in the Class to strategize: `TaxCalculator`
+
+```ruby
+class TaxCalculator
+  include Strategic
+
+  # 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 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
+  include Strategic::Strategy
+  
+  def tax_for(amount)
+    amount * state_rate(context.state)
+  end
+  # ... other strategy methods follow
+end
+
+class TaxCalculator::CanadaStrategy
+  include Strategic::Strategy
+
+  def tax_for(amount)
+    amount * (gst(context.province) + qst(context.province))
+  end
+  # ... other strategy methods follow
+end
+```
+
+(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 = TaxCalculator.new(args)
+tax_calculator.strategy = 'us'
+```
+
+4a. Alternatively, instantiate the strategic model with a strategy to begin with:
+
+```ruby
+tax_calculator = TaxCalculator.new_with_strategy('us', args)
+```
+
+5. Invoke the strategy implemented method:
+
+```ruby
+tax = tax_calculator.tax_for(39.78)
+```
+
+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
+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
 
 Add the following to bundler's `Gemfile`.
 
 ```ruby
-gem 'strategic', '~> 0.8.0'
+gem 'strategic', '~> 1.0.1'
 ```
 
 ### Option 2: Manual
@@ -40,7 +124,7 @@ gem 'strategic', '~> 0.8.0'
 Or manually install and require library.
 
 ```bash
-gem install strategic -v0.8.0
+gem install strategic -v1.0.1
 ```
 
 ```ruby
@@ -50,104 +134,94 @@ 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)
 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
 
-### Example
+These methods can be delcared in a strategic model class body.
 
-1. Class to strategize is: `TaxCalculator`
+- `::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')}`)
 
-```ruby
-class TaxCalculator
-  include Strategic
-
-  def tax_for(amount)
-    amount * 0.09
-  end
-end
-```
+#### Class Methods
 
-2. Directory to create strategies under: `tax_calculator`
+- `::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
 
-3. Strategy class:
+#### Instance Methods
 
-```ruby
-class TaxCalculator::UsStrategy < TaxCalculator
-  def initialize(state)
-    @state = state
-  end
-  def tax_for(amount)
-    amount * state_rate
-  end
-  # ... more code follows
-end
+- `#strategy=`: sets strategy
+- `#strategy`: returns current strategy
 
-class TaxCalculator::CanadaStrategy < TaxCalculator
-  def initialize(province)
-    @province = province
-  end
-  def tax_for(amount)
-    amount * (gst + qst)
-  end
-  # ... more code follows
-end
-```
+### Strategy
 
-4. Get needed strategy:
+#### Class Body Methods
 
-```ruby
-tax_calculator_strategy_class = TaxCalculator.strategy_class_for('us')
-```
+- `::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`)
 
-5. Instantiate strategy:
+#### Class Methods
 
-```ruby
-tax_calculator_strategy = strategy_class.new('IL')
-```
+- `::strategy_name`: returns parsed strategy name of current strategy class
 
-6. Invoke strategy method:
+#### Instance Methods
 
-```ruby
-tax = tax_calculator_strategy.tax_for(39.78)
-```
+- `#context`: returns strategy context (the strategic model instance)
 
-**Alternative approach using `new_strategy`:**
+### Example with Customizations via Class Body Methods
 
 ```ruby
-tax_calculator_strategy = TaxCalculator.new_strategy('US', 'IL')
-tax = tax_calculator_strategy.tax_for(39.78)
-```
+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
 
-**Default strategy for a strategy name that has no strategy class is TaxCalculator**
+class TaxCalculator::UsStrategy
+  include Strategic::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
+  strategy_alias 'USA'
+  strategy_exclusion 'U'
+  
+  # ... strategy methods follow
+end
+
+class TaxCalculator::CanadaStrategy
+  include Strategic::Strategy
+  
+  # ... strategy methods follow
+end
 ```
 
-## Release Notes
+## TODO
 
-**0.8.0:** Initial version with `strategy_class_for`, `new_strategy`, `strategies`, and `strategy_names`
+[TODO.md](TODO.md)
 
-## TODO
+## Change Log
 
-None
+[CHANGELOG.md](CHANGELOG.md)
 
 ## Contributing
 
@@ -161,7 +235,8 @@ None
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-## Copyright
+## License
+
+[MIT](LICENSE.txt)
 
-Copyright (c) 2020 Andy Maleh. See LICENSE.txt for
-further details.
+Copyright (c) 2020-2021 Andy Maleh.

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

@@ -1,3 +1,24 @@
+# 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
   def self.included(klass)
     klass.extend(ClassMethods)
@@ -5,6 +26,26 @@ module Strategic
   end
 
   module ClassMethods
+    def strategy_matcher(&matcher_block)
+      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
+        @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
       strategy_path = File.expand_path(File.join(klass_path, '..', Strategic.underscore(self.name), '**', '*.rb'))
@@ -14,6 +55,21 @@ module Strategic
     end
 
     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 ||= 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)
@@ -21,27 +77,59 @@ module Strategic
       else
         strategy_class_name = string_or_class_or_object.class.name
       end
-      class_name ||= "::#{self.name}::#{Strategic.classify(strategy_class_name)}Strategy"
-      class_eval(class_name)
-    rescue NameError
-      self
+      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
     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 = self.class.strategy_class_for(string_or_class_or_object)&.new(self)
+  end
+      
+  def strategy
+    @strategy
+  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
@@ -54,3 +142,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.8.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Andy Maleh
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-27 00:00:00.000000000 Z
+date: 2021-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -42,28 +42,28 @@ 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
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
@@ -81,47 +81,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.3.0
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.5
+        version: 0.16.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.5
+        version: 0.16.1
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.8.23
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.8.23
 - !ruby/object:Gem::Dependency
   name: puts_debuggerer
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: 0.8.1
 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
@@ -139,17 +139,20 @@ email: andy.am@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - lib/strategic.rb
+- lib/strategic/strategy.rb
 homepage: http://github.com/AndyObtiva/strategic
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -164,9 +167,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.10
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: Painless Strategy Pattern for Ruby and Rails
 test_files: []