sinatras-hat 0.0.3 → 0.1.1

data/lib/core_ext/array.rb

@@ -2,16 +2,4 @@ class Array
   def extract_options!
     last.is_a?(Hash) ? pop : { }
   end
-  
-  def move_to_front(*entries)
-    entries.each do |entry|
-      unshift(entry) if delete(entry)
-    end
-  end
-  
-  def move_to_back(*entries)
-    entries.each do |entry|
-      push(entry) if delete(entry)
-    end
-  end
 end

data/lib/core_ext/hash.rb

@@ -1,8 +1,7 @@
 class Hash
   def make_indifferent!
     keys_values = self.dup
-    indifferent = Hash.new { |h,k| h[k.to_s] if Symbol === k }
-    replace(indifferent)
+    replace(Hash.new { |h,k| h[k.to_s] if Symbol === k })
     merge!(keys_values)
   end
   
@@ -10,7 +9,7 @@ class Hash
     new_params = Hash.new.make_indifferent!
     each_pair do |full_key, value| 
       this_param = new_params
-      split_keys = full_key.split(/\]\[|\]|\[/) 
+      split_keys = full_key.to_s.split(/\]\[|\]|\[/)
       split_keys.each_index do |index| 
         break if split_keys.length == index + 1 
         this_param[split_keys[index]] ||= Hash.new.make_indifferent!

data/lib/core_ext/module.rb

@@ -0,0 +1,14 @@
+class Module
+  def delegate(*methods)
+    options = methods.pop
+    raise ArgumentError, "Delegation needs a target." unless options.is_a?(Hash) && to = options[:to]
+
+    methods.each do |method|
+      module_eval(<<-EOS, "(__DELEGATION__)", 1)
+        def #{method}(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)
+        end
+      EOS
+    end
+  end
+end

data/lib/core_ext/object.rb

@@ -6,10 +6,6 @@ class Object
     self
   end
   
-  def try(m, *a, &b)
-    respond_to?(m) ? send(m, *a, &b) : nil
-  end
-  
   def with(hash)
     hash.each do |key, value|
       meta_def(key) { hash[key] } unless respond_to?(key)

data/lib/sinatras-hat.rb

@@ -1,23 +1,23 @@
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'core_ext')
-$LOAD_PATH << File.join(File.dirname(__FILE__), 'sinatras-hat')
+$LOAD_PATH << File.join(File.dirname(__FILE__))
 
-require 'erb'
+require 'rubygems'
+require 'benchmark'
+require 'sinatra/base'
 require 'extlib'
-require 'dm-core'
-require 'dm-serializer'
-require 'array'
-require 'hash'
-require 'object'
-require 'action'
-require 'actions'
-require 'responses'
-require 'maker'
 
-load 'auth.rb'
+require 'core_ext/array'
+require 'core_ext/hash'
+require 'core_ext/object'
+require 'core_ext/module'
 
-Rack::File::MIME_TYPES['json'] = 'text/x-json'
-Rack::File::MIME_TYPES['yaml'] = 'text/x-yaml'
-
-def mount(model, opts={}, &block)
-  Sinatra::Hat::Maker.new(model).define(self, opts, &block)
-end
+require 'sinatras-hat/logger'
+require 'sinatras-hat/extendor'
+require 'sinatras-hat/authentication'
+require 'sinatras-hat/hash_mutator'
+require 'sinatras-hat/resource'
+require 'sinatras-hat/response'
+require 'sinatras-hat/responder'
+require 'sinatras-hat/model'
+require 'sinatras-hat/router'
+require 'sinatras-hat/actions'
+require 'sinatras-hat/maker'

data/lib/sinatras-hat/actions.rb

@@ -1,65 +1,50 @@
 module Sinatra
   module Hat
+    # Contains all of the actions that Sinatra's Hat supports.
+    # Each action states a name, a path, optionally, the HTTP
+    # verb, then a block which takes a request object, optionally
+    # loads data using the :finder or :record options, then
+    # responds, based on whether or not the action was a success
+    # 
+    # NOTE: only the :create action renders a different :failure
     module Actions
