marley 0.1.0 → 0.2.0

data/README.rdoc

@@ -1,48 +1,75 @@
 =Marley
 
-Marley is a project consisting of several parts:
+Marley is a framework for quickly building RESTful web services and applications.  It consists of several parts:
 
-* A server side micro-framework for returning data from ORM models (currently only Sequel) and other objects (Ruby, based on rack with thin as the default web server)
-* A framework for adding reusable content to the framework ("Joints")
-* A JSON data format ("Reggae") 
-* A simple JS client ("Jamaica") which renders Reggae as HTML.
+* 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.
+* 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 create as many useful default behaviors as possible, while making it easy to override any or all of them.
+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.
 
-Please see the examples/forum.rb to get a basic idea of what a Marley application looks like.
+Please see the examples/forum.rb and the included Joints' code to get a basic idea of what a Marley application looks like.
 
 -----
 
-More about each part:
+==Marley Resources
 
-==Marley
+Marley resources are constants in the Marley::Resources namespace.
 
-* Marley resources are constants in the Marley::Resources namespace.
-  * A resource must respond either to a #controller method or to one or more of #rest_get, #rest_post, #rest_put, or #rest_delete. 
-  * Resources implementing a #controller method should return an object that responds to one or more REST verbs from that method
-  * REST verb methods should return an object which responds to #to_json by returning a string to be sent to the client
+* A resource must respond either to a #controller method or to one or more REST verbs (#rest_get, #rest_post, #rest_put, or #rest_delete). 
+* A #controller method must return an object that responds to one or more REST verbs.
+* REST verb methods should return an object with a #to_json method.
 
-* Marley provides 2 plugins for the Sequel ORM.
-  * RestConvenience - Adds a default controller for standard rest routes to a model
-  * RestAuthorization - Adds default authorization to a model
 
-I use Sequel exclusively, so I've only written these plugins for it.  I imagine it would be pretty trivial to port them to other ORMs.
+==The Parser/Router
+
+The parser splits the request path on '/' and treats the first part as the requested resource.  If no resource is specified in the request, it uses the default resource.  
+
+if the resource has a REST method corresponding the the request verb, the parser calls that method and sends the return value to the client.
+
+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.
+
+==The Default Model Controller
+
+One of the things that the RestConvenience Sequel plugin does is add a #controller method to affected models.  This method instantiates and returns a ModelController object for the model in question.  At initialization, the Controller parses the request path to determine the model instances to which the request refers.  
+
 
 ==Joints
 
-"Joints" are pre-packaged resource sets that can be included in a Marley application.  The joints API is very much a work in progress.
+"Joints" are pre-packaged resource sets that can be included in a Marley application.  A joint can be added to the current Resources by running Marley.joint('_joint_name_').  The Marley.joint method will then do the following:
+
+* Find a file named '_joint_name_' in the 'joints/' directory.
+* Require that file.
+* run its #smoke method.
+
+The Joint#smoke method looks for 3 modules inside the joint's namespace:  Resources, ClassMethods, and InstanceMethods.  
+
+* if the Resources module exists, Joint#smoke will copy all of its constants to Marley::Resources.
+* If the ClassMethods module exists, Joint#smoke will cycle through the modules within it, and extend objects in Marley::Resources with the same name.
+* If the InstanceMethods module exists, Joint#smoke will cycle through the modules within it, and call their #append_features with the corresponding objects in Marley::Resources with the same name.
 
-For now, there are 3 joints included in the Marley distribution:
+For now, there are 5 joints included in the Marley distribution:
 
 * Basic User
 * Basic Messaging
+* Basic Menu System
 * Tagging
+* Tagged Messaging
 
-With a bit of configuration and a few menus, these comprise the example forum application, which is in turn the targt for the test suite.
+With a bit of configuration, these comprise the example forum application, which is in turn the targt for the test suite.
 
 ==Reggae
 
-The server and client use a JSON based data representation I developed for this project and tentatively named "Reggae."  It is documented roughly in Reggae.ebnf.  I am considering some structural changes, which are reflected in Reggae2.ebnf.  I'd love some comments on this.
+The server and client use a JSON based data representation format "Reggae."  Reggae.ebnf describes the format in canonical form, and reggae.rb contains a Reggae parser and generator.  
 
 ==Jamaica
 

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.ruby_opts=['-r test/test_include']
+  t.test_files=FileList['test/*_tests.rb']
+end
+

data/examples/blog.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'sequel'
+require 'digest/sha1'
+
+$: << "#{File.dirname(__FILE__)}/../lib/"
+
+APP_DIR=File.dirname(__FILE__)
+require "marley"
+require "client/jamaica"
+#need to automate the following somehow but can't think of anything that isn't ugly ATM
+DB=Sequel.sqlite("#{APP_DIR}/forum#{ENV["MARLEY_TESTING"] ? '_test' : ''}.sqlite3")#,:loggers => [Logger.new($stdout)])
+
+Marley.config({:app_name => 'The Forum',:client => Marley::Client.new({:app_name => 'The Forum'})})
+
+Marley.joint 'tagged_messaging', {:resources => ['user','admin']}
+Marley.joint 'basic_menu_system'
+
+module Marley
+  module Resources
+    class Author < User
+      def self.requires_user?;true;end
+    end
+    class Post < MJ::TaggedMessaging::Resources::Post
+    end
+  end
+end

data/{test/forum_tests.rb → forum_tests.rb}

@@ -6,7 +6,7 @@ EXAMPLES_DIR=File.dirname(__FILE__) + '/../examples'
 ENV['MARLEY_TESTING']='true'
 `cp #{EXAMPLES_DIR}/empty.sqlite3 #{EXAMPLES_DIR}/forum_test.sqlite3`
 require "#{EXAMPLES_DIR}/forum.rb"
-require "#{EXAMPLES_DIR}/../lib/test_helpers"
+require "#{EXAMPLES_DIR}/../lib/marley/test_helpers"
 
 class UserTests < Test::Unit::TestCase
   def setup
@@ -24,18 +24,18 @@ class UserTests < Test::Unit::TestCase
   end
   should "validate new user properly" do
     assert resp=@client.create
