nala 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0fb5349f94c5a8d5ba4117b425eed6e9e50d336
-  data.tar.gz: 19c87de3c0cf10b66d7af408f6f999335cfe64a6
+  metadata.gz: 1de5be775b1e14835cc70a4e7a8b0068f13caa9d
+  data.tar.gz: 555a05e4158913607cc7b5ff1a8c54b734c89cf4
 SHA512:
-  metadata.gz: 7cbaf45efbcde34c4a2b630cfd90b94a93bf497c5edc1fb759b25f85f923768a5e4de823d43f5c1a1b6bdd43a72a5983b9f1edaa64cb4d1d5632a9e3466b2ec7
-  data.tar.gz: b51059c263359f5bfd0564fa44e3e64d7f7a1b93f5630a7c58351b1c8f440e1fcf080e99878a643d4bdb02c92968dbeea14820f576eb944addfb17a48276d944
+  metadata.gz: 061bf9c1b1ca1b18f16dc5d08753261929365028bca2d84210a4d711f0297e5e659e4396daf352123777a96dcba81c4e15232f0348dc8a14db9b5b5dbd376a9d
+  data.tar.gz: c9ec24f01a7055c227afde5bdbf325b6e590f64e1a659363f08781e6ea985fc91f5a54c212f14d7e5668585303be15d8ca4b2612f8706b6175a96145986c0e82

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) [year] [fullname]
+
+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/lib/nala/event_emitter.rb

@@ -0,0 +1,21 @@
+module Nala
+  class EventEmitter
+    def initialize
+      @events = {}
+    end
+
+    def store_result(event, args)
+      events[event] = args
+    end
+
+    def on(event)
+      yield(*events[event]) if events.key?(event)
+
+      self
+    end
+
+    private
+
+    attr_reader :events
+  end
+end

data/lib/nala/publisher.rb

@@ -0,0 +1,29 @@
+module Nala
+  module Publisher
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+    end
+
+    module ClassMethods
+      def call(*args)
+        EventEmitter.new.tap do |emitter|
+          new(*args).listen_with(emitter).call
+        end
+      end
+    end
+
+    def listen_with(emitter)
+      @emitter = emitter
+
+      self
+    end
+
+    def publish(event, *args)
+      emitter.store_result(event, args)
+    end
+
+    private
+
+    attr_reader :emitter
+  end
+end

data/lib/nala/rspec.rb

@@ -0,0 +1,37 @@
+require "rspec/expectations"
+
+module Nala
+  class BlockSpy
+    attr_reader :called, :args
+
+    def initialize
+      @called = false
+      @args = []
+    end
+
+    def called!
+      @called = true
+    end
+
+    def called_with!(args)
+      called!
+      @args = *args
+    end
+
+    def called?
+      @called
+    end
+  end
+end
+
+RSpec::Matchers.define :be_called_with do |*expected_args|
+  match do |block|
+    block.called? && block.args == expected_args
+  end
+
+  failure_message do |block|
+    return "expected the block to be called but it was not" unless block.called?
+
+    "expected the block to be called with the arguments #{expected_args.inspect} but was called with #{block.args.inspect}"
+  end
+end

data/lib/nala/version.rb

@@ -0,0 +1,3 @@
+module Nala
+  VERSION = "0.0.4"
+end

data/readme.md

@@ -0,0 +1,142 @@
+# Nala
+
+Lightweight gem for adding events to use case style classes.
+
+## Install
+
+To install via RubyGems run:
+
+```
+gem install nala
+```
+
+To install via bundler, add this line to your Gemfile and run `bundle install`:
+
+```
+gem "nala"
+```
+
+## Usage
+
+Nala is intended to be used with use case style classes where the class performs a
+single action. These classes typically have verb names such as `PlaceOrder` etc.
+
+To use, add the `Nala::Publisher` module to your class and expose a `call`
+instance method. If your class requires data, it can be passed to it via the constructor.
+
+For example:
+
+```ruby
+class PlaceOrder
+  include Nala::Publisher
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    # ...
+
+    if order.save
+      publish(:ok, order)
+    else
+      publish(:error)
+    end
+  end
+end
+```
+
+Usage of these use case style classes gives a home to your business logic, removes
+conditionals from your Rails controllers and helps prevent your models getting too
+big.
+
+```ruby
+class OrderController < ApplicationController
+  # ...
+
+  def create
+    PlaceOrder.call(order_params)
+      .on(:ok)    { |order| redirect_to orders_path, :notice => "..." }
+      .on(:error) { render :new }
+  end
+
+  # ...
+end
+```
+
+This comes in handy when there are more than two out comes to a use case:
+
+```ruby
+class RegistrationController < ApplicationController
+  # ...
+
+  def create
+    RegisterAccount.call(account_params)
+      .on(:already_registered) { redirect_to login_path, :notice => "..." }
+      .on(:ok)    { |user| redirect_to dashboard_path, :notice => "..." }
+      .on(:error) { render :new }
+  end
+
+  # ...
+end
+```
+
+## Testing with RSpec
+
+If you are using RSpec then you can use the supplied matcher by adding the following line to your `spec_helper.rb` file:
+
+```ruby
+require "nala/rspec"
+```
+
+Then within your specs, you can confirm that a handler is called with the following:
+
+```ruby
+let(:block) { Nala::BlockSpy.new }
+
+it "invokes a handler for a published event" do
+  SuccessClass.call.on(:success) { block.called! }
+
+  expect(block).to be_called
+end
+```
+
+If you want to check the arguments that are passed to the block you can use the following:
+
+```ruby
+let(:block) { Nala::BlockSpy.new }
+
+it "passes multiple arguments to handlers" do
+  PublishArgsClass.call
+    .on(:multiple) { |*x| block.called_with!(x) }
+
+  expect(block).to be_called_with(:a, :b, :c)
+end
+```
+
+If you need check the arguments attributes in more detail you can do the following:
+
+```ruby
+let(:block) { Nala::BlockSpy.new }
+
+it "passes a user with the correct name" do
+  RegisterUser.call
+    .on(:success) { |*x| block.called_with!(x) }
+
+  user = block.args.first
+  expect(user.name).to eq("Andy")
+end
+```
+
+## Building a publishing gem updates
+
+Bump the version number in `lib/nala/version.rb` and use the same number in the command below:
+
+```
+gem build nala.gemspec
+gem push nala-0.0.3.gem
+```
+
+## License
+
+See the [LICENSE](LICENSE.txt) file for license rights and limitations (MIT).

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nala
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Andy Pike
@@ -58,7 +58,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
 - lib/nala.rb
+- lib/nala/event_emitter.rb
+- lib/nala/publisher.rb
+- lib/nala/rspec.rb
+- lib/nala/version.rb
+- readme.md
 homepage: https://github.com/loyaltylion/nala
 licenses:
 - MIT