rocketio 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 058d969c6b3f050392f25ce9be512029b10cf7cf
-  data.tar.gz: fe12296fa46e09d621044bc15a926099daf0f85d
+  metadata.gz: e9540db8ccba375983a890602be457287f31f7e2
+  data.tar.gz: aeeba39bb33341e1c015c099040793df15e1b396
 SHA512:
-  metadata.gz: 57ff44d810bc535f35cacc5fd09983e9fda1c2902296e14744ec56e7c59a80fa2229c3302ce2a27a0a24fc6a613a4063cc25510c70e124a77fa9286315d70acb
-  data.tar.gz: 98a60d1d19ef24fa204796f607eefb9dea785a11af451ad5bceb6b60027709869f30a79d2402bee2e4521a02b27216340b3b99bf33b56a62c55c67e38881492e
+  metadata.gz: 135b3a8e35301383adf5b21ae1a3a80aa0639feb1d44d5cd96e82c4c4da453844890cffe4517aceb2b5642d664d9893bd8889c10d7d05a58026a4e7220c1544b
+  data.tar.gz: b526fcf90b86d59f0e1a3cf6cd847c1d752919ef4e27a6c9b4e85a741b06795e1a3b7ed2554dfbfe300d3e5b3014390e224840939008a00b2ebf155d37c31873

data/lib/rocketio/controller.rb

@@ -56,6 +56,7 @@ module RocketIO
         }
         invoke_after_filter
       }
+
       response.body ||= RocketIO::EMPTY_ARRAY
       response.body = [] if head? # dropping body on HEAD requests
       response.finish
@@ -122,32 +123,53 @@ module RocketIO
 
   class << Controller
 
-    def inherit setup, opts = {}
-      opts[:from] || raise(ArgumentError, ':from option is required')
-      __send__(:"define_#{setup}_methods", opts[:from])
+    # only public non-inherited methods are included in public API directly.
+    def api
+      return [] if self == RocketIO::Controller
+      public_instance_methods(false).concat(inherited_api) - private_api
+    end
+
+    # inherited methods are excluded from public API
+    # but we still need a way to know what API methods was inherited
+    def inherited_api
+      @__inherited_api__
+    end
+
+    # used internally to keep a list of public methods
+    # that should be excluded from public API
+    def private_api
+      @__private_api__
+    end
+
+    # import some config from some controller
+    def import setup, from:
+      __send__(:"define_#{setup}_methods", from)
     end
 
     def inherited base
       # registering new controller
       RocketIO.controllers.push(base)
 
+      base.instance_variable_set(:@__private_api__, self.private_api.uniq)
+      base.instance_variable_set(:@__inherited_api__, self.api.freeze)
+
       # new controller inherits all setups from superclass
-      base.inherit :before, from: self
-      base.inherit :around, from: self
-      base.inherit :after,  from: self
+      base.import :before, from: self
+      base.import :around, from: self
+      base.import :after,  from: self
 
-      base.inherit :basic_auth,  from: self
-      base.inherit :digest_auth, from: self
-      base.inherit :token_auth,  from: self
+      base.import :basic_auth,  from: self
+      base.import :digest_auth, from: self
+      base.import :token_auth,  from: self
 
-      base.inherit :error_handlers, from: self
-      base.inherit :middleware,     from: self
-      base.inherit :sessions,       from: self
+      base.import :error_handlers, from: self
+      base.import :middleware,     from: self
+      base.import :sessions,       from: self
 
-      base.inherit :engine,    from: self
-      base.inherit :layout,    from: self
-      base.inherit :layouts,   from: self
-      base.inherit :templates, from: self
+      base.import :engine,    from: self
+      base.import :layout,    from: self
+      base.import :layouts,   from: self
+      base.import :templates, from: self
 
       # removing superclass name from new controller name
       path = RocketIO.underscore(base.name.to_s.sub(self.name.to_s + '::', '').gsub('::', '/'))
