emittance 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 000a59df54901139fde2f395a810c5f8a7baf8fd
+  data.tar.gz: c23462f13256fbc860bd5bf56ae244f49e09d2bf
+SHA512:
+  metadata.gz: eafdc2ad4b68f42a04f075aefee0a3359bea3c765b58130d33571e9bf1e802b124d6151e6ac183922cce24b2d84ad780fb0b2c7f94ab93d2adb9245d4fb47cea
+  data.tar.gz: cdc43830eb7f439764fb8e284bcf6c87bf415c69d09f1195282c4297f018cbe1dacab6c52fc2e2aa1fdb5ae46f14b35d3889c156b0b5afd7cf78952042ca47e9

data/.gitignore

@@ -0,0 +1,17 @@
+# editor stuff
+.idea
+.idea/dataSources.xml
+tags
+*.sublime-workspace
+*.sublime-project
+.project
+
+# OS stuff
+.DS_Store
+tmp/**
+
+# CI stuff
+.yardoc
+.yardoc/**
+coverage/**
+doc/**

data/.rspec_status

@@ -0,0 +1,29 @@
+example_id                                            | status | run_time        |
+----------------------------------------------------- | ------ | --------------- |
+./spec/emittance/action_spec.rb[1:1:1]                | passed | 0.00947 seconds |
+./spec/emittance/action_spec.rb[1:1:2]                | passed | 0.0006 seconds  |
+./spec/emittance/broker_spec.rb[1:1:1]                | passed | 0.00151 seconds |
+./spec/emittance/broker_spec.rb[1:2:1]                | passed | 0.0004 seconds  |
+./spec/emittance/broker_spec.rb[1:2:2]                | passed | 0.00086 seconds |
+./spec/emittance/broker_spec.rb[1:3:1]                | passed | 0.00018 seconds |
+./spec/emittance/broker_spec.rb[1:3:2]                | passed | 0.00023 seconds |
+./spec/emittance/broker_spec.rb[1:4:1]                | passed | 0.00016 seconds |
+./spec/emittance/broker_spec.rb[1:4:2]                | passed | 0.00022 seconds |
+./spec/emittance/emitter_spec.rb[1:1:1]               | passed | 0.00038 seconds |
+./spec/emittance/emitter_spec.rb[1:1:2]               | passed | 0.00016 seconds |
+./spec/emittance/emitter_spec.rb[1:2:1]               | passed | 0.00033 seconds |
+./spec/emittance/emitter_spec.rb[1:2:2]               | passed | 0.00026 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:1] | passed | 0.00102 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:2] | passed | 0.00025 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:3] | passed | 0.00017 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:4] | passed | 0.0002 seconds  |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:5] | passed | 0.0002 seconds  |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:6] | passed | 0.00022 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:7] | passed | 0.00019 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:8] | passed | 0.00018 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:1:1:9] | passed | 0.00019 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:2:1]   | passed | 0.00018 seconds |
+./spec/emittance/event/event_builder_spec.rb[1:2:2]   | passed | 0.00016 seconds |
+./spec/emittance/watcher_spec.rb[1:1:1]               | passed | 0.0003 seconds  |
+./spec/emittance/watcher_spec.rb[1:1:2]               | passed | 0.00027 seconds |
+./spec/emittance/watcher_spec.rb[1:1:3]               | passed | 0.00039 seconds |

data/.ruby-version

@@ -0,0 +1 @@
+2.4.2

data/.yardopts

@@ -0,0 +1,4 @@
+--protected
+--no-private
+'lib/**/*.rb'
+--readme README.md

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in test.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    emittance (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    json (2.1.0)
+    method_source (0.9.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    simplecov (0.15.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    yard (0.9.12)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.15)
+  emittance!
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  simplecov
+  yard
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -0,0 +1,41 @@
+# Emittance
+
+Emittance is a flexible eventing library that provides a clean interface for both emitting and capturing events. It follows the following workflow:
+
+1. Objects (and therefore, classes) can emit events, identified by a symbol.
+2. Events are objects that know who emitted them. Their
+3. Objects (and therefore, classes) can watch for events that get emitted.
+
+Per this pattern, objects are responsible for knowing what events they want to listen to. While this is pragmatically the same as a "push"-style message system (watchers don't need to go check a topic themselves), the semantics are a little different.
+
+I created this library because I was dissatisfied with the options currently available, and I wanted to see if I could make something that I would enjoy using.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'emittance'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install emittance
+
+## Usage
+
+Coming soon!
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. 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/aastronauts/emittance.

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,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'emittance'
+
+# 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.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require 'pry'
+Pry.start
+
+# require "irb"
+# IRB.start(__FILE__)

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/emittance.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'emittance/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'emittance'
+  spec.version       = Emittance::VERSION
+  spec.authors       = ['Tyler Guillen']
+  spec.email         = ['tyler@tylerguillen.com']
+
+  spec.summary       = %q{A robust and flexible eventing library for Ruby.}
+  spec.description   = %q{A robust and flexible eventing library for Ruby.}
+  spec.homepage      = 'https://github.com/aastronautss/emittance'
+  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'] = 'TODO: Set to 'http://mygemserver.com''
+  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.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'yard'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/emittance/action.rb

@@ -0,0 +1,199 @@
+##
+# There are certain classes (ergo objects) that represent an action taken by another object. This pattern goes like so:
+#
+#   class Foo
+#     def assign
+#       Assignment.new(self).call
+#     end
+#   end
+#
+#   class Assignment
+#     attr_reader :assignable
+#
+#     def initialize(assignable)
+#       @assignable = assignable
+#     end
+#
+#     def call
+#       do_stuff
+#     end
+#
+#     # ...
+#   end
+#
+# This pattern is useful for maintaining the single responsibility principle, delegating complex tasks to other objects
+# even when (in this particular case), it might be sensible for the +assign+ message to be sent to +Foo+. This has
+# numerous benefits, including the ability for actions like +Assignment+ to take a duck type.
+#
+# However, this can easily just become a proxy for the same antipattern it was made to solve. We might wind up with a
+# +#call+ method like the following:
+#
+#   class Assignment
+#     # ...
+#
+#     def call
+#       do_stuff
+#       do_stuff_to_another_object
+#       do_stuff_to_something_else
+#       do_stuff_to_yet_another_thing
+#     end
+#
+#     # ...
+#   end
+#
+# +Assignment+ is suddenly collaborating with a whole bunch of objects! This isn't bad in itself, but it might cause
+# some problems further on down the road as we add more responsibilities to +Assignment+. Do we really want all these
+# things to happen every time an +Assignment+ happens? If not, assuming this pattern we'll have to add a bunch of
+# control flow:
+#
+#   class Assignment
+#     # ...
+#
+#     def call
+#       do_stuff
+#
+#       if some_condition
+#         do_stuff_to_another_object
+#
+#         if some_other_condition
+#           do_stuff_to_something_else
+#         else
+#           do_stuff_to_yet_another_thing
+#         end
+#       elsif yet_another_condition
+#         do_other_stuff_to_that_other_object
+#       else
+#         dont_actually_do_anything_but_notify_someone
+#       end
+#     end
+#
+#     # ...
+#   end
+#
+# This is obviously an extreme example (but not unheard of!), but it gets to the core of what this module tries to
+# solve. +Emittance::Action+ helps facilitate the single responsibility principle by emitting an event whenever we
+# invoke +#call+ on an object like +Assignment+.
+#
+# == Usage
+#
+# First, define a class and include this module:
+#
+#   class Assignment
+#     include Emittance::Action
+#
+#     attr_reader :assignable
+#
+#     def initialize(assignable)
+#       @assignable = assignable
+#     end
+#   end
+#
+# Per the pattern explained above, instances of this class are representations of an action being carried out. This
+# class should have a very minimal interface (maybe, at most, some getter methods for its instance variables so the
+# handler can make decisions based on its state).
+#
+# Next, we'll implement the +#call+ instance method. +Emittance::Action+ will take care of the dirty work for us:
+#
+#   class Assignment
+#     # ...
+#
+#     def call
+#       do_one_and_i_mean_only_one_thing
+#     end
+#
+#     # ...
+#   end
+#
+# Again, this method should do a single thing. From here, your code should be able to run without error! You might
+# notice, though, that a mysterious class will have been defined after loading this file.
+#
+#   defined? AssignmentHandler
+#   => "constant"
+#
+# Next, we can open up this class to implement the event handler. +Emittance+ will look for a method called
+# +#handle_call+, and invoke it whenever, in this example, +Assignment#call+ is called.
+#
+#   class AssignmentHandler
+#     def handle_call
+#       notify_someone(action)
+#     end
+#
+#     # ...
+#   end
+#
+# The "Action" object is stored as the instance variable +@action+, made available with a getter class +#action+. This
+# will allow us to access its data and make decisions based on it.
+#
+# Now, this seems like we're passing the buck of all that control flow to yet another object, but this pattern has
+# several advantages. First, we can disable +Emittance+ at will, so if we ever want to shut +Assignment+ actions
+# off from their listeners, that is always an option to us. Second, to address the concern raised at the beginning of
+# this paragraph, this paradigm puts us into the mindset of spreading the flow of our program out across multiple
+# action/handler pairs, allowing us to think more clearly about what our code is doing.
+#
+# One possible disadvantage of this pattern is that it suggests a one-to-one pairing between events and handlers.
+#
+module Emittance::Action
+  EMITTING_METHOD = :call
+  HANDLER_METHOD_NAME = "handle_#{EMITTING_METHOD}".to_sym
+
+  class NoHandlerMethodError < StandardError; end
+
+  # @private
+  class << self
+    def included(action_klass)
+      handler_klass_name = Emittance::Action.handler_klass_name(action_klass)
+      handler_klass = Emittance::Action.find_or_create_klass(handler_klass_name)
+
+      action_klass.class_eval do
+        extend Emittance::Emitter
+
+        class << self
+          # @private
+          def method_added(method_name)
+            emitting_method = Emittance::Action::EMITTING_METHOD
+            emits_on method_name if method_name == emitting_method
+            super
+          end
+        end
+      end
+
+      handler_klass.class_eval do
+        attr_reader :action
+
+        extend Emittance::Watcher
+
+        def initialize(action_obj)
+          @action = action_obj
+        end
+
+        watch Emittance::Action.emitting_event_name(action_klass) do |event|
+          handler_obj = new(event.emitter)
+          handler_method_name = Emittance::Action::HANDLER_METHOD_NAME
+
+          if handler_obj.respond_to? handler_method_name
+            handler_obj.send handler_method_name
+          end
+        end
+      end
+    end
+
+    # @private
+    def handler_klass_name(action_klass)
+      "#{action_klass}Handler"
+    end
+
+    # @private
+    def emitting_event_name(action_klass)
+      Emittance::Emitter.emitting_method_event(action_klass, Emittance::Action::EMITTING_METHOD)
+    end
+
+    # @private
+    def find_or_create_klass(klass_name)
+      unless Object.const_defined? klass_name
+        Object.const_set klass_name, Class.new(Object)
+      end
+
+      Object.const_get klass_name
+    end
+  end
+end

data/lib/emittance/broker.rb

@@ -0,0 +1,73 @@
+# @private
+class Emittance::Broker
+  @registrations = {}
+  @enabled = true
+
+  class << self
+    attr_reader :enabled
+
+    def process_event(event)
+      return unless enabled?
+
+      registrations_for(event).each do |registration|
+        registration.call event
+      end
+    end
+
+    def register(identifier, &callback)
+      identifier = normalize_identifier identifier
+      @registrations[identifier] ||= []
+      registrations_for(identifier) << Emittance::Registration.new(identifier, &callback)
+    end
+
+    def register_method_call(identifier, object, method_name)
+      register identifier, &lambda_for_method_call(object, method_name)
+    end
+
+    def clear_registrations!
+      @registrations.keys.each do |identifier|
+        self.clear_registrations_for! identifier
+      end
+    end
+
+    def clear_registrations_for!(identifier)
+      identifier = normalize_identifier identifier
+      @registrations[identifier].clear
+    end
+
+    def registrations_for(identifier)
+      identifier = normalize_identifier identifier
+      @registrations[identifier] || []
+    end
+
+    private
+
+    def normalize_identifier(identifier)
+      if is_event_klass?(identifier) || is_event_object?(identifier)
+        identifier.identifier
+      else
+        coerce_identifier_type identifier
+      end
+    end
+
+    def lambda_for_method_call(object, method_name)
+      ->(event) { object.send method_name, event }
+    end
+
+    def is_event_klass?(identifier)
+      identifier.is_a?(Class) && identifier < Emittance::Event
+    end
+
+    def is_event_object?(identifier)
+      identifier.is_a? Emittance::Event
+    end
+
+    def coerce_identifier_type(identifier)
+      identifier.to_sym
+    end
+
+    def enabled?
+      enabled
+    end
+  end
+end

data/lib/emittance/emitter.rb

@@ -0,0 +1,107 @@
+##
+# An emitter is any object that has the power to emit an event. Extend this module in any class whose singleton or
+# instances you would like to have emit events.
+#
+# == Usage
+#
+# Whenever something warrants the emission of an event, you just need to call +#emit+ on that object. It is generally
+# a good practice for an object to emit its own events, but I'm not your mother so you can emit events from wherever
+# you want. It's probably not the best idea to do that, though. +#emit+ takes 2 params. First, it takes the identifier
+# for the event object type (which can also be the {Emittance::Event} class itself). See the "identifiers" section
+# of {Emittance::Event} for more info on this. The second argument is the payload. This is basically whatever you
+# want it to be, but you might want to standardize this on a per-event basis. The +Emittance+ will then (at this
+# time, synchronously) trigger each callback registered to listen for events of that identifier.
+#
+# +Emitter+ also provides a vanity class method that allows you to emit an event whenever a given method is called.
+# This event gets triggered whenever an instance of the class finishes executing a method. This event is emitted (and
+# therefore, all listening callbacks are triggered) between the point at which the method finishes executing and the
+# return value is passed to its invoker.
+#
+module Emittance::Emitter
+  class << self
+    # @private
+    def extended(extender)
+      Emittance::Emitter.emitter_eval(extender) do
+        include ClassAndInstanceMethods
+        extend ClassAndInstanceMethods
+      end
+    end
+
+    # @private
+    def non_emitting_method_for(method_name)
+      "_non_emitting_#{method_name}".to_sym
+    end
+
+    # @private
+    def emitting_method_event(emitter_klass, method_name)
+      Emittance::Event.event_klass_for(emitter_klass)
+    end
+
+    # @private
+    def emitter_eval(klass, *args, &blk)
+      if klass.respond_to? :class_eval
+        klass.class_eval *args, &blk
+      else
+        klass.singleton_class.class_eval *args, &blk
+      end
+    end
+  end
+
+  # Included and extended whenever {Emittance::Emitter} is extended.
+  module ClassAndInstanceMethods
+    # Emits an {Emittance::Event event object} to watchers.
+    #
+    # @param identifier [Symbol, Emittance::Event] either an explicit Event object or the identifier that can be
+    #   parsed into an Event object.
+    # @param payload [*] any additional information that might be helpful for an event's handler to have. Can be
+    #   standardized on a per-event basis by pre-defining the class associated with the
+    def emit(identifier, payload)
+      now = Time.now
+      event_klass = _event_klass_for identifier
+      event = event_klass.new(self, now, payload)
+      _send_to_broker event
+    end
+
+    private
+
+    # @private
+    def _event_klass_for(*identifiers)
+      Emittance::Event.event_klass_for *identifiers
+    end
+
+    # @private
+    def _send_to_broker(event)
+      Emittance::Broker.process_event event
+    end
+  end
+
+  # Tells the class to emit an event when a any of the given set of methods. By default, the event classes are named
+  # accordingly: If a +Foo+ object +emits_on+ +:bar+, then the event's class will be named +FooBarEvent+, and will be
+  # a subclass of +Emittance::Event+.
+  #
+  # The payload for this event will be the value returned from the method call.
+  #
+  # @param method_names [Symbol, String, Array<Symbol, String>] the methods whose calls emit an event
+  def emits_on(*method_names)
+    method_names.each do |method_name|
+      non_emitting_method = Emittance::Emitter.non_emitting_method_for method_name
+
+      Emittance::Emitter.emitter_eval(self) do
+        if method_defined?(non_emitting_method)
+          warn "Already emitting on #{method_name.inspect}"
+          return
+        end
+
+        alias_method non_emitting_method, method_name
+
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method_name}(*args, &blk)
+            return_value = #{non_emitting_method}(*args, &blk)
+            emit self.class, return_value
+            return_value
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/emittance/event/event_builder.rb

@@ -0,0 +1,74 @@
+# @private
+class Emittance::Event::EventBuilder
+  KLASS_NAME_SUFFIX = 'Event'.freeze
+
+  class << self
+    def object_to_klass(obj)
+      return obj if pass_klass_through?(obj)
+
+      klass_name = klassable_name_for obj
+      klass_name = dress_up_klass_name klass_name
+      find_or_create_event_klass klass_name
+    end
+
+    def klass_to_identifier(klass)
+      identifier_str = klass.name
+      identifier_str = undress_klass_name identifier_str
+      identifier_str = snake_case identifier_str
+
+      identifier_str.to_sym
+    end
+
+    private
+
+    def pass_klass_through?(obj)
+      obj.is_a?(Class) && obj < Emittance::Event
+    end
+
+    def klassable_name_for(obj)
+      name_str = obj.to_s
+      name_str = camel_case name_str
+      name_str = clean_up_punctuation name_str
+
+      name_str
+    end
+
+    def camel_case(str)
+      str = str.sub(/^[a-z\d]*/) { $&.capitalize }
+      str.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+    end
+
+    def snake_case(str)
+      str.gsub(/::/, '_')
+        .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+
+    def clean_up_punctuation(str)
+      str.gsub /[^A-Za-z\d]/, ''
+    end
+
+    def dress_up_klass_name(klass_name)
+      "#{klass_name}#{KLASS_NAME_SUFFIX}"
+    end
+
+    def undress_klass_name(klass_name_str)
+      klass_name_str.gsub /#{KLASS_NAME_SUFFIX}$/, ''
+    end
+
+    def find_or_create_event_klass(klass_name)
+      unless Object.const_defined? klass_name
+        create_event_klass klass_name
+      end
+
+      Object.const_get klass_name
+    end
+
+    def create_event_klass(klass_name)
+      new_klass = Class.new(Emittance::Event)
+      Object.const_set klass_name, new_klass
+    end
+  end
+end

data/lib/emittance/event.rb

@@ -0,0 +1,25 @@
+class Emittance::Event
+  class << self
+    # @return [Symbol] the identifier that can be used by the {Emittance::Broker broker} to find event handlers.
+    def identifier
+      Emittance::Event::EventBuilder.klass_to_identifier self
+    end
+
+    # @private
+    def event_klass_for(identifier)
+      Emittance::Event::EventBuilder.object_to_klass identifier
+    end
+  end
+
+  attr_reader :emitter, :timestamp, :payload
+
+  def initialize(emitter, timestamp, payload)
+    @emitter = emitter
+    @timestamp = timestamp
+    @payload = payload
+  end
+
+  def identifier
+    self.class.identifier
+  end
+end

data/lib/emittance/registration.rb

@@ -0,0 +1,13 @@
+# @private
+class Emittance::Registration
+  attr_reader :identifier
+
+  def initialize(identifier, &callback)
+    @identifier = identifier
+    @callback = callback
+  end
+
+  def call(event)
+    @callback.call event
+  end
+end

data/lib/emittance/version.rb

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

data/lib/emittance/watcher.rb

@@ -0,0 +1,9 @@
+module Emittance::Watcher
+  def watch(identifier, callback_method = nil, &callback)
+    if callback_method
+      Emittance::Broker.register_method_call identifier, self, callback_method
+    else
+      Emittance::Broker.register identifier, &callback
+    end
+  end
+end

data/lib/emittance.rb

@@ -0,0 +1,26 @@
+require 'emittance/version'
+require 'emittance/registration'
+require 'emittance/event'
+require 'emittance/event/event_builder'
+require 'emittance/emitter'
+require 'emittance/watcher'
+require 'emittance/action'
+require 'emittance/broker'
+
+module Emittance
+  class << self
+    @enabled = true
+
+    def enabled?
+      !!@enabled
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def disable
+      @enabled = false
+    end
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: emittance
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tyler Guillen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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: pry
+  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: yard
+  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: simplecov
+  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 robust and flexible eventing library for Ruby.
+email:
+- tyler@tylerguillen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec_status"
+- ".ruby-version"
+- ".yardopts"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- emittance.gemspec
+- lib/.DS_Store
+- lib/emittance.rb
+- lib/emittance/.DS_Store
+- lib/emittance/action.rb
+- lib/emittance/broker.rb
+- lib/emittance/emitter.rb
+- lib/emittance/event.rb
+- lib/emittance/event/event_builder.rb
+- lib/emittance/registration.rb
+- lib/emittance/version.rb
+- lib/emittance/watcher.rb
+homepage: https://github.com/aastronautss/emittance
+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.6.13
+signing_key: 
+specification_version: 4
+summary: A robust and flexible eventing library for Ruby.
+test_files: []