sinatras-hat 0.1.1 → 0.1.2

data/lib/sinatras-hat.rb

@@ -1,6 +1,5 @@
 $LOAD_PATH << File.join(File.dirname(__FILE__))
 
-require 'rubygems'
 require 'benchmark'
 require 'sinatra/base'
 require 'extlib'

data/lib/sinatras-hat/actions.rb

@@ -10,7 +10,7 @@ module Sinatra
     module Actions
       def self.included(map)
         map.action :destroy, '/:id', :verb => :delete do |request|
-          record = model.find(request.params) || responder.not_found(request)
+          record = model.find(request.params) || request.not_found
           record.destroy
           responder.success(:destroy, request, record)
         end
@@ -21,18 +21,19 @@ module Sinatra
         end
         
         map.action :update, '/:id', :verb => :put do |request|
-          record = model.update(request.params) || responder.not_found(request)
+          record = model.update(request.params) || request.not_found
           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)
+          record = model.find(request.params) || request.not_found
           responder.success(:edit, request, record)
         end
 
         map.action :show, '/:id' do |request|
-          record = model.find(request.params) || responder.not_found(request)
+          record = model.find(request.params) || request.not_found
+          set_cache_headers(request, record) unless protected?(:show)
           responder.success(:show, request, record)
         end
         
@@ -44,8 +45,29 @@ module Sinatra
 
         map.action :index, '/' do |request|
           records = model.all(request.params)
+          set_cache_headers(request, records) unless protected?(:index)
           responder.success(:index, request, records)
         end
+        
+        private
+        
+        def set_cache_headers(request, data)
+          
+          set_etag(request, data)
+          set_last_modified(request, data)
+        end
+        
+        def set_etag(request, data)
+          record = model.find_last_modified(Array(data))
+          return unless record.respond_to?(:updated_at)
+          request.etag("#{record.id}-#{record.updated_at}-#{data.is_a?(Array)}")
+        end
+        
+        def set_last_modified(request, data)
+          record = model.find_last_modified(Array(data))
+          return unless record.respond_to?(:updated_at)
+          request.last_modified(record.updated_at)
+        end
       end
     end
   end

data/lib/sinatras-hat/extendor.rb

@@ -6,7 +6,9 @@ module Sinatra
     # instance's parent.
     module Extendor
       def mount(klass, options={}, &block)
-        use Rack::MethodOverride unless kind_of?(Sinatra::Hat::Maker)
+        unless kind_of?(Sinatra::Hat::Maker)
+          use Rack::MethodOverride 
+        end
         
         Maker.new(klass, options).tap do |maker|
           maker.parent = self if kind_of?(Sinatra::Hat::Maker)

data/lib/sinatras-hat/maker.rb

@@ -11,7 +11,6 @@ module Sinatra
         @actions ||= { }
       end
       
-      # 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]
@@ -28,10 +27,15 @@ module Sinatra
         with(options)
       end
       
+      # Simply stores the app instance when #mount is called.
       def setup(app)
         @app = app
       end
       
+      # Processes a request, using the action specified in actions.rb
+      #
+      # TODO The work of handling a request should probably be wrapped
+      #      up in a class.
       def handle(action, request)
         request.error(404) unless only.include?(action)
         protect!(request) if protect.include?(action)
@@ -41,10 +45,14 @@ module Sinatra
         end
       end
       
+      # Allows the DSL for specifying custom flow controls in a #mount
+      # block by altering the responder's defaults hash.
       def after(action)
         yield HashMutator.new(responder.defaults[action])
       end
       
+      # The finder block is used when loading all records for the index
+      # action. It gets passed the model proxy and the request params hash.
       def finder(&block)
         if block_given?
           options[:finder] = block
@@ -53,6 +61,9 @@ module Sinatra
         end
       end
       
+      # The finder block is used when loading a single record, which
+      # is the case for most actions. It gets passed the model proxy
+      # and the request params hash.
       def record(&block)
         if block_given?
           options[:record] = block
@@ -61,6 +72,8 @@ module Sinatra
         end
       end
       
+      # The authenticator block gets called before protected actions. It
+      # gets passed the basic auth username and password.
       def authenticator(&block)
         if block_given?
           options[:authenticator] = block
@@ -69,6 +82,8 @@ module Sinatra
         end
       end
       
+      # A list of actions that get generated by this maker instance. By
+      # default it's all of the actions specified in actions.rb
       def only(*actions)
         if actions.empty?
           options[:only] ||= Set.new(options[:only])
@@ -77,6 +92,17 @@ module Sinatra
         end
       end
       
+      # A way to determine a record's representation in the database
+      def to_param(name=nil)
+        if name
+          options[:to_param] = name
+        else
+          options[:to_param]
+        end
+      end
+      
+      # A list of actions to protect via basic auth. Protected actions
+      # will have the authenticator block called before they are handled. 
       def protect(*actions)
         credentials.merge!(actions.extract_options!)
         
@@ -89,43 +115,53 @@ module Sinatra
         end
       end
       
+      # The path prefix to use for routes and such.
       def prefix
         options[:prefix] ||= model.plural
       end
       
+      # An array of parent Maker instances under which this instance
+      # was nested.
       def parents
-        @parents ||= parent ? Array(parent) + parent.parents : []
+        @parents ||= parent ? parent.parents + Array(parent) : []
       end
       
+      # Looks up the resource path for the specified arguments using this
+      # maker's Resource instance.
       def resource_path(*args)
         resource.path(*args)
       end
       
+      # Default options
       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]) },
+          :record => proc { |model, params| model.send("find_by_#{to_param}", params[:id]) },
           :protect => [ ],
           :formats => { },