@@ -279,11 +301,9 @@ module RocketIO
     def call env
       initialize_controller.call(env)
     end
-
-    def api
-      public_instance_methods(false)
-    end
   end
+
+  Controller.instance_variable_set(:@__private_api__, [])
 end
 
 require 'rocketio/controller/authentication'

data/lib/rocketio/controller/authentication.rb

@@ -46,11 +46,11 @@ module RocketIO
     def self.define_basic_auth_methods source = self
       prompts = (source.instance_variable_get(:@__basic_auth__) || {}).each_with_object(allocate.basic_auth.dup) do |(rm,p),o|
         method = :"__basic_auth__#{rm}__"
-        define_method(method, &p[:block])
+        private_api << define_method(method, &p[:block])
         o[rm] = p.merge(method: method).freeze
       end.freeze
       return if prompts.empty?
-      define_method(:basic_auth) {prompts}
+      private_api << define_method(:basic_auth) {prompts}
     end
 
     def basic_auth; RocketIO::EMPTY_HASH end
@@ -109,18 +109,16 @@ module RocketIO
     def self.define_digest_auth_methods source = self
       prompts = (source.instance_variable_get(:@__digest_auth__) || {}).each_with_object(allocate.digest_auth.dup) do |(rm,p),o|
         method = :"__digest_auth__#{rm}__"
-        define_method(method, &p[:block])
+        private_api << define_method(method, &p[:block])
         o[rm] = p.merge(method: method).freeze
       end.freeze
       return if prompts.empty?
-      define_method(:digest_auth) {prompts}
+      private_api << define_method(:digest_auth) {prompts}
     end
 
     def digest_auth; RocketIO::EMPTY_HASH end
 
-    def user?
-      env[RocketIO::REMOTE_USER]
-    end
+    def user?; env[RocketIO::REMOTE_USER] end
 
     # checks whether authentication is required and
     # send an authorization request if credentials not present or invalid

data/lib/rocketio/controller/authorization.rb

@@ -25,7 +25,7 @@ module RocketIO
     def self.define_token_auth_methods source = self
       prompts = allocate.token_auth.merge(source.instance_variable_get(:@__token_auth__) || {}).freeze
       return if prompts.empty?
-      define_method(:token_auth) {prompts}
+      private_api << define_method(:token_auth) {prompts}
     end
 
     def token_auth; RocketIO::EMPTY_HASH end
@@ -43,11 +43,9 @@ module RocketIO
     def validate_token_auth &block
       RocketIO::TokenAuth.authenticate(env, &block)
     end
-    alias valid_token_auth? validate_token_auth
 
     def request_token_auth realm = RocketIO::DEFAULT_TOKEN_AUTH_REALM
       RocketIO::TokenAuth.authentication_request(realm)
     end
-    alias request_token_auth! request_token_auth
   end
 end

data/lib/rocketio/controller/error_handlers.rb

@@ -36,14 +36,14 @@ module RocketIO
     end
 
     def self.define_error_handlers_methods source = self
-      handlers = (source.instance_variable_get(:@__error_handlers__) || {}).each_with_object({}) do |(code,proc),o|
+      handlers = (source.instance_variable_get(:@__error_handlers__) || {}).each_with_object({}) do |(code,block),o|
         o[code] = :"__#{code}_error_handler__"
-        define_method(o[code], &proc)
+        private_api << define_method(o[code], &block)
       end
       handlers.update(allocate.error_handlers)
       return if handlers.empty?
       handlers.freeze
-      define_method(:error_handlers) {handlers}
+      private_api << define_method(:error_handlers) {handlers}
     end
 
     def error_handlers; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/filters.rb

@@ -73,14 +73,14 @@ module RocketIO
       end
 
       define_singleton_method define_methods do |source = self|
-        filters = (source.instance_variable_get(var) || {}).each_with_object({}) do |(meth,proc),o|
+        filters = (source.instance_variable_get(var) || {}).each_with_object({}) do |(meth,block),o|
           o[meth] = :"__#{filter}_#{meth}__"
