kiyohime 0.2.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 53324caf2d1e0c1d072aca1d030c8adab4079e17
+  data.tar.gz: 6190d412823f68eb6ffe3ccb692abfe09a7a3141
+SHA512:
+  metadata.gz: fa6c6845785f576466c9f8d3369a274f7e4e331c410b8a36a9e935c01ba2d79572dee2a09bde8593c2f99cd796c02e4a2777c9095950f6ce9f9eb1e484166c13
+  data.tar.gz: bd86c5a0b051733e5e24a85291ea8d58354bbda6349d8dcf88feb3dce58ada7e2f1c7d8cddd2979456b56b2fef9d8e6f54eb7b4745cddde2fd8fe1dae16b7414

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.byebug_history
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,34 @@
+ClassLength:
+  Max: 120
+
+LineLength:
+  Max: 200
+
+MethodLength:
+  CountComments: false  # count full line comments?
+  Max: 15
+
+Metrics/AbcSize:
+  Max: 30
+
+Encoding:
+  Description: 'Use UTF-8 as the source file encoding.'
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+AllCops:
+  Exclude:
+    - bin/**/*
+    - db/**/*
+    - config/**/*
+    - Rakefile
+    - script/**/*
+    - spec/factories/**/*
+    - spec/test_app/**/*
+    - node_modules/**/*
+    - !ruby/regexp /old_and_unused\.rb$/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.4
+before_install: gem install bundler -v 1.11.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at shirren@me.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Shirren Premaratne
+
+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,128 @@
+# Kiyohime
+
+Kiyohime is a microservice framework written in Ruby. In Ruby microservices are traditionally written as RESTful services using established frameworks (e.g. Rails, Sinatra, Grape etc). At present there appears to be no elegant microservice framework for the Ruby language that works on a publish/subscribe model. Kiyohime is an attempt to fill this gap.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kiyohime'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kiyohime
+
+## Usage
+
+Kiyohime works by providing a registry. The registry is why services register their interest to receive messages from publishers. The simplest subscriber can be a PORO (plain old ruby object) which implements a method named handle. So for example we could write the following service;
+
+```ruby
+class MySubscriber
+  def handle(message)
+    puts "My subscriber handle invoke: #{message}"
+  end
+end
+```
+
+To register this service and it's method as a subscriber we first need to create an instance of the Registry which we can then use to register our MySubscriber service. The registry is currently powered by Redis. The example below demonstrates how to use the registry;
+
+```ruby
+service = MySubscriber.new
+store = Kiyohime::Stores::RedisStore.new
+registry = Kiyohime::Registry.new('My Registry', store)
+registry.register_services(service)
+```
+
+Runnin the code above should print the following statements to the console;
+
+```
+Registering service: kiyohime.registry.deregister
+Registering service: mysubscriber
+```
+
+Now what we have is a channel named 'mysubscriber' to which we can publish a message. To publish a message one can use Kiyohime, but as we use Redis, a message can be published to our Ruby service in a platform and language agnostic manner. So for example if we have the Redis CLI installed we could send a message to our service using the following command;
+
+```
+redis-cli publish "mysubscriber" "test message"
+```
+
+If you would like to send/publish a message using Kiyohime we can do use as shown below;
+
+```ruby
+publisher = Kiyohime::Publisher.new
+publisher.publish('mysubscriber', 'another test message')
+```
+
+It is important to note that both the publisher and the registry can take a custom Redis object if required. So what if want to write a more sophisticated service, instead of a simple service with the prescriptive interface with a handle method? Well this is certainly possible. Suppose we have the following service definition;
+
+```ruby
+class MyComplexSubscriber
+  def method1(message)
+    puts "My subscriber method1 invoke: #{message}"
+  end
+
+  def method2(hash_arg)
+    puts "My subscriber method2 invoke: #{hash_arg[:key1]}"
+  end
+
+  def method3(hash_arg)
+    puts "My subscriber method3 invoke: #{hash_arg[:key1]}"
+  end
+end
+```
+
+`MyComplexSubscriber` has 3 methods, and I'd like to register method1 and method2 only as subcribers. To do this we need to use a class called the service container. The code below illustrates how to use Kiyohime service container to register method1 and method2 from MyComplexSubscriber.
+
+```ruby
+my_complex_service = MyComplexSubscriber.new
+service_container = Kiyohime::Containers::ServiceRegistration.new(my_complex_service, :method1, :method2)
+store = Kiyohime::Stores::RedisStore.new
+registry = Kiyohime::Registry.new('My Registry', store)
+registry.register_containers(service_container)
+```
+
+Running the code above should print the following to your console;
+
+```
+Registering service: kiyohime.registry.deregister
+Registering service: mycomplexsubscriber.method1
+Registering service: mycomplexsubscriber.method2
+```
+
+If the statements do not appear in the order show above do not worry, as long as they appear your service subscribers have been setup correctly. Note how `method3` is not listed. We can see that when we created the `ServiceRegistration` we are also specifying which methods to setup as subscribers only.
+
+Our examples use simple datatypes and collection types in the example. At present this is all we have tested, but in theory complex types can be passed in the message as long as the size of the complex type does not exceed 256kb, the default limit in Redis.
+
+The methods `register_async` and `register_containers_async` can also take an array of subscribers. So for example if I wanted to register both my `MySubscriber` and `MyComplexSubscriber` in one go? Well the code sample below illustrates how this can be achieved;
+
+```ruby
+service = MySubscriber.new
+service_container1 = Kiyohime::Containers::ServiceRegistration.new(service, :handle)
+my_complex_service = MyComplexSubscriber.new
+service_container2 = Kiyohime::Containers::ServiceRegistration.new(my_complex_service, :method1, :method2)
+store = Kiyohime::Stores::RedisStore.new
+registry = Kiyohime::Registry.new('My Registry', store)
+registry.register_containers_async(service_container1, service_container2)
+```
+
+## Development
+
+After checking out the repo, run `rspec spec` to run the specs. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shirren/kiyohime. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'kiyohime/containers/service_registration'
+require 'kiyohime/exceptions/subscriber_error'
+require 'kiyohime/publisher'
+require 'kiyohime/registry'
+require 'kiyohime/stores/redis_store'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+require './examples/services/service_with_generic_handler'
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'byebug'
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/services/service_with_bespoke_handler.rb

