eva 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Davide D'Agostino
+
+MIT License
+
+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,234 @@
+# Eva
+
+Eva is an effortless event driven micro framework that runs on Ruby (cruby and jruby) through
+[eventmachine](http://eventmachine.rubyforge.org) with a different **syntax**.
+
+The common problem with *EventMachine* is to deal with callbacks, fortunately thanks to
+people like [Ilya Grigorik](https://github.com/igrigorik) and `things`
+like [em-synchrony](https://github.com/igrigorik/em-synchrony) make this job is a little simpler but
+a bit far to be _native_ like in `javascript`.
+
+So here my idea to make **experiment** and try to figure out a new way to write better our applications
+following the nature of the reactor pattern with a special focus on **simplicity** and **clearity**.
+
+
+## Overview
+
+It's **pure ruby**, no lexers and parsers. If you want a fast tast on how it looks like, 
+please see [emitter](https://github.com/DAddYE/eva/blob/master/lib/eva/emitter.rb)
+
+The _idea_ behind it is to build all our apps only using two ruby objects: `namespaces` and `objectspace`
+
+Like in languages like `javascript` or `lua` if we have:
+
+```js
+var hello = function(){ console.log('Hello!') }
+```
+
+in order to invoke our function we should use `hello()` otherwise using only `hello` we will get
+the `Function` object.
+
+In that way is simple to chain functions and do things like:
+
+```js
+var callback = function(obj){ Notifier.sendEmail(obj) }
+doExpensiveTask(var1, var2, callback)
+```
+
+So I applied the same rule on Ruby:
+
+_unless you don't provide method arguments, invoking a method will get a Method Object instead of the result of the method itself_
+
+Here an example:
+
+```rb
+namespace :Greater,
+  say: ->(text) { p text }
+
+Greater.say 'Hello World!'
+=> "Hello World!"
+
+Greater.say
+=> #<Method: Module(Greater)#say!>
+```
+
+The main difference is that using `objectspace` and `namespace` we create
+*unbounded* methods, we can still call directly these methods but appending ! (bang) prefix
+or using [] or using .call
+
+```rb
+Greater.say[]
+Greater.say!
+Greater.say.call
+```
+
+So where this can help us?
+
+Look a the following examples:
+
+```rb
+namespace :Circle,
+  area: ->(n) do
+    Math::PI * n * n
+  end,
+
+  big_calc: -> do
+    perform_a_big_calc
+  end
+
+LotOfNumbers.each &Circle.area
+defer Circle.big_calc
+set_timeout 10, Circle.big_calc
+```
+
+## Namespaces
+
+Namespaces are simply module **functions** a namespace looks like:
+
+```rb
+namespace :Greater,
+  say: ->(text) { p [:say, text] }
+```
+
+You can extend it from another place simply invoking it:
+
+```rb
+namespace :Greater,
+  say_hello: -> do
+    say 'Hello There!'
+  end
+```
+
+Remember that it's ruby so you can include extend other objects like:
+
+```rb
+module OldModule
+  include Greater
+end
+```
+
+Since is a module **function** remember you can invoke methods directly:
+
+```rb
+Greater.say 'Hello World'
+Greater.say_hello! # <<<<< REMBEMBER THAT IF WE DON'T HAVE ARGUMENT TO ADD A ! or []
+```
+
+## Objectspace
+
+Are exactly ruby classes with no exception and the structure is identical to the module
+
+```rb
+objectspace :Greater,
+  say: ->(text){ p [:say, text] }
+```
+
+Also here we can add other methods whenever and wherever we want:
+
+```rb
+namespace :Greater,
+  say_hello: -> do
+    say 'Hello There!'
+  end
+```
+
+So now we can create our Object:
+
+```rb
+greater = Greater.new
+greater.say 'Hello world'
+greater.say_hello! # <<<<< REMBEMBER THAT IF WE DON'T HAVE ARGUMENT TO ADD A ! or []
+```
+
+## Constructors, Private Methods, Attributes ...
+
+In **eva** there are some special _keys_:
+
+* `initialize`: used only for **objects**
+* `include`: to include a module
+* `extend`: to extend an object with the given module
+* `attr_reader, attr_writer, attr_accessor, attr`: to create attributes for **objects** and **spaces**
+* `alias_method`
+
+Finally if you need to create `private` methods you can do that only prefixing with `_`
+
+Example:
+
+```rb
+objectspace :Tester,
+  attr_reader: [:a, :b, :c],
+  attr_writer: [:d, :e, :f],
+  attr_accessor: [:g, :h, :i],
+  initialize: -> do
+    @a, @b, @c = 1, 2, 3
+    f = foo
+    say
+  end,
+  foo: -> { p [:alias, :bar] },
+  alias_method: { :bar => :foo },
+  say: MyMod.say, # this is a delegate
+
+Tester.new
+```
+
+## Evented
+
+As mentioned before, the aim of this project is _play nice_ with [eventmachine](http://eventmachine.rubyforge.org),
+so in _eva_ we extended the main **Object** with few and useful `delegator`:
+
+```rb
+:add_periodic_timer, :add_timer, :add_shutdown_hook, :cancel_timer,
+:defer, :defers_finished?, :fork_reactor, :next_tick,
+:popen, :reactor_running?, :reactor_thread?,
+:schedule, :spawn, :system, :tick_loop
+```
+
+and few aliases:
+
+```rb
+alias :set_interval   :add_periodic_timer
+alias :set_timeout    :add_timer
+alias :clear_interval :cancel_timer
+alias :clear_timeout  :cancel_timer
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eva'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eva
+
+## Usage
+
+You can use `eva` syntax in all your projects simply requiring it, if you plan to use `evented` code
+so `set_timeout, defer ...` you should use `eva` executable:
+
+```sh
+eva examples/timers.rb
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+# Copyright
+
+Copyright (C) 2013 Davide D'Agostino - @DAddYE
+
+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 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/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/benchmark/area.rb

@@ -0,0 +1,24 @@
+require 'bundler/setup'
+require 'benchmark'
+
+namespace :Circle,
+  area: ->(n) do
+    Math::PI * n * n
+  end,
+
+  circumference: ->(n) do
+    Math::PI * n * 2
+  end
+
+TEST = 10_000_000.times.map { rand(100_000..1_000_000) }
+
+Benchmark.bm(15) do |x|
+  x.report('area normal:') { TEST.each { |n| Circle.area(n) } }
+  x.report('area eva:')   { TEST.each(&Circle.area) }
+end
+
+# Results:
+#
+#   user     system      total        real
+#   area normal:     16.940000   0.000000  16.940000 ( 16.947472)
+#   area eva:        6.300000   0.000000   6.300000 (  6.306686)

data/benchmark/fib.rb

@@ -0,0 +1,12 @@
+require 'bundler/setup'
+require 'eva'
+require 'benchmark'
+
+namespace :Fib,
+  calc: ->(n) do
+    n < 2 ? 1 : calc(n-2) + calc(n-1)
+  end
+
+Benchmark.measure do
+  p Fib.calc(35)
+end

data/bin/eva

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path('../../lib', __FILE__)
+require 'eva'
+
+abort 'Please provide a program to run' unless ARGV[0]
+
+Eva.run do
+  require File.expand_path ARGV[0]
+  checker = set_interval 0.123 do
+    timers = schedule { Eva.timers.reject { |k,v| v == checker } }
+    Eva.stop if timers.size.zero? && Eva.defers_finished?
+  end
+end

data/eva.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eva/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'eva'
+  gem.version       = Eva::VERSION
+  gem.authors       = ['DAddYE']
+  gem.email         = ['info@daddye.it']
+  gem.summary       = 'Effortless event driven micro framework with a tasty syntax'
+  gem.description   = gem.summary
+  gem.homepage      = 'https://github.com/DAddYE/eva'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'eventmachine', '~>1.0.0'
+end

data/example/basic.rb

@@ -0,0 +1,140 @@
+require 'bundler/setup'
+require 'eva'
+
+# The first difference is that namespace returns
+# a module function.
+#
+# The second main difference is that using
+# objectspace and namespace we create
+# *unbounded* methods, we can still call
+# directly these methods but appending ! (bang)
+# or using [] or using .call
+#
+#   # Examples:
+#   Greater.say[]
+#   Greater.say!
+#   Greater.say.call
+#   Greater.say # => method(:say!)
+#
+# But if we provide arguments this is not necessary
+#
+#   Greater.say 'Foo'
+#   # is equal to
+#   Greater.say! 'Foo'
+#
+# This patternis well know in javascript where having:
+#
+#   function myFunction(){ doSome }
+#
+# you should *always* call it with parenthesis if not:
+#
+#   a = myFunction
+#   # will returns: [Function: MyFunction]
+#
+# This pattern, applied with eventmachine, enumerator, callbacks
+# etc opens the doors to method chainability and fun stuff ;)
+#
+# Private methods starts with underscore:
+#
+#   namespace :Foo,
+#     im_public: -> {}
+#     _im_private: -> {}
+#
+# You can also use module methods like:
+#
+# * attr
+# * attr_reader
+# * attr_writer
+# * attr_accessor
+# * alias_method
+# * alias
+#
+
+##
+# Namespaces
+#
+namespace :Greater,
+  say: ->(text) { p [:say, text] }
+
+# If we have params
+Greater.say 'Hey'
+
+# if we want we can add methods
+# to that module space ... also **private**
+namespace :Greater,
+  hello: -> { say! 'Hello from Greater!!' },
+  _not_public: -> {}
+
+Greater.hello!
+Greater.not_public! rescue p([:not_public, 'is private'])
+
+##
+# Classes
+#
+objectspace :Foo,
+  say: ->(text){ p [:say, text] }
+
+# we can add methods whenever we want
+objectspace :Foo,
+  initialize: -> { say! 'Hello from Foo!!' }
+  # initialize, include and extend ATM are reserved words so (no-bang)
+  # include: Mod # works too
+  # extend: Mod  # will works too (if we were in a module)
+
+Foo.new
+
+# we can inherit classes
+objectspace :Bar => Foo,
+  hello: -> { say! 'Hello from Bar!!' }
+
+Bar.new.hello!
+#.new will greet Foo and then Bar
+
+# We can include namespace in other modules
+module MyMod
+  include Greater
+end
+
+MyMod.say! 'Hello from MyMod!!'
+
+# And so also in classes
+class MyClass
+  include Greater
+end
+
+MyClass.new.say! 'Hello from MyClass!!'
+
+##
+# Aliases, Delegate && Attributes
+#
+namespace :Aliases,
+  attr_reader: [:a, :b, :c],
+  attr_writer: [:d, :e, :f],
+  attr_accessor: [:g, :h, :i],
+  foo: -> { p [:alias, :bar] },
+  alias_method: { :bar => :foo },
+  say: MyMod.say, # this is a delegate
+  assert: -> {
+    @a, @b, @c = 1, 2, 3
+    say a
+    say b
+    say c
+    self.d, self.e, self.f = 4, 5, 6
+    say @d
+    say @e
+    say @f
+    @g, @h, @i = 7, 8, 9
+    say g
+    say h
+    say i
+    self.g, self.h, self.i = 10, 11, 12
+    say @g
+    say @h
+    say @i
+    say :finish
+  }
+
+Aliases.say 'Hello Aliases !!!'
+Aliases.foo!
+Aliases.assert!
+p [:attr, :are_public, Aliases.i]

data/example/emitter.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+require 'eva'
+
+objectspace Server: Eva::Emitter,
+  initialize: -> {}

data/example/timers.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'eva'
+
+namespace :Timer,
+  init: -> {
+    @sid = set_interval(1, say_hello)
+    set_timeout(4,  quit)
+  },
+  say_hello: -> {
+    puts 'Hello World'
+  },
+  quit: -> {
+    puts 'Bye...'
+    clear_interval @sid
+  }
+
+puts 'Starting ...'
+Timer.init!

data/lib/eva.rb

@@ -0,0 +1,17 @@
+require 'eventmachine'
+
+# Bad things here, but EM doesn't support include/extend
+# in any way know to me
+Object.send :remove_const, :Eva if defined?(Eva)
+Eva = EventMachine
+Eva.send :remove_const, :VERSION
+
+require 'eva/version'
+require 'eva/space'
+require 'eva/ext/object'
+require 'eva/emitter'
+
+module Eva
+  extend self
+  attr_reader :timers
+end

data/lib/eva/emitter.rb

@@ -0,0 +1,68 @@
+##
+# Rif.: http://nodejs.org/api/events.html
+#
+module Eva
+  #
+  # A convenience class for object that needs to
+  # emit or subscribe events, like servers or files
+  #
+  objectspace :Emitter,
+    #
+    # @example:
+    #
+    #   emitter = Emitter.new
+    #   emitter.emit 'connected', user
+    #   client.on 'connected', ->(user) { p [:connected, user] }
+    #
+    initialize: -> do
+      @channels = Hash.new { |h, k| h[k] = [] }
+      @uid = 0
+    end,
+    #
+    # @example:
+    #
+    #   callback = ->(stream) { puts 'someone connected' }
+    #   server.on 'data', cb
+    #   # or
+    #   server.on('data') do |stream|
+    #     puts 'Someone connected'
+    #   end
+    #
+    on: ->(event, &block) do
+      id = gen_id
+      @channel[event] << { id => block }
+      id
+    end,
+    #
+    # @example:
+    #
+    #   callback = -> (stream) { puts 'someone connected' }
+    #   sid = server.on 'connection', callback
+    #   server.off 'connection', callback
+    #   # or
+    #   server.off 'connection', sid
+    #
+    off: ->(event, id) do
+      @channel[event].delete_if { |k, v| [k, v].include?(id) }
+    end,
+    #
+    # Removes all subscribers of a given event
+    #
+    off_all: ->(id) do
+      @channel[event] = []
+    end,
+    #
+    # @example:
+    #
+    #   emitter = Emitter.new
+    #   emitter.emit 'connected', user
+    #
+    emit: ->(event, data) do
+      next_tick do
+        @channel[event].each { |id, block| block[data] }
+      end
+    end,
+    #
+    # @private
+    _gen_id: -> { @uid += 1 }
+end

data/lib/eva/ext/object.rb

@@ -0,0 +1,17 @@
+class Object
+  include Eva::Space
+
+  [
+    :add_periodic_timer, :add_timer, :add_shutdown_hook, :cancel_timer,
+    :defer, :defers_finished?, :fork_reactor, :next_tick,
+    :popen, :reactor_running?, :reactor_thread?,
+    :schedule, :spawn, :system, :tick_loop
+  ].each do |name|
+    define_method(name) { |*args, &block| Eva.send(name, *args, &block) }
+  end
+
+  alias :set_interval   :add_periodic_timer
+  alias :set_timeout    :add_timer
+  alias :clear_interval :cancel_timer
+  alias :clear_timeout  :cancel_timer
+end

data/lib/eva/space.rb

@@ -0,0 +1,91 @@
+module Eva
+
+  class EvaObject
+  end
+
+  module Space
+
+    def namespace(name, methods={})
+      mod = gen_const(name, Module.new)
+      mod.extend mod
+      mod.extend ClassMethods
+      methods.each { |name, block| gen_methods(mod, name, block) }
+      mod
+    end
+
+    def objectspace(name, methods={})
+      if Hash === name
+        (name, superclass), *methods = *name.to_a
+      else
+        superclass = EvaObject
+      end
+
+      klass = gen_const(name, Class.new(superclass))
+      methods.each { |name, block| gen_methods(klass, name, block) }
+      klass
+    end
+
+    module ClassMethods
+      def included(base)
+        base.extend(base) if base.class == Module
+        super
+      end
+    end
+
+    private
+    def gen_methods(obj, name, block)
+      name = name.to_s
+
+      case name
+      when 'attr'
+        obj.send(:attr, *block)
+      when 'attr_reader'
+        obj.send(:attr_reader, *block)
+      when 'attr_writer'
+        obj.send(:attr_writer, *block)
+      when 'attr_accessor'
+        obj.send(:attr_accessor, *block)
+      when 'alias', 'alias_method'
+        block.each { |k,v| obj.send(:alias_method, k, v) }
+      else
+        is_private = name.start_with?('_')
+        name.sub!(/^_/, '') if is_private
+
+        bang = %w[include extend initialize].include?(name.to_s) ? name : "#{name}!"
+
+        block.respond_to?(:to_proc) ?
+          obj.send(:define_method, bang, &block) :
+          obj.send(:define_method, bang){ block }
+
+        return if bang == name
+
+        if Class === obj
+          method = obj.instance_method(bang)
+          obj.send(:define_method, name) do |*a, &b|
+            return send(bang, *a, &b) if b || a.any?
+            method.bind(self)
+          end
+        else
+          method = obj.method(bang)
+          obj.send(:define_method, name) do |*a, &b|
+            return send(bang, *a, &b) if b || a.any?
+            method
+          end
+        end
+
+        if is_private
+          obj.send :private, bang
+          obj.send :private, name
+        end
+      end
+    end
+
+    def gen_const(name, object_type)
+      context = respond_to?(:const_set) ? self : Object
+      obj = context.const_defined?(name) ?
+        context.const_get(name) :
+        context.const_set(name, object_type)
+      obj
+    end
+  end
+end

data/lib/eva/version.rb

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

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: eva
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- DAddYE
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Effortless event driven micro framework with a tasty syntax
+email:
+- info@daddye.it
+executables:
+- eva
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/area.rb
+- benchmark/fib.rb
+- bin/eva
+- eva.gemspec
+- example/basic.rb
+- example/delegate.rb
+- example/emitter.rb
+- example/timers.rb
+- lib/eva.rb
+- lib/eva/emitter.rb
+- lib/eva/ext/object.rb
+- lib/eva/space.rb
+- lib/eva/version.rb
+homepage: https://github.com/DAddYE/eva
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Effortless event driven micro framework with a tasty syntax
+test_files: []
+has_rdoc: