rocketio 0.0.0.pre.alpha → 0.0.0

data/lib/rocketio/util.rb

@@ -1,122 +0,0 @@
-module RocketIO
-
-  # - ensure leading slash
-  # - remove trailing slash
-  # - remove double slashes
-  #
-  # given path may consist of multiple chunks passed as arguments
-  # given chunks are flattened so the method can accept Array arguments.
-  #
-  # @param [String, Symbol] *chunks
-  # @return [String]
-  def rootify_path *chunks
-    RocketIO::SLASH + File.join(*chunks.flatten.map!(&:to_s)).
-      gsub(/\/+/, RocketIO::SLASH).
-      gsub(/\A\/|\/\z/, RocketIO::EMPTY_STRING)
-  end
-
-  # convert CamelCase string/symbol into underscored_name
-  #
-  # @param [String, Symbol] x
-  # @return [String]
-  def underscore x
-    x.to_s.
-      gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
-      gsub(/([a-z\d])([A-Z])/, '\1_\2').
-      downcase
-  end
-
-  # determines which of given parameters are required/optional/splat
-  # and based on this info deduct the min/max required arguments the method can be called with.
-  #
-  # @param [Array] parameters
-  # @return [Array]
-  def parameters_policy parameters
-    min, max = 0, parameters.size
-
-    unlimited = false
-    parameters.each_with_index do |param, i|
-
-      increment = param.first == :req
-
-      if (next_param = parameters.values_at(i+1).first)
-        increment = true if next_param[0] == :req
-      end
-
-      if param.first == :rest
-        increment = false
-        unlimited = true
-      end
-      min += 1 if increment
-    end
-    max = :* if unlimited
-    {min: min, max: max}.freeze
-  end
-
-  def path_params parameters
-    parameters.each_with_index.each_with_object({}) do |(param,i),o|
-      o[param[1]] = (i .. (param[0] == :rest ? -parameters[i .. -1].size : i)).freeze
-    end.freeze
-  end
-
-  # building a constant name for given engine name.
-  # if a class given, return it as is.
-  #
-  # @example
-  #   engine_class(:Slim) #=> :SlimTemplate
-  #
-  # @param engine  name
-  # @return [Symbol, Class]
-  #
-  def engine_class engine
-    return engine if engine.is_a?(Class)
-    (RocketIO::ENGINE_CONST_FORMAT % engine).to_sym
-  end
-
-  def engine_const engine
-    return engine if engine.is_a?(Class)
-    ::Tilt.const_get(engine)
-  end
-
-  def error_renderer error_code, without_layout = nil, context = {}
-    response = RocketIO::ERROR_TEMPLATES[error_code].render(context)
-    return response if without_layout
-    RocketIO::ERROR_TEMPLATES[:layout].render(context.merge(yield: response))
-  end
-
-
-  def caller_to_dirname caller
-    ::File.dirname(caller[0].split(/:\d+:in\s+`/)[0])
-  end
-
-  begin # stolen from Sinatra
-
-    # Lookup or register a mime type in Rack's mime registry. Stolen from Sinatra
-    def mime_type type, value = nil
-      return type if type.nil?
-      return type.to_s if type.to_s.include?(RocketIO::SLASH)
-      type = '.%s' % type unless type.to_s[0] == ?.
-      return Rack::Mime.mime_type(type, nil) unless value
-      Rack::Mime::MIME_TYPES[type] = value
-    end
-
-    # Enable string or symbol key access to the nested params hash.
-    def indifferent_params(object)
-      case object
-      when Hash
-        new_hash = indifferent_hash
-        object.each { |key, value| new_hash[key] = indifferent_params(value) }
-        new_hash
-      when Array
-        object.map { |item| indifferent_params(item) }
-      else
-        object
-      end
-    end
-
-    # Creates a Hash with indifferent access.
-    def indifferent_hash
-      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-    end
-  end
-end

data/test/aliases_test.rb

@@ -1,54 +0,0 @@
-require 'setup'
-
-class A < RocketIO::Controller
-  alias_url :x
-  alias_url :y
-
-  def get; url end
-
-  class B < self
-    alias_url :x
-    alias_url :y
-
-    def get; url end
-  end
-end
-
-spec :Alises do
-
-  it 'uses application root for top-level controllers' do
-    assert(A.aliases) == %w[/x /y]
-  end
-
-  it 'uses parent root on nested controllers' do
-    assert(A::B.aliases) == %w[/a/x /a/y]
-  end
-
-  context 'HTTP requests' do
-    test 'top-level controllers' do
-      app mock_app(A)
-
-      get '/a'
-      assert(last_response).is_ok_with_body '/a'
-
-      get '/x'
-      assert(last_response).is_ok_with_body '/a'
-
-      get '/y'
-      assert(last_response).is_ok_with_body '/a'
-    end
-
-    test 'nested controllers' do
-      app mock_app(A::B)
-
-      get '/a/b'
-      assert(last_response).is_ok_with_body '/a/b'
-
-      get '/a/x'
-      assert(last_response).is_ok_with_body '/a/b'
-
-      get '/a/y'
-      assert(last_response).is_ok_with_body '/a/b'
-    end
-  end
-end

data/test/authentication_test.rb

@@ -1,307 +0,0 @@
-require 'setup'
-
-spec :AuthenticationTest do
-  context 'inheritance' do
-    it 'inherits basic auth procedures from superclass' do
-      a = mock_controller {
-        basic_auth {|u,p| [u,p] == %w[u p]}
-      }
-      b = mock_controller(a)
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      authorize 'u', 'p'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'directly overrides basic auth inherited from superclass' do
-      a = mock_controller {
-        basic_auth {|u,p| [u,p] == %w[u p]}
-      }
-      b = mock_controller(a) {
-        basic_auth {|u,p| [u,p] == %w[x y]}
-      }
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      authorize 'x', 'y'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'uses `inherit` to override basic auth inherited from superclass' do
-      a = mock_controller {
-        basic_auth {|u,p| [u,p] == %w[u p]}
-      }
-      b = mock_controller(a) {
-        basic_auth {|u,p| [u,p] == %w[x y]}
-      }
-      c = mock_controller(a) {
-        inherit :basic_auth, from: b
-      }
-      app(c)
-      get
-      assert(last_response).is_unauthorized
-      authorize 'x', 'y'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'inherits basic auth procedures' do
-      a = mock_controller {
-        basic_auth {|u,p| [u,p] == %w[u p]}
-      }
-      b = mock_controller {
-        inherit :basic_auth, from: a
-      }
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      authorize 'u', 'p'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'inherits digest auth procedures from superclass' do
-      a = mock_controller {
-        digest_auth {|u| {'u' => 'p'}[u]}
-      }
-      b = mock_controller(a)
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      digest_authorize 'u', 'p'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'directly overrides digest auth inherited from superclass' do
-      a = mock_controller {
-        digest_auth {|u| {'u' => 'p'}[u]}
-      }
-      b = mock_controller(a) {
-        digest_auth {|u| {'x' => 'y'}[u]}
-      }
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      digest_authorize 'x', 'y'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'uses `inherit` to override digest auth inherited from superclass' do
-      a = mock_controller {
-        digest_auth {|u| {'u' => 'p'}[u]}
-      }
-      b = mock_controller(a) {
-        digest_auth {|u| {'x' => 'y'}[u]}
-      }
-      c = mock_controller(a) {
-        inherit :digest_auth, from: b
-      }
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      digest_authorize 'x', 'y'
-      get
-      assert(last_response).is_authorized
-    end
-
-    it 'inherits digest auth procedures' do
-      a = mock_controller {
-        digest_auth {|u| {'u' => 'p'}[u]}
-      }
-      b = mock_controller {
-        inherit :digest_auth, from: a
-      }
-      app(b)
-      get
-      assert(last_response).is_unauthorized
-      digest_authorize 'u', 'p'
-      get
-      assert(last_response).is_authorized
-    end
-  end
-
-  context 'basic auth' do
-    context 'protect all request methods' do
-      before do
-        app mock_controller {
-          basic_auth {|u,p| [u,p] == %w[u p]}
-          RocketIO::REQUEST_METHODS.each_value {|m| define_method(m) {}}
-        }
-      end
-
-      it 'returns "401 Unauthorized" if no authorization given' do
-        RocketIO::REQUEST_METHODS.each_value do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "401 Unauthorized" if wrong authorization given' do
-        authorize('x', 'y')
-        RocketIO::REQUEST_METHODS.values.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "200 Ok" response if authorization passed' do
-        authorize('u', 'p')
-        RocketIO::REQUEST_METHODS.values.each do |rqm|
-          send(rqm)
-          assert(last_response).ok?
-        end
-      end
-    end
-
-    context 'protect specific request methods' do
-      before do
-        @protected = %w[get post]
-        app mock_controller {
-          basic_auth(:get)  {|u,p| [u,p] == ['u', 'get'] }
-          basic_auth(:post) {|u,p| [u,p] == ['u', 'post']}
-          define_method(:get) {}
-          define_method(:post) {}
-          define_method(:put) {}
-          define_method(:delete) {}
-        }
-      end
-
-      it 'returns "200 Ok" for un-protected methods' do
-        %w[put delete].each do |rqm|
-          send(rqm)
-          assert(last_response).ok?
-        end
-      end
-
-      it 'returns "401 Unauthorized" if no authorization given' do
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "401 Unauthorized" if wrong authorization given' do
-        authorize('x', 'y')
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "200 Ok" response if authorization passed' do
-        authorize('u', 'get')
-        get
-        assert(last_response).ok?
-
-        authorize('u', 'post')
-        post
-        assert(last_response).ok?
-      end
-    end
-  end
-
-  context 'digest auth' do
-    context 'hashed password' do
-      before do
-        app mock_controller {
-          digest_auth(passwords_hashed: true) {|u| {'u' => '5daad7ee02f846df2874dba8f7522112'}[u]}
-          define_method(:get) {}
-        }
-      end
-
-      it 'returns "401 Unauthorized" if no authorization given' do
-        get
-        assert(last_response).is_unauthorized
-      end
-
-      it 'returns "401 Unauthorized" if wrong authorization given' do
-        digest_authorize('x', 'y')
-        get
-        assert(last_response).is_unauthorized
-      end
-
-      it 'returns "200 Ok" response if authorization passed' do
-        digest_authorize('u', 'p')
-        get
-        assert(last_response).ok?
-      end
-    end
-
-    context 'plain password' do
-      before do
-        app mock_controller {
-          digest_auth {|u| {'u' => 'p'}[u]}
-          define_method(:get) {}
-        }
-      end
-
-      it 'returns "401 Unauthorized" if no authorization given' do
-        get
-        assert(last_response).is_unauthorized
-      end
-
-      it 'returns "401 Unauthorized" if wrong authorization given' do
-        digest_authorize('x', 'y')
-        get
-        assert(last_response).is_unauthorized
-      end
-
-      it 'returns "200 Ok" response if authorization passed' do
-        digest_authorize('u', 'p')
-        get
-        assert(last_response).ok?
-      end
-    end
-
-    context 'protect specific request methods' do
-      before do
-        @protected = %w[get post]
-        app mock_controller {
-          digest_auth(:get)  {|u| {'u' => 'get'}[u] }
-          digest_auth(:post) {|u| {'u' => 'post'}[u]}
-          define_method(:get) {}
-          define_method(:post) {}
-          define_method(:put) {}
-          define_method(:delete) {}
-        }
-      end
-
-      it 'returns "200 Ok" for un-protected methods' do
-        %w[put delete].each do |rqm|
-          send(rqm)
-          assert(last_response).ok?
-        end
-      end
-
-      it 'returns "401 Unauthorized" if no authorization given' do
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "401 Unauthorized" if wrong authorization given' do
-        digest_authorize('x', 'y')
-        @protected.each do |rqm|
-          send(rqm)
-          assert(last_response).is_unauthorized
-        end
-      end
-
-      it 'returns "200 Ok" response if authorization passed' do
-        digest_authorize('u', 'get')
-        get
-        assert(last_response).ok?
-
-        digest_authorize('u', 'post')
-        post
-        assert(last_response).ok?
-      end
-    end
-  end
-end