-      def generate_actions!
-        only.each { |action| send("#{action}!") }
-        children.each do |resource|
-          mount(resource)
-        end
-      end
-      
-      def index!
-        map :index, '/' do |params|
-          call(:finder, params)
-        end
-      end
-    
-      def new!
-        map :new, '/new' do |params|
-          proxy(params).new
-        end
-      end
-      
-      def edit!
-        map :edit, '/:id/edit' do |params|
-          call(:record, params)
-        end
-      end
-    
-      def show!
-        map :show, '/:id' do |params|
-          call(:record, params)
-        end
-      end
-    
-      def create!
-        map :create, '/', :verb => :post do |params|
-          create[proxy(params), parse_for_attributes(params)]
-        end
-      end
-    
-      def update!
-        map :update, '/:id', :verb => :put do |params|
-          update[call(:record, params), parse_for_attributes(params)]
-        end
-      end
-    
-      def destroy!
-        map :destroy, '/:id', :verb => :delete do |params|
-          destroy[call(:record, params), parse_for_attributes(params)]
-        end
-      end
-      
-      private
-      
-      def parse_for_attributes(params, name=model.name.downcase)
-        if handler = accepts[params[:format].try(:to_sym)]
-          params.merge(name => handler.call(params[name]))
-        else
-          params.nest!
-          params[name] ||= { }
-          params[name][parent.model_id] = params[parent.model_id] if parent
-          params
+      def self.included(map)
+        map.action :destroy, '/:id', :verb => :delete do |request|
+          record = model.find(request.params) || responder.not_found(request)
+          record.destroy
+          responder.success(:destroy, request, record)
+        end
+        
+        map.action :new, '/new' do |request|
+          new_record = model.new(request.params)
+          responder.success(:new, request, new_record)
+        end
+        
+        map.action :update, '/:id', :verb => :put do |request|
+          record = model.update(request.params) || responder.not_found(request)
+          result = record.save ? :success : :failure
+          responder.send(result, :update, request, record)
+        end
+        
+        map.action :edit, '/:id/edit' do |request|
+          record = model.find(request.params) || responder.not_found(request)
+          responder.success(:edit, request, record)
+        end
+
+        map.action :show, '/:id' do |request|
+          record = model.find(request.params) || responder.not_found(request)
+          responder.success(:show, request, record)
+        end
+        
+        map.action :create, '/', :verb => :post do |request|
+          record = model.new(request.params)
+          result = record.save ? :success : :failure
+          responder.send(result, :create, request, record)
+        end
+
+        map.action :index, '/' do |request|
+          records = model.all(request.params)
+          responder.success(:index, request, records)
         end
       end
     end

data/lib/sinatras-hat/{auth.rb → authentication.rb}

@@ -3,10 +3,10 @@
 module Sinatra
   module Authorization
     class ProtectedAction
-      attr_reader :credentials, :context, :block
+      attr_reader :credentials, :request, :block
   
-      def initialize(context, credentials={}, &block)
-        @credentials, @context, @block = credentials, context, block
+      def initialize(request, credentials={}, &block)
+        @credentials, @request, @block = credentials, request, block
       end
   
       def check!
@@ -26,7 +26,7 @@ module Sinatra
       end
   
       def unauthorized!
-        context.header 'WWW-Authenticate' => %(Basic realm="#{credentials[:realm]}")
+        request.response.headers['WWW-Authenticate'] = %(Basic realm="#{credentials[:realm]}")
         throw :halt, [ 401, 'Authorization Required' ]
       end
  
@@ -35,25 +35,21 @@ module Sinatra
       end
   
       def auth
-        @auth ||= Rack::Auth::Basic::Request.new(context.request.env)
+        @auth ||= Rack::Auth::Basic::Request.new(request.env)
       end
     end
  
     module Helpers
-      def protect!(credentials, &block)
-        return if authorized?
-        guard = ProtectedAction.new(self, credentials, &block)
+      def protect!(request)
+        return if authorized?(request)
+        guard = ProtectedAction.new(request, credentials, &authenticator)
         guard.check!
         request.env['REMOTE_USER'] = guard.remote_user
       end
  
-      def authorized?
+      def authorized?(request)
         request.env['REMOTE_USER']
       end
     end
   end
 end
- 
-helpers do
-  include Sinatra::Authorization::Helpers
-end

data/lib/sinatras-hat/extendor.rb