@@ -0,0 +1,16 @@
+module Services
+  # Example service with bespoke handlers
+  class ServiceWithBespokeHandler
+    def method1(message)
+      puts "ServiceWithBespokeHandler Recived message #{message} on message1 receiver"
+    end
+
+    def method2(message)
+      puts "ServiceWithBespokeHandler Recived message #{message} on message2 receiver"
+    end
+
+    def method3(message)
+      puts "ServiceWithBespokeHandler Recived message #{message} on message3 receiver"
+    end
+  end
+end

data/examples/services/service_with_generic_handler.rb

@@ -0,0 +1,9 @@
+module Services
+  # Example service which generic handler
+  class ServiceWithGenericHandler
+    def handle(num)
+      puts "ServiceWithGenericHandler Recived message #{num}"
+      num + num
+    end
+  end
+end

data/kiyohime.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kiyohime/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'kiyohime'
+  spec.version       = Kiyohime::VERSION
+  spec.authors       = ['Shirren Premaratne']
+  spec.email         = ['shirren@me.com']
+
+  spec.summary       = 'Kiyohime is a library which provides a wrapper around Redis for pubsub.'
+  spec.description   = 'Kiyohime is a library which provides a wrapper around Redis for pubsub.'
+  spec.homepage      = 'http://github.com/shirren/kiyohime'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.' unless spec.respond_to?(:metadata)
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Add runtime depenencies here
+  spec.add_runtime_dependency 'em-hiredis', '~> 0.3'
+  spec.add_runtime_dependency 'redis', '~> 3.3'
+
+  # Add development dependencies here
+  spec.add_development_dependency 'byebug', '~> 8.2'
+  spec.add_development_dependency 'factory_girl', '~> 4.2'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '~> 0.39'
+  spec.add_development_dependency 'simplecov', '~> 0.11'
+end

data/lib/kiyohime.rb

@@ -0,0 +1,15 @@
+require 'kiyohime/version'
+require 'kiyohime/containers/service_registration'
+require 'kiyohime/exceptions/subscriber_error'
+require 'kiyohime/exceptions/unsupported_channel_name'
+require 'kiyohime/exceptions/unsupported_interface'
+require 'kiyohime/publisher'
+require 'kiyohime/publisher_helper'
+require 'kiyohime/registry'
+require 'kiyohime/stores/redis_store'
+
+# Kiyohime is a simple Microservice framework for Ruby which is built on the publish/subscribe
+# paradigm
+module Kiyohime
+  # Your code goes here...
+end

data/lib/kiyohime/containers/service_registration.rb

@@ -0,0 +1,14 @@
+module Kiyohime
+  module Containers
+    # Services can be registered via this container. It is principally used for services
+    # which add bespoke methods to the registry
+    class ServiceRegistration
+      attr_reader :service, :methods
+
+      def initialize(service, *methods)
+        @service = service
+        @methods = methods
+      end
+    end
+  end
+end

data/lib/kiyohime/exceptions/registry_error.rb

@@ -0,0 +1,13 @@
+module Kiyohime
+  module Exceptions
+    # This error is used to signal when the registry has an issue
+    class RegistryError < StandardError
+      attr_reader :message
+
+      def initialize(message)
+        @message = message
+        super(message)
+      end
+    end
+  end
+end