-          define_method(o[meth], &proc)
+          private_api << define_method(o[meth], &block)
         end
         filters.update(allocate.__send__(filter))
         return unless filters.any?
         filters.freeze
-        define_method(filter) {filters}
+        private_api << define_method(filter) {filters}
       end
     end
 

data/lib/rocketio/controller/middleware.rb

@@ -24,7 +24,7 @@ module RocketIO
     def self.define_middleware_methods source = self
       middleware = ((source.instance_variable_get(:@__middleware__) || []) + allocate.middleware).uniq.freeze
       return if middleware.empty?
-      define_method(:middleware) {middleware}
+      private_api << define_method(:middleware) {middleware}
     end
 
     def middleware; RocketIO::EMPTY_ARRAY end

data/lib/rocketio/controller/render/engine.rb

@@ -60,14 +60,14 @@ module RocketIO
       return unless engine = source.instance_variable_get(:@__engine__)
       if Proc === engine
         selfengine = allocate.engine
-        define_method(:__rocketio_engine__, &engine)
-        define_method(:engine) {
+        private_api << define_method(:__rocketio_engine__, &engine)
+        private_api << define_method(:engine) {
           engine, *engine_options = __rocketio_engine__
           return selfengine unless engine
           [RocketIO.engine_class(engine), engine_options.freeze].freeze
         }
       else
-        define_method(:engine) {engine}
+        private_api << define_method(:engine) {engine}
       end
     end
 

data/lib/rocketio/controller/render/layout.rb

@@ -17,7 +17,7 @@ module RocketIO
     def self.define_layout_methods source = self
       return unless source.instance_variables.include?(:@__layout__)
       layout = source.instance_variable_get(:@__layout__)
-      define_method(:layout) {layout}
+      private_api << define_method(:layout) {layout}
     end
 
     # by default no layout used, so this method returns nil.

data/lib/rocketio/controller/render/layouts.rb

@@ -59,25 +59,25 @@ module RocketIO
         o[name] = :"__#{name}_layout__"
         if setup[:block]
           # block given, do not search for file, use returned value instead
-          define_method(o[name], &setup[:block])
+          private_api << define_method(o[name], &setup[:block])
         elsif setup[:file]
           # file given, search the file in original controller dirname
-          meth_name = :"__#{name}_layout_file__"
+          private_api << meth_name = :"__#{name}_layout_file__"
           meth_proc = setup[:file].is_a?(::Proc) ? setup[:file] : -> {setup[:file]}
-          define_method(meth_name, &meth_proc)
-          define_method o[name] do
+          private_api << define_method(meth_name, &meth_proc)
+          private_api << define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(setup[:root], __send__(meth_name), engine))
-          end
+          }
         else
           # only name given, search for a file with same name in controller's dirname
-          define_method o[name] do
+          private_api << define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(self.dirname, setup[:name], engine))
-          end
+          }
         end
       end.freeze
-      define_method(:layouts) {layouts}
+      private_api << define_method(:layouts) {layouts}
     end
 
     def layouts; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/render/template_vars.rb

@@ -17,12 +17,12 @@ module RocketIO
       vars = source.instance_variable_get(:@__template_vars__).each_with_object(allocate.__template_vars__.dup) do |(name,value),o|
         o[name] = :"__#{name}_template_var__"
         if value.is_a?(Proc)
-          define_method(o[name], &value)
+          private_api << define_method(o[name], &value)
         else
-          define_method(o[name]) {value}
+          private_api << define_method(o[name]) {value}
         end
       end.freeze
-      define_method(:__template_vars__) {vars}
+      private_api << define_method(:__template_vars__) {vars}
     end
 
     def __template_vars__; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/render/templates.rb

@@ -57,25 +57,25 @@ module RocketIO
         o[name] = :"__#{name}_template__"
         if setup[:block]
           # block given, do not search for file, use returned value instead