-    assert_equal "error", resp.resource_type
+    assert_equal :error, resp.resource_type
     assert_equal "validation", resp.error_type
     assert_equal ["is required"], resp.error_details[:name]
     resp=@client.create({:'user[name]' => 'asdf'})
-    assert_equal "error", resp.resource_type
+    assert_equal :error, resp.resource_type
     assert_equal "validation", resp.error_type
     resp=@client.create({:'user[name]' => 'asdf',:'user[password]' => 'asdfaf'})
-    assert_equal "error", resp.resource_type
+    assert_equal :error, resp.resource_type
     assert_equal "validation", resp.error_type
     assert_equal ["Password must contain at least 8 characters"], resp.error_details[:password]
     resp=@client.create(:'user[name]' => 'asdf',:'user[password]' => 'asdfasdf')
-    assert_equal "error", resp.resource_type
+    assert_equal :error, resp.resource_type
     assert_equal "validation", resp.error_type
     assert_equal ["Passwords do not match"], resp.error_details[:confirm_password]
   end
@@ -64,7 +64,7 @@ class UserTests < Test::Unit::TestCase
       params=user.to_params
       assert @client.update(params,{:code => 204})
       assert err=@client.update(params.update('user[password]' => 'zxcvzxcv'),{:code => 400})
-      assert_equal "error", err.resource_type
+      assert_equal :error, err.resource_type
       assert_equal "validation", err.error_type
       assert @client.update(params.update('user[password]' => 'zxcvzxcv','user[confirm_password]' => 'zxcvzxcv', 'user[old_password]' => 'asdfasdf'),:code => 204)
       assert @client.read({},:code => 401)
@@ -104,18 +104,18 @@ class MessageTests < Test::Unit::TestCase
       should "validate new user generated PMs properly" do
         #reject a PM with only recipients
         resp=@client.create({:'private_message[recipients]' => 'user2'},{:code => 400})
