marley 0.5.0 → 0.6.0

data/lib/joints/basic_menu_system.rb

@@ -1,41 +0,0 @@
-
-module Marley
-  module Joints
-    class BasicMenuSystem < Joint
-      RestSection=Marley::Utils.rest_opts_mod('section',['name','title','description','navigation'],lambda {$request[:user].class})
-      def smoke
-        super
-        Sequel::Model.extend RestSection
-      end
-      module Resources
-        class Menu
-          include RestSection
-          def self.rest_get
-            new.rest_section
-          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:'})
-              @section_title="Welcome to #{$request[:opts][:app_name]}"
-              @section_description='Login or signup here.'
-              @section_navigation=[LOGIN_FORM,u]
-            else
-              @section_title = "#{$request[:opts][:app_name]} Main Menu"
-              @section_description="Welcome to #{$request[:opts][:app_name]}, #{$request[:user].name}"
-              @section_navigation=(MR.constants - [self.class.to_s.sub(/.*::/,'').to_sym]).map do |rn|
-                if (resource=MR.const_get(rn)).respond_to?(:rest_section) && (s=resource.rest_section) && s.title
-                  [:link,{:title => s.title, :description =>s.description, :url => "#{resource.resource_name}/section" }]
-                end
-              end.compact
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/joints/basic_messaging.rb

@@ -1,88 +0,0 @@
-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(/.*::/,'')}
-          # 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
-          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? || self.class.actions_get.include?(meth))
-          end
-          def authorize_rest_put(meth); false; end
-          def after_initialize
-            super
-            if new?
-              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
-          @actions_get=['reply','reply_all']
-          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
-          @actions_get=['reply']
-          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

@@ -1,51 +0,0 @@
-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' || ($request[:verb]=='rest_get' && $request[:path][1]=='new'))
-          end
-          def self.rest_section
-            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
-            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

@@ -1,122 +0,0 @@
-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') if MR.constants.include?('PrivateMessage')
-        if MR.constants.include?('Post')
-          MR::Tag.tagging_for('Post', 'User')
-          MR::Tag.tagging_for('Post')
-        end
-      end
-      module MessagePlugin
-        module ClassMethods
-          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
-        module InstanceMethods
-          def rest_associations
-            if ! new?
-              [ respond_to?(:public_tags) ? :public_tags : nil, respond_to?(:user_tags) ? user_tags_dataset.current_user_dataset : 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
-          @actions_get= superclass.actions_get << 'new_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 rest_schema
-            super << [:text, :tags, 0,tags]
-          end
-          def reply
-            r=super
-            r.tags=(user_tags_dataset.current_user_dataset.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
-          @actions_get=(superclass.actions_get << 'new_user_tags') << 'new_tags'
-          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

@@ -1,56 +0,0 @@
-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_dataset
-                  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
-            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::RestActions]
-              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, :extend => Marley::RestActions
-            end
-          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)
-          @actions_delete='remove_parent'
-        end
-        class UserTag < Tag
-          set_dataset DB[:tags].filter(~{:user_id => nil})
-          @actions_delete='remove_parent'
-        end
-      end
-    end
-  end
-end

data/lib/sequel/plugins/rest_auth.rb

@@ -1,53 +0,0 @@
-
-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/rest_convenience.rb

@@ -1,87 +0,0 @@
-
-module Sequel
-  module Plugins::RestConvenience
-    module ClassMethods
-      include Marley::RestActions
-      def controller
-        Marley::ModelController.new(self)
-      end
-      def resource_name
-        self.name.sub(/.*::/,'').underscore
-      end
-      def reggae_link(action=nil)
-        [:link,{:url => "/#{self.resource_name}/#{action}",:title => "#{action.humanize} #{self.resource_name.humanize}".strip}]
-      end
-      def list(params=nil)
-        user=$request[:user]
-        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] || {}).all
-            else
-              user.send(otm)
-            end
-          else
-            user.send(otm,$request[:get_params][resource_name.to_sym])
-          end
-        else
-          raise Marley::AuthorizationError
-        end
-      end
-      def autocomplete(input_content)
-        filter(:name.like("#{input_content.strip}%")).map {|rec| [rec.id, rec.name]}
-      end
-    end
-    module InstanceMethods
-      include Marley::RestActions
-      def edit; self; end
-      def rest_cols 
-        columns.reject do |c| 
-          if new?
-            c.to_s.match(/(^id$)|(_type$)|(date_(created|updated))/)
-          else
-            c.to_s.match(/_type$/)
-          end
-        end
-      end
-      def hidden_cols
-        columns.select {|c| c.to_s.match(/(_id$)/)}
-      end
-      def write_cols
-        rest_cols.reject {|c| c.to_s.match(/(^id$)|(date_(created|updated))/)}
-      end
-      def required_cols;[];end
-      def rest_schema
-        rest_cols.map do |col_name|
-          db_spec=db_schema.to_hash[col_name]
-          col_type=db_spec ? db_spec[:db_type].downcase : col_name
-          restrictions=0
-          restrictions|=RESTRICT_HIDE if hidden_cols.include?(col_name)
-          restrictions|=RESTRICT_RO unless write_cols.include?(col_name)
-          restrictions|=RESTRICT_REQ if required_cols.include?(col_name) || (db_spec && !db_spec[:allow_null])
-          [col_type, col_name, restrictions,send(col_name)]
-        end
-      end
-      def to_s
-        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,:actions => self.class.rest_actions})
-        a.contents=self.class.associations.map do |assoc|
-          assoc=send("#{assoc}_dataset")
-          (assoc.respond_to?(:current_user_dataset) ? assoc.current_user_dataset : assoc).map{|instance| instance.to_a} if assoc.respond_to?(:rest_actions)
-        end.compact unless new?
-        a
-      end
-      def to_json(*args)
-        to_a.to_json
-      end
-      def url(action=nil)
-        "/#{self.class.resource_name}/#{self[:id]}/#{action}".sub('//','/')
-      end
-      def reggae_link(action=nil)
-        [:link,{:url => url,:title => "#{action.humanize}"}]
-      end
-    end
-  end
-end