+          :to_param => :id,
           :credentials => { :username => 'username', :password => 'password', :realm => "The App" },
           :authenticator => proc { |username, password| [username, password] == [:username, :password].map(&credentials.method(:[])) }
         }
       end
-      
-      def inspect
-        "maker: #{klass}"
-      end
-      
+
+      # Generates routes in the context of the given app.
       def generate_routes!
         Router.new(self).generate(@app)
       end
       
+      # The responder determines what kind of response should used for
+      # a given action.
+      #
+      # TODO It might be better off to instantiate a new one of these per
+      # request, instead of having one per maker instance.
       def responder
         @responder ||= Responder.new(self)
       end
       
+      # Handles ORM/model related logic.
       def model
         @model ||= Model.new(self)
       end
@@ -137,26 +173,32 @@ module Sinatra
       
       private
       
+      # Generates paths for this maker instance.
+      def resource
+        @resource ||= Resource.new(self)
+      end
+      
+      def protected?(action)
+        protect.include?(action)
+      end
+      
+      # Handles a request with logging and benchmarking.
       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(' | ')
+        logger.info "[sinatras-hat] " + msg.join(' | ')
         
         result = nil
         
         t = Benchmark.realtime { result = yield }
         
-        logger.info "   Request finished in #{t} sec."
+        logger.info "               Request finished in #{t} sec."
         
         result
       end
-      
-      def resource
-        @resource ||= Resource.new(self)
-      end
     end
   end
 end

data/lib/sinatras-hat/model.rb

@@ -10,21 +10,25 @@ module Sinatra
         @maker = maker
       end
       
+      # Loads all records using the maker's :finder option.
       def all(params)
         params.make_indifferent!
         options[:finder].call(proxy(params), params)
       end
       
+      # Loads one record using the maker's :record option.
       def find(params)
         params.make_indifferent!
         options[:record].call(proxy(params), params)
       end
       
+      # Finds the owner record of a nested resource.
       def find_owner(params)
         params = parent_params(params)
         options[:record].call(proxy(params), params)
       end
       
+      # Updates a record with the given params.
       def update(params)
         if record = find(params)
           params.nest!
@@ -33,25 +37,42 @@ module Sinatra
         end
       end
       
+      # Returns a new instance of the mounted model.
       def new(params={})
         params.nest!
         proxy(params).new(params[singular] || { })
       end
       
+      # Returns the pluralized name for the model.
       def plural
         klass.name.snake_case.plural
       end
       
+      # Returns the singularized name for the model.
       def singular
         klass.name.snake_case.singular
       end
       
+      # Returns the foreign_key to be used for this model.
       def foreign_key
         "#{singular}_id".to_sym
       end
       
+      # Returns the last modified record from the array of records
+      # passed in. It's thorougly inefficient, since it requires all
+      # of the cacheable data to be loaded anyway.
+      def find_last_modified(records)
+        if records.all? { |r| r.respond_to?(:updated_at) }
+          records.sort_by { |r| r.updated_at }.last
+        else
+          records.last
+        end
+      end
+      
       private
       
+      # Returns an association proxy for a nested resource if available,
+      # otherwise it just returns the class.
       def proxy(params)
         return klass unless parent
         owner = parent.find_owner(params)
@@ -62,12 +83,14 @@ module Sinatra
         end
       end
       
+      # Dups and modifies params so that they can be used to find a parent.
       def parent_params(params)
         _params = params.dup.to_mash
         _params.merge! :id => _params.delete(foreign_key)
         _params
       end
       
+      # Returns the parent model if there is one, otherwise nil.
       def parent
         return nil unless maker.parent
         maker.parent.model

data/lib/sinatras-hat/resource.rb

@@ -10,27 +10,37 @@ module Sinatra
       def path(suffix, record=nil)
         suffix = suffix.dup
         
+        parents = path_records_for(record) if record
+        
         path = resources.inject("") do |memo, maker|
           memo += fragment(maker, record)
         end
         
-        suffix.gsub!('/:id', "/#{record.id}") if record
-        
-        clean(path + suffix)
+        path = clean(path + suffix)
+        path.gsub!(/:(\w+)/) { parents.pop.send(@maker.to_param) } if record
+        path
       end
       
       private
       
+      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}/" + interpolate(maker, record)
+          "/#{maker.prefix}/" + key(maker)
       end
       
-      def interpolate(maker, record)
-        foreign_key = maker.model.foreign_key
-        result = record ? record.send(foreign_key) : foreign_key
-        result.inspect
+      def key(maker)
+        maker.model.foreign_key.inspect
       end
       
       def clean(s)

data/lib/sinatras-hat/responder.rb

@@ -49,23 +49,27 @@ module Sinatra
         }
       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(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
       

data/lib/sinatras-hat/response.rb

@@ -13,9 +13,10 @@ module Sinatra
         @request = request
       end
       
-      def render(action)
+      def render(action, options={})
         begin
-          @request.erb action.to_sym, :views_directory => views
+          options.each { |sym, value| @request.send(sym, value) }
+          @request.erb "#{maker.prefix}/#{action}".to_sym
         rescue Errno::ENOENT
           no_template! "Can't find #{File.expand_path(File.join(views, action.to_s))}.erb"
         end

data/lib/sinatras-hat/router.rb

@@ -34,8 +34,8 @@ module Sinatra
         
         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] }        
+        app.send(method, path + "/?") { handler[self] }
+        app.send(method, "#{path}.:format" + "/?") { handler[self] }        
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sinatras-hat
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Pat Nakajima