-        assert_equal "error", resp.resource_type
+        assert_equal :error, resp.resource_type
         assert_equal "validation", resp.error_type
         assert_equal ["is required"], resp.error_details[:title]
         assert_equal ["is required"], resp.error_details[:message]
         #reject a PM to a non-existent user
         resp=@client.create({:'private_message[recipients]' => 'asdfasdfasdfasdf',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'},{:code => 400})
-        assert_equal "error", resp.resource_type
+        assert_equal :error, resp.resource_type
         assert_equal "validation", resp.error_type
         assert resp.error_details[:recipients][0]
         #reject a PM from user to user
         resp=@client.create({:'private_message[recipients]' => 'user2',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'},{:code => 400})
-        assert_equal "error", resp.resource_type
+        assert_equal :error, resp.resource_type
         assert_equal "validation", resp.error_type
         assert resp.error_details[:recipients][0]
       end
@@ -129,7 +129,7 @@ class MessageTests < Test::Unit::TestCase
       end
       should "validate new admin generated PMs properly" do
         resp=@client.create({:'private_message[recipients]' => 'user2'},{:code => 400})
-        assert_equal "error", resp.resource_type
+        assert_equal :error, resp.resource_type
         assert_equal "validation", resp.error_type
         assert_equal ["is required"], resp.error_details[:title]
         assert_equal ["is required"], resp.error_details[:message]
@@ -298,7 +298,7 @@ class MessageTests < Test::Unit::TestCase
     context 'validation' do
       should "get a validation error trying to post without a title or message as admin, user1, or user2" do
         resp=@client.create({},{:code => 400,:auth => @admin_auth})
-        assert_equal "error", resp.resource_type
+        assert_equal :error, resp.resource_type
         assert_equal "validation", resp.error_type
         assert_equal ["is required"], resp.error_details[:title]
         assert_equal ["is required"], resp.error_details[:message]

data/lib/joints/basic_menu_system.rb

@@ -5,23 +5,30 @@ module Sequel::Plugins::RestSection
     SECTION_PROPS.each {|p| attr_accessor :"section_#{p}"}
     def section
       if SECTION_PROPS.find {|p| send(:"section_#{p}").to_s > ''}
-        Marley::ReggaeSection.new [SECTION_PROPS.inject({}) {|props,p| props[p.to_sym]=send(:"section_#{p}");props }]
+        Marley::ReggaeSection.new(SECTION_PROPS.inject({}) do |props,p| 
+          prop=send(:"section_#{p}")
+          props[p.to_sym]=prop.class==Hash ? prop[$request[:user].class] : prop
+          props 
+        end)
       end
     end
   end
 end
-Sequel::Model.plugin :rest_section
 module Marley
   module Joints
     class BasicMenuSystem < Joint
+      def smoke
+        super
+        Sequel::Model.plugin :rest_section
+      end
       module Resources
         class Menu
           class <<self
             attr_accessor :sections
           end
-          attr_accessor :title,:name,:description, :navigation
+          include Sequel::Plugins::RestSection::ClassMethods
           def self.rest_get
-            new.to_json
+            new.section
           end
           def self.requires_user?
             ! $request[:path].to_a.empty?
@@ -31,22 +38,19 @@ module Marley
             if $request[:user].new?
               u=$request[:user].to_a
               u[1].merge!({:description => 'If you don\'t already have an account, please create one here:'})
-              @title="Welcome to #{$request[:opts][:app_name]}"
-              @description='Login or signup here.'
-              @navigation=[LOGIN_FORM,u]
+              @section_title="Welcome to #{$request[:opts][:app_name]}"
+              @section_description='Login or signup here.'
+              @section_navigation=[LOGIN_FORM,u]
             else
-              @title = "#{$request[:opts][:app_name]} Main Menu"
-              @description="Welcome to #{$request[:opts][:app_name]}, #{$request[:user].name}"
-              @navigation=(self.class.sections || MR.constants).map do |rn|
-                if (resource=MR.const_get(rn)).respond_to?(:section) && (s=resource.section)
+              @section_title = "#{$request[:opts][:app_name]} Main Menu"
+              @section_description="Welcome to #{$request[:opts][:app_name]}, #{$request[:user].name}"
+              @section_navigation=(self.class.sections || (MR.constants - [self.class.to_s.sub(/.*::/,'').to_sym])).map do |rn|
+                if (resource=MR.const_get(rn)).respond_to?(:section) && (s=resource.section) && s.title
                   [:link,{:title => s.title, :description =>s.description, :url => "#{resource.resource_name}/section" }]
                 end
               end.compact
             end
           end
-          def to_json
-            [:section,{:title => @title,:description => @description,:name => @name, :navigation => @navigation}]
-          end
         end
       end
     end

data/lib/joints/basic_messaging.rb

@@ -6,6 +6,7 @@ module Marley
       module Resources
         class Message < Sequel::Model
           plugin :single_table_inheritance, :message_type, :model_map => lambda{|v| v ? MR.const_get(v.to_s) : ''}, :key_map => lambda{|klass|klass.name.sub(/.*::/,'')}
+          # CHANGE NEEDED:tree is unnecessary, instead, select by thread_id, order by parent_id, inject [] for nesting.  Should be much faster.
           plugin :tree
           many_to_one :author, :class => :'Marley::Resources::User'
           @owner_col=:author_id
@@ -22,7 +23,6 @@ module Marley
           def after_initialize
             super
             if new?
-              self.author_id=$request[:user][:id]
               self.thread_id=parent ? parent.thread_id : Message.select(:max.sql_function(:thread_id).as(:tid)).all[0][:tid].to_i + 1
             end
           end

data/lib/joints/basic_user.rb

@@ -13,7 +13,7 @@ module Marley
             ! ($request[:verb]=='rest_post')
           end
           def self.section
-            ReggaeSection.new([ {:title => 'User Info', :name => self.to_s.underscore, :navigation => []},$request[:user]]) if $request[:user].class == self
+            ReggaeSection.new( {:title => 'User Info', :name => self.to_s.sub(/.*::/,'').underscore, :navigation => []}) if $request[:user].class == self
           end
           def write_cols;[:name,:email,:password,:confirm_password,:old_password];end
           def rest_schema

data/lib/joints/tagged_messaging.rb

@@ -9,9 +9,11 @@ module Marley
     class TaggedMessaging < Joint
       def smoke
         super
-        MR::Tag.tagging_for('PrivateMessage', 'User')
-        MR::Tag.tagging_for('Post', 'User')
-        MR::Tag.tagging_for('Post')
+        MR::Tag.tagging_for('PrivateMessage', 'User') if MR.constants.include?('PrivateMessage')
+        if MR.constants.include?('Post')
+          MR::Tag.tagging_for('Post', 'User')
+          MR::Tag.tagging_for('Post')
+        end
       end
       module ClassMethods
         module Message

data/lib/{joint.rb → marley/joint.rb}

@@ -1,7 +1,5 @@
 module Marley
   module Joints
-    MR=Marley::Resources
-    MJ=Marley::Joints
     class Joint
       def initialize(opts={})
         config(opts)

data/lib/{reggae.rb → marley/reggae.rb}

@@ -15,17 +15,18 @@ module Marley
     end
     def initialize(*args)
       super
+      self[1]=Utils.hash_keys_to_syms(self[1]) if self[1].class==Hash
       self.class.mk_prop_methods
     end
+    def properties
+      self[1] || nil
+    end
     def resource_type
-      [String, Symbol].include?(self[0].class) ? self[0].to_s : nil
+      [String, Symbol].include?(self[0].class) ? self[0].to_sym : nil
     end
     def is_resource?
       ! resource_type.nil?
     end
-    def properties
-      self[1].class==Hash ? Utils.hash_keys_to_syms(self[1]) : nil
-    end
     def contents
       is_resource? ? Reggae.new(self[2 .. -1]) : nil
     end
@@ -37,7 +38,7 @@ module Marley
       super.class==Array ?  Reggae.new(super).to_resource : super
     end
     def to_resource
-      is_resource? ? Marley.const_get("Reggae#{resource_type.camelize}".to_sym).new(self) : self
+      is_resource? ? Marley.const_get("Reggae#{resource_type.to_s.camelize}".to_sym).new(self) : self
     end
     def find_instances(rn,instances=Reggae.new([]))
       if self.class==ReggaeInstance && self.name.to_s==rn 
@@ -49,9 +50,15 @@ module Marley
     end
   end
   class ReggaeResource < Reggae
+    def resource_type
+      self.class.to_s.sub(/.*Reggae/,'').underscore.to_sym
+    end
     def initialize(*args)
-      super
-      unshift self.class.to_s.sub(/.*Reggae/,'').underscore.to_sym unless is_resource?
+      if args[0].class==Hash
+        initialize [resource_type,args[0]]
+      else
+        super
+      end
     end
   end
   class ReggaeSection < ReggaeResource
@@ -64,27 +71,33 @@ module Marley
     self.valid_properties=[:title,:description,:url]
   end
   class ReggaeInstance < ReggaeResource
-    self.valid_properties=[:name,:new_rec,:search,:url,:get_actions,:delete_action]
-    def schema
-      ReggaeSchema.new(self.properties[:schema])
+    self.valid_properties=[:name,:new_rec,:schema,:search,:url,:get_actions,:delete_action]
+    def initialize(*args)
+      super
+      self.schema=ReggaeSchema.new(self.schema)
     end
     def to_params
-      resource_name=name
       schema.inject({}) do |params,spec| 
-        s=ReggaeColSpec.new(spec)
-        params["#{resource_name}[#{s.col_name}]"]=s.col_value unless (s.col_restrictions & RESTRICT_RO > 0)
+        params["#{name}[#{spec.col_name}]"]=spec.col_value unless (spec.col_restrictions & RESTRICT_RO > 0)
         params
       end
     end
     def instance_action_url(action_name)
       "#{url}#{action_name}" if get_actions.include?(action_name.to_s)
     end
+    def col_value(col_name,col_value=nil)
+      col=schema[col_name]
+      col.col_value=col_value if col_value
+      col.col_value
+    end
+    def set_values(col_hash)
+      col_hash.each_pair {|k,v| col_value(k,v)}
+      self
+    end
   end
   class ReggaeInstanceList < ReggaeResource
     self.valid_properties=[:name,:description,:get_actions,:delete_action,:items]
-    def schema
-      ReggaeSchema.new(self.properties[:schema])
-    end
+    #not implemented yet
   end
   class ReggaeMsg < ReggaeResource
     self.valid_properties=[:title,:description]
@@ -93,11 +106,15 @@ module Marley
     self.valid_properties=[:error_type,:description,:error_details]
   end
   class ReggaeSchema < Array
+    def initialize(*args)
+      super
+      replace(map{|spec| ReggaeColSpec.new(spec)})
+    end
     def [](i)
       if i.class==Fixnum
-        ReggaeColSpec.new(super)
+        super
       else
-        self[find_index {|cs|ReggaeColSpec.new(cs).col_name==i.to_s}]
+        find {|cs|cs.col_name.to_s==i.to_s}
       end
     end
   end

data/lib/{test_helpers.rb → marley/test_helpers.rb}

@@ -1,5 +1,5 @@
 require "rack/test"
-require 'reggae'
+require 'marley/reggae'
 module Marley
   #simple mocking framework; could be expanded to a general use client by adding display code.
   class TestClient
@@ -18,9 +18,11 @@ module Marley
       opts[:url] || '/' + [:root_url, :resource_name, :instance_id, :method].map {|k| opts[k]}.compact.join('/') + opts[:extention].to_s
     end
     def process(verb,params={},opts={})
+      #p 'params:',params,'opts:',opts,"-------------" if opts
       opts||={}
       opts=@opts.merge(opts)
       expected_code=opts[:code] || RESP_CODES[verb]
+      params=params.to_params if params.respond_to?(:to_params)
       if opts[:debug]
         p opts
         p "#{verb} to: '#{make_url(opts)}'" 
@@ -30,14 +32,16 @@ module Marley
       authorize opts[:auth][0],opts[:auth][1] if opts[:auth]
       header 'Authorization',nil unless opts[:auth]  #clear auth from previous requests
       send(verb,make_url(opts),params)
+      #p last_response.body if opts[:debug]
+      #p JSON.parse(last_response.body) if opts[:debug]
       p last_response.status if opts[:debug]
       p expected_code if opts[:debug]
       return false unless (expected_code || RESP_CODES[method])==last_response.status
       Reggae.get_resource(JSON.parse(last_response.body)) rescue last_response.body
     end
     ['create','read','update','del'].each do |op|
-      define_method op.to_sym, Proc.new { |params,opts| 
-        process(CRUD2REST[op],params,opts)
+      define_method op.to_sym, Proc.new { |*args| 
+        process(CRUD2REST[op],args[0],args[1])
       }
     end
     DEFAULT_OPTS.keys.each do |opt|

data/lib/marley.rb

@@ -3,9 +3,10 @@ require 'json/ext'
 require 'rack'
 require 'rack/auth/basic'
 require 'rack/builder'
-require 'sequel_plugins'
-require 'controllers'
-require 'reggae'
+require 'sequel/plugins/rest_convenience'
+require 'sequel/plugins/rest_auth'
+require 'marley/controllers'
+require 'marley/reggae'
 require 'logger'
 Sequel.extension :inflector
 
@@ -26,7 +27,9 @@ module Marley #The main Marley namespace.
   
   module Resources #All objects in the Resources namespace are exposed by the server.
   end
-  require 'joint' #this needs to happen after Marley::Resources is defined
+  module Joints
+  end
+  require 'marley/joint' #this needs to happen after Marley::Resources is defined
   def self.config(opts=nil)
     @marley_opts||=DEFAULT_OPTS
     @marley_opts.merge!(opts) if opts
@@ -36,7 +39,7 @@ module Marley #The main Marley namespace.
   def self.joint(joint_name, *opts)
     joint_d=JOINT_DIRS.find {|d| File.exists?("#{d}/#{joint_name}.rb") }
     require "#{joint_d}/#{joint_name}"
-    @marley_opts[:client] && @marley_opts[:client].joint(joint_d,joint_name)
+    @marley_opts && @marley_opts[:client] && @marley_opts[:client].joint(joint_d,joint_name)
     joint=Marley::Joints.const_get(joint_name.camelize).new(*opts).smoke
   end
   def self.run(opts={})
@@ -145,4 +148,6 @@ module Marley #The main Marley namespace.
     end
   end
 end
+  MR=Marley::Resources
+  MJ=Marley::Joints
 at_exit {Marley.run  if ARGV[0]=='run'}

data/lib/sequel/plugins/rest_auth.rb

@@ -0,0 +1,53 @@
+
+module Sequel::Plugins::RestAuthorization
+  module ClassMethods
+    attr_accessor :owner_col, :allowed_get_methods
+    def inherited(c)
+      super
+      c.owner_col=@owner_col
+      c.allowed_get_methods=@allowed_get_methods
+    end
+    def requires_user?(verb=nil,meth=nil);true;end
+    def authorize(meth)
+      if respond_to?(auth_type="authorize_#{$request[:verb]}")
+        send(auth_type,meth)
+      else
+        case $request[:verb]
+        when 'rest_put','rest_delete'
+          false 
+        when 'rest_post'
+          new($request[:post_params][resource_name.to_sym]||{}).current_user_role=='owner' && meth.nil?
+        when 'rest_get'
+          methods=@allowed_get_methods || ['section','list','new']
+          (methods.class==Hash ? methods[$request[:user].class] : methods).include?(meth)
+        end
+      end
+    end
+  end
+  module InstanceMethods
+    def after_initialize
+      super
+      send("#{self.class.owner_col}=",$request[:user][:id]) if $request && self.class.owner_col && new?
+    end
+    def requires_user?(verb=nil,meth=nil);true;end
+    def authorize(meth)
+      if respond_to?(auth_type="authorize_#{$request[:verb]}")
+        send(auth_type,meth)
+      else
+        current_user_role=='owner'
+      end
+    end
+    def current_user_role
+      "owner" if owners.include?($request[:user])
+    end
+    def owners
+      if self.class.to_s.match(/User$/)||self.class.superclass.to_s.match(/User$/)
+        [self]
+      elsif @owner_col
+        [User[send(@owner_col)]]
+      else
+        self.class.association_reflections.select {|k,v| v[:type]==:many_to_one}.map {|a| self.send(a[0]) && self.send(a[0]).owners}.flatten.compact
+      end
+    end
+  end
+end

data/lib/{sequel_plugins.rb → sequel/plugins/rest_convenience.rb}

@@ -1,3 +1,4 @@
+
 RESTRICT_HIDE=1
 RESTRICT_RO=2
 RESTRICT_REQ=4
@@ -20,7 +21,7 @@ module Sequel::Plugins::RestConvenience
       if user.respond_to?(otm=self.resource_name.pluralize)
         if user.method(otm).arity==0  
           if (relationship=user.send(otm)).respond_to?(:filter)
-            relationship.filter($request[:get_params][resource_name.to_sym])
+            relationship.filter($request[:get_params][resource_name.to_sym] || {}).all
           else
             user.send(otm)
           end
@@ -69,7 +70,7 @@ module Sequel::Plugins::RestConvenience
       respond_to?('name') ? name : id.to_s
     end
     def to_a
-      a=Marley::ReggaeInstance.new([ {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => rest_schema,:get_actions => get_actions}])
+      a=Marley::ReggaeInstance.new( {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => rest_schema,:get_actions => get_actions})
       if respond_to?(:rest_associations) && ! new?
         a.contents=rest_associations.map do |assoc|
           (assoc.class==Symbol ? send(assoc) : assoc).map{|instance| instance.to_a}
@@ -88,54 +89,3 @@ module Sequel::Plugins::RestConvenience
     end
   end
 end
-module Sequel::Plugins::RestAuthorization
-  module ClassMethods
-    attr_accessor :owner_col, :allowed_get_methods
-    def inherited(c)
-      super
-      c.owner_col=@owner_col
-      c.allowed_get_methods=@allowed_get_methods
-    end
-    def requires_user?(verb=nil,meth=nil);true;end
-    def authorize(meth)
-      if respond_to?(auth_type="authorize_#{$request[:verb]}")
-        send(auth_type,meth)
-      else
-        case $request[:verb]
-        when 'rest_put','rest_delete'
-          false 
-        when 'rest_post'
-          new($request[:post_params][resource_name.to_sym]||{}).current_user_role=='owner' && meth.nil?
-        when 'rest_get'
-          (@allowed_get_methods || ['section','list','new']).include?(meth)
-        end
-      end
-    end
-  end
-  module InstanceMethods
-    def after_initialize
-      send("#{self.class.owner_col}=",$request[:user][:id]) if self.class.owner_col && new?
-    end
-    def requires_user?(verb=nil,meth=nil);true;end
-    def authorize(meth)
-      if respond_to?(auth_type="authorize_#{$request[:verb]}")
-        send(auth_type,meth)
-      else
-        current_user_role=='owner'
-      end
-    end
-    def current_user_role
-      "owner" if owners.include?($request[:user])
-    end
-    def owners
-      if self.class.to_s.match(/User$/)||self.class.superclass.to_s.match(/User$/)
-        [self]
-      elsif @owner_col
-        [User[send(@owner_col)]]
-      else
-        self.class.association_reflections.select {|k,v| v[:type]==:many_to_one}.map {|a| self.send(a[0]) && self.send(a[0]).owners}.flatten.compact
-      end
-    end
-  end
-end
-

data/marley.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{marley}
-  s.version = "0.1.0"
+  s.version = "0.2.0"
   s.summary = %q{Irie default restful routes for your models and other objects}
   s.description = %q{Marley implements a web services microframework on top of Rack and Sequel on the server side and Jquery on the client side.}
   s.authors     = ["Herb Daily"]

data/test/menu_tests.rb

@@ -0,0 +1,9 @@
+
+
+class MenuTests < Test::Unit::TestCase
+  def setup
+  end
+  should 'work' do
+    assert true
+  end
+end

data/test/tagged_messaging_tests.rb

@@ -0,0 +1,289 @@
+
+class MessageTests < Test::Unit::TestCase
+  def initialize(*args)
+    super
+    MR::User.delete
+    @client=Marley::TestClient.new(:resource_name => 'user')
+    ['user1','user2','admin'].each do |un|
+      MR::User.new(:name => un,:password => 'asdfasdf', :confirm_password => 'asdfasdf').save
+    end
+    MR::User[:name => 'admin'].update(:user_type => 'Admin')
+    @admin_auth=['admin','asdfasdf']
+    @user1_auth=['user1','asdfasdf']
+    @user2_auth=['user2','asdfasdf']
+  end
+  def setup
+    MR::Message.delete
+    MR::Tag.delete
+    DB[:messages_tags].delete
+  end
+  context "Private Messages" do
+    setup do
+      @client.resource_name='private_message'
+      @pm=MR::PrivateMessage.new.to_a
+    end
+    context "regular user (user1) logged in" do
+      setup do
+        @client.auth=@user1_auth
+      end
+      should "show PM list and new PM form" do
+        assert @client.read({})
+        assert @client.read({}, :method => 'new')
+      end
+      should "validate new user generated PMs properly" do
+        #reject a PM with only recipients
+        @pm.col_value(:recipients, 'user2')
+        resp=@client.create(@pm,{:code => 400})
+        assert_equal :error, resp.resource_type
+        assert_equal "validation", resp.error_type
+        assert_equal ["is required"], resp.error_details[:title]
+        assert_equal ["is required"], resp.error_details[:message]
+        #reject a PM from user to user
+        @pm.set_values({:title => 'asdf', :message => 'asdf'})
+        resp=@client.create(@pm,{:code => 400})
+        assert_equal :error, resp.resource_type
+        assert_equal "validation", resp.error_type
+        assert resp.error_details[:recipients][0]
+        #reject a PM to a non-existent user
+        @pm.col_value(:recipients, 'asdfasdfasdf')
+        resp=@client.create(@pm,{:code => 400})
+        assert_equal :error, resp.resource_type
+        assert_equal "validation", resp.error_type
+        assert resp.error_details[:recipients][0]
+        #accept a PM to admin
+        @pm.col_value(:recipients, 'admin')
+        assert @client.create({:'private_message[recipients]' => 'admin',:'private_message[title]' => 'asdf',:'private_message[message]' => 'asdf'})
+      end
+    end
+    context "admin logged in" do
+      setup do
+        @client.auth=@admin_auth
+      end
+      should "validate new admin generated PMs properly" do
+        resp=@client.create(@pm.set_values(:recipients => 'user2'),{:code => 400})
+        assert_equal :error, resp.resource_type
+        assert_equal "validation", resp.error_type
+        assert_equal ["is required"], resp.error_details[:title]
+        assert_equal ["is required"], resp.error_details[:message]
+      end
+      should "accept a PM to user1" do
+         assert @client.create(@pm.set_values(:'recipients' => 'user1',:'title' => 'asdf',:'message' => 'asdf'))
+      end
+    end
+    context "message with no tags" do
+      setup do
+        @client.auth=@admin_auth
+        @client.create(@pm.set_values({:'recipients' => 'user1',:'title' => 'asdf',:'message' => 'asdf'}))
+      end
+      should "show up in PM list of sender and receiver" do
+        resp=@client.read({})
+        assert_equal 1, resp.length
+        resp=@client.read({},{:auth => @user1_auth})
+        assert_equal 1, resp.length
+      end
+      should "have sent tag for sender" do
+        resp=@client.read({})
+        assert_equal 3, resp[0].length
+        assert_equal "sent", resp.find_instances('user_tag')[0].schema[:tag].col_value
+      end
+      should "have inbox tag for receiver" do
+        resp=@client.read({},{:auth => @user1_auth})
+        assert_equal 3, resp[0].length
+        assert_equal "inbox", resp.find_instances('user_tag')[0].schema[:tag].col_value
+      end
+      should "have reply, reply_all and new_tags instance get actions" do
+        resp=@client.read({})
+        assert_same_elements ['reply','reply_all','new_tags'], resp[0].get_actions
+      end
+      context "user1 instance actions" do
+        setup do
+          @client.auth=@user1_auth
+          @msg=@client.read({})[0]
+          @client.instance_id=@msg.schema[:id].col_value
+          @reply=@client.read({},{:method => 'reply'})
+          @new_tags=@client.read({},:method => 'new_tags')
+        end
+        context "reply" do
+          should "have author in to field and default title beginning with 're:'" do
+            assert_equal 'admin', @reply.schema[:recipients].col_value
+            assert_equal 're: ', @reply.schema[:title].col_value[0 .. 3]
+          end
+          should "accept reply" do
+            assert @client.create(@reply.set_values('message' => 'asdf'),{:method => nil,:instance_id => nil})
+          end
+        end
+        context "new tags" do
+          should "return tag instance with name tag and same url as original message" do
+            assert_equal 'tags', @new_tags.name
+            assert_equal "#{@msg.url}tags", @new_tags.url
+          end
+          should "accept new tags, which should then show up with the original message" do
+            assert @client.create({'private_message[tags]' => 'added_tag1, added_tag2'},{:method => 'tags'})
+            msg=@client.read({})
+            user_tags=msg.find_instances('user_tag')
+            assert_same_elements ["inbox", "added_tag1", "added_tag2"], user_tags.map{|t| t.schema[:tag].col_value}
+          end
+        end
+      end
+    end
+    context "message with 2 tags" do
+      setup do
+        @client.auth=@admin_auth
+        @client.create(@pm.set_values(:recipients => 'user1', :title => 'asdf', :message => 'asdf', :tags => 'test,test2'))
+      end
+      context "sender (admin) logged in" do
+        setup do
+          @msg=@client.read[0]
+          @tags=@msg.find_instances('user_tag')
+        end
+        should "have sent tag and both specified tags for sender" do
+          assert_same_elements ["sent", "test", "test2"], @tags.map{|t| t.schema[:tag].col_value}
+        end
+        should "allow sender to remove his own tags'" do
+          assert_equal 'remove_parent', @tags[0].delete_action
+          assert @client.del({},{:url => @tags[0].url+@msg.url})
+          assert_equal 2, @client.read[0].find_instances('user_tag').length
+        end
+      end
+      context "receiver (user1)" do
+        setup do
+          @client.auth=@user1_auth
+          @msg=@client.read[0]
+          @tags=@msg.find_instances('user_tag')
+        end
+        should "have inbox tag and both specified tags" do
+          assert_same_elements ["inbox", "test", "test2"], @tags.map{|t| t.schema[:tag].col_value}
+        end
+        should "have specified tags in reply" do
+          reply=@client.read({},{:instance_id => @msg.schema[:id].col_value,:method => 'reply'})
+          assert_equal 'test,test2', reply.schema[:tags].col_value
+        end
+        should "allow receiver to remove his own tags'" do
+          assert_equal 'remove_parent', @tags[0].delete_action
+          assert @client.del({},{:url => @tags[0].url+@msg.url})
+          assert_equal 2, @client.read[0].find_instances('user_tag').length
+        end
+      end
+      context 'user2' do
+        should "have no messages" do
+          assert resp=@client.read({},{:auth => @user2_auth})
+          assert_equal 0, resp.length
+        end
+      end
+    end
+    context "message with 2 tags and 2 receivers" do
+      setup do
+        @client.create(@pm.set_values(:recipients => 'user1,user2',:title => 'asdf',:message => 'asdf', :tags => 'test,test2'),{:auth => @admin_auth})
+      end
+      should "have sent tag and both specified for sender" do
+        resp=@client.read({},{:auth => @admin_auth})
+        user_tags=resp[0].find_instances('user_tag')
+        assert_same_elements ["sent", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
+      end
+      should "have inbox tag and both specified for 1st receiver (user1)" do
+        resp=@client.read({},{:auth => @user1_auth})
+        user_tags=resp[0].find_instances('user_tag')
+        assert_same_elements ["inbox", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
+      end
+      should "have inbox tag and both specified for 2st receiver (user2)" do
+        resp=@client.read({},{:auth => @user2_auth})
+        user_tags=resp[0].find_instances('user_tag')
+        assert_same_elements ["inbox", "test", "test2"], user_tags.map{|t| t.schema[:tag].col_value}
+      end
+    end
+    context "message listing" do
+      setup do
+        #3 messages with tag "test" for user 1
+        @client.create(@pm.set_values(:'recipients' => 'user1',:'title' => 'title1',:'message' => 'body1', :'tags' => 'test'),{:auth => @admin_auth})
+        @client.create(@pm.set_values(:'recipients' => 'user1',:'title' => 'title2',:'message' => 'body2', :'tags' => 'test'),{:auth => @admin_auth})
+        @client.create(@pm.set_values(:'recipients' => 'user1',:'title' => 'title3',:'message' => 'body3', :'tags' => 'test'),{:auth => @admin_auth})
+        #2 messages with tag "test1" for user1 and user2
+        @client.create(@pm.set_values(:'recipients' => 'user2,user1',:'title' => 'title1',:'message' => 'body1', :'tags' => 'test1'),{:auth => @admin_auth})
+        @client.create(@pm.set_values(:'recipients' => 'user2,user1',:'title' => 'title2',:'message' => 'body2', :'tags' => 'test1'),{:auth => @admin_auth})
+      end
+      should "for sender (admin) show 3 messages with 'test' tag,2 messages with 'test1' tag, and 5 messages with 'sent' tag" do
+        @client.auth=@admin_auth
+        assert_equal 3, @client.read({:'private_message[tags]' => 'test'}).length
+        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
+        assert_equal 5, @client.read({:'private_message[tags]' => 'sent'}).length
+      end
+      should "for user1 show 3 messages with 'test' tag, 2 messages with 'test1' tag, 5 messages with 'inbox' tag, and 5 messages with 'test' or 'test1' tags" do
+        @client.auth=@user1_auth
+        assert_equal 3, @client.read({:'private_message[tags]' => 'test'}).length
+        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
+        assert_equal 5, @client.read({:'private_message[tags]' => 'inbox'}).length
+        assert_equal 5, @client.read({:'private_message[tags]' => 'test,test1'}).length
+      end
+      should "for user2 show 0 messages with 'test' tag, 2 messages with 'test1' tag, 2 messages with 'inbox' tag and 2 messages with 'test' or 'test1' tags" do
+        @client.auth=@user2_auth
+        assert_equal 0, @client.read({:'private_message[tags]' => 'test'}).length
+        assert_equal 2, @client.read({:'private_message[tags]' => 'test1'}).length
+        assert_equal 2, @client.read({:'private_message[tags]' => 'inbox'}).length
+        assert_equal 2, @client.read({:'private_message[tags]' => 'test,test1'}).length
+      end
+    end
+  end
+  context "Posts" do
+    setup do
+      @client.resource_name='post'
+      @post=MR::Post.new.to_a
+    end
+    context 'validation' do
+      should "get a validation error trying to post without a title or message as admin, user1, or user2" do
+        resp=@client.create({},{:code => 400,:auth => @admin_auth})
+        assert_equal :error, resp.resource_type
+        assert_equal "validation", resp.error_type
+        assert_equal ["is required"], resp.error_details[:title]
+        assert_equal ["is required"], resp.error_details[:message]
+        user1_resp=@client.create({},{:code => 400,:auth => @user1_auth})
+        assert_equal user1_resp, resp
+        user2_resp=@client.create({},{:code => 400,:auth => @user2_auth})
+        assert_equal user2_resp, resp
+      end
+      should "be able to post with title and message as admin, user1, or user2" do
+        assert @client.create(@post.set_values('title' => 'test', 'message' => 'asdf'),{:auth => @admin_auth})
+        assert_equal 1, @client.read({},{:auth => @user1_auth}).length
+        assert @client.create(@post.set_values('title' => 'test', 'message' => 'asdf'),{:auth => @user1_auth})
+        assert_equal 2, @client.read({},{:auth => @user2_auth}).length
+        assert @client.create(@post.set_values('title' => 'test', 'message' => 'asdf'),{:auth => @user2_auth})
+        assert_equal 3, @client.read({},{:auth => @admin_auth}).length
+      end
+    end
+    should 'list posts by public tags' do
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'admintag1,admintag2'),{:auth => @admin_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'admintag1,admintag2,admintag3'),{:auth => @admin_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'user1tag1'),{:auth => @user1_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'user1tag1,user1tag2'),{:auth => @user1_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'user1tag1,user1tag2,user1tag3'),{:auth => @user1_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'user2tag1,user2tag2,user2tag3'),{:auth => @user2_auth})
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'user2tag1,user2tag2,user2tag3,user2tag4'),{:auth => @user2_auth})
+      assert_equal 7, @client.read({},{:auth => @admin_auth}).length
+      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @admin_auth}).length
+      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @user1_auth}).length
+      assert_equal 7, @client.read({'post[title]' => 'test'},{:auth => @user2_auth}).length
+      assert_equal 2, @client.read({'post[tags]' => 'admintag1'},{:auth => @admin_auth}).length
+      assert_equal 2, @client.read({'post[tags]' => 'admintag1'},{:auth => @user1_auth}).length
+      assert_equal 1, @client.read({'post[tags]' => 'admintag3'},{:auth => @user2_auth}).length
+      assert_equal 1, @client.read({'post[tags]' => 'admintag3'},{:auth => @admin_auth}).length
+      assert_equal 2, @client.read({'post[tags]' => 'user1tag2'},{:auth => @admin_auth}).length
+      assert_equal 3, @client.read({'post[tags]' => 'user1tag1'},{:auth => @admin_auth}).length
+      assert_equal 3, @client.read({'post[tags]' => 'user1tag1'},{:auth => @user2_auth}).length
+    end
+    should 'have usable reply, new_tags, and new_user_tags instance actions' do
+      @client.create(@post.set_values('title' => 'test', 'message' => 'asdf','tags' => 'admintag1,admintag2'),{:auth => @admin_auth})
+      @client.auth=@user2_auth
+      posts=@client.read({})
+      assert_same_elements ['reply','new_tags','new_user_tags'], posts[0].get_actions
+      reply=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'reply'})
+      tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_tags'})
+      user_tags=@client.read({},{:instance_id => posts[0].schema[:id].col_value,:method => 'new_user_tags'})
+      assert_equal 're: test', reply.schema[:title].col_value
+      assert @client.create(reply.set_values('message' => 'asdf'),{:method => nil,:instance_id => nil})
+      assert @client.create(tags.to_params.merge('post[tags]' => '1,2,3'),{:url => tags.url})
+      assert_same_elements ['1','2','3','admintag1','admintag2'], @client.read[0].find_instances('public_tag').map{|t| t.schema[:tag].col_value}
+      assert @client.create(user_tags.to_params.merge('post[user_tags]' => '4,5,6'),{:url => user_tags.url})
+      assert_same_elements ['4','5','6'], @client.read[0].find_instances('user_tag').map{|t| t.schema[:tag].col_value}
+      assert_equal [], @client.read({},{:auth => @user1_auth})[0].find_instances('user_tag').map{|t| t.schema[:tag].col_value}
+    end
+  end
+end

