marley 0.5.0 → 0.6.0

data/lib/marley/joints/messages.rb

@@ -0,0 +1,86 @@
+module Marley
+  module Joints
+    class Messages < Joint
+      def smoke
+        super
+        if @opts[:tags]
+          Marley.joint('tags')
+          Marley.plugin(:tagging,{:tag_type => 'private'}).apply(Resources::PrivateMessage)
+          Marley.plugin(:tagging,{:tag_type => 'private'}).apply(Resources::PublicMessage)
+          Marley.plugin(:tagging,{:tag_type => 'public'}).apply(Resources::PublicMessage)
+        end
+      end
+      class Message < Sequel::Model
+        MU.sti(self)
+        MR::User.join_to(self) if MR::User
+        instance_actions![:new?][false]={:get => 'reply'}
+        derived_before_cols![:new?][false]=[:author]
+        ro_cols![:current_user_role] = {'reader' => [/.*/],'owner' => [/^author$/]}
+        def validate
+          super
+          validates_presence [:title]
+        end
+        def reply
+          self.class.new(:title => "re: #{title}",:content => content)
+        end
+        def author
+          MR::User[user_id].to_s
+        end
+      end
+      module Resources
+        class PrivateMessage < Message
+          ro_cols![:new?]={false => [/.*/], true => ['id', 'user_id','author']}
+          attr_writer :recipients
+          def rest_cols
+            [:recipients] + super
+          end
+          Marley::Utils.many_to_many_join(self, MR::User)
+          def self.list_dataset
+            filter(:id => DB[:messages_users].filter(:user_id => current_user[:id]).select(:message_id))
+          end
+          def current_user_role
+            super || (self.users.include?(self.class.current_user) && 'recipient')
+          end
+          def actions(parent_instance=nil)
+            return super if new? || ! recipients.to_s.match(/,/) 
+            [:reply, :reply_all]
+          end
+          def recipients
+            users.map{|u|u.name}.join(',')
+          end
+          def reply
+            super.reggae_instance.set_values(:recipients => author)
+          end
+          def reply_all
+            reply.set_values(:recipients => "#{author},#{recipients}".sub(/\b#{self.class.current_user.name}\b,?/,''))
+          end
+          def validate
+            super
+            errors[:recipients]='Recipients must be specified' unless @recipients
+            @recipients=@recipients.split(',').map do |recipient_name|
+              u=MR::User[:name => recipient_name]
+              errors[:recipients] << "#{recipient_name} is not a valid message recipient" unless u
+              u
+            end
+          end
+          def after_save
+            super
+            @recipients.each {|recipient| add_user recipient} 
+          end
+        end
+        class PublicMessage < Message
+          def current_user_role
+            super || 'reader' 
+          end
+          def actions(parent_instance=nil)
+            if current_user_role=='owner' && ! self.new?
+              {:delete => self.url}.update(super || {})
+            else
+              super
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marley/joints/section.rb

@@ -0,0 +1,63 @@
+module Marley
+  module Plugins
+    class Section < Plugin
+      module ClassMethods
+        def section
+          ReggaeSection.new({
+            :name => send_or_default(:section_name, resource_name.underscore),
+            :title => send_or_default(:section_title, resource_name.humanize),
+            :navigation => send_or_nil(:section_nav),
+            :description => send_or_nil(:section_desc)},
+            send_or_nil(:section_contents))
+        end
+        def section_link
+          reggae_link('section').update(:title => resource_name.humanize.pluralize)
+        end
+        def section_nav
+          send_or_default(:model_actions,{})[:get].map{|a| reggae_link(a)}.compact
+        end
+        def authorize_rest_get(meth)
+          super || (meth.to_s=='section' && (respond_to?(:current_user) ? ! current_user.new? : true) )
+        end
+      end
+    end
+  end
+  module Joints
+    class Section < Joint
+      class Section
+        Marley.plugin('rest_convenience').apply(self)
+        Marley.plugin('section').apply(self)
+        Marley.plugin('current_user_methods').apply(self) if MP.const_defined?(:CurrentUserMethods)
+        def self.rest_get
+          section
+        end
+      end
+      module Resources
+        class MainMenu < Section
+          def self.requires_user?
+            if respond_to?(:current_user)
+              ! ($request[:path].nil? || $request[:path].empty?)
+            else
+              false
+            end
+          end
+          def self.section_nav
+            if respond_to?(:current_user) && (current_user.nil? || current_user.new?)
+              [[:msg,{},'New users, please sign up below'],MR::User.new]
+            else
+              MR.resources_responding_to(:section).sort {|l,r|l.resource_name <=> r.resource_name}.map{|r| r.section_link}.compact
+            end
+          end
+          def self.section_desc
+            if respond_to?(:current_user) && (current_user.nil? || current_user.new?)
+              ReggaeLink.new({:url => '/main_menu', :title => 'Existing users, please click here to log in.'})
+            end
+          end
+          def self.section_link
+            ReggaeLink.new({:url => '/',:title => 'Main Menu'})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marley/joints/tags.rb

@@ -0,0 +1,99 @@
+module Marley
+  module Plugins
+    class Tagging < Plugin
+      @default_opts={:join_type => 'many_to_many', :add_to_write_cols? => true}
+      def apply(*klasses)
+        klasses.each do |klass|
+          klass=MR.const_get(klass) if klass.is_a?(String)
+          # not crazy about this nested if shit.  there may be a better way...
+          if val=klass.instance_variable_get('@derived_after_cols')
+            if val[:new?]
+              val[:new?][:all] << @tag_col_name.to_sym
+            else
+              val[:new?]={:all => [@tag_col_name.to_sym]}
+            end
+          else
+            klass.instance_variable_set('@derived_after_cols',{:new? => {:all => [@tag_col_name.to_sym]}})
+          end
+          @instance_methods_mod.send(:append_features,klass)
+          tag_class=@tag_class
+          join_type=@opts[:"#{klass}_join_type"] || @opts[:join_type]
+          if join_type=='many_to_many'
+            Marley::Utils.many_to_many_join(klass, tag_class)
+          else
+            reciprocal_join=join_type.split('_').reverse.join('_')
+            tag_class.send(reciprocal_join.to_sym, klass.resource_name.pluralize.to_sym, {:class => klass})
+            klass.send(join_type.to_sym, tag_class.resource_name.pluralize.to_sym, {:class => tag_class})
+          end
+        end
+      end
+      def initialize(opts={})
+        super
+        tag_type=@tag_type=@opts[:tag_type]
+        tag_col_name=@tag_col_name="_#{@tag_type}_tags"
+        tag_class=@tag_class=MR.const_get(@tag_col_name.sub(/^_/,'').singularize.camelcase)
+        tags_ds_name=@tags_ds_name="#{tag_col_name.sub(/^_/,'')}_dataset"
+        add_to_write_cols=@opts[:add_to_write_cols?]
+        @instance_methods_mod=Module.new do |m|
+          attr_accessor tag_col_name
+          if add_to_write_cols
+            define_method(:write_cols) {
+              super << tag_col_name.to_sym
+            }
+          end
+
+          define_method("#{tag_col_name}_ds".to_sym) { #e.g. _private_tags_ds
+            send(tags_ds_name).filter({:tags__user_id => (tag_class.associations.include?(:user) ? self.class.current_user[:id] : nil)})
+          }
+          define_method(tag_col_name.to_sym) {    #e.g. _private_tags
+            send("#{tag_col_name}_ds").map {|t| t.tag}.join(', ') unless new?
+          }
+          define_method("add#{tag_col_name}".to_sym) {|tags|  #e.g. add_private_tags
+            vals_hash={:user_id => (tag_class.associations.include?(:user) ? self.class.current_user[:id] : nil)}
+            tags.to_s.split(',').each {|tag| self.send("add#{tag_col_name.singularize}",tag_class.find_or_create(vals_hash.update(:tag => tag))) }
+          }
+          define_method("replace#{tag_col_name}".to_sym) {  #e.g. replace_private_tags
+            send("#{tag_col_name}_ds").each {|tag| send("remove#{tag_col_name}".singularize,tag)}
+            send("add#{tag_col_name}",instance_variable_get("@#{tag_col_name}"))
+          }
+          define_method(:after_save) {
+            super
+            methods.select {|m| m.match(/^replace_.+_tags/)}.each do |replace_method|
+              send(replace_method)
+            end
+          }
+        end
+      end
+    end
+  end
+  module Joints
+    class Tags < Joint
+      module Resources
+        class Tag < Sequel::Model
+          def validate
+            validates_presence :tag
+            validates_unique [:tag,:user_id]
+          end
+          def actions(parent_instance)
+            {:delete => "#{parent_instance ? parent_instance.url : ''}#{url}"}
+          end
+          def before_save
+            super
+            self.tag.downcase!
+            self.tag.strip!
+          end
+        end
+        class PublicTag < Tag
+          @owner_col=nil
+          set_dataset DB[:tags].filter(:tags__user_id => nil).order(:tag)
+        end
+        class PrivateTag < Tag
+          MR::User.join_to(self) if MR::User
+          def self.list_dataset
+            current_user_dataset.order(:tag)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/marley/joints/user.rb

@@ -0,0 +1,120 @@
+require 'digest/sha1'
+module Marley
+  module Plugins
+    class CurrentUserMethods < Plugin
+      @default_opts={ :plugins => [:orm_rest_convenience],:class_attrs =>  [ [:owner_col,:user_id] ], :http_auth => true}
+      def apply(*args)
+        super
+        if @opts[:http_auth]
+          Marley.config(:authenticate => lambda { |env|
+            require 'rack/auth/basic'
+            auth =  Rack::Auth::Basic::Request.new(env)
+            if (auth.provided? && auth.basic? && auth.credentials)
+              $request[:user]=MR::User.authenticate(auth.credentials)
+              raise AuthenticationError unless $request[:user]
+            else
+              $request[:user]=MR::User.new
+            end
+          })
+        end
+      end
+      module ClassMethods
+        def current_user; $request && $request[:user]; end
+        def current_user_class; current_user.class; end
+        def current_user_ds; filter(@owner_col.to_sym => current_user[:id]); end
+        def requires_user?(verb=nil,meth=nil);true;end
+        def authorize_rest_get(meth)
+          model_actions[:get].to_a.include?(meth.to_sym) && !current_user.new?
+        end
+        def authorize_rest_post(meth)
+          new(($request[:post_params][resource_name.to_sym]||{}).reject {|k,v| v.nil?}).current_user_role=='owner' && meth.nil?
+        end
+        def authorize_rest_put(meth);false; end
+        def authorize_rest_delete(meth):false; 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 && current_user_role != 'new'
+          end
+        end
+        def current_user_role
+          if u=self.class.current_user
+            return 'new' if u.new?
+            return "owner" if owners.include?(u)
+          end
+        end
+        def owners
+          if self.class.to_s.match(/User$/)||self.class.superclass.to_s.match(/User$/)
+            [self]
+          elsif self.class.owner_col
+            [MR::User[send(self.class.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
+  end
+  module Joints
+    class User < Joint
+      module Resources
+        class User < Sequel::Model
+          LOGIN_FORM= [:instance,{:name => 'login',:url => 'main_menu',:description => 'Existing users please log in here:',:new_rec => true,:schema => [[:text,'name',RESTRICT_REQ],[:password,'password',RESTRICT_REQ]]}]
+          Marley.plugin('current_user_methods').apply(self)
+          MU.sti(self)
+          @owner_col=nil 
+          required_cols![:new?][true]=['password','confirm_password']
+          derived_after_cols![:new?]={true => [:password,:confirm_password]}
+          derived_after_cols![:current_user_role]={'owner' => [:old_password,:password,:confirm_password]}
+          reject_cols![:current_user_role]={:all => ['pw_hash']}
+          ro_cols![:current_user_role]={'new' => ['id'],nil => [/.*/]} 
+          def self.join_to(klass, user_id_col_name=nil)
+            user_id_col_name||='user_id'
+            klass=MR.const_get(klass) if klass.class==String
+            Marley.plugin(:current_user_methods).apply(klass)
+            klass.owner_col!=user_id_col_name
+            one_to_many klass.resource_name.to_sym, :class => klass, :key => user_id_col_name
+            klass.send(:many_to_one, :user, :class => MR::User, :key => user_id_col_name)
+          end
+          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.authorize_rest_post
+            true
+          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/marley/plugin.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+module Marley
+  module Plugins
+    Gem.find_files("lib/marley/plugins/*.rb").each do |f|
+      self.autoload(File.basename(f,'.rb').camelize, f)
+    end
+    class Plugin
+      extend Marley::Utils::ClassAttrs
+      class_attr(:default_opts,{})
+      def initialize(opts={})
+        config(opts)
+      end
+      def apply(*klasses)
+        plugin=self.class
+        klasses.flatten.each do |klass|
+          resource=klass.class==String ? MR.const_get(klass) : klass
+          @opts[:required_plugins].to_a.each do |p|
+            Marley.plugin(p).apply(klass)
+          end
+          plugin.constants.include?('ClassMethods') && resource.extend(plugin.const_get('ClassMethods'))
+          plugin.constants.include?('InstanceMethods') && resource.send(:include, plugin.const_get('InstanceMethods'))
+          if @opts[:lazy_class_attrs] || @opts[:class_attrs] 
+            resource.extend Marley::Utils::ClassAttrs
+          end
+          if lazy_attrs=@opts[:lazy_class_attrs]
+            resource.lazy_class_attrs(lazy_attrs[0],lazy_attrs[1..-1])
+          end
+          @opts[:class_attrs].to_a.each do |att|
+            resource.class_attr(*att)
+          end
+        end
+        nil
+      end
+      def config(opts)
+        @opts=(@opts || self.class.default_opts || {}).merge(opts)
+      end
+    end
+  end
+end

data/lib/marley/plugins/orm_rest_convenience.rb

@@ -0,0 +1,92 @@
+module Marley
+  module Plugins
+    class OrmRestConvenience < Plugin
+      #next 3 must go
+      Sequel::Model.plugin :validation_helpers
+      Sequel::Plugins::ValidationHelpers::DEFAULT_OPTIONS.merge!(:presence => {:message => 'is required'})
+      Sequel::Model.plugin :timestamps, :create => :date_created, :update => :date_updated
+
+      @default_opts={
+        :required_plugins => [:rest_convenience],
+        :class_attrs =>[ [:model_actions,{:get => [:new, :list]}] ],
+        :lazy_class_attrs =>  [ :new?,[:instance_actions,{:all => nil}],
+        [:derived_before_cols,{:all => []}],
+        [:derived_after_cols,{:all => []}],
+        [:reject_cols,{true => [/^id$/,/_type$/,/date_(created|updated)/], false => [/_type$/]}],
+        [:ro_cols,{true => [/^id$/,/_id$/], false => [/^id$/,/_id$/,/date_(created|updated)/]}],
+        [:hidden_cols,{:all => [/_id$/]}],
+        [:required_cols,{:all => []}] ]
+      }
+      module ClassMethods
+        def controller; Marley::ModelController.new(self); end
+        # the next 2 will have to be overridden for most applications
+        def authorize(verb); send_or_default("authorize_#{verb}",true) ; end
+        def requires_user?; false; end
+
+        def foreign_key_name; :"#{(respond_to?(:table_name) ? table_name : resource_name).to_s.singularize}_id"; end
+
+        def list(params={})
+          if respond_to?(:list_dataset)
+            list_dataset.filter(params).all
+          else
+            filter(params).all
+          end
+        end
+        def sti
+          plugin :single_table_inheritance, :"#{self.to_s.sub(/.*::/,'').underscore}_type", :model_map => lambda{|v| MR.const_get(v.to_sym)}, :key_map => lambda{|klass|klass.name.sub(/.*::/,'')}
+        end
+      end
+      module InstanceMethods
+        # the next 2 will have to be overridden for most applications
+        def authorize(verb); true ; end
+        def requires_user?; false; end
+          
+        def col_mods_match(mod_type); lambda {|c| c.to_s.match(Regexp.union(send(:"_#{mod_type}")))}; end
+
+        def rest_cols; _derived_before_cols.to_a + (columns.reject &col_mods_match(:reject_cols)) + _derived_after_cols.to_a;end
+        def write_cols; rest_cols.reject &col_mods_match(:ro_cols);end
+        def hidden_cols; rest_cols.select &col_mods_match(:hidden_cols);end
+        def required_cols; rest_cols.select &col_mods_match(:required_cols);end
+        def actions(parent_instance=nil); _instance_actions; end
+
+        def rest_associations;[];end
+
+        def reggae_schema
+          Marley::ReggaeSchema.new(
+            rest_cols.map do |col_name|
+              db_spec=db_schema.to_hash[col_name]
+              col_type=db_spec ? db_spec[:db_type].downcase : "text"
+              col_type=:password if col_name.to_s.match(/password/)
+              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 : "#{self.class.name} #{id.to_s}"
+        end
+        def reggae_instance(parent_instance=nil)
+          a=Marley::ReggaeInstance.new( 
+            {:name => self.class.resource_name,:url => url ,:new_rec => self.new?,:schema => reggae_schema,:actions => self.actions(parent_instance)}
+          )
+          a.contents=rest_associations.to_a.map do |assoc|
+            assoc.map{|instance|  instance.reggae_instance(self)} 
+          end unless new?
+          a
+        end
+        def to_json(*args)
+          reggae_instance.to_json
+        end
+        def url(action=nil)
+          "/#{self.class.resource_name}/#{self[:id]}/#{action}".sub(/\/$/,'')
+        end
+        def reggae_link(action='')
+          ReggaeLink.new({:url => url,:title => "#{action.humanize}"})
+        end
+      end
+    end
+  end
+end