event_object 0.9.4 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e81c485937d85b0c9cd88b13cac0567f4aa0e03f
-  data.tar.gz: 7ce74e45fd9f99329ffb8db70cf1c1852027307a
+  metadata.gz: efb92fc3d9f1021bb0cadb829e71023c737f62be
+  data.tar.gz: 6fb27e337868fc9fce74306554abab0138db5ab0
 SHA512:
-  metadata.gz: 76a40e1cdc625aea5a08916da033eb5cc600a2b0255f9f1d84914baf57263e0fa6b0beb2c61e641d80ade7469ab5c2027f5de70d25da3e6d1a1140868b4a56bf
-  data.tar.gz: 2956ba950da83365cef180a7788e02b6eeb0ffa93003dcb7a8b97cc144bdbf21043c42728cb1011d80e97a78d7d471dd6a828d2e3c47632af6c21e554f65a1d7
+  metadata.gz: 2b605073d048a3bffae93301ef440af33ae94e3d3f81295e2755bb2b02490fef53a45823bbcf6d0257b7167a9431f4cc2ce3e2a4c1838a695604674c0b176a4b
+  data.tar.gz: 5e7ee0daed6aba4e270252a1c07e91b4154e825cdcd7f91b7d9523d373a149084a8b19e38c33997794d19c1d088f665d54c8487016ba79b2c5867be1a3d580da

data/LICENSE.txt

@@ -1,22 +1,21 @@
-Copyright (c) 2014 che
+The MIT License (MIT)
 
-MIT License
+Copyright (c) 2014-2016 Maksim V. <inre.storm@gmail.com>
 
-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:
+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 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.
+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

@@ -2,33 +2,59 @@
 
 EventObject - event-driven programming for ruby
 
-## Installation
+Минималистичность кода, простота использования, нету излишнего кода...
+Данных гем поможет обеспечить простой способ поддержики событий для руби объектов. Так же имеет
+простой синтаксис иницилизации и вызова событий.
 
-Add this line to your application's Gemfile:
+## Array refines
 
-```ruby
-gem 'event_object'
-```
+Событие представляет собой ruby array.
 
-And then execute:
+Простой пример:
 
-    $ bundle
+```ruby
+using EventObject
+event = [lambda { 'BEGIN' }, lambda { 'END' }]
+p event.fire
+# ["BEGIN", "END"]
+```
 
-Or install it yourself as:
+В примере мы запустили все события в фиксированном контексте, однако мы можем изменить контекст на другой
+с помощью метода instance_fire
 
-    $ gem install event_object
+## Class refines
 
-## Usage
+Позволяют легко создавать события в объекте
 
 ```ruby
-using EventObject
 class EventEmitter
+  using Emmy
   events :success, :error
 end
+```
 
+## Object refines
+
+```ruby
 emitter = EventEmitter.new
 emitter.on :success do
   [200, {}, "OK"]
 end
 p emitter.success!
 ```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'event_object'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install event_object

data/event_object.gemspec

@@ -4,24 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'event_object/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "event_object"
+  spec.name          = 'event_object'
   spec.version       = EventObject::VERSION
-  spec.authors       = ["che"]
-  spec.email         = ["chelovekov@gmail.com"]
-  spec.summary       = %q{EventObject - do ruby object to be event-driven }
-  #spec.description   = %q{TODO: Write a longer description. Optional.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Maksim V.']
+  spec.email         = ['inre.storm@gmail.com']
+  spec.summary       = %q{Event-driven programming for ruby}
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/inre/event_object'
+  spec.license       = 'MIT'
 
-  spec.required_ruby_version     = '>= 2.0.0'
+  spec.required_ruby_version     = '>= 2.1.0'
   spec.required_rubygems_version = '>= 2.3.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.6"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency 'bundler', "~> 1.6"
+  spec.add_development_dependency 'rake', "~> 10.0"
+  spec.add_development_dependency 'rspec', "~> 3.3.0"
 end

data/lib/event_object/array.rb

@@ -1,21 +1,41 @@
 module EventObject
   refine Array do
-    # array like event
+    # Emit event with specified arguments and specified block.
+    #
+    # @example
+    #    using EventObject
+    #    event = [() -> 1, () -> 2]
+    #    p event.fire
+    #    # [1, 2]
+    #
+    # @param *a [...] arguments to be passed
+    # @param &b [Block] block to be passed
+    # @return [Array] the results of the call
     def fire(*a, &b)
-      dup.collect { |h| h.call(*a, &b) }
+      dup.map { |h| h.call(*a, &b) }
     end
+    alias emit fire
 
