cargobull 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 868c60b92a3cf7f1763e57529d5d504c2f32a3a4
+  data.tar.gz: 1d6a799fdf3b5832eee6c2f4a981ac1c3325fcfa
+SHA512:
+  metadata.gz: 391caf4e77d14fab93440ee642eb2beec5dc568c739a7d267eb707befa344c9712c5088db13ad3491bbff41ba2a4b30a26f523e934fea23206501801a97d5a41
+  data.tar.gz: 1edbfe36a522992ac5ebc7710dc4b3cef40ffc3438e6fa2245b8703b36cae8a1a77e9731876056b59846693d695ab00f7e78b990556184b60be9f9ecd79f8fa6

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2014, Matthias Geier
+Copyright (c) 2014-2016, Matthias Geier
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/lib/cargobull.rb

@@ -4,6 +4,19 @@ require 'cargobull/service'
 require 'cargobull/dispatch'
 require 'cargobull/rackup'
 
+module Cargobull
+  def self.runner(cargoenv=env.get)
+    ->(env) do
+      cenv = cargoenv.dup
+      cenv[:rackenv] = env
+      cenv[:request_path] = env["REQUEST_PATH"]
+      cenv[:request_method] = env["REQUEST_METHOD"]
+      cenv.freeze
+      Rackup.call(cenv)
+    end
+  end
+end
+
 if File.exist?('./setup.rb')
   require 'cargobull/initialize'
   require './setup'

data/lib/cargobull/dispatch.rb

@@ -1,47 +1,50 @@
 
 module Cargobull
   module Dispatch
-    def self.translate_method_call(method)
-      return case method.to_s.downcase
-      when "get", "post"
-        :read
-      when "put"
-        :create
-      when "patch"
-        :update
-      when "delete"
-        :delete
-      else
-        raise RuntimeError.new("Unsupported method: #{method}")
-      end
+    METHOD_MAP = {
+      "GET" => :read,
+      "POST" => :create,
+      "PATCH" => :update,
+      "PUT" => :update,
+      "DELETE" => :delete
+    }
+
+    def self.translate_method_call(env, method)
+      METHOD_MAP[method.to_s] ||
+        [405, { "Content-Type" => env[:ctype] }, env[:e405] ]
+    end
+
+    def self.translate_action_call(env, action)
+      Service.dispatch_to(action) ||
+        [404, { "Content-Type" => env[:ctype] }, env[:e404] ]
     end
 
-    def self.translate_action_call(action)
-      klass = Service.dispatch_to(action)
-      if klass.nil?
-        raise RuntimeError.new("Unsupported action: #{action}")
-      end
-      return klass
+    def self.call(env, method, action, *params)
+      dispatch(env, env[:transform_in], env[:transform_out], method, action,
+        *params)
     end
 
-    def self.call(method, action, *args)
-      klass = self.translate_action_call(action)
+    def self.dispatch(env, tfin, tfout, method, action, *params)
+      klass = translate_action_call(env, action)
+      return klass if klass.is_a?(Array) # break on error
+      klass = klass.constantize
+
+      method = translate_method_call(env, method)
+      return method if method.is_a?(Array) # break on error
 
-      blk = Cargobull.env.transform_in
-      args = [blk.call(*args)] if blk
+      params = tfin.call(*params) if tfin
 
-      obj = klass.new(*args)
-      method = self.translate_method_call(method)
-      unless obj.respond_to?(method)
-        raise RuntimeError.new("#{action} does not respond to #{method}")
-      end
+      obj = klass.is_a?(Class) ? klass.new : klass
 
-      return self.transform(obj.send(method))
+      return obj.respond_to?(method) ?
+        transform(env, obj.send(method, *params), &tfout) :
+        [404, { "Content-Type" => env[:ctype] }, env[:e404]]
     end
 
-    def self.transform(data)
-      blk = Cargobull.env.transform_out
-      return blk ? blk.call(data) : data
+    def self.transform(env, data)
+      data = yield(data) if block_given?
+      return data.is_a?(Array) && data.count == 3 ? data :
+        [200, { "Content-Type" => env[:ctype] }, data]
     end
   end
 end

data/lib/cargobull/env.rb

@@ -1,31 +1,35 @@
 
 module Cargobull
   def self.env
-    return Env
+    Env
   end
 
-  class Env
-    class << self
-      attr_reader :dispatch_url, :serve_url, :transform_out, :transform_in
-      attr_accessor :default_files, :default_path
-    end
-
-    @dispatch_url = "/"
-    @serve_url = "/files"
-    @default_files = ['index.html', 'index.htm']
+  module Env
+    DEFAULTS = {
+      dispatch_url: "/api",
+      file_url: "/",
+      default_files: ["index.html", "index.htm"],
+      default_path: nil,
+      ctype: "text/plain",
+      e403: "Forbidden",
+      e404: "Not found",
+      e405: "Method not allowed",
+      e500: "Internal error",
+      transform_out: nil,
+      transform_in: nil
+    }
 