-          define_method(o[name], &setup[:block])
+          private_api << define_method(o[name], &setup[:block])
         elsif setup[:file]
           # file given, search the file in original controller dirname
-          meth_name = :"__#{name}_template_file__"
+          private_api << meth_name = :"__#{name}_template_file__"
           meth_proc = setup[:file].is_a?(Proc) ? setup[:file] : -> {setup[:file]}
-          define_method(meth_name, &meth_proc)
-          define_method o[name] do
+          private_api << define_method(meth_name, &meth_proc)
+          private_api << define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(setup[:root], __send__(meth_name), engine))
-          end
+          }
         else
           # only name given, search for a file with same name in controller's dirname
-          define_method o[name] do
+          private_api << define_method(o[name]) {
             engine, * = resolve_engine
             read_template(find_template(self.dirname, setup[:name], engine))
-          end
+          }
         end
       end.freeze
-      define_method(:templates) {templates}
+      private_api << define_method(:templates) {templates}
     end
 
     def templates; RocketIO::EMPTY_HASH end

data/lib/rocketio/controller/sessions.rb

@@ -56,7 +56,7 @@ module RocketIO
     def self.define_sessions_methods source = self
       return unless source.instance_variables.include?(:@__sessions__)
       sessions = source.instance_variable_get(:@__sessions__)
-      define_method(:sessions) {sessions}
+      private_api << define_method(:sessions) {sessions}
     end
 
     def sessions; end

data/lib/rocketio/version.rb

@@ -1,3 +1,3 @@
 module RocketIO
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/rocketio.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /(gem|lock)\z/}
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = '~> 2.0'
+  spec.required_ruby_version = '~> 2.2'
 
   spec.add_runtime_dependency 'rack', '~> 1.5'
   spec.add_runtime_dependency 'mustache', '~> 1'
@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '~> 1.7'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'tokyo', '~> 0'
-  spec.add_development_dependency 'rack-radar'
+  spec.add_development_dependency 'rack-radar', '~> 0'
 end

data/test/api_test.rb

