bradphelan-sinatras-hat 0.1.2

data/lib/sinatras-hat.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+require 'benchmark'
+require 'sinatra/base'
+require 'extlib'
+
+require 'core_ext/array'
+require 'core_ext/hash'
+require 'core_ext/object'
+require 'core_ext/module'
+
+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

@@ -0,0 +1,81 @@
+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 self.included(map)
+        map.action :destroy, '/:id', :verb => :delete do |request|
+          record = model.find(request.params) || request.not_found
+          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) || 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) || request.not_found
+          responder.success(:edit, request, record)
+        end
+
+        map.action :show, '/:id' do |request|
+          record = model.find(request.params) || request.not_found
+          set_cache_headers(request, record) unless protected?(:show)
+          responder.success(:show, request, record)
+        end
+        
+        map.action :create, '/', :verb => :post do |request|
+          record = model.new(request.params)
+          if record
+            puts "RECORD #{record.to_csv}"
+            result = record.save ? :success : :failure
+            puts "RESULT #{result}"
+            responder.send(result, :create, request, record)
+          else
+            responder.send(:failure, request, request.not_found)
+          end
+
+        end
+
+        map.action :index, '/' do |request|
+          records = model.all(request.params) || request.not_found
+          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
+end

data/lib/sinatras-hat/authentication.rb

@@ -0,0 +1,55 @@
+# from http://www.gittr.com/index.php/archive/sinatra-basic-authentication-selectively-applied
+# adapted by pat nakajima for sinatra's hat
+module Sinatra
+  module Authorization
+    class ProtectedAction
+      attr_reader :credentials, :request, :block
+  
+      def initialize(request, credentials={}, &block)
+        @credentials, @request, @block = credentials, request, block
+      end
+  
+      def check!
+        unauthorized! unless auth.provided?
+        bad_request! unless auth.basic?
+        unauthorized! unless authorize(*auth.credentials)
+      end
+ 
+      def remote_user
+        auth.username
+      end
+ 
+      private
+  
+      def authorize(username, password)
+        block.call(username, password)
+      end
+  
+      def unauthorized!
+        request.response.headers['WWW-Authenticate'] = %(Basic realm="#{credentials[:realm]}")
+        throw :halt, [ 401, 'Authorization Required' ]
+      end
+ 
+      def bad_request!
+        throw :halt, [ 400, 'Bad Request' ]
+      end
+  
+      def auth
+        @auth ||= Rack::Auth::Basic::Request.new(request.env)
+      end
+    end
+ 
+    module Helpers
+      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?(request)
+        request.env['REMOTE_USER']
+      end
+    end
+  end
+end

data/lib/sinatras-hat/extendor.rb

@@ -0,0 +1,24 @@
+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)
+        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)
+          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

@@ -0,0 +1,187 @@
+module Sinatra
+  module Hat
+    # This is where it all comes together
+    class Maker
+      include Sinatra::Hat::Extendor
+      include Sinatra::Authorization::Helpers
+      
+      attr_reader :klass, :app
+      
+      def self.actions
+        @actions ||= { }
+      end
+      
+      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
+
+      def self.option_setter(name, options={})
+        setter = options[:collection] ? 'Set.new(args)' : 'args.first'
+        class_eval(<<-END, __FILE__, __LINE__)
+          def #{name}(*args, &block)
+            return options[#{name.inspect}] = block if block_given?
+            return options[#{name.inspect}] = #{setter} unless args.empty?
+            return options[#{name.inspect}]
+          end
+        END
+      end
+      
+      include Sinatra::Hat::Actions
+      
+      #  ======================================================
+      
+      # The finder block is used when loading all records for the index
+      # action. It gets passed the model proxy and the request params hash.
+      option_setter :finder
+      
+      # 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.
+      option_setter :record
+      
+      # The authenticator block gets called before protected actions. It
+      # gets passed the basic auth username and password.
+      option_setter :authenticator
+      
+      # A list of actions that get generated by this maker instance. By
+      # default it's all of the actions specified in actions.rb
+      option_setter :only, :collection => true
+      
+      # A way to determine a record's representation in the database
+      option_setter :to_param
+      
+      # The path prefix to use for generating groutes.
+      option_setter :prefix
+      
+      option_setter :format
+      
+      def initialize(klass, overrides={})
+        @klass = klass
+        options.merge!(overrides)
+        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)
+        
+        log_with_benchmark(request, action) do
+          instance_exec(request, &self.class.actions[action][:fn])
+        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
+      
+      # 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!)
+        
+        if actions.empty?
+          options[:protect] ||= Set.new([])
+        else
+          actions == [:all] ? 
+            Set.new(options[:protect] = only) :
+            Set.new(options[:protect] = actions)
+        end
+      end
+      
+      # An array of parent Maker instances under which this instance
+      # was nested.
+      def 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,
+          :format => nil,
+          :prefix => model.plural,
+          :finder => proc { |model, params| model.all },
+          :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
+
+      # 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
+      
+      # TODO Hook this into Rack::CommonLogger
+      def logger
+        @logger ||= Logger.new(self)
+      end
+      
+      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 "[sinatras-hat] " + msg.join(' | ')
+        
+        result = nil
+        
+        t = Benchmark.realtime { result = yield }
+        
+        logger.info "               Request finished in #{t} sec."
+        
+        result
+      end
+    end
+  end
+end

data/lib/sinatras-hat/model.rb

@@ -0,0 +1,110 @@
+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
+      
+      # Loads all records using the maker's :finder option.
+      def all(params)
+        params.make_indifferent!
+        p = proxy(params)
+        if p
+          options[:finder].call(p, params)
+        else
+          nil
+        end
+      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!
+          record.attributes = (params[singular] || { })
+          record
+        end
+      end
+      
+      # Returns a new instance of the mounted model.
+      def new(params={})
+        params.nest!
+        p = proxy(params)
+        if p
+          p.new(params[singular] || { })
+        else
+          nil
+        end
+      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 nil
+      def proxy(params)
+        return klass unless parent
+        owner = parent.find_owner(params)
+        if owner and owner.respond_to?(plural)
+          owner.send(plural)
+        else
+          nil
+        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
+      end
+    end
+  end
+end