gin 0.0.0 → 1.0.0

data/lib/gin/response.rb

@@ -0,0 +1,51 @@
+class Gin::Response < Rack::Response
+
+  NO_HEADER_STATUSES = [100, 101, 204, 205, 304].freeze #:nodoc:
+  H_CTYPE   = "Content-Type".freeze   #:nodoc:
+  H_CLENGTH = "Content-Length".freeze #:nodoc:
+
+  attr_accessor :status
+  attr_reader :body
+
+  def body= value
+    value = value.body while Rack::Response === value
+    @body = value.respond_to?(:each) ? value : [value.to_s]
+    @body
+  end
+
+
+  def finish
+    body_out = body
+    header[H_CTYPE] ||= 'text/html;charset=UTF-8'
+
+    if NO_HEADER_STATUSES.include?(status.to_i)
+      header.delete H_CTYPE
+      header.delete H_CLENGTH
+
+      if status.to_i > 200
+        close
+        body_out = []
+      end
+    end
+
+    update_content_length
+
+    [status.to_i, header, body_out]
+  end
+
+
+  private
+
+  def update_content_length
+    if header[H_CTYPE] && !header[H_CLENGTH]
+      case body
+      when Array
+        header[H_CLENGTH] = body.inject(0) do |l, p|
+                              l + Rack::Utils.bytesize(p)
+                            end.to_s
+      when File
+        header[H_CLENGTH] = body.size.to_s
+      end
+    end
+  end
+end

data/lib/gin/router.rb