-    # run events consecutive
-    def chain(a)
-      dup.inject(a) { |a, c| c.call(a) }
+    # Emit event with specified arguments within the context. It's giving the each listener
+    # access to object intance variables. Unlike fire, the block is not allowed.
+    #
+    # @param context [Object] the context of the receiver
+    # @return [Array]
+    def instance_fire(context, *a)
+      dup.map { |h| context.instance_exec(*a, &h) }
     end
 
-    def fire_for(t, *a)
-      dup.collect { |h| t.instance_exec(*a, &h) }
-    end
-
-    def off(proc=nil)
-      (proc) ? delete(proc) : clear
+    # Removes the specified listener from the array. If no arguments are supplied then
+    # all listeners will be removed.
+    #
+    # @example
+    #   events = [() -> 1, () -> 2]
+    #   events.off
+    #
+    # @param listener [Proc] listener or nil
+    # @return [Proc, Array] listener or nil or array of listeners
+    def off(listener=nil)
+      listener ? delete(listener) : clear
     end
   end
 end

data/lib/event_object/class.rb

@@ -1,21 +1,32 @@
 module EventObject
   refine Class do
-    def def(met, &b)
-      define_method met, &b
-    end
-
-    def cdef(met, &b)
-      define_singleton_method met, &b
+    # Create events in specified class. For each event we create two methods:
+    # `event` and `event!`. `event` returns an array of event listeners. `event!` emits
+    # the listeners.
+    #
+    # @param [Array] the array of the symbols
+    # @return [Symbol]
+    def events(*ev)
+      ev.each { |name| self.def("#{name}!") { |*a, &b| var(name, Array).fire(*a, &b) } }
+      ev.map { |name| self.def(name) { var(name, Array) } }
     end
 
-    def events(*ev)
-      ev.each { |name| self.def(name) { var(name, Array) } }
-      ev.each { |name| self.def("#{name}!") { |*a| var(name, Array).fire(*a) } }
+    # Define an instance method. `def` is public method.
+    #
+    # @param [Symbol]
+    # @return [Symbol]
+    def def(symbol, &b)
+      define_method symbol, &b
     end
 
-    def var(name, init=nil)
-    	key = "@#{name}"
-      class_variable_defined?(key) ? class_variable_get(key) : class_variable_set(key, (init.is_a?(Class) ? init.new : init))
+    # Get a class variable. If the variable is undefined then the variable will be initialized.
+    #
+    # @param symbol [Symbol] the name of the variable
+    # @param init [...] default value
+    # @return [...] the value
+    def var(symbol, init=nil)
+      class_variable_defined?(sym = "@#{symbol}") ? class_variable_get(sym) :
+      class_variable_set(sym, (init.is_a?(Class) ? init.new : init))
     end
   end
 end

data/lib/event_object/nil_class.rb

@@ -1,11 +1,17 @@
 module EventObject
   refine NilClass do
+
+    # if event missing it does nothing
     def fire(*a)
       []
     end
 
-    def fire_for(t, *a)
+    def instance_fire(t, *a)
       []
     end
+
+    def off(listener=nil)
+      nil
+    end
   end
 end

data/lib/event_object/object.rb

@@ -1,42 +1,91 @@
 module EventObject
   refine Object do
-    def def(method, &b)
-      define_singleton_method method, &b
-    end
 
-    def var(name, init=nil)
-      instance_variable_get("@#{name}") || instance_variable_set("@#{name}", (init.is_a?(Class) ? init.new : init))
+    # Add the `listener` block for the specified `event`. `on` calls can be chained.
+    #
+    # @example
+    #    class EventEmitter
+    #      using Emmy
+    #      events :success, :error
+    #    end
+    #    emitter = EventEmitter.new
+    #    emitter.on :success do
+    #      [200, {}, "OK"]
+    #    end
+    #    p emitter.success!
+    #
+    # @param event [Symbol]
+    # @param listener [Proc]
+    # @param block [Block]
+    # @return [Proc]
+    def on(event, listener=nil, &block)
+      var(event, Array).tap { |e| e << (listener || block) }; (listener || block)
     end
 
-    def on(name, bb=nil, &b)
-      var(name, Array).tap { |e| e << (bb || b) }; (bb || b)
+    # Add the `listener` block for the specified `event`. When event happened `listener` will be removed.
+    #
+    # @param event
+    # @param listener
+    # @param block
+    # @return [Proc]
+    def once(event, listener=nil, &block)
+      (ev = nil).tap { |ev|
+        var(event, Array).tap { |e| e << (ev = ->(*a) { (listener || block).call(*a); e.delete(ev) }) }
+      }
     end
 
+    # Remove events depending on the argument counts.
     #