@@ -0,0 +1,155 @@
+require 'setup'
+
+spec :api do
+
+  it 'should contain only public non-inherited methods' do
+    c = mock_controller {
+      basic_auth  {}
+      digest_auth {}
+      token_auth  {}
+      error(500)  {}
+      before      {}
+      around      {}
+      after       {}
+      use proc    {}
+      sessions :cookies
+      engine :ERB
+      layout :main
+      define_layout(:main) {}
+      define_layout(:file, file: :file)
+      define_template(:main) {}
+      define_template(:file, file: :file)
+      define_template_var(:var) {}
+    }
+    assert(c.api).empty?
+  end
+
+
+  it 'should inherit api methods' do
+    a = mock_controller {
+      def x; end
+    }
+    
+    b = mock_controller(a) {
+      def y; end
+    }
+
+    assert(b.api).include?(:x)
+    assert(b.api).include?(:y)
+  end
+
+
+  context :private_api do
+
+    it 'should contain auth methods' do
+      c = mock_controller {
+        basic_auth  {}
+        digest_auth {}
+        token_auth  {}
+      }
+      assert(c.private_api).include?(:basic_auth)
+      assert(c.private_api).include?(:__basic_auth__get__)
+
+      assert(c.private_api).include?(:digest_auth)
+      assert(c.private_api).include?(:__digest_auth__get__)
+
+      assert(c.private_api).include?(:token_auth)
+    end
+
+    it 'should contain error handler methods' do
+      c = mock_controller {
+        error(500) {}
+      }
+      assert(c.private_api).include?(:error_handlers)
+      assert(c.private_api).include?(:__404_error_handler__)
+      assert(c.private_api).include?(:__409_error_handler__)
+      assert(c.private_api).include?(:__501_error_handler__)
+    end
+
+    it 'should contain filters methods' do
+      c = mock_controller {
+        before {}
+        around {}
+        after  {}
+      }
+      assert(c.private_api).include?(:before)
+      assert(c.private_api).include?(:'__before_*__')
+
+      assert(c.private_api).include?(:around)
+      assert(c.private_api).include?(:'__around_*__')
+
+      assert(c.private_api).include?(:after)
+      assert(c.private_api).include?(:'__after_*__')
+
+    end
+
+    it 'should contain middleware methods' do
+      c = mock_controller {
+        use proc {}
+      }
+      assert(c.private_api).include?(:middleware)
+    end
+
+    it 'should contain session methods' do
+      c = mock_controller {
+        sessions :cookies
+      }
+      assert(c.private_api).include?(:sessions)
+    end
+
+    context :render do
+
+      it 'should contain engine methods' do
+        c = mock_controller {
+          engine :ERB
+        }
+
+        assert(c.private_api).include?(:engine)
+      end
+
+      it 'should contain engine methods when engine defined as block' do
+        c = mock_controller {
+          engine {:ERB}
+        }
+
+        assert(c.private_api).include?(:engine)
+        assert(c.private_api).include?(:__rocketio_engine__)
+      end
+
+      it 'should contain layout methods' do
+        c = mock_controller {
+          layout :main
+          define_layout(:main) {}
+          define_layout(:file, file: :file)
+        }
+
+        assert(c.private_api).include?(:layout)
+        assert(c.private_api).include?(:layouts)
+        assert(c.private_api).include?(:__file_layout_file__)
+        assert(c.private_api).include?(:__file_layout__)
+      end
+
+      it 'should contain template methods' do
+        c = mock_controller {
+          define_template(:main) {}
+          define_template(:file, file: :file)
+        }
+
+        assert(c.private_api).include?(:templates)
+        assert(c.private_api).include?(:__file_template_file__)
+        assert(c.private_api).include?(:__file_template__)
+      end
+
+      it 'should contain template_var methods' do
+        c = mock_controller {
+          define_template_var(:var) {}
+        }
+
+        assert(c.private_api).include?(:__template_vars__)
+        assert(c.private_api).include?(:__var_template_var__)
+      end
+
+    end
+
+  end
+end

data/test/authentication_test.rb

@@ -38,7 +38,7 @@ spec :AuthenticationTest do
         basic_auth {|u,p| [u,p] == %w[x y]}
       }
       c = mock_controller(a) {
-        inherit :basic_auth, from: b
+        import :basic_auth, from: b
       }
       app(c)
       get
@@ -53,7 +53,7 @@ spec :AuthenticationTest do
         basic_auth {|u,p| [u,p] == %w[u p]}
       }
       b = mock_controller {
-        inherit :basic_auth, from: a
+        import :basic_auth, from: a
       }
       app(b)
       get
@@ -99,7 +99,7 @@ spec :AuthenticationTest do
         digest_auth {|u| {'x' => 'y'}[u]}
       }
       c = mock_controller(a) {
-        inherit :digest_auth, from: b
+        import :digest_auth, from: b
       }
       app(b)
       get
@@ -114,7 +114,7 @@ spec :AuthenticationTest do
         digest_auth {|u| {'u' => 'p'}[u]}
       }
       b = mock_controller {
-        inherit :digest_auth, from: a
+        import :digest_auth, from: a
       }
       app(b)
       get

data/test/authorization_test.rb

@@ -38,7 +38,7 @@ spec :AuthorizationTest do
         token_auth {|t| t == 'y'}
       }
       c = mock_controller(a) {
-        inherit :token_auth, from: b
+        import :token_auth, from: b
       }
       app(c)
       get
@@ -53,7 +53,7 @@ spec :AuthorizationTest do
         token_auth {|t| t == 'x'}
       }
       b = mock_controller {
-        inherit :token_auth, from: a
+        import :token_auth, from: a
       }
       app(b)
       get