@@ -0,0 +1,222 @@
+class Gin::Router
+
+  class PathArgumentError < Gin::Error; end
+
+  class Mount
+    DEFAULT_ACTION_MAP = {
+      :index   => %w{get /},
+      :show    => %w{get /:id},
+      :new     => %w{get /new},
+      :create  => %w{post /:id},
+      :edit    => %w{get /:id/edit},
+      :update  => %w{put /:id},
+      :destroy => %w{delete /:id}
+    }
+
+    VERBS = %w{get post put delete head options trace}
+
+    VERBS.each do |verb|
+      define_method(verb){|action, *args| add(verb, action, *args)}
+    end
+
+
+    def initialize ctrl, base_path, sep="/", &block
+      @sep       = sep
+      @ctrl      = ctrl
+      @routes    = []
+      @actions   = []
+      @base_path = base_path.split(@sep)
+
+      instance_eval(&block) if block_given?
+      defaults unless block_given?
+    end
+
+
+    # Create restful routes if they aren't taken already.
+    def defaults restful_only=false
+      (@ctrl.actions - @actions).each do |action|
+        verb, path = DEFAULT_ACTION_MAP[action]
+        verb, path = ['get', "/#{action}"] if !restful_only && verb.nil?
+
+        add(verb, action, path) unless verb.nil? ||
+          @routes.any?{|(r,n,(c,a,p))| r == make_route(verb, path)[0] }
+      end
+    end
+
+
+    def any action, path=nil
+      VERBS.each{|verb| send verb, action, path}
+    end
+
+
+    def make_route verb, path
+      param_keys = []
+      route = [verb].concat @base_path
+      route.concat path.split(@sep)
+      route.delete_if{|part| part.empty?}
+
+      route.map! do |part|
+        if part[0] == ":"
+          param_keys << part[1..-1]
+          "%s"
+        else
+          part
+        end
+      end
+
+      [route, param_keys]
+    end
+
+
+    def add verb, action, *args
+      path = args.shift        if String === args[0]
+      name = args.shift.to_sym if args[0]
+
+      path ||= action.to_s
+      name ||= :"#{action}_#{@ctrl.controller_name}"
+
+      route, param_keys = make_route(verb, path)
+      @routes << [route, name, [@ctrl, action, param_keys]]
+      @actions << action.to_sym
+    end
+
+
+    def each_route &block
+      @routes.each{|(route, name, value)| block.call(route, name, value) }
+    end
+  end
+
+
+  class Node
+    attr_accessor :value
+
+    def initialize
+      @children = {}
+    end
+
+    def [] key
+      @children[key]
+    end
+
+    def add_child key, val=nil
+      @children[key] ||= Node.new
+      @children[key].value = val unless val.nil?
+    end
+  end
+
+
+  def initialize separator="/" # :nodoc:
+    @sep = separator
+    @routes_tree = Node.new
+    @routes_lookup = {}
+  end
+
+
+  ##
+  # Add a Controller to the router with a base path.
+
+  def add ctrl, base_path=nil, &block
+    base_path ||= ctrl.controller_name
+
+    mount = Mount.new(ctrl, base_path, @sep, &block)
+
+    mount.each_route do |route_ary, name, val|
+      curr_node = @routes_tree
+
+      route_ary.each do |part|
+        curr_node.add_child part
+        curr_node = curr_node[part]
+      end
+
+      curr_node.value = val
+      route = [route_ary[0], "/" << route_ary[1..-1].join(@sep), val[2]]
+
+      @routes_lookup[name]      = route if name
+      @routes_lookup[val[0..1]] = route
+    end
+  end
+
+
+  ##
+  # Check if a Controller and action combo has a route.
+
+  def has_route? ctrl, action
+    !!@routes_lookup[[ctrl, action]]
+  end
+
+
+  ##
+  # Yield every Controller, action, route combination.
+
+  def each_route &block
+    @routes_lookup.each do |key,route|
+      next unless Array === key
+      block.call route, key[0], key[1]
+    end
+  end
+
+
+  ##
+  # Get the path to the given Controller and action combo or route name,
+  # provided with the needed params. Routes with missing path params will raise
+  # MissingParamError. Returns a String starting with "/".
+  #
+  #   path_to FooController, :show, :id => 123
+  #   #=> "/foo/123"
+  #
+  #   path_to :show_foo, :id => 123
+  #   #=> "/foo/123"
+
+  def path_to *args
+    key = Class === args[0] ? args.slice!(0..1) : args.shift
+    verb, route, param_keys = @routes_lookup[key]
+    raise PathArgumentError, "No route for #{Array(key).join("#")}" unless route
+
+    params = (args.pop || {}).dup
+
+    route = route.dup
+    route = route % param_keys.map do |k|
+      params.delete(k) || params.delete(k.to_sym) ||
+        raise(PathArgumentError, "Missing param #{k}")
+    end unless param_keys.empty?
+
+    route << "?#{Gin.build_query(params)}" unless params.empty?
+
+    route
+  end
+
+
+  ##
+  # Takes a path and returns an array of 3 items:
+  #   [controller_class, action_symbol, path_params_hash]
+  # Returns nil if no match was found.
+
+  def resources_for http_verb, path
+    param_vals = []
+    curr_node  = @routes_tree[http_verb.to_s.downcase]
+
+    path.scan(%r{/([^/]+|$)}) do |(key)|
+      next if key.empty?
+
+      if curr_node[key]
+        curr_node = curr_node[key]
+
+      elsif curr_node["%s"]
+        param_vals << key
+        curr_node = curr_node["%s"]
+
+      else
+        return
+      end
+    end
+
+    return unless curr_node.value
+    rsc = curr_node.value.dup
+
+    rsc[-1] = param_vals.empty? ?
+              Hash.new :
+              rsc[-1].inject({}){|h, name| h[name] = param_vals.shift; h}
+
+    rsc
+  end
+end

data/lib/gin/stream.rb

@@ -0,0 +1,56 @@
+##
+# Taken from Sinatra.
+#
+# Class of the response body in case you use #stream.
+#
+# Three things really matter: The front and back block (back being the
+# block generating content, front the one sending it to the client) and
+# the scheduler, integrating with whatever concurrency feature the Rack
+# handler is using.
+#
+# Scheduler has to respond to defer and schedule.
+
+class Gin::Stream
+  def self.schedule(*) yield end
+  def self.defer(*)    yield end
+
+
+  def initialize(scheduler = self.class, keep_open = false, &back)
+    @back, @scheduler, @keep_open = back.to_proc, scheduler, keep_open
+    @callbacks, @closed = [], false
+  end
+
+  def close
+    return if @closed
+    @closed = true
+    @scheduler.schedule { @callbacks.each { |c| c.call }}
+  end
+
+  def each(&front)
+    @front = front
+    @scheduler.defer do
+      begin
+        @back.call(self)
+      rescue Exception => e
+        @scheduler.schedule { raise e }
+      end
+      close unless @keep_open
+    end
+  end
+
+  def <<(data)
+    @scheduler.schedule { @front.call(data.to_s) }
+    self
+  end
+
+  def callback(&block)
+    return yield if @closed
+    @callbacks << block
+  end
+
+  alias errback callback
+
+  def closed?
+    @closed
+  end
+end