-    def self.dispatch_url=(url)
-      sanitized_url = (url || "").split('/').reject(&:empty?).first
-      @dispatch_url = sanitized_url ? "/#{sanitized_url}" : "/"
-      @serve_url = sanitized_url ? "/" : "/files"
+    def self.get(*args)
+      update(DEFAULTS.dup, *args)
     end
 
-    def self.transform_out=(blk)
-      @transform_out = blk
-    end
+    def self.update(env, *args)
+      (args.first.is_a?(Hash) ? args.first : Hash[*args]).reduce(env) do
+        |acc, (k, v)|
 
-    def self.transform_in=(blk)
-      @transform_in = blk
+        acc[k.to_sym] = respond_to?(k) ? send(k, v) : v
+        next acc
+      end
     end
   end
 end

data/lib/cargobull/extensions/string.rb

@@ -33,24 +33,31 @@
 #
 class String
   def constantize
-    return self.to_s.split('::').reduce(Module){ |m, c| m.const_get(c) }
+    split('::').reduce(Module){ |m, c| m.const_get(c) }
+  end
+
+  def path_to_modules
+    split(/\//).map(&:capitalize).join('::')
+  end
+
+  def modules_to_path
+    sub(/:+/, '/')
   end
 
   def camelize
-    return self.to_s.split(/_/).map(&:capitalize).join.
-      split(/\//).map(&:capitalize).join('::')
+    split(/_/).map(&:capitalize).join.path_to_modules
   end
 
   def camelize!
-    self.replace(self.to_s.camelize)
+    replace(camelize)
   end
 
   def underscore
-    return self.to_s.sub(/:+/, '/').split(/([A-Z]?[^A-Z]*)/).reject(&:empty?).
+    modules_to_path.split(/([A-Z]?[^A-Z]*)/).reject(&:empty?).
       map(&:downcase).join('_').gsub(/\/_/, '/')
   end
 
   def underscore!
-    self.replace(self.to_s.underscore)
+    replace(underscore)
   end
 end

data/lib/cargobull/initialize.rb

@@ -4,7 +4,7 @@ module Cargobull
     @file_map = []
 
     def self.sanitize_file_name(file_name)
-      return "./#{File.basename(file_name)}"
+      "./#{File.basename(file_name)}"
     end
 
     def self.dir(*args)
@@ -13,18 +13,9 @@ module Cargobull
 
       sanitized_args.each do |dir|
         ruby_files = Dir["#{dir}/**/*.rb"]
-        @file_map = ruby_files.reduce(@file_map) do |acc, f|
-          file_name = f.sub(/^#{dir}\/?/, '').sub(/\.rb$/, '').camelize
-          *mods, klass_name = file_name.split('::')
-          mod = mods.reduce(Object) do |acc, mod_str|
-            unless acc.const_defined?(mod_str)
-              acc.const_set(mod_str, Module.new)
-            end
-            next acc.const_get(mod_str)
-          end
-
-          mod.autoload(klass_name, f)
-          acc << f
+        @file_map = ruby_files.each do |f|
+          full_klass = f.sub(/^#{dir}\/?/, '').sub(/\.rb$/, '').camelize
+          register_file(full_klass, f)
         end
       end
     end
@@ -32,8 +23,21 @@ module Cargobull
     def self.file(klass_str, file_name)
       file_name = sanitize_file_name(file_name)
       return unless File.file?(file_name)
-      Object.autoload(klass_str, file_name)
-      @file_map << file_name
+      register_file(klass_str, file_name)
+    end
+
+    def self.register_file(full_klass, fname)
+      *mods, klass_name = full_klass.split('::')
+      mod = mods.reduce(Object) do |acc, mod_str|
+        unless acc.const_defined?(mod_str)
+          acc.const_set(mod_str, Module.new)
+        end
+        next acc.const_get(mod_str)
+      end
+
+      mod.autoload(klass_name, fname)
+      @file_map << fname
+      Service.register(full_klass)
     end
 
     def self.init_all

data/lib/cargobull/rackup.rb

@@ -1,50 +1,53 @@
 
 module Cargobull
-  class Rackup
-    def file(env)
-      path = env["REQUEST_PATH"]
-      path.gsub!(/\/\.+/, '')
-      path.sub!(/^#{Cargobull.env.serve_url}\/?/i, '')
+  module Rackup
+    def self.file(env)
+      path = env[:request_path].gsub(/\/\.+/, '').
+        sub(/^#{env[:serve_url]}\/?/i, '')
       if path.empty?
-        path = Cargobull.env.default_files.detect do |f|
+        path = env[:default_files].detect do |f|
           File.file?("./files/#{f}")
         end
       end
       path = "./files/#{path}"
       if File.file?(path)
         return [200, {}, File.open(path, File::RDONLY)]
-      elsif Cargobull.env.default_path
-        return [200, {},
-          File.open("./files/#{Cargobull.env.default_path}", File::RDONLY)]
+      elsif env[:default_path]
+        return [200, {}, File.open("./files/#{env[:default_path]}",
+          File::RDONLY)]
       else
-        return [404, {}, "Not found"]
+        return [404, { "Content-Type" => env[:ctype] }, env[:e404] ]
       end
     end
 
-    def dispatch(env)
-      req = Rack::Request.new(env)
-      action = env["REQUEST_PATH"].sub(/^#{Cargobull.env.dispatch_url}\/?/, '').
-        gsub(/\/[^\/]+/, '')
-      params = req.POST.merge(req.GET)
-      data = Cargobull::Dispatch.call(env["REQUEST_METHOD"], action, params)
-      return [200, {}, data]
-    rescue RuntimeError
-      return [404, {}, "Not found"]
+    def self.dispatch(env)
+      req = Rack::Request.new(env[:rackenv])
+      action = env[:request_path].sub(/^#{env[:dispatch_url]}\/?/, '')
+      params = req.GET
+      if req.content_type == "application/x-www-form-urlencoded"
+        params.merge!(req.POST)
+      else
+        params[:body] = req.body
+      end
+      return Dispatch.call(env, env[:request_method], action, params)
     end
 
-    def self.routes
-      routes = [
-        [/^#{Cargobull.env.serve_url}\/?/i, :file],
-        [/^#{Cargobull.env.dispatch_url}\/?/i, :dispatch]
-      ]
-      routes.reverse! if Cargobull.env.serve_url == '/'
+    def self.routes(env)
+      routes = [:file, :dispatch].map do |type|
+        [/^#{env["#{type}_url".to_sym]}\/?/i, type]
+      end
+      routes.reverse! if env[:file_url] == '/'
       return routes.unshift([/^\/favicon/i, :file])
     end
 
-    def call(env)
-      path = env["REQUEST_PATH"]
-      _, match_method = self.class.routes.detect{ |pattern, _| path =~ pattern }
-      return self.send(match_method, env)
+    def self.call(env)
+      path = env[:request_path]
+      _, match_method = routes(env).detect{ |pattern, _| path =~ pattern }
+      if match_method.nil?
+        return [500, { "Content-Type" => env[:ctype] }, env[:e500] ]
+      else
+        return send(match_method, env)
+      end
     end
   end
 end

data/lib/cargobull/service.rb

@@ -8,21 +8,17 @@ module Cargobull
     end
 
     def self.dispatch_to(action)
-      return self.dispatch.detect do |klass|
-        next klass.name.underscore == action.to_s
+      return dispatch.detect do |klass_name|
+        next klass_name.underscore == action.to_s
       end
     end
 
-    def self.register(klass)
-      @dispatch << klass
+    def self.register(klass_name)
+      @dispatch << klass_name unless @dispatch.include?(klass_name)
     end
 
     def self.included(base)
-      self.register base
-    end
-
-    def initialize(*args)
-      @params = args.shift || {}
+      register(base.name)
     end
   end
 end

data/lib/cargobull/test_helper.rb

@@ -2,33 +2,11 @@ require 'cargobull'
 
 module Cargobull
   module TestHelper
-    def response
-      return @response || ""
-    end
-
     [:get, :post, :put, :patch, :delete].each do |m|
-      define_method(m) do |action, *args|
-        @response = nil
-        @response = Cargobull::Dispatch.call(m, action, *args)
-      end
-    end
-
-    def assert_raise(except_klass)
-      begin
-        yield
-      rescue except_klass
-        assert true
-        return
-      end
-      assert false
-    end
-
-    def assert_nothing_raised
-      begin
-        yield
-        assert true
-      rescue
-        assert false
+      define_method(m) do |env, action, *args, &blk|
+        r = Cargobull::Dispatch.call(env, m.to_s.upcase, action, *args)
+        blk.call(r) if block_given?
+        next r
       end
     end
   end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cargobull
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Matthias Geier
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-28 00:00:00.000000000 Z
+date: 2016-04-14 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -17,38 +16,37 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.md
 - lib/cargobull.rb
-- lib/cargobull/service.rb
-- lib/cargobull/test_helper.rb
 - lib/cargobull/dispatch.rb
-- lib/cargobull/initialize.rb
-- lib/cargobull/rackup.rb
 - lib/cargobull/env.rb
 - lib/cargobull/extensions/string.rb
-- LICENSE.md
+- lib/cargobull/initialize.rb
+- lib/cargobull/rackup.rb
+- lib/cargobull/service.rb
+- lib/cargobull/test_helper.rb
 homepage: https://github.com/matthias-geier/cargobull
 licenses:
 - BSD-2
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Multipurpose dispatcher for RESTful services
 test_files: []