-    # obj.off(:ev)
-    # obj.off(:ev, proc)
-    # obj.off(:ev, target, :meth)
-    def off(*a)
-      case a.size
-      when 1 then var(a[0], Array).clear
-      when 2 then var(a[0], Array).tap { |e| e.delete a[1] }
-      when 3 then var(a[0], Array).tap { |e| e.delete a[1].method(a[2]) }
+    # @example
+    #   obj.off(:event)             # Remove all event listensers for the specified `event`
+    #   obj.off(:event, proc)       # Remove an event listener
+    #   obj.off(:ev, object, :meth)
+    # @param args [...]
+    # @return []
+    def off(*args)
+      case args.size
+      when 1 then var(args[0], Array).clear
+      when 2 then var(args[0], Array).delete(args[1])
+      when 3 then var(args[0], Array).delete(args[1].method(args[2]))
+      else
+        raise "too many arguments"
       end
       self
     end
 
-    def once(name, &b)
-      (ev = nil).tap { |ev|
-        var(name, Array).tap { |e| e << (ev = ->() { b.call; e.delete(ev) }) }
-      }
+    # Add the `instance` method with `name` like block for the specified event.
+    #
+    # @param instance [Object]
+    # @param event [Symbol]
+    # @param name [Symbol]
+    # @return []
+    def listen(instance, event, name)
+      instance.on event, method(name)
     end
 
-    def listen(target, ev, meth)
-      target.on ev, method(meth)
+    # Remove all listeners being methods of the `instance`.
+    #
+    # @param []
+    # @return []
+    def stop_listen(instance, event)
+      instance.var(event, Array).delete_if { |e| e.is_a?(Method) && e.receiver == self }
     end
 
-    def stop_listen(target, ev)
-      target.var(ev, Array).delete_if { |e| e.is_a?(Method) && e.receiver == self }
+    # Define an instance method. The method will be appeared only in this instance.
+    #
+    # @param symbol [Symbol]
+    # @return [Symbol]
+    def def(symbol, &b)
+      define_singleton_method symbol, &b
+    end
+
+    # Get an instance variable. If the variable is undefined then the variable will be initialized.
+    #
+    # @param symbol [Symbol]
+    # @param init [...]
+    # @return [Symbol]
+    def var(symbol, init=nil)
+      instance_variable_get(sym = "@#{symbol}") || instance_variable_set(sym, (init.is_a?(Class) ? init.new : init))
     end
   end
 end

data/lib/event_object/version.rb

@@ -1,3 +1,3 @@
 module EventObject
-  VERSION = "0.9.4"
+  VERSION = '1.0'
 end

data/spec/array_nil_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe EventObject do
+  using EventObject
+
+  it "creates an array of events" do
+    events = []
+    listener   = lambda { :result }
+    events.push listener
+    events_with_arguments = []
+    events_with_arguments.push lambda { |num| num+1 }
+
+    expect(events.fire.last).to be(:result)
+    expect(events.instance_fire(self).last).to be(:result)
+    expect(events_with_arguments.fire(5).last).to be(6)
+
+    events.off(listener)
+    expect(events).to be_empty
+  end
+
+  it "fires NilClass methods" do
+    expect(nil.fire).to eq([])
+    expect(nil.instance_fire(self)).to eq([])
+  end
+
+  it "creates events and fires it" do
+    emitter = EventEmitter.new
+    emitter.on :success do
+      18
+    end
+    emitter.on :success do
+      42
+    end
+
+    expect(emitter.success!).to eq([18,42])
+    expect(emitter.success.fire).to eq([18,42])
+    expect(emitter.error).to be_empty
+    expect(emitter.error.fire).to be_empty
+  end
+
+=begin
+  DEPRECATED
+  it "makes event chain" do
+    emitter = EventEmitter.new
+    emitter.on :data do |chunk|
+      chunk + " world"
+    end
+    emitter.on :data do |chunk|
+      chunk + "!!!"
+    end
+
+    data =  emitter.data.chain('Hello')
+
+    expect(data).to eq('Hello world!!!')
+  end
+=end
+end

