context-pattern 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 160ec1333c94272d332b55acccaee5b32435a2d6
+  data.tar.gz: 96a764e13dec3cad58a5e43639f59946daf63bb2
+SHA512:
+  metadata.gz: ae92a3e686f0164548e11d882c4e19bec842ed29198a62b432e0868524e95b719aee3125e152e17e91cf20758aec29d7f448cc9fde994ecf22d56195f123b7a2
+  data.tar.gz: 7d2f947aaf3a9e3a4ca66de889e0a78e597e2df35824acb1da4cf34acf71ac229aef9b62d3345fb8bc1a443a1013f25009fd5bd911256ac6670a4a08186c17a9

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.DS_Store
+.ruby-version

data/Gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+gemspec
+
+# The AR environment variable lets you test against different
+# versions of Rails. For example:
+#
+#  AR=3.2.13 rm Gemfile.lock && bundle install && bundle exec rspec
+#  AR=4.0.0  rm Gemfile.lock && bundle install && bundle exec rspec
+#
+if ENV['AR']
+  gem 'activerecord', ENV['AR']
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2019 Appfolio Inc.
+
+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 @@
+# context-pattern

data/Rakefile

@@ -0,0 +1,6 @@
+desc 'Run tests'
+task :test do |t|
+  sh 'rspec spec'
+end
+
+task :default => :test

data/context-pattern.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless defined? Gem
+require File.dirname(__FILE__) + "/lib/context/version"
+
+Gem::Specification.new do |s|
+  s.name = "context-pattern"
+  s.version = Context::VERSION
+  s.authors = ["Barun Singh"]
+  s.email = "bsingh@wegowise.com"
+  s.homepage = "http://github.com/barunio/context-pattern"
+  s.summary = "Start using the Context Pattern in your Rails app"
+  s.description = "Start using the Context Pattern in your Rails app"
+  s.required_rubygems_version = ">= 1.3.6"
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.extra_rdoc_files = ["README.md", "LICENSE.txt"]
+  s.license = 'MIT'
+
+  s.add_dependency('rails', '>= 3.2', '< 5.2')
+  s.add_dependency('memoizer')
+
+  s.add_development_dependency('rspec', '~> 3.0')
+  s.add_development_dependency('rake', '>= 10.4')
+end

data/lib/context-pattern.rb

@@ -0,0 +1,4 @@
+require 'context/base_context'
+require 'context/controller'
+
+require 'context/railtie' if defined?(Rails)

data/lib/context/base_context.rb

