mini_tools 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7e2e7b08f84dd78b66b910afdca999cdd290f448
+  data.tar.gz: 6505ac0a2b4ed5da4d0390b2cb144ad28e823600
+SHA512:
+  metadata.gz: f79242651ae5ec09e4a6cd2768d59b5daf8153524216c6eb0aaf9403a4acecff1c7f14049190e32b8f2dba9566406e40a9aa307a91cdf069dae76f5793dd04ef
+  data.tar.gz: caeff60a929d70380562bc18ccb836b621b6378fb513c8eca28bd0844668f1abb029dd247ae724423661314f80de4307830d5ff0d5c0f42c81ce69b449776709

data/lib/mini_tools.rb

@@ -0,0 +1,3 @@
+require 'mini_tools/command'
+require 'mini_tools/configuration'
+require 'mini_tools/item_factory'

data/lib/mini_tools/command.rb

@@ -0,0 +1,26 @@
+require 'mini_tools/response'
+
+module MiniTools
+  # Creates a very simple command object using the MiniTools::Response class
+  #
+  # ```
+  # class SimpleCommand
+  #   def call value
+  #     yield response :success, 'It worked' if value == true
+  #     yield response :failure, 'It failed' if value == false
+  #   end
+  # end
+  # ```
+  #
+  # Then use with
+  #
+  # SimpleCommand.new.call some_value do |response|
+  #   response.on(:success) ->(message) { puts 'Successful'; puts message }
+  #   response.on(:failure) ->(message) { puts 'Unsuccessful'; puts message }
+  # end
+  module Command
+    def response result, *args
+      Response.new(result, *args)
+    end
+  end
+end

data/lib/mini_tools/configuration.rb

@@ -0,0 +1,56 @@
+module MiniTools
+  # Used to build simple configuration objects.
+  #
+  # ```
+  # class SimpleConfig
+  #   include MiniTools::Configuration
+  #
+  #   allow :value_1, value_2
+  #   allow :value_3
+  # end
+  # ```
+  #
+  # Then we can set the values with
+  #
+  # ```
+  # SimpleConfig.configure do |config|
+  #   config.value_1 = 'some-value'
+  #   config.value_2 = 'another-value'
+  #   config.value_3 = 'a-third-value'
+  # end
+  # ```
+  #
+  # and access the values with
+  #
+  # ```
+  # SimpleConfig.config.value_1 # some-value
+  # ```
+  module Configuration
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Adds values to the allowed list of settings. Accepts either a single
+      # settings key or array and can be called multiple times.
+      def allow *values
+        @settings = settings.concat(values).uniq
+      end
+
+      # Returns the configuration object
+      def config
+        @config ||= Struct.new(*settings).new
+      end
+
+      # Accepts a block of configuration values
+      def configure
+        yield config
+      end
+
+      # Returns an array of allowed settings
+      def settings
+        @settings ||= []
+      end
+    end
+  end
+end

data/lib/mini_tools/item_factory.rb

@@ -0,0 +1,67 @@
+module MiniTools
+  # The ItemFactory is used for creating instances of classes based on a map
+  # of keys to classes. For example, assume we a list of commands to be run
+  # that looks something like this
+  # ```
+  # commands = [
+  #   [:notification_email, 'someone@somewhere.co.uk'],
+  #   [:update_account, account_instance],
+  # ]
+  # ```
+  # Each of these commands has an associated Command object.
+  # Then we can create an ItemFactory to dynamically build the instances we
+  # need
+  #
+  # ```
+  # class CommandFactory
+  #   include MiniTools::ItemFactory
+  #
+  #   map(
+  #     notification_email: EmailNotifier,
+  #     update_account: AccountUpdater
+  #   )
+  # end
+  #
+  # commands.each do |command, args|
+  #   CommandFactory.build(command).execute(args)
+  # end
+  # ```
+  #
+  module ItemFactory
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_reader :default_klass
+
+      # Builds the appropriate item based on `value`. Any additional args are
+      # passed on to the item's initializer
+      def build value, *args
+        klass_for(value).new(*args)
+      end
+
+      # Defines the map of values to class types
+      def map values
+        @klass_map = values
+      end
+
+      # Sets the default class if there is no match in the map
+      def default klass
+        @default_klass = klass
+      end
+
+      private
+
+      def klass_map
+        @klass_map ||= {}
+      end
+
+      def klass_for value
+        value = value.call if value.respond_to? :call
+        return klass_map[value] if klass_map.has_key? value
+        return default_klass
+      end
+    end
+  end
+end

data/lib/mini_tools/response.rb

@@ -0,0 +1,14 @@
+module MiniTools
+  class Response
+    attr_reader :result, :args
+
+    def initialize result, *args
+      @result = result
+      @args = args
+    end
+
+    def on *outcome
+      yield(*args) if outcome.include?(result)
+    end
+  end
+end

data/lib/mini_tools/version.rb

@@ -0,0 +1,3 @@
+module MiniTools
+  VERSION = '0.0.1'
+end