@@ -0,0 +1,22 @@
+module Sinatra
+  module Hat
+    # This module gives both Sinatra::Base and Sinatra::Hat::Maker
+    # the #mount method, which is used to mount resources. When
+    # mount is called in an instance of Maker, it sets the new
+    # instance's parent.
+    module Extendor
+      def mount(klass, options={}, &block)
+        use Rack::MethodOverride unless kind_of?(Sinatra::Hat::Maker)
+        
+        Maker.new(klass, options).tap do |maker|
+          maker.parent = self if kind_of?(Sinatra::Hat::Maker)
+          maker.setup(@app || self)
+          maker.instance_eval(&block) if block_given?
+          maker.generate_routes!
+        end
+      end
+    end
+  end
+end
+
+Sinatra::Base.extend(Sinatra::Hat::Extendor)

data/lib/sinatras-hat/hash_mutator.rb

@@ -0,0 +1,18 @@
+module Sinatra
+  module Hat
+    # Used for specifying custom responses using a corny DSL.
+    class HashMutator
+      def initialize(hash)
+        @hash = hash
+      end
+      
+      def success(&block)
+        @hash[:success] = block
+      end
+      
+      def failure(&block)
+        @hash[:failure] = block
+      end
+    end
+  end
+end

data/lib/sinatras-hat/logger.rb

@@ -0,0 +1,36 @@
+module Sinatra
+  module Hat
+    # TODO This needs to be using Rack::CommonLogger
+    class Logger
+      def initialize(maker)
+        @maker = maker
+      end
+      
+      def info(msg)
+        say msg
+      end
+      
+      def debug(msg)
+        say msg
+      end
+      
+      def warn(msg)
+        say msg
+      end
+      
+      def error(msg)
+        say msg
+      end
+      
+      def fatal(msg)
+        say msg
+      end
+      
+      private
+      
+      def say(msg)
+        puts msg if @maker.app and @maker.app.logging
+      end
+    end
+  end
+end

data/lib/sinatras-hat/maker.rb

@@ -1,227 +1,161 @@
 module Sinatra
   module Hat
+    # This is where it all comes together
     class Maker
-      attr_accessor :parent
-      attr_reader :model, :context, :options
+      include Sinatra::Hat::Extendor
+      include Sinatra::Authorization::Helpers
       
-      include Actions, Responses
+      attr_reader :klass, :app
       
-      def initialize(model)
-        @model = model
-        with(options)
-      end
-    
-      def define(context, opts={}, &block)
-        @context = context
-        @options.merge!(opts)
-        instance_eval(&block) if block_given?
-        generate_actions!
+      def self.actions
+        @actions ||= { }
       end
       
-      def mount(klass, opts={}, &block)
-        child = Maker.new(klass)
-        child.parent = self
-        child.define(context, opts, &block)
-        child
+      # enables the douche-y DSL you see in actions.rb
+      def self.action(name, path, options={}, &block)
+        verb = options[:verb] || :get
+        Router.cache << [verb, name, path]
+        actions[name] = { :path => path, :verb => verb, :fn => block }
       end
+
+      include Sinatra::Hat::Actions
       
-      def resource_path(suffix)
-        resources = parents + [self]
-        path = resources.inject("") do |memo, maker|
-          memo += eql?(maker) ?
-            "/#{maker.prefix}" :
-            "/#{maker.prefix}/:#{maker.model.name}_id"
-        end
-        (path + suffix).tap do |s|
-          s.downcase!
-          s.gsub!(%r(/$), '')
-        end
-      end
+      #  ======================================================
       
-      def parents
-        @parents ||= parent ? Array(parent) + parent.parents : []
-      end
-
-      def protect(*args)
-        opts = args.extract_options!
-        credentials.update(opts)
-        actions = get_or_set_option(:protect, args) do
-          self.protect += args
-          self.protect.uniq!
-        end
-        
-        [actions].flatten
+      def initialize(klass, overrides={})
+        @klass = klass
+        options.merge!(overrides)
+        with(options)
       end
-
-      def only(*args)
-        result = get_or_set_option(:only, args) do
-          self.only = args
-          self.only.uniq!
-        end
-        
-        result = Array(result)
-        
-        result.move_to_back(:index)
-        result.move_to_front(:new, :edit)
-        
-        result
+      
+      def setup(app)
+        @app = app
       end
       
-      def children(*args)
-        result = get_or_set_option(:children, args) do
-          self.children = args
-          self.children.uniq!
-        end
+      def handle(action, request)
+        request.error(404) unless only.include?(action)
+        protect!(request) if protect.include?(action)
         
