zactor 0.0.4 → 0.0.5

data/Gemfile

@@ -1,17 +1,13 @@
 source "http://rubygems.org"
 
 group :development do
-  gem "rspec", ">= 2"
+  gem "rspec", "~> 2.3.0"
   gem "yard", "~> 0.6.0"
   gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
   gem "rcov", ">= 0"
   gem "bluecloth"
   gem "rr"
-  gem "guard-rspec"
-  gem "growl"
-  gem "ruby-debug19"
-  gem "em-spec", :git => "https://github.com/mloughran/em-spec.git", :branch => 'rspec2'
 end
 
-
 gemspec

data/Gemfile.lock

@@ -1,80 +1,33 @@
-GIT
-  remote: https://github.com/mloughran/em-spec.git
-  revision: fc888b289a424fa93848ffdac3dc4b24fdd34950
-  branch: rspec2
-  specs:
-    em-spec (0.2.2)
-
 PATH
   remote: .
   specs:
-    zactor (0.0.4)
+    zactor (0.0.5)
       activesupport (> 0.1)
-      bson (> 0.1)
-      bson_ext (> 0.1)
-      em-zeromq (> 0.1)
-      ffi (> 0.1)
-      ffi-rzmq (> 0.1)
-      ruby-interface (> 0)
+      i18n (> 0.1)
 
 GEM
   remote: http://rubygems.org/
   specs:
     activesupport (3.0.7)
-    archive-tar-minitar (0.5.2)
     bluecloth (2.1.0)
-    bson (1.2.4)
-    bson_ext (1.2.4)
-    columnize (0.3.2)
-    configuration (1.2.0)
     diff-lcs (1.1.2)
-    em-zeromq (0.2.1)
-      eventmachine (>= 1.0.0.beta.3)
-      ffi-rzmq (>= 0.7.2)
-    eventmachine (1.0.0.beta.3)
-    ffi (1.0.7)
-      rake (>= 0.8.7)
-    ffi-rzmq (0.7.2)
-    growl (1.0.3)
-    guard (0.3.0)
-      open_gem (~> 1.4.2)
-      thor (~> 0.14.6)
-    guard-rspec (0.2.0)
-      guard (>= 0.2.2)
+    git (1.2.5)
     i18n (0.5.0)
-    launchy (0.3.7)
-      configuration (>= 0.0.5)
-      rake (>= 0.8.1)
-    linecache19 (0.5.11)
-      ruby_core_source (>= 0.1.4)
-    open_gem (1.4.2)
-      launchy (~> 0.3.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
     rake (0.8.7)
     rcov (0.9.9)
     rr (1.0.2)
-    rspec (2.5.0)
-      rspec-core (~> 2.5.0)
-      rspec-expectations (~> 2.5.0)
-      rspec-mocks (~> 2.5.0)
-    rspec-core (2.5.1)
-    rspec-expectations (2.5.0)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.5.0)
-    ruby-debug-base19 (0.11.24)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby_core_source (>= 0.1.4)
-    ruby-debug19 (0.11.6)
-      columnize (>= 0.3.1)
-      linecache19 (>= 0.5.11)
-      ruby-debug-base19 (>= 0.11.19)
-    ruby-interface (0.0.2)
-      activesupport (> 0.1)
-      i18n (> 0.1)
-      ruby-interface
-    ruby_core_source (0.1.4)
-      archive-tar-minitar (>= 0.5.2)
-    thor (0.14.6)
+    rspec-mocks (2.3.0)
     yard (0.6.5)
 
 PLATFORMS
@@ -83,12 +36,9 @@ PLATFORMS
 DEPENDENCIES
   bluecloth
   bundler (~> 1.0.0)
-  em-spec!
-  growl
-  guard-rspec
+  jeweler (~> 1.5.2)
   rcov
   rr
-  rspec (>= 2)
-  ruby-debug19
+  rspec (~> 2.3.0)
   yard (~> 0.6.0)
   zactor!

data/README.md

@@ -1,167 +1,93 @@
-Что это
-=======
-Zactor позволяет любой руби-объект научить общаться с другими объектами посредством отправки и получения сообщений. При этом неважно где именно расположен объект, в том же процессе, в соседнем, или на другой физической машине.
+RubyInterface
+=============
 