data/lib/kiyohime/exceptions/subscriber_error.rb

@@ -0,0 +1,15 @@
+module Kiyohime
+  module Exceptions
+    # This error is used to signal when a subscriber throws an error
+    class SubscriberError < StandardError
+      attr_reader :message, :action, :data
+
+      def initialize(message, action = nil, data = nil)
+        @message = message
+        @action = action
+        @data = data
+        super(message)
+      end
+    end
+  end
+end

data/lib/kiyohime/exceptions/unsupported_channel_name.rb

@@ -0,0 +1,7 @@
+module Kiyohime
+  module Exceptions
+    # This error is used to signal an unsupported name for a channel
+    class UnsupportedChannelName < StandardError
+    end
+  end
+end

data/lib/kiyohime/exceptions/unsupported_interface.rb

@@ -0,0 +1,7 @@
+module Kiyohime
+  module Exceptions
+    # This error is used to signal a service without a generic handler
+    class UnsupportedInterface < StandardError
+    end
+  end
+end

data/lib/kiyohime/parsers/channel_parser.rb

@@ -0,0 +1,45 @@
+require 'kiyohime/exceptions/unsupported_channel_name'
+
+module Kiyohime
+  module Parsers
+    # Microservices receive and send messages along channels, channel names can be derived
+    # from the name of the type
+    class ChannelParser
+      # Convert a type name to a channel name. A type name can be a Ruby type or a string
+      # representation of the type name
+      def parse_type_to_channel_name(type_name)
+        type_name = type_name.to_s.downcase.gsub(/::/, '.')
+        if type_name.empty? || !type_name_valid?(type_name)
+          raise Kiyohime::Exceptions::UnsupportedChannelName
+        else
+          type_name
+        end
+      end
+
+      # Convert a type name and method name to a channel name. A type name can be a Ruby type or a string
+      # representation of the type name. A method name can be a symbol or a string
+      def parse_type_and_method_to_channel_name(type_name, method_name)
+        type_name = type_name.to_s.downcase.gsub(/::/, '.')
+        method_name = method_name.to_s.downcase
+        if type_name.empty? || method_name.empty? ||
+           !type_name_valid?(type_name) || !method_name_valid?(method_name)
+          raise Kiyohime::Exceptions::UnsupportedChannelName
+        else
+          "#{type_name}.#{method_name}"
+        end
+      end
+
+      private
+
+      # Validate the type name to make sure we can convert it to a valid channel name
+      def type_name_valid?(channel_name)
+        (/^[a-z]+(\.[a-z]+)*(\.[a-z]+){0,1}$/ =~ channel_name).nil? ? false : true
+      end
+
+      # Validate the method name to make sure we can convert it to a valid channel name
+      def method_name_valid?(method_name)
+        (/^[a-z]+[_0-9a-zA-Z]*$/ =~ method_name).nil? ? false : true
+      end
+    end
+  end
+end

data/lib/kiyohime/publisher.rb

@@ -0,0 +1,23 @@
+require 'redis'
+require 'kiyohime/stores/redis_store'
+
+module Kiyohime
+  # A publisher can be used to publish a message to a specific function. It also has the facility to
+  # list the names of the available functions
+  class Publisher
+    attr_reader :store
+
+    # Initialises the publisher by obtaining a Redis connection
+    def initialize(store = nil)
+      @store = store || Kiyohime::Stores::RedisStore.new.redis
+    end
+
+    # A message can be published to a service/function, a message can be a simple type, or at
+    # present a JSON compliant type
+    def publish(service, message)
+      if store
+        puts "Published message: #{message} to service: #{service}" if store.publish(service, message)
+      end
+    end
+  end
+end

data/lib/kiyohime/publisher_helper.rb

@@ -0,0 +1,15 @@
+require 'redis'
+require 'kiyohime/stores/redis_store'
+require 'kiyohime/publisher'
+
+module Kiyohime
+  # This helper can be mixed into classes which want to just simply open a Redis connection
+  # and then publish a message
+  module PublisherHelper
+    # Create a redis publisher
+    def publisher
+      @redis_connection ||= Kiyohime::Stores::RedisStore.new.redis
+      Kiyohime::Publisher.new(@redis_connection)
+    end
+  end
+end

data/lib/kiyohime/registry.rb

