bradphelan-sinatras-hat 0.1.2

data/lib/sinatras-hat/resource.rb

@@ -0,0 +1,57 @@
+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)
+        records = record ? path_records_for(record) : []
+        results = resources.inject("") do |memo, maker|
+          memo += fragment(maker, record)
+        end
+        
+        interpolate(clean(results + suffix.dup), records)
+      end
+      
+      private
+      
+      def interpolate(uri, records)
+        return uri if records.empty?
+        uri.gsub(/:(\w+)/) { records.pop.to_param }
+      end
+      
+      def path_records_for(record)
+        [record].tap do |parents|
+          resources.reverse.each do |resource|
+            parents << resource.model.find_owner(parents.last.attributes)
+            parents.compact!
+            parents.uniq!
+          end
+        end
+      end
+      
+      def fragment(maker, record)
+        @maker.eql?(maker) ?
+          "/#{maker.prefix}" :
+          "/#{maker.prefix}/" + key(maker)
+      end
+      
+      def key(maker)
+        maker.model.foreign_key.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,106 @@
+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
+
+      # Called when a request is handled successfully. For most GET
+      # requests, this is always the case. For update/create actions,
+      # it is when the record is created/updated successfully.
+      def success(name, request, data)
+        handle(:success, name, request, data)
+      end
+
+      # Called when a request is not able to handled. This could be
+      # because a record could not be created or saved.
+      def failure(name, request, data)
+        handle(:failure, name, request, data)
+      end
+
+      # Serializes the data passed in, first looking for a custom formatter,
+      # then falling back on trying to call to_[format] on the data. If neither
+      # are available, returns an error with the status code 406.
+      def serialize(data, format)
+        return nil unless format
+        name = format.to_sym
+        mime = get_mime_type(format)
+        formatter = to_format(name)
+        formatter[data] ? [formatter[data], mime] : nil
+      end
+
+      private
+
+      def handle(result, name, request, data)
+        if format = request.params[:format] || maker.format
+          response, mime = serialize(data, format)
+          request.content_type(mime) if mime
+          response or request.error(406)
+        else
+          request.instance_variable_set(ivar_name(data), data)
+          response = Response.new(maker, request)
+          response.instance_exec(data, &defaults[name][result])
+        end
+      end
+
+      def get_mime_type(format)
+        Rack::Mime::MIME_TYPES['.' + format.to_s]
+      end
+
+      def ivar_name(data)
+        "@" + (data.kind_of?(Array) ? 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,60 @@
+module Sinatra
+  class NoTemplateError < StandardError; end
+  
+  module Hat
+    # Tells Sinatra what to do next.
+    class Response
+      attr_reader :maker
+      
+      delegate :model, :resource_path, :to => :maker
+      
+      def initialize(maker, request)
+        @maker = maker
+        @request = request
+      end
+      
+      # Now uses haml by default
+      def render(action, options={})
+        begin
+          options.each { |sym, value| @request.send(sym, value) }
+          @request.haml "#{maker.prefix}/#{action}.html".to_sym
+        rescue Errno::ENOENT
+          no_template! "Can't find #{File.expand_path(File.join(views, action.to_s))}.html.haml"
+        end
+      end
+      
+      def redirect(*args)
+        @request.redirect url_for(*args)
+      end
+      
+      def url_for(resource, *args)
+        case resource
+        when String then resource
+        when Symbol then resource_path(Maker.actions[resource][:path], *args)
+        else maker_for(resource).resource_path('/:id', resource)
+        end
+      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 maker_for(record)
+        resource = record.is_a?(model.klass) ? maker : maker.parents.detect { |m| record.is_a?(m.model.klass) }
+        resource || maker
+      end
+    end
+  end
+end

data/lib/sinatras-hat/router.rb

@@ -0,0 +1,46 @@
+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}*" + "/?") do
+          id, format = (params[:id].to_s + params[:splat].join).split('.')
+          params['id'] = id
+          params['format'] = format
+          handler[self]
+        end
+      end
+    end
+  end
+end

data/sinatras-hat.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sinatras-hat}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pat Nakajima"]
+  s.date = %q{2009-01-17}
+  s.email = %q{patnakajima@gmail.com}
+  s.files = ["README.md", "lib/core_ext", "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/actions.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"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Simple REST-ful resources with Sinatra.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<extlib>, [">= 0"])
+      s.add_runtime_dependency(%q<metaid>, [">= 0"])
+      s.add_runtime_dependency(%q<sinatra>, [">= 0"])
+    else
+      s.add_dependency(%q<extlib>, [">= 0"])
+      s.add_dependency(%q<metaid>, [">= 0"])
+      s.add_dependency(%q<sinatra>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<extlib>, [">= 0"])
+    s.add_dependency(%q<metaid>, [">= 0"])
+    s.add_dependency(%q<sinatra>, [">= 0"])
+  end
+end