-Zactor использует zmq как бекенд для сообщений, eventmachine и em-zeromq для асинхронной работы с zmq, RubyInterface для описания себя, BSON для сериализации данных.
+Простенький патерн определения интерфейсов в руби. В противовес стандартным миксинам, для каждого интерфейса создается свой класс и соответсвенно экземпляр класса для каждого объекта с интерфейсом.
 
-Каждый zactor-объект имеет свой identity, который генерируется автоматически, либо задается вручную и постоянен. Совокупность identity, host и port на которых был рожден этот объект, это достаточная информация для того что бы отправить этому объекту сообщение из другого объекта. Выглядит примерно так:
-   
-        zactor.actor =>
-        {"identity"=>"actor.2154247120-0.0.0.0:8000", "host"=>"0.0.0.0:8000"}
-  
-Ипользование
-============
-
-Для начала нужно стартануть Zactor.
-  
-    Zactor.start 8000
-  
-Процесс забиндится на 0.0.0.0:8000, через эту точку будет происходить общение между zactor-процессами. Стартоваться должен в запущенном EM-контексте.
-
-В каждый zactor-активный класс нужно делать include Zactor, после чего у класса и его экземпляров для доступа к функциями Zactor появится метод zactor. После создания объекта нужно выполнить zactor.init
-
-    class A
-      include Zactor
-  
-      def initialize
-        zactor.init
-      end
-    end
-  
-Для отправки сообщений другому объекту нам нужно знать его идентификатор. Идентификатор можно получить тремя способами:
-
-* Непосрдественной передачей. При инициализации или в любом другом месте, это исключительно внутренняя логика приложения. Идентификатор объекта можно получить вызвав zactor.actor
-* При получении сообщения. В сообщении всегда содержится информация об отправителе
-* Если объект имеет заранее известный identity, то мы можем получить его полный идентификатор вызвав Zactor.get_actor с identity и хостом, на котором он запущен
-  
-    actor = Zactor.get_actor "broker", :host => "0.0.0.0:8001"
-  
-Получив идентификатор можно отправлять ему сообщения
-  
-    zactor.send_request actor, :show_me, :boobs
-
-  
-Каждый класс может определять какие именно ивенты он может получать и что с ними делать
- 
-    include Zactor
-
-    zactor do
-      event(:show_me) do |o, msg, what|
-        case what
-        when :boobs
-          do_it
-        else
-          do_smth_else
+    module Tree
+      extend RubyInterface
+      interface :tree do
+        include Enumerable
+        attr_accessor :parent
+    
+        def childs
+          @childs ||= []
         end
-      end
-    end
-  
-Рассмотрим пример банального ping-pong
-
-    class A
-      include Zactor
-
-      def initialize
-        zactor.init
-        ping Zactor.get_actor("b")
-      end
-  
-      def ping(actor) 
-        puts "Ping!"
-        zactor.send_request actor, :ping do |res|
-          puts res
+    
+        def each(&blk)
+          blk.call(owner)
+          childs.each { |v| v.tree.each(&blk) }
         end
-      end
-    end
-
-
-    class B
-      include Zactor
-  
-      zactor do
-        identity "b"
     
-        event(:ping) do |o, msg|
-          msg.reply "Pong!"
+        def set_parent(parent)
+          parent.tree.childs << owner
+          @parent = parent
         end
       end
-  
-      def initialize
-        zactor.init
-      end
-
     end
 
-    EM.run do
-      Zactor.start 8000
-  
-      a = A.new
-      b = B.new
+    class A
+      include Tree
     end