data/test/filters_test.rb

@@ -26,9 +26,9 @@ spec :Filters do
         def get; end
       }
       b = mock_controller {
-        inherit :before, from: a
-        inherit :around, from: a
-        inherit :after, from: a
+        import :before, from: a
+        import :around, from: a
+        import :after, from: a
       }
       app(b)
       get
@@ -49,9 +49,9 @@ spec :Filters do
         after(:get)  {after  << :b}
       }
       c = mock_controller(a) {
-        inherit :before, from: b
-        inherit :around, from: b
-        inherit :after, from: b
+        import :before, from: b
+        import :around, from: b
+        import :after, from: b
       }
       app(c)
       get
@@ -73,9 +73,9 @@ spec :Filters do
         after(:post)  {after_post  << :b}
       }
       c = mock_controller(a) {
-        inherit :before, from: b
-        inherit :around, from: b
-        inherit :after, from: b
+        import :before, from: b
+        import :around, from: b
+        import :after, from: b
       }
       app(c)
       get

data/test/middleware_test.rb

@@ -29,7 +29,7 @@ spec :Middleware do
     }
     b = mock_controller {
       use(ware) { buff << 3 }
-      inherit :middleware, from: a
+      import :middleware, from: a
       def get; end
     }
     app mock_app(b)
@@ -47,7 +47,7 @@ spec :Middleware do
       def get; end
     }
     c = mock_controller(a) {
-      inherit :middleware, from: b
+      import :middleware, from: b
       def get; end
     }
     app mock_app(c)

data/test/render/engine_test.rb

@@ -28,7 +28,7 @@ spec :engine do
       engine :Turbo
     }
     c = mock_controller(a) {
-      inherit :engine, from: b
+      import :engine, from: b
     }
     assert(c.initialize_controller.engine) == [:TurboTemplate, []]
   end

data/test/render/layout_test.rb

@@ -29,7 +29,7 @@ spec :Views do
         layout :baster
       }
       c = mock_controller(a) {
-        inherit :layout, from: b
+        import :layout, from: b
       }
       assert(c.initialize_controller.layout) == :baster
     end

data/test/render/layouts_test.rb

@@ -40,7 +40,7 @@ spec :layouts do
         define_layout(:x) {'b'}
       }
       c = mock_controller(a) {
-        inherit :layouts, from: b
+        import :layouts, from: b
       }.initialize_controller
       assert(c.__send__ c.layouts[:x]) == 'b'
     end
@@ -53,7 +53,7 @@ spec :layouts do
         define_layout(:b) {'b'}
       }
       c = mock_controller(a) {
-        inherit :layouts, from: b
+        import :layouts, from: b
       }.initialize_controller
       assert(c.__send__ c.layouts[:a]) == 'a'
       assert(c.__send__ c.layouts[:b]) == 'b'
@@ -65,7 +65,7 @@ spec :layouts do
       }
       b = mock_controller {
         define_layout(:x) {'b'}
-        inherit :layouts, from: a
+        import :layouts, from: a
       }.initialize_controller
       assert(b.__send__ b.layouts[:x]) == 'a'
     end
@@ -76,7 +76,7 @@ spec :layouts do
       }
       b = mock_controller {
         define_layout(:b) {'b'}
-        inherit :layouts, from: a
+        import :layouts, from: a
       }.initialize_controller
       assert(b.__send__ b.layouts[:a]) == 'a'
       assert(b.__send__ b.layouts[:b]) == 'b'
@@ -87,7 +87,7 @@ spec :layouts do
         define_layout(:x) {'a'}
       }
       b = mock_controller {
-        inherit :layouts, from: a
+        import :layouts, from: a
         define_layout(:x) {'b'}
       }.initialize_controller
       assert(b.__send__ b.layouts[:x]) == 'b'

data/test/render/template_vars_test.rb