data/spec/actions/create_spec.rb

@@ -0,0 +1,68 @@
+require 'spec/spec_helper'
+
+describe "handle create" do
+  attr_reader :maker, :app, :request, :article
+  
+  before(:each) do
+    build_models!
+    mock_app {  }
+    @maker = new_maker(Article)
+    @request = fake_request("article[name]" => "The article")
+    stub(request).redirect(anything)
+  end
+  
+  def handle(*args)
+    maker.handle(:create, *args)
+  end
+  
+  it "instantiates a new record and saves it" do
+    mock.proxy(article = Article.new).save
+    mock.proxy(maker.model).new("article[name]" => "The article") { article }
+    handle(request)
+  end
+  
+  describe "responding" do
+    attr_reader :new_article
+    
+    before(:each) do
+      @new_article = Article.new
+    end
+    
+    context "when the save is successful" do
+      before(:each) do
+        stub(Article).new(anything).returns(new_article)
+      end
+      
+      context "when there's no format" do
+        it "redirects" do
+          mock(request).redirect(anything)
+          mock.proxy(maker.responder).success(:create, request, new_article)
+          handle(request)
+        end
+      end
+    end
+
+    context "when the save is not successful" do
+      before(:each) do
+        stub(Article).new(anything).returns(new_article)
+        stub(new_article).save { false }
+      end
+      
+      context "when there's no format" do
+        it "renders edit template" do
+          mock(request).erb :"articles/new"
+          mock.proxy(maker.responder).failure(:create, request, new_article)
+          handle(request)
+        end
+      end
+
+      # context "when there is a format" do
+      #   it "serializes the record" do
+      #     request_with_format = fake_request(:format => "yaml")
+      #     mock.proxy(maker.responder).serialize("yaml", article)
+      #     handle(request_with_format)
+      #   end
+      # end
+    end
+  end
+end

data/spec/actions/destroy_spec.rb

@@ -0,0 +1,58 @@
+require 'spec/spec_helper'
+
+describe "handle destroy" do
+  attr_reader :maker, :app, :request, :article
+  
+  before(:each) do
+    build_models!
+    mock_app {  }
+    @maker = new_maker(Article)
+    @request = fake_request(:id => @article.to_param)
+    stub(maker.model).find(:id => @article.to_param) { @article }
+    stub(request).redirect(anything)
+  end
+  
+  def handle(*args)
+    maker.handle(:destroy, *args)
+  end
+  
+  it "takes a request" do
+    handle(request)
+  end
+  
+  context "when the record exists" do
+    it "loads correct record" do
+      mock.proxy(maker.model).find(:id => @article.to_param) { article }
+      handle(request)
+    end
+
+    it "destroys the record" do
+      mock.proxy(article).destroy
+      handle(request)
+    end
+
+    describe "rendering a response" do
+      before(:each) do
+        params = { :id => @article.to_param }
+        @request = fake_request(params)
+        stub(maker.model).find(params).returns(article)
+      end
+
+      it "redirects to the index" do
+        mock(request).redirect('/articles')
+        handle(request)
+      end
+    end
+  end
+  
+  context "when the record does not exist" do
+    before(:each) do
+      stub(maker.model).find(:id => @article.to_param) { nil }
+    end
+    
+    it "returns not_found" do
+      mock.proxy(request).not_found
+      catch(:halt) { handle(request) }
+    end
+  end
+end

data/spec/actions/edit_spec.rb

@@ -0,0 +1,52 @@
+require 'spec/spec_helper'
+
+describe "handle show" do
+  attr_reader :maker, :app, :request
+  
+  before(:each) do
+    build_models!
+    mock_app {  }
+    @maker = new_maker(Article)
+    @request = fake_request(:id => @article.to_param)
+  end
+  
+  def handle(*args)
+    maker.handle(:edit, *args)
+  end
+  
+  it "takes a request" do
+    handle(request)
+  end
+  
+  describe "rendering not_found" do
+    before(:each) do
+      stub(maker.model).find(request.params).returns(nil)
+      stub(request).not_found # because it throws :halt otherwise
+    end
+    
+    it "returns not_found" do
+      mock(request).not_found
+      handle(request)
+    end
+  end
+  
+  describe "rendering a successful response" do
+    it "loads correct record" do
+      mock.proxy(maker.model).find(:id => @article.to_param) { :article }
+      handle(request)
+    end
+    
+    context "when there's no :format param" do
+      before(:each) do
+        params = { :id => @article.to_param }
+        @request = fake_request(params)
+        stub(maker.model).find(params).returns(:article)
+      end
+      
+      it "renders the show template" do
+        mock.proxy(maker.responder).success(:edit, request, :article)
+        handle(request)
+      end
+    end
+  end
+end