-  
-A посылает сообщение :ping для B, а B отвечает "Pong!"
-
-В коллбэк определенный в event передается объект получившый сообщение, объект сообщения ({Zactor::Message}) и далее переданные в запросе аргументы (если они есть). У {Zactor::Message} есть два основных метода: sender, возвращающий идентификатор отправителя и reply, который посылает ответ на запрос.
-
-Важный момент, identity должно задаваться ДО zactor.init и после этого не может меняться.
-
-ZMQ
-===
-
-При Zactor.start стартует брокер, по одному на каждый процесс, через него проходят все сообщения данного процесса, принимает сообщения через SUB-сокет, отправляет через PUB. SUB подписан на все сообщения. Каждый zactor-объект создает по паре сокетов, PUB подключается к SUB-брокера, а SUB к PUB-брокера. SUB подписывается на сообщения содержащие его identity.
-
-![ZMQ](images/zmq1.png)
-
-Рассмотрим жизнь сообщения на примере с ping-ping. В случае с b в том же процессе:
-
-<div class=wsd wsd_style="default"><pre>
-A[PUB]->Broker[SUB]: Посылаем запрос :ping
-Broker[SUB]->Broker[PUB]: Перебрасываем запрос в PUB сокет
-Broker[PUB]->B[SUB]: Передаем получателю сообщение
-B[PUB]->Broker[SUB]: Отправляем ответ "Pong!"
-Broker[SUB]->Broker[PUB]: Перебрасываем запрос в PUB сокет
-Broker[PUB]->A[SUB]: Отправитель получает ответ
-</pre></div><script type="text/javascript" src="http://www.websequencediagrams.com/service.js"></script>
 
-В случае с b в другом процессе:
+При разработке интерфейса не нужно задумываться о конфликтах имен переменных, методов, можно делать все что угодно. Аргументом к методу interface передается название метода, по которому этот интерфейс будет доступен.
 
-<div class=wsd wsd_style="default"><pre>
-A[PUB for App2]->App2 Broker[SUB]: Посылаем запрос :ping
-App2 Broker[SUB]->App2 Broker[PUB]: Перебрасываем запрос в PUB сокет
-App2 Broker[PUB]->B[SUB]: Передаем получателю сообщение
-B[PUB for App1]->App1 Broker[SUB]: Отправляем ответ "Pong!"
-App1 Broker[SUB]->App1 Broker[PUB]: Перебрасываем запрос в PUB сокет
-App1 Broker[PUB]->A[SUB]: Отправитель получает ответ
-</pre></div><script type="text/javascript" src="http://www.websequencediagrams.com/service.js"></script>
+    a = A.new
+    b = A.new
 
-Балансировка
-============
-
-Так как это ZMQ, мы можем очень просто изменить тип получения сообщения. Например, добавив балансер. Теперь можно запускать процессы со ссылкой на этот балансер.
-
-    Zactor.start :balancer => "0.0.0.0:4000"
-    
-У нас получится примерно следующая схема:
-
-![ZMQ](images/zmq2.png)
-
-Теперь наш ping можно отправлять в балансер, а отвечать будет один из подключенных воркеров.
-
-    ping Zactor.get_actor("b", :host => "0.0.0.0:4000")
+    a.tree.set_parent b
+    b.tree.childs # => [a]
+    b.tree.map { |o| o } # => [b, a]
     
+А при использовании методов относящихся к интерфейсу мы явно видим к какому же интерфейсу он относится. Всем профит!
 
-Протокол обмена
-===============
+В интерфейсе доступен метод owner, возвращающий родительский объект. У класса интерфейса есть <tt>interface_base</tt>, возвращающий класс, куда интерфейс был заинклужен.
 
+Помимо инстанс метода, создается так же класс-метод. В него можно передать блок, который выполнится в скоупе класса интерфейса. Сам метод возвращает класс интерфейса.
 
-Perfomance
-==========
+    module StateMachine
+      extend RubyInterface
+      interface :state_machine do
+        def self.state(name)
+          puts "New state #{name}"
+        end
+      end
+    end
 
-А хрен его знает, толком не мерялось ничего :)
+    class A
+      include StateMachine
+  
+      state_machine do
+        state(:parked) # => New state parked
+        state(:idling) # => New state idling
+      end
+    end
+    
+При наследовании класса с интерфейсом, создается новый класс интерфейса и наследуется от предыдущего, т.е. повторяет иерархию класса, в который он включен.
 
-TODO
-====
+Если в блоке <tt>interface</tt> вызывается метод <tt>interfaced</tt>, то исполнение блока, передаваемого <tt>interfaced</tt> 
+происходит после добавления интерфейса в класс, в контексте этого класса.
 