@@ -0,0 +1,121 @@
+require 'rails'
+require 'memoizer'
+
+module Context
+  class MethodOverrideError < ::StandardError
+    def initialize(context_class, method_names)
+      @context_class = context_class
+      @method_names = method_names
+    end
+
+    def message
+      "#{@context_class.name} can not overwrite methods already defined in "\
+      "the context chain: #{@method_names}"
+    end
+  end
+
+  class BaseContext
+    include Memoizer
+    delegate :link_to, to: 'ActionController::Base.helpers'
+
+    class << self
+      include Memoizer
+
+      def decorate(ancestor_context_method, decorator:, args: [], memoize: false)
+        define_method(ancestor_context_method) do
+          decorator.new(
+            @parent_context.public_send(ancestor_context_method),
+            *(args.map { |arg| instance_eval(arg.to_s) })
+          )
+        end
+
+        @decorated_methods ||= []
+        @decorated_methods << ancestor_context_method.to_sym
+
+        if memoize
+          public_send(:memoize, ancestor_context_method)
+          @decorated_methods << "_unmemoized_#{ancestor_context_method}".to_sym
+        end
+      end
+
+      def is_decorated?(method_name)
+        @decorated_methods.is_a?(Array) &&
+          @decorated_methods.include?(method_name.to_sym)
+      end
+
+      def has_view_helper?(method_name)
+        @view_helpers.is_a?(Array) && @view_helpers.include?(method_name.to_sym)
+      end
+
+      def view_helpers(*method_names)
+        @view_helpers ||= []
+        @view_helpers += method_names.map(&:to_sym)
+      end
+
+      def wrap(parent_context, **args)
+        existing_public_methods = parent_context.context_method_mapping.keys
+        new_public_methods = public_instance_methods(false)
+        redefined_methods = existing_public_methods & new_public_methods
+        redefined_methods.reject! { |method| is_decorated?(method) }
+
+        unless redefined_methods.empty?
+          raise Context::MethodOverrideError.new(self, redefined_methods)
+        end
+
+        new(parent_context: parent_context, **args)
+      end
+    end
+
+    attr_accessor :parent_context
+
+    def initialize(attributes = {})
+      attributes.each do |k, v|
+        if respond_to?(:"#{k}=")
+        then public_send(:"#{k}=", v)
+        else raise ArgumentError, "unknown attribute: #{k}"
+        end
+      end
+    end
+
+    def context_class_chain
+      @context_class_chain ||=
+        ((@parent_context.try(:context_class_chain) || []) + [self.class.name])
+    end
+
+    def has_view_helper?(method_name)
+      self.class.has_view_helper?(method_name) ||
+        (@parent_context.present? &&
+          @parent_context.has_view_helper?(method_name))
+    end
+
+    def context_method_mapping
+      @context_method_mapping ||=
+        (@parent_context.try(:context_method_mapping) || {})
+          .merge(get_context_method_mapping)
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @parent_context
+        @parent_context.public_send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      @parent_context&.respond_to?(method_name, include_private)
+    end
+
+    def whereis(method_name)
+      context_method_mapping[method_name.to_sym]
+    end
+
+    private
+
+    def get_context_method_mapping
+      self.class.public_instance_methods(false).reduce({}) do |hash, method_name|
+        hash.merge!(method_name => self.class.name)
+      end
+    end
+  end
+end

data/lib/context/controller.rb

@@ -0,0 +1,16 @@
+module Context
+  module Controller
+    def self.included(base)
+      base.send(:prepend_before_action, :__set_base_context)
+    end
+
+    def extend_context(context, **args)
+    context_class = "#{context}Context".constantize
+    @context = context_class.wrap(@context, **args)
+    end
+
+    def __set_base_context
+      @context = Context::BaseContext.new
+    end
+  end
+end

data/lib/context/railtie.rb

@@ -0,0 +1,11 @@
+module Context
+  class Railtie < Rails::Railtie
+
+    initializer 'context-pattern.include_url_helpers_in_base_context' do
+      ActiveSupport.on_load :active_record do
+        Context::BaseContext.send :include, Rails.application.routes.url_helpers
+      end
+    end
+
+  end
+end

data/lib/context/version.rb

@@ -0,0 +1,3 @@
+module Context
+  VERSION = '1.0.0'
+end

data/spec/base_context_spec.rb