@@ -39,7 +39,7 @@ spec :template_vars do
         define_template_var(:a, 'b')
       }
       c = mock_controller(a) {
-        inherit :template_vars, from: b
+        import :template_vars, from: b
       }.initialize_controller
       assert(c.template_vars[:a]) == 'b'
     end
@@ -52,7 +52,7 @@ spec :template_vars do
         define_template_var(:b, 'b')
       }
       c = mock_controller(a) {
-        inherit :template_vars, from: b
+        import :template_vars, from: b
       }.initialize_controller
       assert(c.template_vars[:a]) == 'a'
       assert(c.template_vars[:b]) == 'b'
@@ -64,7 +64,7 @@ spec :template_vars do
       }
       b = mock_controller {
         define_template_var(:a, 'b')
-        inherit :template_vars, from: a
+        import :template_vars, from: a
       }.initialize_controller
       assert(b.template_vars[:a]) == 'a'
     end

data/test/render/templates_test.rb

@@ -40,7 +40,7 @@ spec :templates do
         define_template(:x) {'b'}
       }
       c = mock_controller(a) {
-        inherit :templates, from: b
+        import :templates, from: b
       }.initialize_controller
       assert(c.__send__ c.templates[:x]) == 'b'
     end
@@ -53,7 +53,7 @@ spec :templates do
         define_template(:b) {'b'}
       }
       c = mock_controller(a) {
-        inherit :templates, from: b
+        import :templates, from: b
       }.initialize_controller
       assert(c.__send__ c.templates[:a]) == 'a'
       assert(c.__send__ c.templates[:b]) == 'b'
@@ -65,7 +65,7 @@ spec :templates do
       }
       b = mock_controller {
         define_template(:x) {'b'}
-        inherit :templates, from: a
+        import :templates, from: a
       }.initialize_controller
       assert(b.__send__ b.templates[:x]) == 'a'
     end
@@ -76,7 +76,7 @@ spec :templates do
       }
       b = mock_controller {
         define_template(:b) {'b'}
-        inherit :templates, from: a
+        import :templates, from: a
       }.initialize_controller
       assert(b.__send__ b.templates[:a]) == 'a'
       assert(b.__send__ b.templates[:b]) == 'b'
@@ -87,7 +87,7 @@ spec :templates do
         define_template(:x) {'a'}
       }
       b = mock_controller {
-        inherit :templates, from: a
+        import :templates, from: a
         define_template(:x) {'b'}
       }.initialize_controller
       assert(b.__send__ b.templates[:x]) == 'b'

data/test/sessions_test.rb

@@ -49,7 +49,7 @@ spec :Sessions do
       sessions :cookies
     }
     b = mock_controller(:b) {
-      inherit :sessions, from: a
+      import :sessions, from: a
       def get(y); session[:x] = y end
       def post;   session[:x]     end
     }
@@ -84,7 +84,7 @@ spec :Sessions do
       def post;   session[:x]     end
     }
     c = mock_controller(a) {
-      inherit :sessions, from: b
+      import :sessions, from: b
       def get(y); session[:x] = y end
       def post;   session[:x]     end
     }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rocketio
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Slee Woo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2016-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -98,14 +98,14 @@ dependencies:
   name: rack-radar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
 description: Simple, fast, scalable web framework for Ruby
@@ -155,6 +155,7 @@ files:
 - lib/rocketio/version.rb
 - rocketio.gemspec
 - test/aliases_test.rb
+- test/api_test.rb
 - test/authentication_test.rb
 - test/authorization_test.rb
 - test/cache_control_test.rb
@@ -201,7 +202,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - "~>"
     - !ruby/object:Gem::Version
-      version: '2.0'
+      version: '2.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -212,5 +213,5 @@ rubyforge_project:
 rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
-summary: '["rocketio-0.0.8", "Simple, fast, scalable web framework for Ruby"]'
+summary: '["rocketio-0.1.0", "Simple, fast, scalable web framework for Ruby"]'
 test_files: []