marley 0.1.0

data/lib/controllers.rb

@@ -0,0 +1,69 @@
+module Marley
+  class ModelController
+    def initialize(model)
+      @model=model
+      if $request[:path][1].to_s.match(/^\d+$/) #references a specific instance by ID
+        @instance=@model[$request[:path][1].to_i]
+        @method_name=$request[:path][2]  
+        if @method_name
+          raise RoutingError unless @instance.respond_to?(@method_name)
+          @method=@instance.method(@method_name)
+        end
+      else #class method -- should yield 0 or more instances of model in an array
+        @method_name=$request[:path][1] 
+        @method_name='list' if @method_name.nil? && $request[:verb]=='rest_get'
+        if @method_name
+          raise RoutingError unless @model.respond_to?(@method_name)
+          @method=@model.method(@method_name)
+        end
+      end
+      if (a=@instance || @model).requires_user?
+        raise AuthorizationError unless a.authorize(@method_name)
+      end
+      if @method && $request[:verb] != 'rest_post'
+        @instances=if p=$request[:get_params][@model.resource_name.to_sym] 
+                     @method.call(p) 
+                   elsif i=$request[:path][3]
+                     @method.call[i.to_i]
+                   else 
+                     @method.call
+                   end 
+      end
+    end
+    def rest_get; @instances || @instance; end
+    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] 
+        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)
+        @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
+    end
+    def rest_delete
+      raise RoutingError unless @instance
+      if @instances
+        @instances.each do |instance|
+          meth="remove_#{instance.class}"
+          raise RoutingError unless @instance.respond_to?(meth)
+          @instance.send(meth,instance)
+        end
+      else
+        @instance.destroy
+      end
+    end
+  end
+end

data/lib/joint.rb

@@ -0,0 +1,27 @@
+module Marley
+  module Joints
+    MR=Marley::Resources
+    MJ=Marley::Joints
+    class Joint
+      def initialize(opts={})
+        config(opts)
+      end
+      def smoke
+        klass=self.class
+        { 'resources' => lambda {|c| MR.const_set(c,klass::Resources.const_get(c))},
+          'class_methods' => lambda {|c| MR.const_get(c).extend klass::ClassMethods.const_get(c)},
+          'instance_methods' => lambda {|c| klass::InstanceMethods.const_get(c).send :append_features, MR.const_get(c)}
+        }.each_pair do |mod_name, importer|
+          if klass.constants.include?(mod_name.camelize)
+            klass.const_get(mod_name.camelize).constants.each do |c|
+              importer.call(c) unless @opts[mod_name.to_sym] && ! @opts[mod_name.to_sym].include?(c.underscore)
+            end
+          end
+        end
+      end
+      def config(opts)
+        @opts=(@opts || {}).merge(opts)
+      end
+    end
+  end
+end

data/lib/joints/basic_menu_system.rb