data/public/400.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Bad Request</title>
+    <link rel="stylesheet" type="text/css" href="/gin.css"/>
+  </head>
+  <body>
+    <div class="canvas error">
+      <h1>Bad Request</h1>
+      <p>The server could not process your request as formed.</p>
+    </div>
+  </body>
+</html>
+

data/public/404.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Page Not Found</title>
+    <link rel="stylesheet" type="text/css" href="/gin.css"/>
+  </head>
+  <body>
+    <div class="canvas error">
+      <h1>Page Not Found</h1>
+      <p>The page you requested does not exist.</p>
+    </div>
+  </body>
+</html>

data/public/500.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Server Error</title>
+    <link rel="stylesheet" type="text/css" href="/gin.css"/>
+  </head>
+  <body>
+    <div class="canvas error">
+      <h1>Server Error</h1>
+      <p>An unexpected error occurred. We have been notified, of this issue.<br/>
+    Please check again later.</p>
+    </div>
+  </body>
+</html>

data/public/error.html

@@ -0,0 +1,38 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>%s</title>
+    <link rel="stylesheet" type="text/css" href="/gin.css"/>
+  </head>
+  <body>
+    <div class="canvas">
+      <img src="/gin_sm.png" class="logo"/>
+      <h1>%s</h1>
+      <p>%s</p>
+      <div id="apptrace" class="trace">
+        <a href="#" onclick="show_fulltrace()">Show Full Trace</a>
+        %s
+      </div>
+      <div id="fulltrace" class="trace">
+        <a href="#" onclick="hide_fulltrace()">Hide Full Trace</a>
+        %s
+      </div>
+    </div>
+    <script>
+var apptrace  = document.getElementById('apptrace');
+var fulltrace = document.getElementById('fulltrace');
+
+function show_fulltrace(){
+  apptrace.style.display  = "none";
+  fulltrace.style.display = "block";
+  return true;
+}
+
+function hide_fulltrace(){
+  apptrace.style.display  = "block";
+  fulltrace.style.display = "none";
+  return true;
+}
+    </script>
+  </body>
+</html>

data/public/gin.css

@@ -0,0 +1,61 @@
+
+body {
+  font-family: Helvetica Neue, Helvetica, Sans-Serif;
+  background-color: #eee;
+  margin: 50px;
+}
+
+.canvas {
+  border: 1px solid #ccc;
+  padding: 12px;
+  padding-top: 10px;
+  border-radius: 15px;
+  box-shadow: 3px 3px 10px #aaa;
+  background-color: #fff;
+  margin: 0 auto;
+  margin-top: 50px;
+  max-width: 1200px;
+}
+
+.canvas h1 {
+  margin-top: 0;
+  border-bottom: 1px solid #ccc;
+}
+
+.canvas pre {
+  clear: both;
+  margin: 15px;
+  padding: 15px;
+  border: 1px solid #ccc;
+  overflow: scroll;
+  background-color: #efefef;
+  border-radius: 10px;
+  box-shadow: 3px 3px -10px #aaa;
+}
+
+.error {
+  width: 500px;
+}
+
+.trace a {
+  float: right;
+  color: #687c93;
+  font-size: 12px;
+  text-decoration: none;
+  position: relative;
+  top: -75px;
+  margin-right: 15px;
+}
+
+#fulltrace {
+  display: none;
+}
+
+img.logo {
+  float: left;
+  position: relative;
+  top: -35px;
+  left: -35px;
+  margin-bottom: -50px;
+  margin-right: -25px;
+}