data/spec/command_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+require 'mini_tools/command'
+
+describe MiniTools::Command do
+  class TestCommand
+    include MiniTools::Command
+
+    def call param
+      yield response :success, 'OK' and return if param == 1
+      yield response :error, 'Fail' and return if param == 0
+      yield response :unknown, 'Other' if ![0, 1].include?(param)
+    end
+  end
+
+  subject { TestCommand.new }
+
+  describe 'response yielding' do
+    describe 'when the interaction is successful' do
+      it 'should yield a success response' do
+        call_with 1
+        assert_equal 'success', @state
+        assert_equal 'OK', @message
+      end
+    end
+
+    describe 'when the interaction errors' do
+      it 'should yield an error response' do
+        call_with 0
+        assert_equal 'error', @state
+        assert_equal 'Fail', @message
+      end
+    end
+
+    describe 'when there is an unknown response' do
+      it 'should yield an unknown response' do
+        call_with 2
+        assert_equal 'unknown', @state
+        assert_equal 'Other', @message
+      end
+    end
+
+    describe 'when handling multiple responses with the same block' do
+      it 'should work with the first case' do
+        subject.call 0 do |response|
+          response.on(:error, :unknown) do
+            @state = 'handled'
+          end
+        end
+
+        assert_equal 'handled', @state
+      end
+
+      it 'should work with the second case' do
+        subject.call 2 do |response|
+          response.on(:error, :unknown) do
+            @state = 'handled'
+          end
+        end
+
+        assert_equal 'handled', @state
+      end
+
+      it 'should not handle other cases' do
+        subject.call 1 do |response|
+          response.on(:error, :unknown) do
+            @state = 'handled'
+          end
+        end
+
+        assert_nil @state
+      end
+    end
+  end
+
+  def call_with param
+    @state = false
+    @message = nil
+
+    subject.call param do |response|
+      response.on(:success) do |m|
+        @state = 'success'
+        @message = m
+      end
+
+      response.on(:error) do |m|
+        @state = 'error'
+        @message = m
+      end
+
+      response.on(:unknown) do |m|
+        @state = 'unknown'
+        @message = m
+      end
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+require 'mini_tools/configuration'
+
+describe MiniTools::Configuration do
+  class TestConfig
+    include MiniTools::Configuration
+
+    allow :setting_1, :setting_2
+    allow :setting_3
+  end
+
+  subject { TestConfig }
+
+  describe 'configuration' do
+    it 'should be configurable using a config block' do
+      TestConfig.configure do |config|
+        config.setting_1 = 'a-setting'
+        config.setting_2 = 'another-setting'
+        config.setting_3 = 'a-third-setting'
+      end
+
+      assert_equal 'a-setting', TestConfig.config.setting_1
+      assert_equal 'another-setting', TestConfig.config.setting_2
+      assert_equal 'a-third-setting', TestConfig.config.setting_3
+    end
+
+    it 'should raise an error when an unknown setting is used' do
+      assert_raises NoMethodError do
+        TestConfig.configure do |config|
+          config.unkown_setting = 'unknown-setting'
+        end
+      end
+    end
+
+    it 'should be updateable once set' do
+      TestConfig.configure do |config|
+        config.setting_1 = 'a-setting'
+        config.setting_2 = 'another-setting'
+      end
+
+      TestConfig.configure do |config|
+        config.setting_1 = 'a-revised-setting'
+      end
+
+      assert_equal 'a-revised-setting', TestConfig.config.setting_1
+      assert_equal 'another-setting', TestConfig.config.setting_2
+    end
+  end
+end

data/spec/item_factory_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+require 'mini_tools/item_factory'
+
+describe MiniTools::ItemFactory do
+  class TestItemFactory
+    class BaseItem; def initialize(arg1, arg2); end; end
+    class CoolItem; def initialize(arg1, arg2); end; end
+
+    include MiniTools::ItemFactory
+
+    map(
+      cool_item: CoolItem
+    )
+
+    default BaseItem
+  end
+
+  describe 'building items' do
+    it 'should return the default item for unknown values passing on any extra args' do
+      TestItemFactory::BaseItem
+        .stubs(:new)
+        .with(:arg1, :arg2)
+        .returns('base-item')
+
+      assert_equal 'base-item', TestItemFactory.build(:any_item, :arg1, :arg2)
+    end
+
+    it 'should return the specific item if set' do
+      TestItemFactory::CoolItem
+        .stubs(:new)
+        .with(:arg1, :arg2)
+        .returns('cool-item')
+
+      assert_equal 'cool-item', TestItemFactory.build(:cool_item, :arg1, :arg2)
+    end
+
+    it 'should accept a proc that returns the value' do
+      TestItemFactory::CoolItem
+        .stubs(:new)
+        .with(:arg1, :arg2)
+        .returns('cool-item')
+
+      assert_equal 'cool-item', TestItemFactory.build(->{:cool_item}, :arg1, :arg2)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+testdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
+
+libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
+$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
+
+require 'minitest/autorun'
+require 'mocha/mini_test'

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: mini_tools
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Adam Phillips
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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: A set of simple lightweight tools to demonstrate some useful object patterns
+  in Ruby
+email: adam@29ways.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mini_tools.rb
+- lib/mini_tools/command.rb
+- lib/mini_tools/configuration.rb
+- lib/mini_tools/item_factory.rb
+- lib/mini_tools/response.rb
+- lib/mini_tools/version.rb
+- spec/command_spec.rb
+- spec/configuration_spec.rb
+- spec/item_factory_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/adamphillips/mini_tools
+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.4.3
+signing_key: 
+specification_version: 4
+summary: A set of simple lightweight tools to demonstrate patterns in Ruby
+test_files:
+- spec/command_spec.rb
+- spec/configuration_spec.rb
+- spec/item_factory_spec.rb
+- spec/spec_helper.rb