marley 0.5.0 → 0.6.0

data/README.rdoc

@@ -4,12 +4,9 @@ Marley is a framework for quickly building RESTful web services and applications
 
 * A simple Rack application that acts as request parser/router.
 * A default controller for ORM model classes.
-* Two plugins for the Sequel ORM.
-  * RestConvenience - Connects the class to a default controller.
-  * RestAuthorization - Adds default authorization methods to a model class and its instances.
+* A plugin system similar to Sequel's.
 * Marley Joints - A framework for creating reusable Marley resource sets.
 * Reggae - A JSON data format
-* Jamaica - A minimal JS/jQuery client which renders Reggae resources as browser DOM objects.
 
 The point of the whole thing is to minimize the amount of non-model (non-datacentric) code that needs to be written to implement a web service/application.
 
@@ -34,9 +31,7 @@ if the resource has a REST method corresponding the the request verb, the parser
 
 The parser also traps various errors and returns the appropriate error message to the client.
 
-== The Sequel plugins
-
-Marley activates both of them for Sequel::Model.  This will soon change to an option.
+:include: rdoc/plugins.rdoc
 
 ==The Default Model Controller
 
@@ -49,5 +44,5 @@ One of the things that the RestConvenience Sequel plugin does is add a #controll
 
 ==Jamaica
 
-The default Marley client is "Jamaica", which consists of JS/CSS for browsers.  It sucks right now and I'm hoping somebody takes it over as a sub-project, but it does work - at least on FF.
+The default Marley client is "Jamaica", which consists of JS/CSS for browsers.  It has now been moved to a separate repository at https://github.com/herbdaily/jamaica
 

data/lib/marley.rb

@@ -1,37 +1,32 @@
-#!/usr/bin/ruby
+#!/usr/bin/env ruby
 require 'json/ext'
-require 'json/add/core'
-require 'marley/reggae'
-require 'marley/utils'
 require 'rack'
-require 'rack/auth/basic'
 require 'rack/builder'
+require 'logger'
 require 'sequel'
-require 'sequel/plugins/rest_convenience'
-require 'sequel/plugins/rest_auth'
+require 'marley/core_ext'
+require 'marley/utils'
+require 'marley/reggae'
+require 'marley/errors'
+require 'marley/router'
+require 'marley/resources'
 require 'marley/controllers'
-require 'logger'
+require 'marley/joint' 
+require 'marley/plugin' 
+require 'client/jamaica' #should prob be ditched
 Sequel.extension :inflector
 
-Sequel::Model.plugin :rest_convenience
-Sequel::Model.plugin :rest_authorization
-Sequel::Model.plugin :validation_helpers
-Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(:presence => {:message => 'is required'})
-Sequel::Model.plugin :timestamps, :create => :date_created, :update => :date_updated
-
 log_fn='log/marley.log'
 $log=Logger.new(File.exists?(log_fn) ? log_fn : $stdout) 
 
 module Marley 
-  JOINT_DIRS=[File.expand_path("joints/",File.dirname(__FILE__)),"#{Dir.pwd}/joints"]
-  DEFAULT_OPTS={:http_auth => true,:app_name => 'Application',:port => 1620,:default_user_class => :User, :auth_class => :User,:default_resource => 'Menu', :server => 'thin'}
-  RESP_CODES={'get' => 200,'post' => 201,'put' => 204,'delete' => 204}
-  
-  module Resources 
-  end
-  module Joints
-  end
-  require 'marley/joint' #this needs to happen after Marley::Resources is defined
+  DEFAULT_OPTS={
+    :app_name => 'Application',
+    :port => 1620,
+    :default_resource => 'MainMenu',
+    :server => 'thin',
+    :client => Marley::Client.new}
+  RESP_CODES={'get' => 200,'post' => 201,'put' => 203,'delete' => 204}
   
   def self.config(opts=nil)
     @marley_opts||=DEFAULT_OPTS
@@ -40,123 +35,24 @@ module Marley
     @marley_opts
   end
   
