RubyGems - patchbay - Versions diffs - 0.0.1.pre - Mend

patchbay 0.0.1.pre

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

data/lib/patchbay.rb +231 -0
metadata +46 -0

data/lib/patchbay.rb ADDED Viewed

@@ -0,0 +1,231 @@
+require 'rack/mime'
+require 'rack/handler'
+class Patchbay
+    class Route < Struct.new(:handler, :url_parts, :verb)
+    end
+    NoRoute_Message = <<EOT
+<html><body>
+<h1>404</h1><p>Patchbay: Routing Error</p>
+</body></html>
+EOT
+    Forbidden_Message = <<EOT
+<html><body>
+<h1>403</h1>
+<p>Forbidden</p>
+</body></html>
+EOT
+    Exception_Message = <<EOT
+<html><body>
+<h1>500</h1>
+<p>Internal Server Error</p>
+</body></html>
+EOT
+    def path_is_subdir_of(path_to_test, root_path)
+        File.fnmatch(File.join(root_path, '**'), File.realpath(path_to_test))
+    end
+    class Router
+        def initialize
+            @routes = []
+        end
+        def matches?(route, url_parts)
+            if route.url_parts.size != url_parts.size
+                return false
+            end
+            params = { }
+            route.url_parts.zip(url_parts) do |parts|
+                route_url_part = parts[0]
+                url_part = parts[1]
+                if route_url_part =~ /:(.+)/
+                    params[$1.intern] = url_part
+                else
+                    if route_url_part != url_part
+                        return false
+                    end
+                end
+            end
+            return params
+        end
+        def match(verb, url)
+            parts = url.gsub(/^\/+/,'').split('/')
+            @routes.each do |route|
+                if route.verb == verb
+                    result = matches?(route, parts)
+                    if result
+                        return [ route.handler, result ]
+                    end
+                end
+            end
+            return [ nil, nil ]
+        end
+        def add(verb, route, handler)
+            parts = route.gsub(/^\/+/,'').split('/')
+            routeObj = Route.new
+            routeObj.url_parts = parts
+            routeObj.handler = handler
+            routeObj.verb = verb
+            @routes << routeObj
+        end
+    end
+    def self.router
+        @router ||= Router.new
+        @router
+    end
+    def router
+        self.class.router
+    end
+    def self.get(route, &action)
+        router.add('GET', route, action)
+    end
+    def self.put(route, &action)
+        router.add('PUT', route, action)
+    end
+    def self.post(route, &action)
+        router.add('POST', route, action)
+    end
+    def self.delete(route, &action)
+        router.add('DELETE', route, action)
+    end
+    def self.files_dir
+        @files_dir
+    end
+    def self.files_dir=(new_dir)
+        @files_dir = File.realpath(new_dir)
+    end
+    def files_dir
+        self.class.files_dir
+    end
+    def environment
+        @environment
+    end
+    def params
+        @params
+    end
+    def handle_file
+        url_parts = environment['PATH_INFO'].split('/')
+        file_path = File.join(files_dir, url_parts)
+        if File.exists?(file_path) and path_is_subdir_of(file_path, files_dir)
+            if File.readable?(file_path)
+                send_file(file_path)
+            else
+                handle_forbidden
+            end
+        elsif File.exists?(file_path)
+            handle_no_route
+        else
+            handle_no_route
+        end
+    end
+    def send_file(file_path)
+        mime_type = Rack::Mime.mime_type(File.extname(file_path))
+        @response = [200, { "Content-Type" => mime_type }, File.new(file_path)]
+    end
+    def call(env)
+        # find a handler for this request
+        handler, route_params = router.match(env['REQUEST_METHOD'], env['PATH_INFO'])
+        @params = route_params
+        @environment = env
+        @response = nil
+        begin
+            if handler
+                self.instance_eval(&handler)
+            else
+                if files_dir
+                    handle_file
+                else
+                    handle_no_route
+                end
+            end
+            unless @response
+                fail "No response was generated"
+            end
+        rescue Exception => e
+            handle_exception(e)
+        end
+        @response
+    end
+    def render(options={})
+        if @response
+            fail "can only render once per request"
+        end
+        @response = [200, { "Content-Type" => "text/html" }, []]
+        options.each do |key, value|
+            case key
+                when :error
+                    @response[0] = value
+                else
+                    @response[1]["Content-Type"] = Rack::Mime.mime_type("."+key.to_s)
+                    @response[2] << value
+            end
+        end
+    end
+    def handle_no_route
+        @response = [404, { "Content-Type" => "text/html" }, [NoRoute_Message]]
+    end
+    def handle_exception(e)
+        @response = [500, { "Content-Type" => "text/html" }, [Exception_Message]]
+        $stderr.puts e.inspect
+        e.backtrace.each { |bt| $stderr.puts bt }
+    end
+    def handle_forbidden
+        @response = [403, { "Content-Type" => "text/html" }, [Forbidden_Message]]
+    end
+    def run(options={})
+        handler = find_rack_handler
+        handler_name = handler.name.gsub(/.*::/,'')
+        $stderr.puts "Patchbay starting, using #{handler_name}"
+        handler.run(self, options)
+    end
+private
+    def find_rack_handler
+        servers = %w/thin mongrel webrick/
+        servers.each do |server|
+            begin
+                return Rack::Handler.get(server)
+            rescue LoadError
+            end
+        end
+    end
+end

metadata ADDED Viewed

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: patchbay
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Andrew Armenia
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-09-13 00:00:00.000000000Z
+dependencies: []
+description: ! "Patchbay is the web framework for non-web apps. \nIt's designed for
+  simplicity, minimalism, and easy integration.\n"
+email: andrew@asquaredlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/patchbay.rb
+homepage: http://rubygems.org/gems/patchbay
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.6
+signing_key:
+specification_version: 3
+summary: Embed HTTP APIs in non-web apps easily
+test_files: []