-        [result].flatten
+        log_with_benchmark(request, action) do
+          instance_exec(request, &self.class.actions[action][:fn])
+        end
       end
       
-      def authenticator(&block)
-        if block_given?
-          @authenticator = block
-        else
-          @authenticator ||= proc { |username, password|
-            credentials[:username] == username and credentials[:password] == password
-          }
-        end
+      def after(action)
+        yield HashMutator.new(responder.defaults[action])
       end
       
       def finder(&block)
         if block_given?
-          @finder = block
+          options[:finder] = block
         else
-          @finder ||= proc { |params| all }
+          options[:finder]
         end
       end
       
       def record(&block)
         if block_given?
-          @record = block
+          options[:record] = block
         else
-          @record ||= proc { |params| first(:id => params[:id]) }
+          options[:record]
         end
       end
       
-      def create(&block)
+      def authenticator(&block)
         if block_given?
-          @create = block
+          options[:authenticator] = block
         else
-          @create ||= proc do |model, params|
-            result = model.new
-            result.attributes = params[model_name]
-            result.save ? result : nil
-          end
+          options[:authenticator]
         end
       end
       
-      def update(&block)
-        if block_given?
-          @update = block
+      def only(*actions)
+        if actions.empty?
+          options[:only] ||= Set.new(options[:only])
         else
-          @update ||= proc do |record, params|
-            record.attributes = params[model_name]
-            record.save ? record : false
-          end
+          Set.new(options[:only] = actions)
         end
       end
       
-      def destroy(&block)
-        if block_given?
-          @destroy = block
+      def protect(*actions)
+        credentials.merge!(actions.extract_options!)
+        
+        if actions.empty?
+          options[:protect] ||= Set.new([])
         else
-          @destroy ||= proc do |record, params|
-            record.destroy
-            :destroyed
-          end
+          actions == [:all] ? 
+            Set.new(options[:protect] = only) :
+            Set.new(options[:protect] = actions)
         end
       end
       
-      def map(name, path, opts={}, &block)
-        opts[:verb] ||= :get
-        klass = self
-        actions[name] = Action.new(self, name, block)
+      def prefix
+        options[:prefix] ||= model.plural
+      end
       
-        context.send(opts[:verb], resource_path(path)) do
-          begin
-            klass.templated(self, name, opts)
-          rescue Errno::ENOENT => e
-            klass.rescue_template_error(e)
-          end
-        end
-        
-        context.send(opts[:verb], "#{resource_path(path)}.:format") do
-          begin
-            klass.serialized(self, name, opts)
-          rescue UnsupportedFormat => e
-            klass.rescue_format_error(e)
-          end
-        end
+      def parents
+        @parents ||= parent ? Array(parent) + parent.parents : []
       end
       
-      def rescue_format_error(e)
-        throw :halt, [
-          406, [
-            "The `#{e.format}` format is not supported.\n",
-            "Valid Formats: #{accepts.keys.join(', ')}\n",
-          ].join("\n")
-        ]
+      def resource_path(*args)
+        resource.path(*args)
       end
-
-      # TODO Create a real template for this error.
-      def rescue_template_error(e)
-        msg = "<pre>There was a problem with your view template:\n\n  "
-        msg << e.message
-        msg << "\n</pre>"
+      
+      def options
+        @options ||= {
+          :only => Set.new(Maker.actions.keys),
+          :parent => nil,
+          :finder => proc { |model, params| model.all },
+          :record => proc { |model, params| model.find_by_id(params[:id]) },
+          :protect => [ ],
+          :formats => { },
+          :credentials => { :username => 'username', :password => 'password', :realm => "The App" },
+          :authenticator => proc { |username, password| [username, password] == [:username, :password].map(&credentials.method(:[])) }
+        }
       end
       
-      def call(method, params)
-        proxy(params).instance_exec(params, &send(method))
+      def inspect
+        "maker: #{klass}"
       end
       
-      def proxy(params={})
-        return model if parent.nil?
-        fake_params = params.dup
-        fake_params.merge!("id" => params[parent.model_id])
-        fake_params.make_indifferent!
-        parent.call(:record, fake_params).try(prefix) || model
+      def generate_routes!
+        Router.new(self).generate(@app)
       end
       
