nakajima-sinatras-hat 0.0.2 → 0.0.3

data/lib/core_ext/array.rb

@@ -5,17 +5,13 @@ class Array
   
   def move_to_front(*entries)
     entries.each do |entry|
-      if deleted = delete(entry)
-        unshift(deleted)
-      end
+      unshift(entry) if delete(entry)
     end
   end
   
   def move_to_back(*entries)
     entries.each do |entry|
-      if deleted = delete(entry)
-        push(deleted)
-      end
+      push(entry) if delete(entry)
     end
   end
 end

data/lib/sinatras-hat/action.rb

@@ -0,0 +1,15 @@
+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/actions.rb

@@ -9,52 +9,44 @@ module Sinatra
       end
       
       def index!
-        map :index, resource_path('/') do |params|
+        map :index, '/' do |params|
           call(:finder, params)
         end
       end
     
       def new!
-        map :new, resource_path('/new') do |params|
+        map :new, '/new' do |params|
           proxy(params).new
         end
       end
       
       def edit!
-        map :edit, resource_path('/:id/edit') do |params|
+        map :edit, '/:id/edit' do |params|
           call(:record, params)
         end
       end
     
       def show!
-        map :show, resource_path('/:id') do |params|
+        map :show, '/:id' do |params|
           call(:record, params)
         end
       end
     
       def create!
-        map :create, resource_path('/'), :verb => :post do |params|
-          result = proxy(params).new
-          result.attributes = parse_for_attributes(params)
-          result.save
-          result
+        map :create, '/', :verb => :post do |params|
+          create[proxy(params), parse_for_attributes(params)]
         end
       end
     
       def update!
-        map :update, resource_path('/:id'), :verb => :put do |params|
-          result = call(:record, params)
-          result.attributes = parse_for_attributes(params)
-          result.save
-          result
+        map :update, '/:id', :verb => :put do |params|
+          update[call(:record, params), parse_for_attributes(params)]
         end
       end
     
       def destroy!
-        map :destroy, resource_path('/:id'), :verb => :delete do |params|
-          result = call(:record, params)
-          result.destroy
-          :ok
+        map :destroy, '/:id', :verb => :delete do |params|
+          destroy[call(:record, params), parse_for_attributes(params)]
         end
       end
       
@@ -62,12 +54,12 @@ module Sinatra
       
       def parse_for_attributes(params, name=model.name.downcase)
         if handler = accepts[params[:format].try(:to_sym)]
-          handler.call params[name]
+          params.merge(name => handler.call(params[name]))
         else
           params.nest!
           params[name] ||= { }
           params[name][parent.model_id] = params[parent.model_id] if parent
-          params[name]
+          params
         end
       end
     end

data/lib/sinatras-hat/maker.rb

@@ -3,7 +3,7 @@ module Sinatra
     class Maker
       attr_accessor :parent
       attr_reader :model, :context, :options
-
+      
       include Actions, Responses
       
       def initialize(model)
@@ -102,12 +102,76 @@ module Sinatra
         end
       end
       
+      def create(&block)
+        if block_given?
+          @create = block
+        else
+          @create ||= proc do |model, params|
+            result = model.new
+            result.attributes = params[model_name]
+            result.save ? result : nil
+          end
+        end
+      end
+      
+      def update(&block)
+        if block_given?
+          @update = block
+        else
+          @update ||= proc do |record, params|
+            record.attributes = params[model_name]
+            record.save ? record : false
+          end
+        end
+      end
+      
+      def destroy(&block)
+        if block_given?
+          @destroy = block
+        else
+          @destroy ||= proc do |record, params|
+            record.destroy
+            :destroyed
+          end
+        end
+      end
+      
       def map(name, path, opts={}, &block)
         opts[:verb] ||= :get
         klass = self
+        actions[name] = Action.new(self, name, block)
+      
+        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
+      end
       
-        context.send(opts[:verb], path) { klass.templated(self, name, opts, &block) }
-        context.send(opts[:verb], "#{path}.:format") { klass.serialized(self, name, opts, &block) }
+      def rescue_format_error(e)
+        throw :halt, [
+          406, [
+            "The `#{e.format}` format is not supported.\n",
+            "Valid Formats: #{accepts.keys.join(', ')}\n",
+          ].join("\n")
+        ]
+      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>"
       end
       
       def call(method, params)
@@ -123,14 +187,19 @@ module Sinatra
       end
       
       def model_id
-        "#{model.name.downcase}_id".to_sym
+        "#{model_name}_id".to_sym
+      end
+      
+      def model_name
+        model.name.downcase
       end
       
       def options
         @options ||= {
           :only => [:new, :edit, :show, :create, :update, :destroy, :index],
           :prefix => Extlib::Inflection.tableize(model.name),
-          :protect => [],
+          :actions => { },
+          :protect => [ ],
           :formats => { },
           :renderer => :erb,
           :children => [],

data/lib/sinatras-hat/responses.rb

@@ -1,40 +1,49 @@
 module Sinatra
   module Hat
+    # TODO: Move these to Action class?
     module Responses
-      def templated(event, name, opts={}, &block)
+      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 = block.call(event.params)
+        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={}, &block)
+      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 = block.call(event.params)
-          handle = formats[format.to_sym]
-          result = handle ? handle.call(object) : object.try("to_#{format}")
+          event.content_type(format) rescue nil
+          object = actions[name].handle(event)
+          result = serializer_for(format).call(object)
           return result unless result.nil?
         end
       
-        throw :halt, [
-          406, [
-            "The `#{format}` format is not supported.\n",
-            "Valid Formats: #{accepts.keys.join(', ')}\n",
-          ].join("\n")
-        ]
+        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

data/lib/sinatras-hat.rb

@@ -8,6 +8,7 @@ require 'dm-serializer'
 require 'array'
 require 'hash'
 require 'object'
+require 'action'
 require 'actions'
 require 'responses'
 require 'maker'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: nakajima-sinatras-hat
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -54,6 +54,7 @@ files:
 - lib/core_ext/object.rb
 - lib/sinatras-hat
 - 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