sinatras-hat 0.0.2

data/lib/core_ext/array.rb

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

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

data/lib/core_ext/object.rb

@@ -0,0 +1,49 @@
+require 'metaid'
+
+class Object
+  def tap
+    yield self
+    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)
+      meta_def("#{key}=") { |v| hash[key] = v } unless respond_to?("#{key}=")
+    end
+    
+    return unless block_given?
+
+    result = yield
+
+    hash.each do |key, value|
+      meta_eval { remove_method(key) }
+      meta_eval { remove_method("#{key}=") }
+    end
+
+    result
+  end
+
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block)
+    begin
+      old_critical, Thread.critical = Thread.critical, true
+      n = 0
+      n += 1 while respond_to?(mname="__instance_exec#{n}")
+      InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    ensure
+      Thread.critical = old_critical
+    end
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+    end
+    ret
+  end
+end

data/lib/sinatras-hat.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'core_ext')
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'sinatras-hat')
+
+require 'erb'
+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'
+
+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

data/lib/sinatras-hat/actions.rb

@@ -0,0 +1,67 @@
+module Sinatra
+  module Hat
+    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
+        end
+      end
+    end
+  end
+end

data/lib/sinatras-hat/auth.rb

@@ -0,0 +1,59 @@
+# 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, :context, :block
+  
+      def initialize(context, credentials={}, &block)
+        @credentials, @context, @block = credentials, context, 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!
+        context.header '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(context.request.env)
+      end
+    end
+ 
+    module Helpers
+      def protect!(credentials, &block)
+        return if authorized?
+        guard = ProtectedAction.new(self, credentials, &block)
+        guard.check!
+        request.env['REMOTE_USER'] = guard.remote_user
+      end
+ 
+      def authorized?
+        request.env['REMOTE_USER']
+      end
+    end
+  end
+end
+ 
+helpers do
+  include Sinatra::Authorization::Helpers
+end

data/lib/sinatras-hat/maker.rb

@@ -0,0 +1,228 @@
+module Sinatra
+  module Hat
+    class Maker
+      attr_accessor :parent
+      attr_reader :model, :context, :options
+      
+      include Actions, Responses
+      
+      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!
+      end
+      
+      def mount(klass, opts={}, &block)
+        child = Maker.new(klass)
+        child.parent = self
+        child.define(context, opts, &block)
+        child
+      end
+      
+      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
+      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
+      end
+      
+      def children(*args)
+        result = get_or_set_option(:children, args) do
+          self.children = args
+          self.children.uniq!
+        end
+        
+        [result].flatten
+      end
+      
+      def authenticator(&block)
+        if block_given?
+          @authenticator = block
+        else
+          @authenticator ||= proc { |username, password|
+            credentials[:username] == username and credentials[:password] == password
+          }
+        end
+      end
+      
+      def finder(&block)
+        if block_given?
+          @finder = block
+        else
+          @finder ||= proc { |params| all }
+        end
+      end
+      
+      def record(&block)
+        if block_given?
+          @record = block
+        else
+          @record ||= proc { |params| first(:id => params[:id]) }
+        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
+      
+      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)
+        proxy(params).instance_exec(params, &send(method))
+      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
+      end
+      
+      def model_id
+        "#{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),
+          :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'] }
+          }
+        }
+      end
+      
+      private
+      
+      def get_or_set_option(name, args, opts={})
+        args.length > 0 ? yield : options[name]
+      end
+    end
+  end
+end

data/lib/sinatras-hat/responses.rb

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

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: sinatras-hat
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !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: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/core_ext
+- lib/core_ext/hash.rb
+- lib/core_ext/array.rb
+- lib/core_ext/object.rb
+- lib/sinatras-hat
+- lib/sinatras-hat/maker.rb
+- lib/sinatras-hat/actions.rb
+- lib/sinatras-hat/auth.rb
+- lib/sinatras-hat/responses.rb
+- lib/sinatras-hat.rb
+has_rdoc: false
+homepage: 
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Simple REST-ful resources with Sinatra.
+test_files: []
+