edgycircle_toolbox 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0fac7454ff83b9d4e105dd363d09f0db834c9216
+  data.tar.gz: 394e20e69e366e0049e81cd827e7fd3e2bf67e1b
+SHA512:
+  metadata.gz: 35b8761a11d9e893dd0872c10fee0f01e9ea57c6a0c161089b89a005e4434524e7a2f05ce2519e596b3b2fb4daea06f4a31f2836e3a9292d90d8d32ce1e531c5
+  data.tar.gz: 72421b139359fe670c455ba756f15164f79a38bf9c84f6c70777b64df7f12491d1c065473677ecae032f565cc06afe28062976e065b5d46c009d4e0c8ec81df9

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in edgycircle_toolbox.gemspec
+gemspec

data/README.md

@@ -0,0 +1,214 @@
+A loose collection of Ruby related code that currently has no specific place to live in.
+
+## HasAttributes Module
+~~~ruby
+require 'edgycircle_toolbox/has_attributes'
+
+class Dummy
+  include EdgycircleToolbox::HasAttributes
+  attributes :a, :b
+end
+
+dummy = Dummy.new({ a: 1, b: 2, c: 3 })
+
+dummy.a # => 1
+dummy.b # => 2
+dummy.c # => NoMethodError
+
+dummy.attributes # => [:a, :b]
+~~~
+
+## CQRS CommandResult
+Returning `self` from `add_error`, `add_event` and `set_command` allows us write concise code like `return result.add_error(:authentication_error) unless authenticated?`.
+~~~ruby
+require 'edgycircle_toolbox/cqrs/command_result'
+
+command = :command_a
+result = EdgycircleToolbox::CQRS::CommandResult.new(command)
+
+result.add_error(:error) # => result
+result.add_event(:event) # => result
+result.set_command(:command_b) # => result
+result.failure? # => true
+~~~
+
+## CQRS Handler Module
+A handler class has to implement `call(command)` and accept a command instance as parameter.
+~~~ruby
+require 'edgycircle_toolbox/cqrs/handler'
+
+class DummyHandler
+  include EdgycircleToolbox::CQRS::Handler
+
+  def call(command)
+    # Business Logic
+  end
+end
+~~~
+
+## CQRS Command Module
+A command class can have a schema and attributes. The schema can be used by the command bus to validate the data before a command is built. Currently the definitions are redundant, changing this could be an improvement made in the future. Every command has a default attribute `id` and a schema to validate its presence and make sure it's a string.
+
+The module uses [dry-validation](http://dry-rb.org/gems/dry-validation/) for the schema and its validation.
+~~~ruby
+require 'edgycircle_toolbox/cqrs/command'
+
+class DummyCommand
+    include EdgycircleToolbox::CQRS::Command
+
+    schema do
+      required(:title).filled(:str?)
+    end
+
+    attributes :title
+  end
+~~~
+
+## CQRS Command Bus
+Can build commands from a parameter hash if the data fits the commands schema. A submitted command is passed to the corresponding handler. Events from the command handler get published on the message bus. Both `build` and `submit` return a `CommandResult`.
+~~~ruby
+require 'edgycircle_toolbox/cqrs/command_bus'
+
+command_bus = EdgycircleToolbox::CQRS::CommandBus.new
+command_bus.register EnterTicketCommand, EnterTicketHandler
+
+command_result = command_bus.build(parameter_hash)
+command_result = command_bus.submit(command_result.command)
+~~~
+
+## CQRS Message Bus
+~~~ruby
+require 'edgycircle_toolbox/cqrs/message_bus'
+
+class RandomEvent
+end
+
+class CommonEvent
+end
+
+EdgycircleToolbox::CQRS::MessageBus.subscribe([RandomEvent], ->(event) { puts 'Output 1' })
+EdgycircleToolbox::CQRS::MessageBus.subscribe([RandomEvent, CommonEvent], ->(event) { puts 'Output 2' })
+
+EdgycircleToolbox::CQRS::MessageBus.publish(RandomEvent.new)
+# =>
+# Output 1
+# Output 2
+
+EdgycircleToolbox::CQRS::MessageBus.publish(CommonEvent.new)
+# =>
+# Output 2
+~~~
+
+## CQRS Model Collector
+Can be used to collect data based on events.
+~~~ruby
+require 'edgycircle_toolbox/cqrs/model_collector'
+
+class RandomEvent
+end
+
+class CommonEvent
+end
+
+EdgycircleToolbox::CQRS::ModelCollector.register(RandomEvent, ->(event) { [1, 2] })
+EdgycircleToolbox::CQRS::ModelCollector.register(RandomEvent, ->(event) { [3] })
+EdgycircleToolbox::CQRS::ModelCollector.register(CommonEvent, ->(event) { [4] })
+
+EdgycircleToolbox::CQRS::ModelCollector.for_events([
+  RandomEvent.new, 
+  CommonEvent.new
+])
+# =>
+# [1, 2, 3, 4]
+~~~
+
+## Sonapi Resource Module
+~~~ruby
+require 'edgycircle_toolbox/sonapi/resource'
+
+class CommandResource
+  include EdgycircleToolbox::Sonapi::Resource
+
+  type "commands"
+
+  dynamic_attributes Proc.new { |object| object.attribute_names - [:id] }
+  parameter_filter Proc.new { |name, value| true }
+end
+
+class TicketResource
+  include EdgycircleToolbox::Sonapi::Resource
+
+  type "tickets"
+
+  attribute :estimate
+end
+~~~
+
+## Sonapi Dynamic Resource
+~~~ruby
+require 'edgycircle_toolbox/sonapi/dynamic_resource'
+
+class Dummy
+end
+
+class Tree
+end
+
+class DummyResource
+  include EdgycircleToolbox::Sonapi::Resource
+
+  type "dummies"
+end
+
+class TreeResource
+  include EdgycircleToolbox::Sonapi::Resource
+
+  type "trees"
+end
+
+EdgycircleToolbox::Sonapi::DynamicResource.register(Dummy, DummyResource)
+EdgycircleToolbox::Sonapi::DynamicResource.register(Tree, TreeResource)
+
+EdgycircleToolbox::Sonapi::DynamicResource.serialize([Dummy.new, Tree.new])
+~~~
+
+## Sonapi Error Resource
+The `ErrorResource` can serialize errors conforming to the `SerializableError` interface.
+~~~ruby
+require 'edgycircle_toolbox/sonapi/error_resource'
+
+EdgycircleToolbox::Sonapi::ErrorResource.serialize([error_a, error_b])
+~~~
+
+## Sonapi SerializableError Module
+An error class has to implement the `title`, `pointer` and `detail` methods.
+~~~ruby
+require 'edgycircle_toolbox/sonapi/serializable_error'
+
+class EmailTakenError
+  include EdgycircleToolbox::Sonapi::SerializableError
+
+  def initialize(email)
+    @email = email
+  end
+
+  def title
+    "Email Taken Error"
+  end
+
+  def pointer
+    nil
+  end
+
+  def detail
+    "The email #{@email} is already taken, please use something different"
+  end
+end
+~~~
+
+## Sonapi ValidationError
+~~~ruby
+require 'edgycircle_toolbox/sonapi/validation_error'
+
+EdgycircleToolbox::Sonapi::ValidationError.new(:title, "Title is not long enough")
+~~~

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/edgycircle_toolbox.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'edgycircle_toolbox/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "edgycircle_toolbox"
+  spec.version       = EdgycircleToolbox::VERSION
+  spec.authors       = ["David Strauß"]
+  spec.email         = ["david@strauss.io"]
+
+  spec.summary       = %q{A loose collection of Ruby related code that currently has specific place to live in.}
+  spec.description   = %q{A loose collection of Ruby related code that currently has specific place to live in.}
+  spec.homepage      = "https://www.edgycircle.com"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+
+  spec.add_dependency "dry-validation", "~> 0.10"
+  spec.add_dependency "dry-container", "~> 0.5"
+end

data/lib/edgycircle_toolbox.rb

@@ -0,0 +1,5 @@
+require "edgycircle_toolbox/version"
+
+module EdgycircleToolbox
+  # Your code goes here...
+end

data/lib/edgycircle_toolbox/cqrs/command.rb

@@ -0,0 +1,31 @@
+require 'dry-validation'
+require 'edgycircle_toolbox/has_attributes'
+
+module EdgycircleToolbox
+  module CQRS
+    module Command
+      module ClassMethods
+        def schema(&block)
+          if block_given?
+            base = Dry::Validation.Schema(build: false) do
+              required(:id).filled(:str?)
+            end
+
+            @schema = Dry::Validation.Form(rules: base.rules, &block)
+          else
+            @schema
+          end
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(HasAttributes)
+
+        base.class_eval do
+          attributes :id
+        end
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/cqrs/command_builder.rb

@@ -0,0 +1,42 @@
+require 'dry-container'
+
+module EdgycircleToolbox
+  module CQRS
+    class CommandBuilder
+      class DecoratorContainer
+        include Dry::Container::Mixin
+
+        configure do |config|
+          config.registry = ->(container, key, item, options) { (container[key] ||= []).push(item) }
+          config.resolver = ->(container, key) { container[key] || [] }
+        end
+      end
+
+      def initialize
+        @command_container = Dry::Container.new
+        @decorator_container = DecoratorContainer.new
+      end
+
+      def register(command_class)
+        key = command_class.name.split("::").last.gsub("Command", "")
+        @command_container.register(key, command_class)
+      end
+
+      def decorate(command_class, decorator_class)
+        @decorator_container.register(command_class, decorator_class)
+      end
+
+      def build(valid_parameters, context = nil)
+        command_class = @command_container.resolve(valid_parameters[:name])
+        decorator_classes = @decorator_container.resolve(command_class)
+        command = command_class.new(valid_parameters)
+        decorator_classes.inject(command) { |command, decorator_class| decorator_class.new(command, context) }
+      end
+
+      def validate(original_parameters)
+        command_class = @command_container.resolve(original_parameters[:name])
+        command_class.schema.call(original_parameters)
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/cqrs/command_bus.rb

@@ -0,0 +1,62 @@
+require 'dry-container'
+require 'edgycircle_toolbox/cqrs/message_bus'
+require 'edgycircle_toolbox/cqrs/command_result'
+require 'edgycircle_toolbox/cqrs/command_builder'
+require 'edgycircle_toolbox/sonapi/validation_error'
+
+module EdgycircleToolbox
+  module CQRS
+    class CommandBus
+      def initialize
+        @container = Dry::Container.new
+        @command_builder = CommandBuilder.new
+      end
+
+      def register(command, handler)
+        command_builder.register(command)
+
+        container.namespace(:handlers) do
+          register(command, handler)
+        end
+      end
+
+      def decorate_command(command_class, decorator_class)
+        command_builder.decorate(command_class, decorator_class)
+      end
+
+      def submit(command)
+        result = container.resolve("handlers.#{command.class.name}").new.call(command)
+        result.events.each { |event| MessageBus.publish(event) }
+        result
+      end
+
+      def build(original_parameters, context = nil)
+        result = CommandResult.new
+        validation = command_builder.validate(original_parameters)
+
+        if validation.failure?
+          build_validation_errors(validation).each { |error| result.add_error(error) }
+        else
+          validated_parameters = validation.output
+          command = command_builder.build(validated_parameters, context)
+          result.set_command(command)
+        end
+
+        result
+      end
+
+      private
+      attr_reader :container, :command_builder
+
+      def command_class_for(name)
+        container.resolve("commands.#{name}")
+      end
+
+      def build_validation_errors(validation)
+        validation.messages(full: true).map do |attribute, messages|
+          messages.map { |message| ValidationError.new(attribute, message) }
+        end.flatten
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/cqrs/command_result.rb

@@ -0,0 +1,33 @@
+module EdgycircleToolbox
+  module CQRS
+    class CommandResult
+      attr_reader :command, :errors, :events
+
+      def initialize(command = nil)
+        @command = command
+        @events = []
+        @errors = []
+      end
+
+      def add_error(error)
+        errors << error
+        self
+      end
+
+      def add_event(event)
+        events << event
+        self
+      end
+
+      def set_command(command)
+        @command = command
+        self
+      end
+
+      def failure?
+        errors.size > 0
+      end
+    end
+  end
+end
+

data/lib/edgycircle_toolbox/cqrs/handler.rb

@@ -0,0 +1,9 @@
+module EdgycircleToolbox
+  module CQRS
+    module Handler
+      def call(command)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/cqrs/message_bus.rb

@@ -0,0 +1,22 @@
+require 'dry-container'
+
+module EdgycircleToolBox
+  module CQRS
+    class MessageBus
+      extend Dry::Container::Mixin
+
+      configure do |config|
+        config.registry = ->(container, key, item, options) { (container[key] ||= []).push(item) }
+        config.resolver = ->(container, key) { container[key] || [] }
+      end
+
+      def self.subscribe(events, callable)
+        events.each { |event| register(event, callable) }
+      end
+
+      def self.publish(event)
+        resolve(event.class).each { |callable| callable.call(event) }
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/cqrs/model_collector.rb

@@ -0,0 +1,18 @@
+require 'dry-container'
+
+module EdgycircleToolbox
+  module CQRS
+    class ModelCollector
+      extend Dry::Container::Mixin
+
+      configure do |config|
+        config.registry = ->(container, key, item, options) { (container[key] ||= []).push(item) }
+        config.resolver = ->(container, key) { container[key] || [] }
+      end
+
+      def self.for_events(events)
+        events.map { |event| resolve(event.class).map { |callable| callable.call(event) } }.flatten
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/has_attributes.rb

@@ -0,0 +1,37 @@
+module EdgycircleToolbox
+  module HasAttributes
+    module ClassMethods
+      def attributes(*attributes)
+        @attributes ||= []
+
+        return @attributes unless attributes.any?
+
+        attributes.each do |attribute|
+          define_attr_accessor(attribute)
+          @attributes << attribute
+        end
+      end
+
+      def define_attr_accessor(attribute)
+        attr_accessor(attribute)
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    def initialize(attributes = {})
+      attributes.each do |key, value|
+        setter = "#{key}="
+        public_send(setter, value) if respond_to?(setter)
+      end
+    end
+
+    def attributes
+      self.class.attributes
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/blueprint.rb

@@ -0,0 +1,28 @@
+module EdgycircleToolbox
+  module Sonapi
+    class Blueprint
+      attr_accessor :type, :attribute_names, :dynamic_attributes, :parameter_filter
+
+      def initialize(type, attribute_names = [])
+        @type = type
+        @attribute_names = attribute_names
+        @dynamic_attributes = Proc.new { [] }
+        @parameter_filter = Proc.new do |name, value|
+          @attribute_names.include?(name.to_s) || name == :id
+        end
+      end
+
+      def add_attribute(attribute_name)
+        @attribute_names << attribute_name
+      end
+
+      def attribute_names(object)
+        @attribute_names + dynamic_attributes.call(object).map(&:to_s)
+      end
+
+      def deserialize_parameter?(name, value)
+        parameter_filter.call(name, value)
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/deserializer.rb

@@ -0,0 +1,34 @@
+module EdgycircleToolbox
+  module Sonapi
+    class Deserializer
+      attr_reader :blueprint
+
+      def initialize(blueprint)
+        @blueprint = blueprint
+      end
+
+      def call(parameters)
+        Hash[
+          filter_parameter_pairs(parameter_pairs(parameters))
+        ]
+      end
+
+      private
+      def parameter_pairs(parameters)
+        id_pair = [:id, parameters["data"]["id"]]
+
+        parameters["data"]["attributes"].to_a.map do |pair|
+          [format_attribute_name(pair[0]), pair[1]]
+        end << id_pair
+      end
+
+      def format_attribute_name(attribute_name)
+        attribute_name.to_s.gsub("-", "_").to_sym
+      end
+
+      def filter_parameter_pairs(pairs)
+        pairs.select { |pair| blueprint.deserialize_parameter?(pair[0], pair[1]) }
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/dynamic_resource.rb

@@ -0,0 +1,13 @@
+require 'dry-container'
+
+module EdgycircleToolbox
+  module Sonapi
+    class DynamicResource
+      extend Dry::Container::Mixin
+
+      def self.serialize(models)
+        models.map { |model| resolve(model.class).serialize_resource(model)  }
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/error_resource.rb

@@ -0,0 +1,22 @@
+module EdgycircleToolbox
+  module Sonapi
+    class ErrorResource
+      def self.serialize(errors)
+        {
+          "errors" => errors.map do |error|
+            hash = {
+              "title" => error.title,
+              "detail" => error.detail
+            }
+
+            if error.pointer
+              hash["source"] = { "pointer" => error.pointer }
+            end
+
+            hash
+          end
+        }
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/resource.rb

@@ -0,0 +1,57 @@
+require 'edgycircle_toolbox/sonapi/blueprint'
+require 'edgycircle_toolbox/sonapi/serializer'
+require 'edgycircle_toolbox/sonapi/deserializer'
+
+module EdgycircleToolbox
+  module Sonapi
+    module Resource
+      module ClassMethods
+        def type(type)
+          @blueprint = Blueprint.new(type)
+        end
+
+        def serialize_resource(object)
+          Serializer.new(@blueprint).call(object)
+        end
+
+        def serialize(object, options = {})
+          if object.respond_to?(:map)
+            data = object.map { |item| serialize_resource(item) }
+          else
+            data = serialize_resource(object)
+          end
+
+          result = {
+            "data" => data
+          }
+
+          if options[:included_resources]
+            result.merge!({ "included" => options[:included_resources] })
+          end
+
+          result
+        end
+
+        def deserialize(parameters)
+          Deserializer.new(@blueprint).call(parameters)
+        end
+
+        def attribute(attribute_name)
+          @blueprint.add_attribute attribute_name.to_s
+        end
+
+        def dynamic_attributes(callable)
+          @blueprint.dynamic_attributes = callable
+        end
+
+        def parameter_filter(callable)
+          @blueprint.parameter_filter = callable
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/serializable_error.rb

@@ -0,0 +1,17 @@
+module EdgycircleToolbox
+  module Sonapi
+    module SerializableError
+      def title
+        raise NotImplementedError
+      end
+
+      def pointer
+        raise NotImplementedError
+      end
+
+      def detail
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/sonapi/serializer.rb

@@ -0,0 +1,33 @@
+module EdgycircleToolbox
+  module Sonapi
+    class Serializer
+      attr_reader :blueprint
+
+      def initialize(blueprint)
+        @blueprint = blueprint
+      end
+
+      def call(object)
+        {
+          "type" => blueprint.type,
+          "id" => object.id,
+          "attributes" => collect_attributes(object)
+        }
+      end
+
+      private
+      def collect_attributes(object)
+        Hash[
+          blueprint.attribute_names(object).map do |attribute_name|
+            [format_attribute_name(attribute_name), object.send(attribute_name)]
+          end
+        ]
+      end
+
+      def format_attribute_name(attribute_name)
+        attribute_name.gsub("_", "-")
+      end
+    end
+  end
+end
+

data/lib/edgycircle_toolbox/sonapi/validation_error.rb

@@ -0,0 +1,22 @@
+module EdgycircleToolbox
+  module Sonapi
+    class ValidationError
+      include SerializableError
+
+      attr_reader :detail, :attribute
+
+      def initialize(attribute, detail)
+        @attribute = attribute
+        @detail = detail
+      end
+
+      def pointer
+        "data/attributes/#{attribute.to_s.gsub("_", "-")}"
+      end
+
+      def title
+        "Validation Error"
+      end
+    end
+  end
+end

data/lib/edgycircle_toolbox/version.rb

@@ -0,0 +1,3 @@
+module EdgycircleToolbox
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: edgycircle_toolbox
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Strauß
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+description: A loose collection of Ruby related code that currently has specific place
+  to live in.
+email:
+- david@strauss.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- edgycircle_toolbox.gemspec
+- lib/edgycircle_toolbox.rb
+- lib/edgycircle_toolbox/cqrs/command.rb
+- lib/edgycircle_toolbox/cqrs/command_builder.rb
+- lib/edgycircle_toolbox/cqrs/command_bus.rb
+- lib/edgycircle_toolbox/cqrs/command_result.rb
+- lib/edgycircle_toolbox/cqrs/handler.rb
+- lib/edgycircle_toolbox/cqrs/message_bus.rb
+- lib/edgycircle_toolbox/cqrs/model_collector.rb
+- lib/edgycircle_toolbox/has_attributes.rb
+- lib/edgycircle_toolbox/sonapi/blueprint.rb
+- lib/edgycircle_toolbox/sonapi/deserializer.rb
+- lib/edgycircle_toolbox/sonapi/dynamic_resource.rb
+- lib/edgycircle_toolbox/sonapi/error_resource.rb
+- lib/edgycircle_toolbox/sonapi/resource.rb
+- lib/edgycircle_toolbox/sonapi/serializable_error.rb
+- lib/edgycircle_toolbox/sonapi/serializer.rb
+- lib/edgycircle_toolbox/sonapi/validation_error.rb
+- lib/edgycircle_toolbox/version.rb
+homepage: https://www.edgycircle.com
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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.5
+signing_key: 
+specification_version: 4
+summary: A loose collection of Ruby related code that currently has specific place
+  to live in.
+test_files: []