-* Сделать событие отваливания объектов. Наверное, что-то вроде простого аналога link в эрланге.
-* Добавить таймауты для запросов с коллбэками. Сейчас они будут висеть бесконечно и засрут память.
-* Доступ к отправителю в колллбэке запроса. В случае с балансировкой он будет не тем же, кому мы посылали сообщение
+Пример:
+   
+     module A
+       extend RubyInterface
+       interface :int do
+         interfaced do
+           def baz
+             self.class.int_interface.foo
+           end
+         end
+     
+         def self.foo
+           "bar"
+         end
+       end
+     end
+     
+     class B
+       include A
+     end
+     
+     B.new.baz # => "bar"
+
+В каждом модуле может быть определено произвольное количество интерфейсов

data/Rakefile

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 require 'rubygems'
 require 'bundler'
 begin

data/lib/ruby-interface/version.rb

@@ -0,0 +1,3 @@
+module RubyInterface
+  VERSION = "0.0.5"
+end

data/lib/ruby-interface/yard.rb

@@ -0,0 +1,8 @@
+class RubyInterfaceHandler < YARD::Handlers::Ruby::Base
+  handles method_call(:interface)
+  
+  def process
+    parse_block(statement.last.last)
+  rescue YARD::Handlers::NamespaceMissingError
+  end
+end