-      def model_id
-        "#{model_name}_id".to_sym
+      def responder
+        @responder ||= Responder.new(self)
       end
       
-      def model_name
-        model.name.downcase
+      def model
+        @model ||= Model.new(self)
       end
       
-      def options
-        @options ||= {
-          :only => [:new, :edit, :show, :create, :update, :destroy, :index],
-          :prefix => Extlib::Inflection.tableize(model.name),
-          :actions => { },
-          :protect => [ ],
-          :formats => { },
-          :renderer => :erb,
-          :children => [],
-          :to_param => :id,
-          :nest_params => true,
-          :credentials => {
-            :username => 'admin',
-            :password => 'password',
-            :realm => 'TheApp.com'
-          },
-          :accepts => {
-            :yaml => proc { |string| YAML.load(string) },
-            :json => proc { |string| JSON.parse(string) },
-            :xml  => proc { |string| Hash.from_xml(string)['hash'] }
-          }
-        }
+      # TODO Hook this into Rack::CommonLogger
+      def logger
+        @logger ||= Logger.new(self)
       end
       
       private
       
-      def get_or_set_option(name, args, opts={})
-        args.length > 0 ? yield : options[name]
+      def log_with_benchmark(request, action)
+        msg = [ ]
+        msg << "#{request.env['REQUEST_METHOD']} #{request.env['PATH_INFO']}"
+        msg << "Params: #{request.params.inspect}"
+        msg << "Action: #{action.to_s.upcase}"
+        
+        logger.info ">> " + msg.join(' | ')
+        
+        result = nil
+        
+        t = Benchmark.realtime { result = yield }
+        
+        logger.info "   Request finished in #{t} sec."
+        
+        result
+      end
+      
+      def resource
+        @resource ||= Resource.new(self)
       end
     end
   end

data/lib/sinatras-hat/model.rb

@@ -0,0 +1,77 @@
+module Sinatra
+  module Hat
+    # A wrapper around the model class that we're mounting
+    class Model
+      attr_reader :maker
+      
+      delegate :options, :klass, :prefix, :to => :maker
+      
+      def initialize(maker)
+        @maker = maker
+      end
+      
+      def all(params)
+        params.make_indifferent!
+        options[:finder].call(proxy(params), params)
+      end
+      
+      def find(params)
+        params.make_indifferent!
+        options[:record].call(proxy(params), params)
+      end
+      
+      def find_owner(params)
+        params = parent_params(params)
+        options[:record].call(proxy(params), params)
+      end
+      
+      def update(params)
+        if record = find(params)
+          params.nest!
+          record.attributes = (params[singular] || { })
+          record
+        end
+      end
+      
+      def new(params={})
+        params.nest!
+        proxy(params).new(params[singular] || { })
+      end
+      
+      def plural
+        klass.name.snake_case.plural
+      end
+      
+      def singular
+        klass.name.snake_case.singular
+      end
+      
+      def foreign_key
+        "#{singular}_id".to_sym
+      end
+      
+      private
+      
+      def proxy(params)
+        return klass unless parent
+        owner = parent.find_owner(params)
+        if owner and owner.respond_to?(plural)
+          owner.send(plural)
+        else
+          klass
+        end
+      end
+      
+      def parent_params(params)
+        _params = params.dup.to_mash
+        _params.merge! :id => _params.delete(foreign_key)
+        _params
+      end
+      
+      def parent
+        return nil unless maker.parent
+        maker.parent.model
+      end
+    end
+  end
+end

data/lib/sinatras-hat/resource.rb

@@ -0,0 +1,47 @@
+module Sinatra
+  module Hat
+    # Handles the logic of generating a path for a given resource,
+    # taking any and all parents into consideration.
+    class Resource
+      def initialize(maker)
+        @maker = maker
+      end
+      
+      def path(suffix, record=nil)
+        suffix = suffix.dup
+        
+        path = resources.inject("") do |memo, maker|
+          memo += fragment(maker, record)
+        end
+        
+        suffix.gsub!('/:id', "/#{record.id}") if record
+        
+        clean(path + suffix)
+      end
+      
+      private
+      
+      def fragment(maker, record)
+        @maker.eql?(maker) ?
+          "/#{maker.prefix}" :
+          "/#{maker.prefix}/" + interpolate(maker, record)
+      end
+      
+      def interpolate(maker, record)
+        foreign_key = maker.model.foreign_key
+        result = record ? record.send(foreign_key) : foreign_key
+        result.inspect
+      end
+      
+      def clean(s)
+        s.downcase!
+        s.gsub!(%r(/$), '')
+        s
+      end
+      
+      def resources
+        @maker.parents + [@maker]
+      end
+    end
+  end
+end

