rocketio 0.0.0 → 0.0.1

data/lib/rocketio/util.rb

@@ -0,0 +1,122 @@
+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/lib/rocketio/version.rb

@@ -1,3 +1,3 @@
-module Rocketio
-  VERSION = "0.0.0"
+module RocketIO
+  VERSION = '0.0.1'.freeze
 end

data/rocketio.gemspec

@@ -1,23 +1,27 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'rocketio/version'
+require File.expand_path('../lib/rocketio/version', __FILE__)
 
 Gem::Specification.new do |spec|
-  spec.name          = "rocketio"
-  spec.version       = Rocketio::VERSION
-  spec.authors       = ["Slee Woo"]
-  spec.email         = ["mail@sleewoo.com"]
-  spec.summary       = %q{Write a short summary. Required.}
-  spec.description   = %q{Write a longer description. Optional.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.name          = 'rocketio'
+  spec.version       = String.new(RocketIO::VERSION)
+  spec.authors       = ['Slee Woo']
+  spec.email         = ['mail@sleewoo.com']
+  spec.summary       = [spec.name, spec.version]*'-',
+  spec.description   = 'Simple, fast, scalable web framework for Ruby'
+  spec.homepage      = 'https://github.com/rocketio/' + spec.name
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /(gem|lock)\z/}
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.required_ruby_version = '~> 2.0'
+
+  spec.add_runtime_dependency 'rack', '~> 1.5'
+  spec.add_runtime_dependency 'mustache', '~> 1'
+  spec.add_runtime_dependency 'tilt', '~> 2'
+
+  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'
 end

data/test/aliases_test.rb

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

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