data/spec/class_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe EventObject do
+  using EventObject
+
+  it "defines the instance method for the specified class" do
+    expect {
+      klass = Class.new
+      klass.def :foo do
+        1
+      end
+      obj = klass.new
+      expect(obj.foo).to be 1
+    }.to_not raise_error
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe EventObject do
+  using EventObject
+
+  class EventEmitter
+    events :success, :error, :data
+  end
+
+  class ParentObject
+    def ok
+      'OK'
+    end
+  end
+
+
+  # dup required in fires
+  it "adds event to event" do
+    emitter = EventEmitter.new
+    counter = 0
+    emitter.on :success do
+      counter += 1
+      emitter.on :success do
+        counter += 1
+      end
+    end
+
+    emitter.success!
+
+    expect(counter).to be 1
+  end
+
+  it "adds instance method like listener to an event" do
+    emitter = EventEmitter.new
+    obj = ParentObject.new
+    obj.listen(emitter, :success, :ok)
+    expect(emitter.success!.last).to eq 'OK'
+
+    emitter.off(:success, obj, :ok)
+    expect(emitter.success!).to be_empty
+  end
+
+  it "stops listen event" do
+    emitter = EventEmitter.new
+    obj = ParentObject.new
+    obj.listen(emitter, :success, :ok)
+    expect(emitter.success!.last).to eq 'OK'
+
+    obj.stop_listen(emitter, :success)
+    expect(emitter.success!).to be_empty
+  end
+
+  it "defines singleton method" do
+    expect {
+      object = Object.new
+      object.def :foo do
+        1
+      end
+      expect(object.foo).to be 1
+    }.to_not raise_error
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_object
 version: !ruby/object:Gem::Version
-  version: 0.9.4
+  version: '1.0'
 platform: ruby
 authors:
-- che
+- Maksim V.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2016-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,17 +44,17 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.0
-description: 
+        version: 3.3.0
+description: Event-driven programming for ruby
 email:
-- chelovekov@gmail.com
+- inre.storm@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -71,9 +71,11 @@ files:
 - lib/event_object/nil_class.rb
 - lib/event_object/object.rb
 - lib/event_object/version.rb
-- spec/event_object_spec.rb
+- spec/array_nil_spec.rb
+- spec/class_spec.rb
+- spec/object_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/inre/event_object
 licenses:
 - MIT
 metadata: {}
@@ -85,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -93,10 +95,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 2.3.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: EventObject - do ruby object to be event-driven
+summary: Event-driven programming for ruby
 test_files:
-- spec/event_object_spec.rb
+- spec/array_nil_spec.rb
+- spec/class_spec.rb
+- spec/object_spec.rb
 - spec/spec_helper.rb

data/spec/event_object_spec.rb

@@ -1,110 +0,0 @@
-require "spec_helper"
-
-describe EventObject do
-  using EventObject
-
-  class EventEmitter
-    events :success, :error, :data
-  end
-
-  class ParentObject
-    def ok
-      'OK'
-    end
-  end
-
-  it "should create array of events" do
-    events = []
-    proc   = lambda { :result }
-    events.push proc
-    events_with_arguments = []
-    events_with_arguments.push lambda { |num| num+1 }
-
-    expect(events.fire.last).to be(:result)
-    expect(events.fire_for(self).last).to be(:result)
-    expect(events_with_arguments.fire(5).last).to be(6)
-
-    events.off(proc)
-    expect(events).to be_empty
-  end
-
-  it "should NilClass has fire" do
-    expect(nil.fire).to eq([])
-    expect(nil.fire_for(self)).to eq([])
-  end
-
-  it "should create events and fire them" do
-    emitter = EventEmitter.new
-    emitter.on :success do
-      18
-    end
-    emitter.on :success do
-      42
-    end
-
-    expect(emitter.success!).to eq([18,42])
-    expect(emitter.success.fire).to eq([18,42])
-    expect(emitter.error).to be_empty
-    expect(emitter.error.fire).to be_empty
-  end
-
-  # dup required in fires
-  it "add event in event" do
-    emitter = EventEmitter.new
-    counter = 0
-    emitter.on :success do
-      counter += 1
-      emitter.on :success do
-        counter += 1
-      end
-    end
-
-    emitter.success!
-
-    expect(counter).to be 1
-  end
-
-  it "listen other object" do
-    emitter = EventEmitter.new
-    obj = ParentObject.new
-    obj.listen(emitter, :success, :ok)
-    expect(emitter.success!.last).to eq 'OK'
-
-    emitter.off(:success, obj, :ok)
-    expect(emitter.success!).to be_empty
-  end
-
-  it "stop listen" do
-    emitter = EventEmitter.new
-    obj = ParentObject.new
-    obj.listen(emitter, :success, :ok)
-    expect(emitter.success!.last).to eq 'OK'
-
-    obj.stop_listen(emitter, :success)
-    expect(emitter.success!).to be_empty
-  end
-
-  it "events chain" do
-    emitter = EventEmitter.new
-    emitter.on :data do |chunk|
-      chunk + " world"
-    end
-    emitter.on :data do |chunk|
-      chunk + "!!!"
-    end
-
-    data =  emitter.data.chain('Hello')
-
-    expect(data).to eq('Hello world!!!')
-  end
-
-  it "define singleton method" do
-    expect {
-      object = Object.new
-      object.def :foo do
-        1
-      end
-      expect(object.foo).to be 1
-    }.to_not raise_error
-  end
-end