data/lib/sinatras-hat/responder.rb

@@ -0,0 +1,94 @@
+module Sinatra
+  module Hat
+    # The responder assigns data to instance variables, then either
+    # gets the appropriate response proc and instance_exec's it in the
+    # context of a new Response object, or serializes the data.
+    class Responder
+      delegate :model, :to => :maker
+      
+      attr_reader :maker
+      
+      def initialize(maker)
+        @maker = maker
+      end
+      
+      def defaults
+        @defaults ||= {
+          :show => {
+            :success => proc { |data| render(:show) },
+            :failure => proc { |data| redirect('/') }
+          },
+
+          :index => {
+            :success => proc { |data| render(:index) },
+            :failure => proc { |data| redirect('/') }
+          },
+
+          :create => {
+            :success => proc { |data| redirect(data) },
+            :failure => proc { |data| render(:new) }
+          },
+
+          :new => {
+            :success => proc { |data| render(:new) },
+            :failure => proc { |data| redirect('/') }
+          },
+
+          :edit => {
+            :success => proc { |data| render(:edit) }
+          },
+
+          :destroy => {
+            :success => proc { |data| redirect(resource_path('/')) }
+          },
+
+          :update => {
+            :success => proc { |data| redirect(data) },
+            :failure => proc { |data| render(:edit) }
+          }
+        }
+      end
+      
+      def success(name, request, data)
+        handle(:success, name, request, data)
+      end
+      
+      def failure(name, request, data)
+        handle(:failure, name, request, data)
+      end
+      
+      def serialize(request, data)
+        name = request.params[:format].to_sym
+        formatter = to_format(name)
+        formatter[data] || request.error(406)
+      end
+      
+      def not_found(request)
+        request.not_found
+      end
+            
+      private
+      
+      def handle(result, name, request, data)
+        if format = request.params[:format]
+          serialize(request, data)
+        else
+          request.instance_variable_set(ivar_name(data), data)
+          response = Response.new(maker, request)
+          response.instance_exec(data, &defaults[name][result])
+        end
+      end
+      
+      def ivar_name(data)
+        "@" + (data.respond_to?(:each) ? model.plural : model.singular)
+      end
+      
+      def to_format(name)
+        maker.formats[name] || Proc.new do |data|
+          method_name = "to_#{name}"
+          data.respond_to?(method_name) ? data.send(method_name) : nil
+        end
+      end
+    end
+  end
+end

data/lib/sinatras-hat/response.rb

@@ -0,0 +1,53 @@
+module Sinatra
+  class NoTemplateError < StandardError; end
+  
+  module Hat
+    # Tells Sinatra what to do next.
+    class Response
+      attr_reader :maker
+      
+      delegate :resource_path, :to => :maker
+      
+      def initialize(maker, request)
+        @maker = maker
+        @request = request
+      end
+      
+      def render(action)
+        begin
+          @request.erb action.to_sym, :views_directory => views
+        rescue Errno::ENOENT
+          no_template! "Can't find #{File.expand_path(File.join(views, action.to_s))}.erb"
+        end
+      end
+      
+      def redirect(*args)
+        @request.redirect url_for(*args)
+      end
+      
+      private
+      
+      def no_template!(msg)
+        raise NoTemplateError.new(msg)
+      end
+      
+      def views
+        @views ||= begin
+          if views_dir = @request.options.views
+            File.join(views_dir, maker.prefix)
+          else
+            no_template! "Make sure you set the :views option!"
+          end
+        end
+      end
+      
+      def url_for(resource, *args)
+        case resource
+        when String then resource
+        when Symbol then resource_path(Maker.actions[resource][:path], *args)
+        else resource_path('/:id', resource)
+        end
+      end
+    end
+  end
+end

data/lib/sinatras-hat/router.rb