data/test/test_include.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'sequel'
+require 'marley'
+require 'marley/test_helpers'
+
+`cp test/empty.sqlite3 test/test.sqlite3`
+DB=Sequel.sqlite("test/test.sqlite3")
+
+RESERVED_PM_TAGS=['inbox','sent']
+RESERVED_POST_TAGS=['announcement']
+
+Marley.joint 'tagged_messaging'
+Marley.joint 'basic_menu_system'
+

data/test/user_tests.rb

@@ -0,0 +1,72 @@
+
+class UserTests < Test::Unit::TestCase
+  def setup
+    MR::User.delete
+    @client=Marley::TestClient.new(:resource_name => 'user',:code => 200)
+    @user=@client.read({},:resource_name => '',:code => 200).navigation[1]
+  end
+  should "return login form with no params" do
+    assert @client.read({},{:resource_name => ''})
+  end
+  should "not allow access to menus, private messages, or posts" do
+    @client.code=401
+    assert @client.read({:resource_name =>'pm_menu'})
+    assert @client.read({:resource_name =>'post_menu'})
+    assert @client.read({:resource_name =>'private_message'})
+    assert @client.read({:resource_name =>'post'})
+  end
+  should "validate new user properly" do
+    @client.code=400
+    resp=@client.create(@user)
+    assert_equal :error, resp.resource_type
+    assert_equal "validation", resp.error_type
+    assert_equal ["is required"], resp.error_details[:name]
+    @user.col_value(:name,'asdf')
+    resp=@client.create(@user)
+    assert_equal :error, resp.resource_type
+    assert_equal "validation", resp.error_type
+    @user.col_value(:password,'asdfaf')
+    resp=@client.create(@user)
+    assert_equal :error, resp.resource_type
+    assert_equal "validation", resp.error_type
+    assert_equal ["Password must contain at least 8 characters"], resp.error_details[:password]
+    @user.col_value(:password,'asdfaasdf')
+    resp=@client.create(@user)
+    assert_equal :error, resp.resource_type
+    assert_equal "validation", resp.error_type
+    assert_equal ["Passwords do not match"], resp.error_details[:confirm_password]
+    @user.col_value(:confirm_password,'asdfaasdf')
+    assert @client.create(@user,{:code => 201})
+    assert @client.create(@user)
+  end
+  context "existing user logged in" do
+    setup do
+      @client.code=201
+      assert @client.create(:'user[name]' => 'user1',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
+      assert @client.create(:'user[name]' => 'user2',:'user[password]' => 'asdfasdf',:'user[confirm_password]' => 'asdfasdf')
+      @client.code=200
+      @client.auth=['user1','asdfasdf']
+    end
+    should "show correct menu items" do
+      menu= @client.read({},:resource_name => '')
+      assert_same_elements ["User Info","Private Messages","Public Posts"], menu.navigation.map{|n| n.title}
+    end
+    should "allow viewing and changing of user columns with proper validation" do
+      @client.instance_id=1
+      assert user=@client.read({})
+      assert @client.update(user,{:code => 204})
+      user.col_value(:password, 'zxcvzxcv')
+      assert err=@client.update(user,{:code => 400})
+      assert_equal :error, err.resource_type
+      assert_equal "validation", err.error_type
+      user.col_value(:confirm_password, 'zxcvzxcv')
+      user.col_value(:old_password, 'asdfasdf')
+      assert @client.update(user,:code => 204)
+      assert @client.read({},:code => 401)
+      @client.auth=['user1','zxcvzxcv']
+      assert @client.read({})
+      @client.instance_id=2
+      assert @client.update(user,:code => 403)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: marley
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Herb Daily
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-09 00:00:00 -03:00
+date: 2011-11-18 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -51,16 +51,21 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- marley-0.1.gem
 - marley.gemspec
+- Rakefile
 - Favicon.ico
 - README.rdoc
 - marley-0.1.0.gem
 - TODO
 - reggae.ebnf
+- forum_tests.rb
 - lib/marley.rb
-- lib/test_helpers.rb
-- lib/sequel_plugins.rb
+- lib/marley/test_helpers.rb
+- lib/marley/joint.rb
+- lib/marley/controllers.rb
+- lib/marley/reggae.rb
+- lib/sequel/plugins/rest_convenience.rb
+- lib/sequel/plugins/rest_auth.rb
 - lib/client/jamaica.css
 - lib/client/jquery-1.6.2.js
 - lib/client/jamaica.rb
@@ -72,18 +77,21 @@ files:
 - lib/joints/user_based_navigation.rb
 - lib/joints/basic_menu_system.rb
 - lib/joints/tagged_messaging.rb
-- lib/joint.rb
-- lib/controllers.rb
-- lib/reggae.rb
 - examples/forum.js
 - examples/forum.sql
+- examples/blog.rb
 - examples/forum.rb
 - examples/forum.sqlite3
 - examples/forum_test.sqlite3
 - examples/empty.sqlite3
 - examples/forum.css
 - examples/run.sh
-- test/forum_tests.rb
+- test/menu_tests.rb
+- test/test_include.rb
+- test/empty.sqlite3
+- test/user_tests.rb
+- test/test.sqlite3
+- test/tagged_messaging_tests.rb
 has_rdoc: true
 homepage: http://github.com/herbdaily/marley
 licenses: []