@@ -0,0 +1,92 @@
+require 'kiyohime/exceptions/subscriber_error'
+require 'kiyohime/parsers/channel_parser'
+
+module Kiyohime
+  # A registry is a listing of services/functions which are accessible via a publish/subscribe paradigm. This
+  # services/functions are accessible through the Publisher
+  class Registry
+    attr_reader :name, :channel_parser, :store, :pubsub
+
+    # A registry should be provided with a name, and an underlying store. If the hiredis flag
+    # is set to true we use the hiredis wrapper around redis instead
+    def initialize(name, store)
+      @name = name
+      @store = store
+      @channel_parser = Kiyohime::Parsers::ChannelParser.new
+    end
+
+    # Non blocking registration of services. The run block creates an event loop, this allows
+    # the process to continue and service publications via registered subscribers
+    def register_services(*services)
+      EM.run do
+        initialise_registry
+        subscribe_deregister
+        services.each { |service| register(service) }
+      end
+    end
+
+    # Non blocking registration of services. The run block creates an event loop, this allows
+    # the process to continue and service publications via registered subscribers
+    def register_containers(*service_containers)
+      EM.run do
+        initialise_registry
+        subscribe_deregister
+        service_containers.each { |service_container| register_container(service_container) }
+      end
+    end
+
+    private
+
+    # A service should be able to register it's global interest in receiving all messages to a
+    # particular channel, this means, the object must define a generic handler named handle. Multiple
+    # services are registered in a single go using an evented publish subscribe approach
+    def register(service)
+      channel = channel_parser.parse_type_to_channel_name(service.class)
+      if service.respond_to?(:handle)
+        puts "Registering service: #{channel}"
+        pubsub.subscribe(channel) do |message|
+          begin
+            service.handle(message)
+          rescue => e
+            puts "Kiyohime Error: #{e}"
+          end
+        end
+      end
+    end
+
+    # A service should be able to register it's global interest in receiving all messages to a
+    # channel name derived using the service name and method name. This unlike the generic register
+    # method which assumes the service implements a particular interface
+    def register_container(service_container)
+      service_container.methods.each do |method_name|
+        channel = channel_parser.parse_type_and_method_to_channel_name(service_container.service.class, method_name.to_sym)
+        puts "Registering service: #{channel}"
+        pubsub.subscribe(channel) do |message|
+          if service_container.service.respond_to?(method_name.to_sym)
+            begin
+              service_container.service.send(method_name.to_sym, message)
+            rescue => e
+              puts "Kiyohime Error: #{e}"
+            end
+          end
+        end
+      end
+    end
+
+    # When the first series of services are registered via the registry, the deregister subscriber
+    # is also registered, this is used to un-subscribe services
+    def subscribe_deregister
+      dereg_channel = channel_parser.parse_type_and_method_to_channel_name(self.class, :deregister)
+      puts "Registering service: #{dereg_channel}"
+      pubsub.subscribe(dereg_channel) do |message|
+        puts "Unsubscribing from channel #{message}"
+        pubsub.unsubscribe(message)
+      end
+    end
+
+    # Initialisation of the registry within the scope of an EventMachine block
+    def initialise_registry
+      @pubsub = store.hiredis
+    end
+  end
+end

data/lib/kiyohime/stores/redis_store.rb

@@ -0,0 +1,23 @@
+require 'em-hiredis'
+require 'redis'
+
+module Kiyohime
+  module Stores
+    # A rudimentary abstraction of the store which will advance over time no doubt
+    class RedisStore
+      attr_reader :url
+
+      def initialize(uri = nil)
+        @url = uri || ENV['REDIS_URL'] || ENV['REDISCLOUD_URL'] || 'redis://127.0.0.1:6379/0'
+      end
+
+      def redis
+        Redis.new(url: url)
+      end
+
+      def hiredis
+        EM::Hiredis.connect(url).pubsub
+      end
+    end
+  end
+end

data/lib/kiyohime/version.rb

@@ -0,0 +1,3 @@
+module Kiyohime
+  VERSION = '0.2.7'.freeze
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: kiyohime
+version: !ruby/object:Gem::Version
+  version: 0.2.7
+platform: ruby
+authors:
+- Shirren Premaratne
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !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: 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: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+description: Kiyohime is a library which provides a wrapper around Redis for pubsub.
+email:
+- shirren@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/services/service_with_bespoke_handler.rb
+- examples/services/service_with_generic_handler.rb
+- kiyohime.gemspec
+- lib/kiyohime.rb
+- lib/kiyohime/containers/service_registration.rb
+- lib/kiyohime/exceptions/registry_error.rb
+- lib/kiyohime/exceptions/subscriber_error.rb
+- lib/kiyohime/exceptions/unsupported_channel_name.rb
+- lib/kiyohime/exceptions/unsupported_interface.rb
+- lib/kiyohime/parsers/channel_parser.rb
+- lib/kiyohime/publisher.rb
+- lib/kiyohime/publisher_helper.rb
+- lib/kiyohime/registry.rb
+- lib/kiyohime/stores/redis_store.rb
+- lib/kiyohime/version.rb
+homepage: http://github.com/shirren/kiyohime
+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.8
+signing_key: 
+specification_version: 4
+summary: Kiyohime is a library which provides a wrapper around Redis for pubsub.
+test_files: []