@@ -0,0 +1,42 @@
+module Sinatra
+  module Hat
+    # Tells Sinatra which routes to generate. The routes
+    # created automatically when the actions are loaded.
+    class Router
+      delegate :resource_path, :logger, :to => :maker
+      
+      attr_reader :maker, :app
+      
+      def self.cache
+        @cache ||= []
+      end
+      
+      def initialize(maker)
+        @maker = maker
+      end
+      
+      def generate(app)
+        @app = app
+        
+        Router.cache.each do |route|
+          map(*route)
+        end
+      end
+      
+      private
+      
+      def map(method, action, path)
+        path = resource_path(path)
+        
+        handler = lambda do |request|
+          maker.handle(action, request)
+        end
+        
+        logger.info ">> route for #{maker.klass} #{action}:\t#{method.to_s.upcase}\t#{path}"
+        
+        app.send(method, path) { handler[self] }
+        app.send(method, "#{path}.:format") { handler[self] }        
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sinatras-hat
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.1
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-16 00:00:00 -04:00
+date: 2009-01-17 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,16 +32,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: metaid
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: 
 email: patnakajima@gmail.com
 executables: []
@@ -52,16 +42,23 @@ extra_rdoc_files: []
 
 files: 
 - lib/core_ext
-- lib/core_ext/hash.rb
 - lib/core_ext/array.rb
+- lib/core_ext/hash.rb
+- lib/core_ext/module.rb
 - lib/core_ext/object.rb
 - lib/sinatras-hat
-- lib/sinatras-hat.rb
-- lib/sinatras-hat/maker.rb
-- lib/sinatras-hat/action.rb
 - lib/sinatras-hat/actions.rb
-- lib/sinatras-hat/auth.rb
-- lib/sinatras-hat/responses.rb
+- lib/sinatras-hat/authentication.rb
+- lib/sinatras-hat/extendor.rb
+- lib/sinatras-hat/hash_mutator.rb
+- lib/sinatras-hat/logger.rb
+- lib/sinatras-hat/maker.rb
+- lib/sinatras-hat/model.rb
+- lib/sinatras-hat/resource.rb
+- lib/sinatras-hat/responder.rb
+- lib/sinatras-hat/response.rb
+- lib/sinatras-hat/router.rb
+- lib/sinatras-hat.rb
 has_rdoc: false
 homepage: 
 post_install_message: 

data/lib/sinatras-hat/action.rb

@@ -1,15 +0,0 @@
-module Sinatra
-  module Hat
-    class Action
-      attr_reader :maker, :handler
-      
-      def initialize(maker, name, handler)
-        @maker, @handler = maker, handler
-      end
-      
-      def handle(event)
-        handler[event.params]
-      end
-    end
-  end
-end

data/lib/sinatras-hat/responses.rb

@@ -1,62 +0,0 @@
-module Sinatra
-  module Hat
-    # TODO: Move these to Action class?
-    module Responses
-      class UnsupportedFormat < StandardError
-        attr_reader :format
-        
-        def initialize(format)
-          @format = format
-        end
-      end
-      
-      def templated(event, name, opts={})
-        event.protect!(:realm => credentials[:realm], &authenticator) if protecting?(name)
-        
-        root = File.join(Sinatra.application.options.views, prefix)
-        result = actions[name].handle(event)
-        event.instance_variable_set ivar_name(result), result
-        return opts[:verb] == :get ?
-          event.render(renderer, name, :views_directory => root) :
-          event.redirect(redirection_path(result))
-      end
-    
-      def serialized(event, name, opts={})
-        format = event.params[:format].to_sym
-        
-        event.protect!(:realm => credentials[:realm], &authenticator) if protecting?(name)
-        
-        if accepts[format] or opts[:verb].eql?(:get)
-          event.content_type(format) rescue nil
-          object = actions[name].handle(event)
-          result = serializer_for(format).call(object)
-          return result unless result.nil?
-        end
-      
-        raise UnsupportedFormat.new(format)
-      end
-      
-      private
-      
-      def serializer_for(format)
-        formats[format.to_sym] ||= proc do |object|
-          object.try("to_#{format}")
-        end
-      end
-      
-      def protecting?(name)
-        protect.include?(:all) or protect.include?(name)
-      end
-    
-      def redirection_path(result)
-        result.is_a?(Symbol) ?
-          "/#{prefix}" :
-          "/#{prefix}/#{result.send(to_param)}"
-      end
-    
-      def ivar_name(result)
-        "@" + (result.respond_to?(:each) ? prefix : model.name.downcase)
-      end
-    end
-  end
-end