@@ -0,0 +1,391 @@
+require 'context-pattern'
+
+class TestDecorator
+  attr_accessor :decorator_val
+
+  def initialize(str, other_str = '')
+    self.decorator_val = "#{str}..#{other_str}"
+  end
+end
+
+class TestContext < Context::BaseContext
+  view_helpers :method1,
+               :method2
+
+  attr_accessor :foo
+
+  def method1
+    'method1'
+  end
+
+  def method2
+    'method2'
+  end
+
+  def method3
+    'method3'
+  end
+
+  def bowie
+    "ziggy#{Random.rand}"
+  end
+
+  def random
+    Random.rand
+  end
+
+  def rolling
+    'rolling'
+  end
+
+  protected
+
+  attr_accessor :bar1
+
+  def protected_method
+    'protected_method'
+  end
+
+  private
+
+  def private_method
+    'private_method'
+  end
+end
+
+class TestContext2 < Context::BaseContext
+  decorate :bowie, decorator: TestDecorator
+  decorate :random, decorator: TestDecorator, memoize: true
+  decorate :rolling, decorator: TestDecorator, args: [:stones]
+
+  attr_accessor :blah
+
+  private
+
+  def stones
+    'stones'
+  end
+end
+
+class TestContext3 < Context::BaseContext
+  def alpha
+    'alpha'
+  end
+end
+
+describe Context::BaseContext do
+  describe '.new' do
+    it 'accepts attributes when there are associated public setter methods' do
+      context = TestContext.new(foo: 1)
+      expect(context.foo).to eq(1)
+    end
+
+    it 'raises an ArgumentError if the setter is protected' do
+      method = :bar1
+      expect(TestContext.instance_methods.include?(method)).to eq(true)
+      expect { TestContext.new(method => 1) }
+        .to raise_error(ArgumentError, "unknown attribute: #{method}")
+    end
+
+    it 'raises an ArgumentError if the setter is private' do
+      method = :bar2
+      expect(TestContext.new.instance_eval("#{method} = 1")).to eq(1)
+      expect { TestContext.new(method => 1) }
+        .to raise_error(ArgumentError, "unknown attribute: #{method}")
+    end
+  end
+
+  describe '.has_view_helper?' do
+    it 'is true for declared view helpers' do
+      expect(TestContext.has_view_helper?(:method1)).to eq(true)
+      expect(TestContext.has_view_helper?('method2')).to eq(true)
+    end
+
+    it 'is false for public methods that are not declared as view helpers' do
+      method = :method3
+      expect(TestContext.public_instance_methods.include?(method)).to eq(true)
+      expect(TestContext.has_view_helper?(method)).to eq(false)
+    end
+  end
+
+  describe '.wrap' do
+    it 'returns a new instance with the `parent_context` attribute set to '\
+    'the supplied context' do
+      contextA = TestContext.new
+      contextB = TestContext2.wrap(contextA)
+
+      expect(contextB.class).to eq(TestContext2)
+      expect(contextB.class.superclass).to eq(Context::BaseContext)
+      expect(contextB.parent_context).to eq(contextA)
+    end
+
+    it 'allows setting attributes when wrapping a context' do
+      contextA = TestContext.new
+      contextB = TestContext2.wrap(contextA, blah: 1)
+
+      expect(contextB.blah).to eq(1)
+    end
+
+    it 'allows accessing attributes of parent contexts after wrapping' do
+      contextA = TestContext.new(foo: 1)
+      contextB = TestContext2.wrap(contextA)
+
+      expect(contextB.foo).to eq(1)
+    end
+
+    it 'allows setting attributes of parent contexts when wrapping a context' do
+      contextA = TestContext.new
+      contextB = TestContext2.wrap(contextA, foo: 1)
+
+      expect(contextA.foo).to eq(1)
+      expect(contextB.foo).to eq(1)
+    end
+
+    it 'raises a MethodOverrideError if a context attempts to overwrite a '\
+    'public instance method defined in a parent context' do
+      contextA = TestContext.new
+      other_context_class = Class.new(Context::BaseContext) do
+        def self.name
+          'BadContext'
+        end
+
+        def method1
+          'overwrite'
+        end
+      end
+
+      expect { other_context_class.wrap(contextA) }.to raise_error(
+        Context::MethodOverrideError,
+        'BadContext can not overwrite methods already defined in the '\
+        'context chain: [:method1]'
+      )
+    end
+
+    it 'allows overwriting non-public methods' do
+      contextA = TestContext.new
+      other_context_class = Class.new(Context::BaseContext) do
+        def private_method
+          'overwrite'
+        end
+
+        def protected_method
+          'overwrite'
+        end
+      end
+
+      expect { other_context_class.wrap(contextA) }.not_to raise_error
+    end
+  end
+
+  describe '.decorate is used in conjunction with `wrap` to provide an '\
+  'explicit interface for decorating method values retrieved from earlier in '\
+  'the context chain' do
+    let(:instance) { TestContext.new }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'works when there are no arguments' do
+      allow(Random).to receive(:rand).and_return(1)
+
+      expect(instance.bowie).to eq('ziggy1')
+
+      decorated = instance2.bowie
+      expect(decorated).to be_a(TestDecorator)
+      expect(decorated.decorator_val).to eq('ziggy1..')
+    end
+
+    it 'works when there are arguments supplied to the decorator, with the '\
+    'arguments coming from method evaluations in the context' do
+      expect(instance.rolling).to eq('rolling')
+
+      decorated = instance2.rolling
+      expect(decorated).to be_a(TestDecorator)
+      expect(decorated.decorator_val).to eq('rolling..stones')
+    end
+
+    it 'does not memoize by default' do
+      allow(Random).to receive(:rand).and_return(1, 2, 3)
+
+      expect(instance2.bowie.decorator_val).to eq('ziggy1..')
+      expect(instance2.bowie.decorator_val).to eq('ziggy2..')
+    end
+
+    it 'memoizes when the relevant option is set to true' do
+      allow(Random).to receive(:rand).and_return(1, 2, 3)
+
+      expect(instance2.random.decorator_val).to eq('1..')
+      expect(instance2.random.decorator_val).to eq('1..')
+    end
+
+    it 'cascades decorated values to contexts down the chain' do
+      cascaded_decorated = instance3.rolling
+      expect(cascaded_decorated).to be_a(TestDecorator)
+      expect(cascaded_decorated.decorator_val).to eq('rolling..stones')
+    end
+  end
+
+  describe '#context_class_chain' do
+    let(:instance) { TestContext.new(foo: 1) }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'returns an array of all chained context class names in the order '\
+    'they were wrapped' do
+      expect(instance.context_class_chain).to eq(['TestContext'])
+      expect(instance2.context_class_chain)
+        .to eq(['TestContext', 'TestContext2'])
+      expect(instance3.context_class_chain)
+        .to eq(['TestContext', 'TestContext2', 'TestContext3'])
+    end
+  end
+
+  describe '#has_view_helper?' do
+    let(:instance) { TestContext.new(foo: 1) }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'is true for a declared view helper' do
+      expect(instance.has_view_helper?(:method1)).to eq(true)
+      expect(instance.has_view_helper?('method2')).to eq(true)
+    end
+
+    it 'is false for public methods not declared as view helpers' do
+      expect(instance.method3).to eq('method3')
+      expect(instance.has_view_helper?(:method3)).to eq(false)
+    end
+
+    it 'is true if a wrapped context has a certain declared view helper' do
+      expect(instance2.has_view_helper?(:method1)).to eq(true)
+      expect(instance2.has_view_helper?('method2')).to eq(true)
+    end
+
+    it 'is true if a grand-wrapped context has a declared view helper' do
+      expect(instance3.has_view_helper?(:method1)).to eq(true)
+      expect(instance3.has_view_helper?('method2')).to eq(true)
+    end
+  end
+
+  describe '#context_method_mapping' do
+    let(:instance) { TestContext.new }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'returns a hash of public instance method names as keys and the '\
+    'context name as values' do
+      expect(instance.context_method_mapping).to eq(
+        {
+          :bowie => 'TestContext',
+          :foo => 'TestContext',
+          :foo= => 'TestContext',
+          :method1 => 'TestContext',
+          :method2 => 'TestContext',
+          :method3 => 'TestContext',
+          :random => 'TestContext',
+          :rolling => 'TestContext',
+        }
+      )
+    end
+
+    it 'includes public instance methods from a wrapped context, with that '\
+    'wrapped context class name as the associated value for those methods' do
+      expect(instance2.context_method_mapping).to eq(
+        {
+          :_unmemoized_random => 'TestContext2',
+          :blah => 'TestContext2',
+          :blah= => 'TestContext2',
+          :bowie => 'TestContext2',
+          :foo => 'TestContext',
+          :foo= => 'TestContext',
+          :method1 => 'TestContext',
+          :method2 => 'TestContext',
+          :method3 => 'TestContext',
+          :random => 'TestContext2',
+          :rolling => 'TestContext2'
+        }
+      )
+    end
+
+    it 'returns the expected values for multiple-wrapped contexts' do
+      expect(instance3.context_method_mapping).to eq(
+        {
+          :_unmemoized_random => 'TestContext2',
+          :alpha => 'TestContext3',
+          :blah => 'TestContext2',
+          :blah= => 'TestContext2',
+          :bowie => 'TestContext2',
+          :foo => 'TestContext',
+          :foo= => 'TestContext',
+          :method1 => 'TestContext',
+          :method2 => 'TestContext',
+          :method3 => 'TestContext',
+          :random => 'TestContext2',
+          :rolling => 'TestContext2'
+        }
+      )
+    end
+  end
+
+  describe '#whereis' do
+    let(:instance) { TestContext.new }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'returns the name of the context class in the chain where a method is '\
+    'defined' do
+      expect(instance3.whereis('foo=')).to eq('TestContext')
+      expect(instance3.whereis(:method2)).to eq('TestContext')
+      expect(instance3.whereis('blah')).to eq('TestContext2')
+      expect(instance3.whereis('alpha')).to eq('TestContext3')
+    end
+
+    it 'handles decorated methods, showing the class that most recently '\
+    'did the decoration' do
+      expect(instance3.whereis(:bowie)).to eq('TestContext2')
+    end
+
+    it 'returns nil if the method is not a public method' do
+      expect(instance.instance_eval('protected_method'))
+        .to eq('protected_method')
+      expect(instance.whereis(:protected_method)).to eq(nil)
+
+      expect(instance.instance_eval('private_method')).to eq('private_method')
+      expect(instance.whereis(:private_method)).to eq(nil)
+    end
+
+    it 'returns nil if the method does not exist' do
+      expect(instance.whereis(:obladiblahda)).to eq(nil)
+    end
+  end
+
+  describe 'method_missing' do
+    let(:instance) { TestContext.new(foo: 1) }
+    let(:instance2) { TestContext2.wrap(instance) }
+    let(:instance3) { TestContext3.wrap(instance2) }
+
+    it 'responds to public methods from a wrapped context' do
+      expect(instance2.method3).to eq('method3')
+    end
+
+    it 'response to public methods from a grand-wrapped context' do
+      expect(instance3.method3).to eq('method3')
+    end
+
+    it 'does not respond to protected methods from a wrapped context' do
+      expect(instance.instance_eval('protected_method'))
+        .to eq('protected_method')
+
+      expect { instance2.instance_eval('protected_method') }
+        .to raise_error(NoMethodError)
+      expect { instance2.protected_method }.to raise_error(NoMethodError)
+    end
+
+    it 'does not respond to private methods from a wrapped context' do
+      expect(instance.instance_eval('private_method'))
+        .to eq('private_method')
+
+      expect { instance2.instance_eval('private_method') }
+        .to raise_error(NoMethodError)
+      expect { instance2.private_method }.to raise_error(NoMethodError)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: context-pattern
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Barun Singh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: memoizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: Start using the Context Pattern in your Rails app
+email: bsingh@wegowise.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+- LICENSE.txt
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- context-pattern.gemspec
+- lib/context-pattern.rb
+- lib/context/base_context.rb
+- lib/context/controller.rb
+- lib/context/railtie.rb
+- lib/context/version.rb
+- spec/base_context_spec.rb
+homepage: http://github.com/barunio/context-pattern
+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: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.1
+signing_key: 
+specification_version: 4
+summary: Start using the Context Pattern in your Rails app
+test_files: []