event_driven 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f700fc113b0a05226ca3483f2905312423026723
+  data.tar.gz: 2aff47b0bb76b3563b6988ca14475ddae554f458
+SHA512:
+  metadata.gz: 075c186eec05ecb0834c8c2d5ddc2aedf325f905a326ba91058f6af624afafc14dd6da19c35dd47057937febc22b31212097cd041e284486e9957449f3a2838f
+  data.tar.gz: d916097a4b2032bc9f52158c39dcc311abdee03fbd0f9db0857947b86caf32f71aa3ca87870e8587397e39f2a14152e8624905830ee3b51faf2ed3f0057fca51

data/README.md

@@ -0,0 +1,65 @@
+# EventDriven
+
+Provides a basic ruby port of Symfony's EventDispatacher component.  
+
+Eventing allows connecting two components of an application without coupling between them.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'event_driven'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install event_driven
+
+## Usage
+
+Basic event usage:
+
+```ruby
+  # Creating a custom event class
+  class PartyInvitation < EventDriven::Event
+    attr_reader :message
+    
+    def initialize(message)
+      @message = message
+    end
+  end
+  
+  # Any ruby object that implements #call can be used as a listener  
+  handler = -> (event, event_name) do
+    puts "#{event_name} - message #{event.message}" 
+  end
+  
+  # Creating a dispatcher
+  dispatcher = EventDriven::Dispatcher.new
+  
+  # Add a listener to any event name
+  dispatcher.add_listener(event_name: :party_time, listener: handler)
+  
+  # Fire an event to let other parts of the system know it happened
+  
+  party_anouncement = PartyInvitation.new("It's party time!")
+  
+  dispatcher.dispatch(event_name: :party_time, event: party_anouncement)
+```
+
+## 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/emerson-h/event_driven.
+

data/Rakefile

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

data/lib/event_driven.rb

@@ -0,0 +1,7 @@
+require 'event_driven/version'
+require 'event_driven/dispatcher'
+require 'event_driven/event'
+
+# A port of Symfony's EventDispatcher {https://github.com/symfony/event-dispatcher}
+module EventDriven
+end

data/lib/event_driven/dispatcher.rb

@@ -0,0 +1,97 @@
+module EventDriven
+  # A basic event dispatcher
+  class Dispatcher
+    attr_reader :events, :sorted_listeners
+    private :events, :sorted_listeners
+
+    def initialize
+      @events = Hash.new do |hash, event_name|
+        hash[event_name] = Hash.new do |events_by_priority, priority|
+          events_by_priority[priority] = Array.new
+        end
+      end
+      @sorted_listeners = Hash.new do |hash, event_name|
+        hash[event_name] = Array.new
+      end
+    end
+
+    # Adds a listener to a specific event
+    #
+    # @param event_name [String, Symbol] the name of the desired event
+    # @param listener [Callable] the listener to add to the event. Should implement #call, which will be invoked with
+    #   event and event_name when an event is dispatched
+    # @param priority [Fixnum] optional
+    def add_listener(event_name:, listener:, priority: 0)
+      events[event_name][priority] << listener
+      update_sorted_listeners(event_name)
+    end
+
+
+    # Does an event have any listeners
+    #
+    # @param event_name [String, Symbol] the name of the desired event
+    #
+    # @return [Boolean] true if there are listeners
+    def listeners_for?(event_name)
+      events[event_name].any? do |events_by_priority|
+        events_by_priority.length > 0
+      end
+    end
+
+    # Get the priority a listener has for a given event name
+    #
+    # @param event_name [String, Symbol] the name of the desired event
+    # @param listener [Callable] the desired listener
+    #
+    # @return [Fixnum, nil] returns the priority or nil if the listener is not subscribed to the event
+    def priority(event_name:, listener:)
+      prioritized_events = events[event_name]
+      prioritized_events.each_pair do |priority, listeners|
+        return priority if listeners.include?(listener)
+      end
+    end
+
+    # Dispatches the passed event to all subscribed listeners in priority order
+    #
+    # @param event_name [String, Symbol] the name of the event being dispatched
+    # @param event [EventDriven::Event] the event to dispatch along with the name
+    #
+    # @return [void]
+    def dispatch(event_name:, event: EventDriven::Event.new)
+      listeners_for(event_name).each do |listener|
+        listener.call(event, event_name) unless event.stopped?
+      end
+    end
+
+    # All of the listeners for the passed event name
+    #
+    # @param event_name [String, Symbol] the name of the desired event
+    #
+    # @return [Array<Callable>] the listeners for the provided event sorted by priority
+    def listeners_for(event_name)
+      unless sorted_listeners.has_key?(event_name)
+        update_sorted_listeners(event_name)
+      end
+      sorted_listeners[event_name]
+    end
+
+    # Removes a listener from a specified event name
+    #
+    # @param event_name [String, Symbol] the name of the desired event
+    # @param listener [Callable] the listener to remove
+    #
+    # @return [void]
+    def remove_listener(event_name:, listener:)
+      events[event_name].each_value do |listeners|
+        listeners.delete(listener)
+      end
+      update_sorted_listeners(event_name)
+    end
+
+    private def update_sorted_listeners(event_name)
+      sorted_listeners.delete(event_name)
+      sorted_pair_iterator = events[event_name].each_pair.sort { |pair_a, pair_b| -pair_a[0] <=> -pair_b[0] }
+      sorted_listeners[event_name] = sorted_pair_iterator.map { |priority_listeners_list| priority_listeners_list[1..-1] }.flatten
+    end
+  end
+end

data/lib/event_driven/event.rb

@@ -0,0 +1,18 @@
+module EventDriven
+  # The most basic event. Does not store information, but allows clients to stop propagation
+  class Event
+    # Stops the event from being sent to other listeners
+    #
+    # @return [void]
+    def stop_propagation
+      @stopped = true
+    end
+
+    # Whether the event has been stopped
+    #
+    # @return [Boolean] true if the event was stopped
+    def stopped?
+      !!@stopped
+    end
+  end
+end

data/lib/event_driven/version.rb

@@ -0,0 +1,3 @@
+module EventDriven
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: event_driven
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Emerson Huitt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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'
+description: Provides a dispatch system, a basic event class, and a basic listener
+  implementation
+email:
+- emerson.huitt@scimedsolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/event_driven.rb
+- lib/event_driven/dispatcher.rb
+- lib/event_driven/event.rb
+- lib/event_driven/version.rb
+homepage: https://github.com/emerson-h
+licenses: []
+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.2.2
+signing_key: 
+specification_version: 4
+summary: EventDriven is a port of symfony/event-dispatcher, and provides a set of
+  tools for interacting with events in a system
+test_files: []