zactor 0.0.5 → 0.0.6

data/lib/ruby-interface/version.rb

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

data/lib/ruby-interface/yard.rb

@@ -1,8 +0,0 @@
-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

@@ -1,71 +0,0 @@
-# -*- 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/spec/ruby_interface_spec.rb

@@ -1,127 +0,0 @@
-# -*- 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