strategic 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b79636eeccc8c6b813d95c05e0aba4e864d8cbc
+  data.tar.gz: 4fb40967c29ffa5c788db5432c0a80444ab5c3db
+SHA512:
+  metadata.gz: 654d0e603dbe10f748ba3025664bf0480a4833d62be091ffb3f6b807754487a8284f2687f7f9c40658d499e99342f408c2c282c8590962664c16cf6504453aa9
+  data.tar.gz: 74f1272d40abb8e22520914614bf99a80455f99480007f4b7bc54b0b785065afcf8762822cf34bae977108e42895971c4bf9ac822d18f81620f9914925f461bd

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2017 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.

data/README.md

@@ -0,0 +1,167 @@
+# Strategic (Painless Strategy Pattern in Ruby and Rails)
+[![Gem Version](https://badge.fury.io/rb/strategic.svg)](http://badge.fury.io/rb/strategic)
+
+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.
+
+Still, there are a number of challenges with repeated implementation of 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.
+- Avoiding duplication of strategy dispatch code for multiple domain models
+- Have different strategies mirror an existing domain model hierarchy
+
+`strategic` solves these problems by offering:
+- Strategy Pattern support through a Ruby mixin and strategy path/name convention
+- Automatic discovery of strategies based on path/name convention
+- Ability to fetch needed strategy without use of conditionals
+- 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",
+externalizing all logic concerning algorithmic variations into separate strategy
+classes that are easy to find, maintain and extend.
+
+## Instructions
+
+### Option 1: Bundler
+
+Add the following to bundler's `Gemfile`.
+
+```ruby
+gem 'strategic', '~> 0.8.0'
+```
+
+### Option 2: Manual
+
+Or manually install and require library.
+
+```bash
+gem install strategic -v0.8.0
+```
+
+```ruby
+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:
+ - Lives under the original class namespace
+ - Extends the original class to strategize
+ - 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
+6. Invoke strategy method needed
+
+Alternative approach:
+
+Combine steps 4 and 5 using `new_strategy` method, which takes both strategy name
+and constructor parameters
+
+Passing an invalid strategy name to `strategy_class_for` returns original class as the default
+strategy.
+
+### Example
+
+1. Class to strategize is: `TaxCalculator`
+
+```ruby
+class TaxCalculator
+  include Strategic
+
+  def tax_for(amount)
+    amount * 0.09
+  end
+end
+```
+
+2. Directory to create strategies under: `tax_calculator`
+
+3. Strategy class:
+
+```ruby
+class TaxCalculator::UsStrategy < TaxCalculator
+  def initialize(state)
+    @state = state
+  end
+  def tax_for(amount)
+    amount * state_rate
+  end
+  # ... more code follows
+end
+
+class TaxCalculator::CanadaStrategy < TaxCalculator
+  def initialize(province)
+    @province = province
+  end
+  def tax_for(amount)
+    amount * (gst + qst)
+  end
+  # ... more code follows
+end
+```
+
+4. Get needed strategy:
+
+```ruby
+tax_calculator_strategy_class = TaxCalculator.strategy_class_for('us')
+```
+
+5. Instantiate strategy:
+
+```ruby
+tax_calculator_strategy = strategy_class.new('IL')
+```
+
+6. Invoke strategy method:
+
+```ruby
+tax = tax_calculator_strategy.tax_for(39.78)
+```
+
+**Alternative approach using `new_strategy`:**
+
+```ruby
+tax_calculator_strategy = TaxCalculator.new_strategy('US', 'IL')
+tax = tax_calculator_strategy.tax_for(39.78)
+```
+
+**Default strategy for a strategy name that has no strategy class is TaxCalculator**
+
+```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
+```
+
+## Release Notes
+
+**0.8.0:** Initial version with `strategy_class_for`, `new_strategy`, `strategies`, and `strategy_names`
+
+## TODO
+
+None
+
+## Contributing
+
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Change directory into project
+* Run `gem install bundler && bundle && rake` and make sure RSpec tests are passing
+* Start a feature/bugfix branch.
+* Write RSpec tests, Code, Commit and push until you are happy with your contribution.
+* 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
+
+Copyright (c) 2020 Andy Maleh. See LICENSE.txt for
+further details.

data/lib/strategic.rb

@@ -0,0 +1,56 @@
+module Strategic
+  def self.included(klass)
+    klass.extend(ClassMethods)
+    klass.require_strategies
+  end
+
+  module ClassMethods
+    def require_strategies
+      klass_path = caller[1].split(':').first
+      strategy_path = File.expand_path(File.join(klass_path, '..', Strategic.underscore(self.name), '**', '*.rb'))
+      Dir.glob(strategy_path) do |strategy|
+        Object.const_defined?(:Rails) ? require_dependency(strategy) : require(strategy)
+      end
+    end
+
+    def strategy_class_for(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
+        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
+    end
+
+    def new_strategy(string_or_class_or_object, *args, &block)
+      strategy_class_for(string_or_class_or_object).new(*args, &block)
+    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
+    end
+
+    def strategy_names
+      strategies.map(&:name).map { |class_name| Strategic.underscore(class_name.split(':').last).sub(/_strategy$/, '') }
+    end
+  end
+
+  private
+
+  def self.classify(text)
+    text.split("_").map {|word| "#{word[0].upcase}#{word[1..-1]}"}.join
+  end
+
+  def self.underscore(text)
+    text.chars.reduce('') {|output,c| !output.empty? && c.match(/[A-Z]/) ? output + '_' + c : output + c}.downcase
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: strategic
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Andy Maleh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  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
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !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.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.5
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: puts_debuggerer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.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
+  logic variations in the same domain models.
+  Strategy Pattern solves that problem by externalizing logic variations to
+  separate classes outside the domain models.
+  One difficulty with implementing Strategy Pattern is making domain models aware
+  of newly added strategies without touching their code (Open/Closed Principle).
+  Strategic solves that problem by supporting Strategy Pattern with automatic discovery
+  of strategies and ability fetch the right strategy without conditionals.
+  This allows you to make any domain model "strategic" by simply following a convention
+  in the directory/namespace structure you create your strategies under so that the domain
+  model automatically discovers all available strategies.
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- lib/strategic.rb
+homepage: http://github.com/AndyObtiva/strategic
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Painless Strategy Pattern for Ruby and Rails
+test_files: []