+  def self.plugin(plugin_name, *opts)
+    Plugins.const_get(plugin_name.to_s.camelize).new(*opts)
+  end
   def self.joint(joint_name, *opts)
-    unless Marley::Joints.constants.include?(joint_name.camelize)
-      joint_d=JOINT_DIRS.find {|d| File.exists?("#{d}/#{joint_name}.rb") }
-      require "#{joint_d}/#{joint_name}"
-      @marley_opts && @marley_opts[:client] && @marley_opts[:client].joint(joint_d,joint_name)
-    end
-    Marley::Joints.const_get(joint_name.camelize).new(*opts).smoke
+    Joints.const_get(joint_name.to_s.camelize).new(*opts).smoke
   end
 
   def self.run(opts={})
-    @marley_opts||=DEFAULT_OPTS
-    marley_opts=@marley_opts.merge!(opts)
+    marley_opts=self.config(opts)
     Rack::Handler.get(marley_opts[:server]).run(Rack::Builder.new {
       use Rack::Reloader,0
       use Rack::Static, :urls => [opts[:image_path]] if opts[:image_path]
       run(Marley::Router.new(marley_opts))
     }.to_app,{:Port => @marley_opts[:port]})
   end
-  class Router  
-    def initialize(opts={},app=nil)
-      @opts=DEFAULT_OPTS.merge(opts)
-    end
-    def call(env)
-      request= Rack::Request.new(env)
-      @auth =  Rack::Auth::Basic::Request.new(env)
-      $request={:request => request,:opts => @opts}
-      $request[:get_params]=Marley::Utils.hash_keys_to_syms(request.GET)
-      $request[:post_params]=Marley::Utils.hash_keys_to_syms(request.POST)
-      $request[:content_type]=request.xhr? ? 'application/json' : env['HTTP_ACCEPT'].to_s.sub(/,.*/,'') 
-      $request[:content_type]='text/html' unless $request[:content_type] > ''
-      $request[:content_type]='application/json' if env['rack.test']==true #there has to be a better way to do this...
-      if @opts[:http_auth]
-        if (@auth.provided? && @auth.basic? && @auth.credentials)
-          $request[:user]=Resources.const_get(@opts[:auth_class]).authenticate(@auth.credentials)
-          raise AuthenticationError unless $request[:user]
-        else
-          $request[:user]=Resources.const_get(@opts[:default_user_class]).new
-        end
-      end
-      $request[:path]=request.path.sub(/\/\/+/,'/').split('/')[1..-1]
-      verb=request.request_method.downcase
-      verb=$request[:post_params].delete(:_method).match(/^(put|delete)$/i)[1] rescue verb 
-      $request[:verb]="rest_#{verb}"
-      rn=$request[:path] ? $request[:path][0].camelize : @opts[:default_resource]
-      raise RoutingError unless Resources.constants.include?(rn)
-      @resource=Resources.const_get(rn)
-      raise AuthenticationError if @opts[:http_auth] && @resource.respond_to?('requires_user?') && @resource.requires_user? && $request[:user].new?
-      @controller=nil
-      @controller=@resource.controller if @resource.respond_to?(:controller)
-      @controller=@resource if @resource.respond_to?($request[:verb]) 
-      raise RoutingError unless @controller
-      json=@controller.send($request[:verb]).to_json
-      html=@opts[:client] ? @opts[:client].to_s(json) : json
-      resp_code=RESP_CODES[verb]
-      headers||={'Content-Type' => "#{$request[:content_type]}; charset=utf-8"}
-      [resp_code,headers,$request[:content_type].match(/json/) ? json : html]
-    rescue Sequel::ValidationFailed
-      ValidationError.new($!.errors).to_a
-    rescue
-      if $!.class.superclass==MarleyError
-        $!.to_a
-      else
-        p $!,$!.backtrace
-      end
-    ensure
-      $log.info $request.merge({:request => nil,:user => $request[:user] ? $request[:user].name : nil})
-    end
-  end
-  class MarleyError < StandardError
-    class << self
-      attr_accessor :resp_code,:headers,:description,:details
-    end
-    @resp_code=500
-    def initialize
-      self.class.details=self.backtrace
-    end
-    def log_error
-      $log.fatal("#$!.message}\n#{$!.backtrace}")
-    end
-    def to_a
-      log_error
-      json=[:error,{:error_type => self.class.name.underscore.sub(/_error$/,'').sub(/^marley\//,''),:description => self.class.description, :error_details => self.class.details}].to_json
-      self.class.headers||={'Content-Type' => "#{$request[:content_type]}; charset=utf-8"}
-      [self.class.resp_code,self.class.headers,json]
-    end
-  end
-  class ValidationError < MarleyError
-    @resp_code=400
-    def initialize(errors)
-      self.class.details=errors
-    end
-    def log_error
-      $log.error(self.class.details)
-    end
-  end
-  class AuthenticationError < MarleyError
-    @resp_code=401
-    @headers={'WWW-Authenticate' => %(Basic realm="Application")}
-    def log_error
-      $log.error("Authentication failed for #{@auth.credentials[0]}") if (@auth && @auth.provided? && @auth.basic? && @auth.credentials)
-    end
-  end
-  class AuthorizationError < MarleyError
-    @resp_code=403
-    @description='You are not authorized for this operation'
-    def log_error
-      $log.error("Authorizationt Error:#{self.message}")
-    end
-  end
-  class RoutingError < MarleyError
-    @resp_code=404
-    @description='Not Found'
-    def log_error
-      $log.fatal("path:#{$request[:path]}\n   msg:#{$!.message}\n   backtrace:#{$!.backtrace}")
-    end
-  end
 end
-  MR=Marley::Resources
-  MJ=Marley::Joints
+MR=Marley::Resources
+MJ=Marley::Joints
+MP=Marley::Plugins
+MU=Marley::Utils
 at_exit {Marley.run  if ARGV[0]=='run'}

data/lib/marley/controllers.rb

@@ -5,6 +5,7 @@ module Marley
       @model=model
       if $request[:path][1].to_s.match(/^\d+$/) #references a specific instance by ID
         @instance=@model[$request[:path][1].to_i]
+        raise RoutingError unless @instance
         @method_name=$request[:path][2]  
         if @method_name
           raise RoutingError unless @instance.respond_to?(@method_name)
@@ -35,24 +36,28 @@ module Marley
     def rest_post
       if @instance
         raise RoutingError unless @method
-        params=$request[:post_params][@model.resource_name.to_sym][@method_name.to_sym] || $request[:post_params][@method_name.to_sym] 
+        params=$request[:post_params][@method_name.to_sym] || $request[:post_params][@model.resource_name.to_sym][@method_name.to_sym] 
         raise ValidationFailed unless params
         params=[params] unless params.class==Array
         params.map do |param|
           @instance.send("add_#{@method_name}",param)
         end
       else
-        @instance=@model.new($request[:post_params][@model.resource_name.to_sym] || {})
-        @instance.save(@instance.write_cols)
+        params=($request[:post_params][@model.resource_name.to_sym]||{})
+        @instance=@model.new(params.reject {|k,v| v.nil?}) #reject nils to work around sequel validation flaw
+        raise AuthorizationError if params.keys.find {|k| ! @instance.write_cols.include?(k) }
+        params.keys.each {|k| @instance.send("#{k.to_s}=",params[k]) if k.to_s.match(/^_/)}
+        @instance.save
         @instance.respond_to?('create_msg') ? @instance.create_msg : @instance
       end
     end
     def rest_put
       raise RoutingError unless @instance
-      (@instances || [@instance]).map do |i|
-        i.modified!
-        i.update_only($request[:post_params][@model.resource_name.to_sym],i.write_cols)
-      end
+      params=($request[:post_params][@model.resource_name.to_sym]||{})
+      raise AuthorizationError if params.keys.find {|k| ! @instance.write_cols.include?(k) }
+      params.keys.each {|k| @instance.send("#{k.to_s}=",params[k]) if k.to_s.match(/^_/)}
+      @instance.modified!
+      @instance.update_only(params,@instance.write_cols)
     end
     def rest_delete
       raise RoutingError unless @instance

data/lib/marley/core_ext.rb

@@ -0,0 +1,8 @@
+class Object
+  def send_or_default(meth, default)
+    respond_to?(meth) ? send(meth) : default
+  end
+  def send_or_nil(meth)
+    send_or_default(meth,nil)
+  end
+end

data/lib/marley/errors.rb

@@ -0,0 +1,51 @@
+module Marley
+  class MarleyError < StandardError
+    class << self
+      attr_accessor :resp_code,:headers,:description,:details
+    end
+    @resp_code=500
+    def initialize
+      self.class.details=self.backtrace
+    end
+    def log_error
+      $log.fatal("#$!.message}\n#{$!.backtrace}")
+    end
+    def to_a
+      log_error
+      json=[:error,{:error_type => self.class.name.underscore.sub(/_error$/,'').sub(/^marley\//,''),:description => self.class.description, :error_details => self.class.details}].to_json
+      self.class.headers||={'Content-Type' => "#{$request[:content_type]}; charset=utf-8"}
+      [self.class.resp_code,self.class.headers,json]
+    end
+  end
+  class ValidationError < MarleyError
+    @resp_code=400
+    def initialize(errors)
+      self.class.details=errors
+    end
+    def log_error
+      $log.error(self.class.details)
+    end
+  end
+  class AuthenticationError < MarleyError
+    @resp_code=401
+    @headers={'WWW-Authenticate' => %(Basic realm="Application")}
+    def log_error
+      $log.error("Authentication failed for #{@auth.credentials[0]}") if (@auth && @auth.provided? && @auth.basic? && @auth.credentials)
+    end
+  end
+  class AuthorizationError < MarleyError
+    @resp_code=403
+    @description='You are not authorized for this operation'
+    def log_error
+      $log.error("Authorizationt Error:#{self.message}")
+    end
+  end
+  class RoutingError < MarleyError
+    @resp_code=404
+    @description='Not Found'
+    def log_error
+      $log.fatal("path:#{$request[:path]}\n   msg:#{$!.message}\n   backtrace:#{$!.backtrace}")
+    end
+  end
+end
+

data/lib/marley/joint.rb

@@ -1,35 +1,30 @@
 module Marley
   module Joints
-    # @abstract Subclass and implement one or more of the following modules within the class namespace:
-    #    - Resources - All constansts in this module will be imported into Marley::Resources
-    #    - ClassMethods - Modules within this module will extend any constant in Marley::Resources with the same name.
-    #    - InstanceMethods - Modules within this module will append their features to any constant in Marley::Resources with the same name. 
+    Gem.find_files("lib/marley/joints/*.rb").each do |f|
+      self.autoload(File.basename(f,'.rb').camelize, f)
+    end
     class Joint
-      MODS=['Resources','Plugins']
-      MODS.each {|mod| const_set(mod,Module.new)}
-      def self.mods
-        MODS.map {|mod_name| self.const_get(mod_name) } 
-      end
+      extend Marley::Utils::ClassAttrs
+      class_attr(:default_opts,{})
+      attr_accessor :opts
       def initialize(opts={})
         config(opts)
       end
       def smoke
-        self.class::Resources.constants.each do |resource_name|
-          MR.const_set(resource_name, self.class::Resources.const_get(resource_name)) unless (@opts[:resources] && ! @opts[:resources].include?(resource_name))
+        @opts[:required_joints].to_a.each do |j|
+          Marley.joint(j)
         end
-        self.class.constants.grep(/.+Plugin$/).each do |plugin_name|
-          plugin=self.class.const_get(plugin_name)
-          resource_name=plugin_name.sub(/Plugin$/,'')
-          if MR.constants.include?(resource_name)
-            resource=MR.const_get(resource_name)
-            plugin.constants.include?('ClassMethods') && resource.extend(plugin.const_get('ClassMethods'))
-            plugin.constants.include?('InstanceMethods') && plugin.const_get('InstanceMethods').send(:append_features,resource)
+        resources=self.class::Resources
+        resources.constants.each do |resource_name|
+          @opts[:plugins].to_a.each do |plugin_name|
+            Marley.plugin(plugin_name).apply(resources.const_get(resource_name))
           end
+          MR.const_set(resource_name, resources.const_get(resource_name)) unless (@opts[:resources] && ! @opts[:resources].include?(resource_name) )
         end
         self
       end
       def config(opts)
-        @opts=(@opts || {}).merge(opts)
+        @opts=(@opts || self.class.default_opts || {}).merge(opts)
       end
     end
   end

data/lib/marley/joints/forum.rb

@@ -0,0 +1,88 @@
+
+module Marley
+  module Plugins
+    class MessageThreading < Plugin
+      module ClassMethods
+        def topics(params=nil)
+          filters=[]
+          if params && params[:tags]
+            filters << {:id => MR::Tag.join(:messages_tags, :tag_id => :id).select(:message_id).filter(:tag => params[:tags])}
+          end
+          filters.inject(self.dataset.filter(:parent_id => nil)) {|ds,f| ds.filter(f)}
+        end
+        def list(params=nil)
+          (params.is_a?(Sequel::Dataset) ?  params : topics(params)).map{|t| t.thread}
+        end
+      end
+      module InstanceMethods
+        def write_cols
+          super.push(:topic_id, :parent_id)
+        end
+        def children
+          self.class.filter(:parent_id => id).all
+        end
+        def thread
+          return reggae_instance if children.length==0
+          foo=reggae_instance
+          foo[2] = children.map{|m| m.thread} 
+          foo
+        end
+        def before_save
+          super
+          self.topic_id||=self.class.max(:topic_id).to_i+1
+        end
+        def reply
+          foo=reggae_instance.set_values(:parent_id => id,:title => "re: #{title}")
+          foo.new_rec=true
+          foo.url=self.class.new.url
+          foo.schema.delete_if {|c| [:author,:id].include?(c[NAME_INDEX])}
+          foo
+        end
+      end
+    end
+    class MessageNav < Plugin
+      module ClassMethods
+        def section_nav
+          [
+            self.reggae_link(:new, 'New Post'),
+            self.reggae_link(:list, 'All Posts'),
+            self.reggae_link(:recent_topics, 'Recent Topics')
+          ].push(
+            Marley::ReggaeMsg.new({
+              :title => 'Topics Tagged With:', 
+              :description => MR::Tag.filter(:id => topics.join(:messages_tags).where(:messages__id => :message_id).select(:tag_id)).map{|t| reggae_link('list',t.tag,"#{resource_name}[tags]=#{t.tag}")}})
+          )
+        end
+        def section_contents
+        end
+        def recent_topics
+          list(:date_created > Date.today - 2)
+        end
+      end
+    end
+  end
+  module Joints
+    class Forum < Joint
+      Marley.plugin('orm_rest_convenience').apply(Sequel::Model)
+      Marley.joint('user')
+      Marley.joint('messages',{:tags => true})
+      Marley.joint('section')
+      Marley.plugin(:section).apply('PrivateMessage')
+      Marley.plugin(:section).apply('PublicMessage')
+      Marley.plugin(:message_threading).apply('PublicMessage')
+      Marley.plugin(:message_nav).apply('PublicMessage')
+      class << MR::PublicMessage
+        def section_title;'Public Forums';end
+      end
+      module Resources
+        class Topic < MJ::Messages::Message
+        end
+        class TopicTag < MR::Tag
+        end
+        class Admin < MR::User
+          def self.requires_user?; true;end
+        end
+      end
+    end
+  end
+end