data/lib/ruby_interface.rb

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/string/inflections'
+
+module RubyInterface
+  def interface(method_name, &interface_body)
+    mod_inst = self.const_set("#{method_name.to_s.camelize}InstanceMethods", Module.new)
+    mod_inst.module_eval <<-EOT, __FILE__, __LINE__ + 1
+      def #{method_name}
+        @#{method_name}_interface ||= self.class.#{method_name}_interface.new(self)
+      end                                                             
+      EOT
+
+
+    mod_class = self.const_set("#{method_name.to_s.camelize}ClassMethods", Module.new)
+    mod_class.module_eval <<-EOT, __FILE__, __LINE__ + 1
+      def #{method_name}(&blk)
+        self.#{method_name}_interface.class_eval(&blk) if blk
+        self.#{method_name}_interface
+      end
+
+      def inherited(subclass)
+        new_class = subclass.const_set("#{method_name.to_s.camelize}InterfaceClass", Class.new(self.#{method_name}_interface))
+        new_class.interface_base = subclass
+        subclass.#{method_name}_interface = new_class
+        super
+      end
+      EOT
+
+    interface_module = self
+    
+    add_interface do |base|
+      base.send(:class_attribute, "#{method_name}_interface")
+      interface_class = base.const_set("#{method_name.to_s.camelize}InterfaceClass", Class.new(RubyInterface::InterfaceClass))
+      interface_class.interface_base = base
+      interface_class.class_eval(&interface_body) if interface_body
+      base.send("#{method_name}_interface=", interface_class)
+      base.extend mod_class
+      base.send :include, mod_inst
+      base.class_eval(&interface_class.interfaced) if interface_class.interfaced
+    end
+
+    interface_module.define_singleton_method(:included) do |base|
+      @_deps.each {|d| d.call(base)}
+    end
+  end
+
+  private
+  def add_interface &block
+    @_deps ||= []
+    @_deps << block
+  end
+
+  class InterfaceClass
+    class_attribute :interface_base
+    attr_accessor :owner      
+    def initialize(owner)
+      @owner = owner
+    end
+
+    class << self
+      def interfaced(&block)
+        if block_given?
+          @_interfaced_block = block
+        else
+          @_interfaced_block
+        end
+      end
+    end
+  end
+end

data/{zactor.gemspec → ruby-interface.gemspec}

@@ -1,15 +1,15 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "zactor/version"
+require "ruby-interface/version"
 
 Gem::Specification.new do |s|
   s.name = %q{zactor}
-  s.version = Zactor::VERSION
-  s.summary = "Zactor"
+  s.version = RubyInterface::VERSION
+  s.summary = "Ruby interface"
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Andrew Rudenko"]
+  s.authors = ["Andrew Rudenko", "Nick Recobra"]
   s.date = %q{2011-03-24}
-  s.description = %q{Zactor}
+  s.description = %q{Ruby interface}
   s.email = %q{ceo@prepor.ru}
 
   s.files         = `git ls-files`.split("\n")
@@ -17,12 +17,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency('ffi', ["> 0.1"])
-  s.add_dependency('ruby-interface', ["> 0"])
-  s.add_dependency('ffi-rzmq', ["> 0.1"])
-  s.add_dependency('em-zeromq', ["> 0.1"])
-  s.add_dependency('bson', ["> 0.1"])
-  s.add_dependency('bson_ext', ["> 0.1"])
   s.add_dependency('activesupport', ["> 0.1"])
-end
-
+  s.add_dependency(%q<i18n>, ["> 0.1"])
+end

data/spec/ruby_interface_spec.rb

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe RubyInterface do
+  def make_interface
+    mod = Module.new
+    mod.extend(RubyInterface)
+    mod
+  end
+  
+  describe "Создание интерфейса" do
+    let(:mod) { make_interface.tap { |v| v.interface(:test) } }
+    
+    it "должен вызываться interfaced, если определен" do
+      @proc = proc {}
+      klass = Class.new
+      mod.interface :int do
+        interfaced(&@proc)
+      end
+      mock(klass).class_eval(&@proc)
+      mock(klass).class_eval(&@proc)
+      klass.send :include, mod
+    end
+    
+    describe "Класс с интерфейсом" do
+      subject { klass }
+      let(:klass) { Class.new.tap { |v| v.send :include, mod } }
+      let(:interface_klass) { klass.test_interface }
+      its(:test) { should eq(interface_klass) }
+      
+      it "может дополнять класс интерфейса" do
+        interface_klass.respond_to?(:test).should be_false
+        klass.test do
+          mattr_accessor :test
+        end
+        interface_klass.respond_to?(:test).should be_true
+      end
+      
+      it "должен содержать класс интерфейса" do
+        klass::TestInterfaceClass.ancestors.should include(RubyInterface::InterfaceClass)
+        klass.test_interface.should eq(klass::TestInterfaceClass)
+      end
+      
+      describe "Класс интерфейса" do
+        subject { interface_klass }
+        its(:interface_base) { should eq(klass) }
+        
+        describe "Объект с интерфейсом" do
+          subject { obj }
+          let(:obj) { klass.new }
+          its(:test) { should be_kind_of(interface_klass)}
+          describe "Объект интерфейса" do
+            subject { interface_obj }
+            let(:interface_obj) { obj.test }
+            its(:owner) { should eq(obj) }
+            let(:mod) do 
+              make_interface.tap do |v| 
+                v.interface(:test) do
+                  def foo
+                    "bar"
+                  end
+                end
+              end              
+            end
+            
+            it "должен поддерживать методы определенные в интерфейсе" do
+              interface_obj.foo.should eq('bar')
+            end
+          end
+        end
+        
+        describe "при наследовании" do
+          let(:klass2) { Class.new(klass) }
+          it "должен создавать новый интерфейс-класс, наследуя старый" do
+            klass2.test.ancestors.should include(interface_klass)
+          end
+          it "новый интерфейс-класс должен ссылаться на новый класс" do
+            klass2.test.interface_base.should eq(klass2)
+          end
+        end
+      end
+      
+
+    end
+  end
+
+  describe "Модуль с двумя интерфейсами" do
+    before(:each) do
+      @mod = Module.new
+      @mod.send :extend, RubyInterface
+      @mod.interface :first do
+        interfaced do
+          def baz
+            first.foo
+          end
+        end
+      
+        def foo
+          "bar"
+        end
+      end
+
+      @mod.interface :second do
+        interfaced do
+          self.second_interface.foo
+        end
+
+        def self.foo
+          "baz"
+        end
+      end
+    end
+
+    it "не должно происходить ошибок при подключении модуля с двумя интерфейсами" do
+      b = Class.new
+      lambda { b.send :include, @mod }.should_not raise_error
+    end
+
+    it "должны появиться интерфейсы с методами" do
+      b = Class.new
+      b.send :include, @mod
+      bb = b.new
+      bb.baz.should eq("bar")
+      bb.second_interface.foo.should eq("baz")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
-require 'zactor'
 require 'rr'
+require 'ruby_interface'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.