@@ -0,0 +1,54 @@
+
+module Sequel::Plugins::RestSection
+  SECTION_PROPS='name','title','description','navigation'
+  module ClassMethods
+    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 }]
+      end
+    end
+  end
+end
+Sequel::Model.plugin :rest_section
+module Marley
+  module Joints
+    class BasicMenuSystem < Joint
+      module Resources
+        class Menu
+          class <<self
+            attr_accessor :sections
+          end
+          attr_accessor :title,:name,:description, :navigation
+          def self.rest_get
+            new.to_json
+          end
+          def self.requires_user?
+            ! $request[:path].to_a.empty?
+          end
+          def initialize
+            @name='main'
+            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]
+            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)
+                  [: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
+  end
+end

data/lib/joints/basic_messaging.rb

@@ -0,0 +1,88 @@
+require 'sanitize'
+
+module Marley
+  module Joints
+    class BasicMessaging < Joint
+      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(/.*::/,'')}
+          plugin :tree
+          many_to_one :author, :class => :'Marley::Resources::User'
+          @owner_col=:author_id
+          def rest_cols; [:id,:author_id,:message,:title,:parent_id]; end
+          def write_cols; new? ?  rest_cols - [:id] : []; end
+          def required_cols; write_cols - [:parent_id]; end
+          def rest_schema
+            super << [:text,:author,RESTRICT_RO,author.to_s]
+          end
+          def authorize_rest_get(meth)
+            current_user_role && (meth.nil? || get_actions.include?(meth))
+          end
+          def authorize_rest_put(meth); false; end
+          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
+          def before_save
+            self.message=Sanitize.clean(self.message,:elements => %w[blockquote em strong ul ol li p code])
+          end
+          def validate
+            validates_presence [:author,:message,:title]
+            validates_type MR::User, :author
+          end
+          def thread
+            children.length > 0 ? to_a << children.map{|m| m.thread} : to_a
+          end
+        end
+        class PrivateMessage < Message
+          def get_actions;['reply','reply_all'];end
+          def rest_cols; super << :recipients; end
+          def current_user_role
+            super || (recipients.match(/\b#{$request[:user][:name]}\b/) && "recipient")
+          end
+          def authorize_rest_get(meth)
+            super && ($request[:user]==author || self.recipients.match(/\b#{$request[:user].name}\b/))
+          end
+          def authorize_rest_post(meth)
+            meth.to_s > '' && (author_id==$request[:user][:id] || recipients.match(/\b#{$request[:user][:name]}\b/))
+          end
+          def self.authorize_rest_post(asdf)
+            true #may need to change this, for now auth is handled in validation
+          end
+          def reply
+            self.class.new({:parent_id => self[:id],:author_id => $request[:user][:id],:recipients => author.name, :title => "re: #{title}"})
+          end
+          def reply_all
+            foo=reply
+            foo.recipients="#{author.name},#{recipients}".gsub(/\b(#{$request[:user][:name]})\b/,'').sub(',,',',')
+            foo
+          end
+          def validate
+            super
+            validates_presence [:recipients]
+            self.recipients.split(',').each do |recipient|
+              if u=MR::User[:name => recipient]
+                errors.add(:recipients, "You may only send PM's to Admins or Mods. #{recipient} is neither of those") unless (['Admin','Moderator'].include?(MR::User[:name => recipient].user_type) || [MR::Admin,MR::Moderator].include?($request[:user].class))
+              else
+                errors.add(:recipients, "Invalid user: #{recipient}")
+              end
+            end
+          end
+        end
+        class Post < Message
+          def get_actions;['reply'];end
+          def current_user_role
+            super || 'reader'
+          end
+          def authorize_rest_post(meth);true;end
+          def reply
+            self.class.new({:parent_id => self[:id],:author_id => $request[:user][:id], :title => "re: #{title}"})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/joints/basic_user.rb

@@ -0,0 +1,51 @@
+require 'digest/sha1'
+LOGIN_FORM= [:instance,{:url => 'login',:description => 'Existing users please log in here:',:new_rec => true,:schema => [[:text,'name',RESTRICT_REQ],[:password,'password',RESTRICT_REQ]]}]
+module Marley
+  module Joints
+    class BasicUser < Joint
+      module Resources
+        class User < Sequel::Model
+          set_dataset :users
+          plugin :single_table_inheritance, :user_type, :model_map => lambda{|v| MR.const_get(v.to_sym)}, :key_map => lambda{|klass|klass.name.sub(/.*::/,'')}
+          attr_reader :menus
+          attr_accessor :old_password,:password, :confirm_password
+          def self.requires_user?
+            ! ($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
+          end
+          def write_cols;[:name,:email,:password,:confirm_password,:old_password];end
+          def rest_schema
+            schema=super.delete_if {|c| [:pw_hash,:description,:active].include?(c[NAME_INDEX])}
+            schema.push([:password,:old_password,0]) unless new?
+            schema.push([:password,:password ,new? ? RESTRICT_REQ : 0],[:password,:confirm_password,new? ? RESTRICT_REQ : 0])
+            schema
+          end
+          def self.authenticate(credentials)
+            u=find(:name => credentials[0], :pw_hash => Digest::SHA1.hexdigest(credentials[1]))
+            u.respond_to?(:user_type) ? Marley::Resources.const_get(u[:user_type].to_sym)[u[:id]] : u
+          end
+          def validate
+            super
+            validates_presence [:name]
+            validates_unique [:name]
+            if self.new? || self.old_password.to_s + self.password.to_s + self.confirm_password.to_s > ''
+              errors[:password]=['Password must contain at least 8 characters'] if self.password.to_s.length < 8
+              errors[:confirm_password]=['Passwords do not match'] unless self.password==self.confirm_password
+              errors[:old_password]=['Old Password Incorrect'] if !self.new? && Digest::SHA1.hexdigest(self.old_password.to_s) != self.pw_hash
+            end
+          end
+          def before_save
+            if self.new? || self.old_password.to_s + self.password.to_s + self.confirm_password.to_s > ''
+              self.pw_hash=Digest::SHA1.hexdigest(self.password)
+            end
+          end
+          def create_msg
+            [[:msg,{:title => 'Success!'},"Your login, '#{self.name}', has been sucessfully created. You can now log in."]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/joints/tagged_messaging.rb

@@ -0,0 +1,122 @@
+Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(:presence => {:message => 'is required'})
+Sequel::Model.plugin :timestamps, :create => :date_created, :update => :date_updated
+
+Marley.joint 'basic_user',{:resources => []}
+Marley.joint 'tagging'
+Marley.joint 'basic_messaging',{:resources => ['message']}
+module Marley
+  module Joints
+    class TaggedMessaging < Joint
+      def smoke
+        super
+        MR::Tag.tagging_for('PrivateMessage', 'User')
+        MR::Tag.tagging_for('Post', 'User')
+        MR::Tag.tagging_for('Post')
+      end
+      module ClassMethods
+        module Message
+          def list(params={})
+            if associations.include?(:public_tags)
+              specified_tags=params.delete(:tags)
+              specified_user_tags=params.delete(:user_tags)
+            else
+              specified_user_tags=params.delete(:tags)
+            end
+            tag_ids=MR::PublicTag.filter(:tag => specified_tags.split(/\s*,\s*/)).select(:id) if specified_tags
+            user_tag_ids=$request[:user].user_tags_dataset.filter(:tag => specified_user_tags.split(/\s*,\s*/)).select(:id) if specified_user_tags
+            items=filter(params)
+            #would love to make the following line more generic...
+            items=filter("author_id=#{$request[:user][:id]} or recipients like('%#{$request[:user][:name]}%')".lit) if new.rest_cols.include?(:recipients)
+            items=items.join(:messages_tags,:message_id => :id).filter(:tag_id => tag_ids) if specified_tags
+            items=items.join(:messages_tags,:message_id => :id).filter(:tag_id => user_tag_ids) if specified_user_tags
+            items.group(:thread_id).order(:max.sql_function(:date_created).desc,:max.sql_function(:date_updated).desc).map{|t|self[:parent_id => nil, :thread_id => t[:thread_id]].thread} rescue []
+          end
+        end
+      end
+      module InstanceMethods
+        module Message
+          def rest_associations
+            if ! new?
+              [ respond_to?(:public_tags) ? :public_tags : nil, respond_to?(:user_tags) ? user_tags_dataset.current_user_tags : nil].compact
+            end
+          end
+          def new_tags
+            [:instance,{:name => 'tags',:url => "#{url}tags", :new_rec => true, :schema => [['number','message_id',RESTRICT_HIDE,id],['text','tags',RESTRICT_REQ]]}]
+          end
+          def new_user_tags
+            [:instance,{:name => 'user_tags',:url => "#{url}user_tags", :new_rec => true, :schema => [['number','user_tags[message_id]',RESTRICT_HIDE,id],['text','user_tags[tags]',RESTRICT_REQ]]}]
+          end
+          def add_tags(tags,user=nil)
+            if respond_to?(:public_tags)
+              tags.to_s.split(',').each {|tag| add_public_tag(MR::PublicTag.find_or_create(:tag => tag))}
+            else
+              add_user_tags(tags,user)
+            end
+          end
+          def add_user_tags(tags,user=nil) #does not conflict with add_user_tag
+            user||=$request[:user][:id]
+            if user.class==String
+              user.split(',').each {|u| add_user_tags(tags,MR::User[:name => u][:id])}
+            elsif user.class==Array
+              user.each {|u| add_user_tags(tags,u)}
+            elsif user.class==Fixnum
+              tags.to_s.split(',').each {|tag| add_user_tag(MR::UserTag.find_or_create(:user_id => user, :tag => tag))}
+            end
+          end
+        end
+      end
+      module Resources
+        class User < MJ::BasicUser::Resources::User
+        end
+        class Admin < User 
+          def self.requires_user?;true;end
+        end
+        class Moderator < User
+          def self.requires_user?;true;end
+        end
+        class PrivateMessage < MJ::BasicMessaging::Resources::PrivateMessage
+          attr_accessor :tags
+          @section_title='Private Messages'
+          @section_name='pms'
+          def self.section_navigation
+            $request[:user].user_tags.map{|t| [:link,{:url => "/private_message?private_message[tag]=#{t.tag}",:title => t.tag.humanize}]}.unshift(PrivateMessage.reggae_link('new'))
+          end
+          def get_actions; super << 'new_tags';end
+          def rest_schema
+            super << [:text, :tags, 0,tags]
+          end
+          def reply
+            r=super
+            r.tags=(user_tags_dataset.current_user_tags.map{|t|t.tag} - RESERVED_PM_TAGS).join(',')
+            r
+          end
+          def after_create
+            add_user_tags("inbox,#{tags}",recipients)
+            add_user_tags("sent,#{recipients.match(/\b#{author.name}\b/) ? '' : tags}",author_id)
+          end
+        end
+        class Post < MJ::BasicMessaging::Resources::Post
+          attr_accessor :tags,:my_tags
+          @section_title='Public Posts'
+          @section_name='posts'
+          def self.section_navigation
+            MR::Tag.filter(:user_id => nil).map{|t| [:link,{:url => "/post?post[tag]=#{t.tag}",:title => t.tag.humanize}]}.unshift([:link,{:url => '/post?post[untagged]=true',:title => 'Untagged Messages'}]).unshift(Post.reggae_link('new'))
+          end
+          def get_actions;(super << 'new_user_tags') << 'new_tags';end
+          def rest_schema
+            (super << [:text, :tags, 0,tags] ) << [:text, :my_tags, 0,my_tags] 
+          end
+          def reply
+            r=super
+            r.tags=self.tags
+            r
+          end
+          def after_create
+            add_tags(tags) if tags
+            add_user_tags(my_tags) if my_tags
+          end
+        end
+      end
+    end
+  end
+end

data/lib/joints/tagging.rb

@@ -0,0 +1,60 @@
+module Marley
+  module Joints
+    class Tagging < Joint
+      module Resources
+        class Tag < Sequel::Model
+          def self.tagging_for(klass, user_class=nil,join_table=nil)
+            current_user_tags=Module.new do
+                def current_user_tags
+                  filter(:tags__user_id => $request[:user][:id])
+                end
+              end
+            tagged_class=Marley::Resources.const_get(klass.to_sym)
+            join_table||=:"#{tagged_class.table_name}_tags"
+            klass_key=:"#{tagged_class.table_name.to_s.singularize}_id"
+            tag_key=:tag_id
+            attr_accessor klass_key
+            if user_class
+              UserTag.many_to_many klass.underscore.to_sym,:class => "Marley::Resources::#{klass}", :join_table => join_table,:left_key => tag_key,:right_key => klass_key,:extend => current_user_tags
+              tagged_class.many_to_many :user_tags, :class => 'Marley::Resources::UserTag',:join_table => join_table,:left_key => klass_key,:right_key => tag_key, :extend => current_user_tags
+              Marley::Resources.const_get(user_class).one_to_many :user_tags, :class => 'Marley::Resources::UserTag'
+              UserTag.many_to_one user_class.underscore.to_sym,:class => "Marley::Resources::#{user_class}"
+            else
+              PublicTag.many_to_many klass.underscore.to_sym,:class => "Marley::Resources::#{klass}", :join_table => join_table,:left_key => tag_key,:right_key => klass_key
+              tagged_class.many_to_many :public_tags,:class => "Marley::Resources::PublicTag",:join_table => join_table,:left_key => klass_key,:right_key => tag_key
+            end
+          end
+          def to_a
+            a=super
+            a[1][:delete_action]='remove_parent'
+            a
+          end
+          def validate
+            validates_presence :tag
+            validates_unique [:tag,:user_id]
+          end
+          def before_save
+            super
+            self.tag.downcase!
+            self.tag.strip!
+          end
+          def after_save
+            super
+            assoc=methods.grep(/_id=$/) - ['user_id=']
+            assoc.each do |a|
+              if c=self.send(a.sub(/=$/,''))
+                send "add_#{a.sub(/_id=/,'')}", Marley::Resources.const_get(a.sub(/_id=/,'').camelize.to_sym)[c]
+              end
+            end
+          end
+        end
+        class PublicTag < Tag
+          set_dataset DB[:tags].filter(:user_id => nil)
+        end
+        class UserTag < Tag
+          set_dataset DB[:tags].filter(~{:user_id => nil})
+        end
+      end
+    end
+  end
+end