newbamboo-modmonkey_client 0.0.2

data/History.txt

@@ -0,0 +1,4 @@
+== 0.0.1 2008-11-11
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.txt
+Rakefile
+lib/modmonkey_client.rb
+lib/modmonkey_client/mod_monkey.rb
+lib/modmonkey_client/profile.rb
+lib/modmonkey_client/item.rb
+lib/modmonkey_client/moderatables.rb
+script/console
+script/destroy
+script/generate
+spec/spec.opts
+spec/spec_helper.rb
+tasks/rspec.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on modmonkey_client, see http://modmonkey_client.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.txt

@@ -0,0 +1,198 @@
+There is a ruby gem which handles a lot of stuff for you
+
+General principles
+---
+
+items and profiles which have corresponding things on the server
+
+Models
+---
+
+Item
+---
+
+database fields
+
+<pre>
+  class AddImages < ActiveRecord::Migration
+    def self.up
+      create_table :test_images do |t|
+        t.string :photo_file_name
+        t.string :mm_key
+        t.string :mm_approved
+        t.string :mm_id
+        t.string :test_user_id
+      end
+    end
+
+    def self.down
+      drop_table :test_images
+    end
+  end
+</pre>
+
+Adding moderation to the model
+
+<pre>
+  class Comment < ActiveRecord::Base
+    extend ModMonkey::Item::ActMethods
+    make_moderatable :content_type=>'text',
+                     :profile_info => {
+                       :identifier => lambda{|obj| obj.test_user.email},
+                       :profile_url => lambda{|obj| SITE_URL+"/test_users/#{obj.test_user.id}"}
+                      },
+                     :item_url => lambda{|obj| SITE_URL+"/test_comments/#{obj.id}"},
+                     :editable_attrs => [:body]
+
+    def mm_content
+      { :body => self.body }
+    end
+  end  
+</pre>
+
+optional attrs and methods
+
+* content_type
+* mm_content
+* editable_attrs
+* item_url
+* profile_url
+* asset_url
+
+Specifying these values can be done via: lambdas, symbols or variables
+
+
+callbacks created automatically for the following:
+
+* create
+  * adds item to queue
+* update
+  * updates item in queue
+* delete
+  * removes item from queue
+  
+Though these are automatic, it is usually necessary to think about how failure is handled. Section on this in "Maintenance".
+
+assumptions about moderated content and applying decisions
+---
+
+The default behaviour is to switch mm_approved on or off with a modified find. However this could be overridden to destroy the objects completely, or do some other strategy.
+
+added methods
+---
+
+* reject
+* approve
+
+usually necessary to apply callbacks to these to cover:
+
+* cascading
+* banning user
+* emailing notifications
+
+---
+
+Profile
+---
+
+database fields
+
+<pre>
+  class CreateTestUsers < ActiveRecord::Migration
+    def self.up
+      create_table :test_users do |t|
+        t.string :email
+        t.boolean :banned
+
+        t.timestamps
+      end
+    end
+
+    def self.down
+      drop_table :test_users
+    end
+  end
+</pre>
+
+Adding moderatble functionality
+---
+
+<pre>
+  class User < ActiveRecord::Base
+    extend ModMonkey::Profile::ActMethods
+    make_moderatable
+  end
+</pre>
+
+methods called via the options given:
+
+* ban
+* unban
+
+usually necessary to apply callbacks to these to cover:
+
+* cascading
+* banning user
+* emailing notifications
+
+---
+
+Controllers
+---
+
+SECURITY
+
+implementation - AOP
+
+Items
+---
+
+<pre>
+  class TestImagesController < ApplicationController
+    extend ModMonkey::ControllerActMethods
+    make_moderatable                    
+  end
+</pre>
+
+mm_update
+
+update action applies decision etc
+
+Flags
+---
+
+Method which can be posted to to add a flag to the item in the queue. Can have an optional reason, if UI supports this.
+
+---
+
+Profile
+---
+
+<pre>  
+  class TestUsersController < ApplicationController
+    extend ModMonkey::ProfileControllerActMethods
+    make_moderatable
+  end
+</pre>
+
+mm\_profile\_update checks permission and calls apply\_mod\_monkey\_params
+
+all the callbacks for banning etc
+
+- doesn't do cascading on the users content on this side, but does on the server ?
+
+---
+
+Routes
+---
+
+items which are moderated need to have a flags resource which can be posted to -
+often helpful to have a helper in views
+
+Gotchas
+---
+
+* login_required
+
+Rake tasks
+---

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 2
+:major: 0
+:minor: 0

data/lib/modmonkey_client.rb

@@ -0,0 +1,20 @@
+$:.unshift(File.expand_path(File.dirname(__FILE__))) unless 
+  $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+begin
+  require 'rest_client'
+rescue LoadError
+  require 'rubygems'
+  gem 'rest-client'
+  require 'rest_client'
+end
+
+require 'modmonkey_client/mod_monkey'
+require 'modmonkey_client/item.rb'
+require 'modmonkey_client/profile.rb'
+require 'modmonkey_client/moderatables.rb'
+# require 'modmonkey_client/hasher.rb'
+# require 'modmonkey_client/rest_client_extensions.rb'
+# require 'modmonkey_client/config.rb'
+
+            

data/lib/modmonkey_client/item.rb

@@ -0,0 +1,175 @@
+module ModMonkey
+  module Item
+    module ActMethods
+
+      attr_accessor :mm_attr_store
+      attr_accessor :editable_attrs
+      attr_accessor :mandatory_keys
+      attr_accessor :optional_keys
+
+      def make_moderatable(options={}, &block)
+        self.mandatory_keys =  [:content_type, :profile_info, :item_url]
+        self.optional_keys =   [:asset_url, :context_url, :content_description]
+     
+        # Process passed in options
+        # These 'dynamic methods' are stored either as a lambda, proc, symbol for method, or ordinary variable
+        validate_keys(options)
+  
+        self.editable_attrs = options[:editable_attrs] || []
+        self.mm_attr_store = options.select{|k,v| (mandatory_keys+optional_keys).include? k }
+
+        unless included_modules.include?(Moderatable)
+          before_create :set_default_approval_status
+          after_create :create_mm_item
+          after_update :update_mm_item
+          after_destroy :destroy_mm_item
+          attr_accessor :mm_update
+          named_scope :approved, :conditions => {:mm_approved => true}
+          include Moderatable
+          ModMonkey::Moderatables.add(self)
+        end
+      end
+      
+      def validate_keys(options)
+        unless (options.keys | self.mandatory_keys) == options.keys
+          raise ArgumentError, "make_moderatable needs the following mandatory keys: #{(mandatory_keys).join(', ')}" 
+        end
+        if options[:profile_info] &&
+            !options[:profile_info].is_a?(Symbol) && 
+            options[:profile_info][:profile_url].blank?
+            raise ArgumentError, "make_moderatable needs the profile_url to be specified" 
+        end
+      end
+      
+      def find(*args)
+        with_scope :find=>{:conditions=>"#{self.to_s.tableize}.mm_approved=1"} do
+          super
+        end
+      end
+      
+      def find_unmoderated()
+        find(:all, :conditions => "mm_id is null")
+      end
+
+      def resource_url
+         # File.join(::ModMonkey::Config.api_domain, 'accounts', ::ModMonkey::Config.api_key, "items")
+         File.join(MM_API_DOMAIN, 'accounts', MM_API_KEY, "items")
+      end
+      
+      def default_content_description
+        self.to_s.humanize
+      end
+
+    end
+
+    module Moderatable
+      attr_accessor :mm_item
+      
+
+      
+      # mod monkey
+      def apply_mod_monkey_params( params )  
+        apply_decision(params)
+        update_content(params)
+        self.save!
+      end
+
+      # mod monkey callbacks
+      def reject
+        self.mm_approved = false
+        self.save
+      end
+      def approve
+        self.mm_approved = true
+        self.save
+      end
+
+      def flag(params={})
+        flag = Hash.from_xml(RestClient::Resource.new(self.class.resource_url+"/#{self.mm_id}/flags").post(params))
+      end
+
+      def mm_attrs
+        # Evaluate each attribute and return the hash
+        attrs = {}
+        self.class.mm_attr_store.each do |attr_name,value|
+          evaluated_value = evaluate_value(value)
+          attrs[attr_name] = evaluated_value
+        end
+        attrs
+      end   
+
+      def evaluate_value(value) 
+        if value.respond_to?(:call) then value.call(self)
+        elsif value.is_a?(Symbol) && self.respond_to?(value) then self.send(value)
+        elsif value.is_a?(Hash) then 
+          new_hash = {}
+          value.each {|k,v| new_hash[k] = evaluate_value(v)}
+          new_hash  
+        else value       
+        end
+      end
+
+      def mm_content
+        raise NotImplementedError, 'the method mm_content needs to be implemented in the including class'
+      end
+
+      def add_to_queue
+        create_mm_item
+      end
+      
+      def moderated?
+        !self.mm_id.blank?
+      end
+      
+      protected
+
+      def set_default_approval_status
+        self.mm_approved = true
+      end
+
+      # mod monkey
+      def apply_decision(mm_item)
+        case mm_item['decision']
+        when 'rejected'
+          self.reject
+        when 'approved'
+          self.approve
+        end
+      end
+
+      def update_content(mm_item)
+        evaluate_value(self.class.editable_attrs).each do |attr|
+          self.write_attribute( attr, mm_item[ attr.to_s ] )
+        end
+      end
+
+      # mod monkey
+      def create_mm_item           
+        begin
+          attrs_for_create = {:item => self.mm_attrs.merge(self.mm_content)}
+          self.mm_item = Hash.from_xml(RestClient::Resource.new(self.class.resource_url).post(attrs_for_create))['item']
+          self.mm_id = self.mm_item['id']
+          self.mm_key = self.mm_item['item_key']
+          self.save
+        rescue Exception => e      
+          logger.info("#{e.inspect}, backtrace: #{e.backtrace.join("\n")} - #{mm_item.inspect} with #{attrs_for_create.inspect}")
+        end
+      end
+
+      def update_mm_item
+        true
+      end
+
+      def destroy_mm_item
+        RestClient::Resource.new(self.mm_item_url).delete if self.moderated?
+      end
+
+      protected
+      
+      def mm_item_url
+        self.class.resource_url + "/#{self.mm_id}"
+      end
+      
+    end
+  end
+end

data/lib/modmonkey_client/mod_monkey.rb

@@ -0,0 +1,134 @@
+raise %q(Please define the following constants in your environment:
+MM_API_DOMAIN
+SITE_URL
+MM_API_KEY
+SITE_HOSTNAME
+) unless (defined?(MM_API_DOMAIN) &&
+defined?(SITE_URL) &&
+defined?(MM_API_KEY) &&
+defined?(SITE_HOSTNAME)) 
+
+module ModMonkey
+
+  APPROVAL_STATES = {
+    'APPROVED' => 'approved',
+    'REJECTED' => 'rejected'
+  }
+
+  ITEMS_RESOURCE_URL = File.join(MM_API_DOMAIN, 'accounts', MM_API_KEY, "items")
+
+  module ControllerActMethods
+    def make_moderatable(options={}, &block)
+      unless included_modules.include?(MonkeyController)
+				if defined?(Merb) 
+				  before :mm_update, :only => [:update]
+				  provides :xml, :only => [:update]
+				  include MerbMonkeyController
+        else
+          before_filter :mm_update, :only => [:update]
+          include MonkeyController
+        end
+      end
+    end
+  end
+  
+  module ProfileControllerActMethods
+    def make_moderatable(options={}, &block)
+      unless included_modules.include?(MonkeyProfileController)
+				if defined?(Merb)
+				  before :mm_profile_update, :only => [:update]
+				  provides :xml, :only => [:update]
+          include MerbMonkeyProfileController
+        else
+          before_filter :mm_profile_update, :only => [:update]
+          include MonkeyProfileController
+        end
+      end
+    end
+  end
+
+######  RAILS
+
+  module MonkeyProfileController
+    private
+
+    # this method is called before any update actions in your controllers
+    def mm_profile_update
+      if params[:mod_monkey_profile]
+        #@test_user = TestUser.find_by_mm_id(params[:mod_monkey_profile][:id])
+        @test_user = TestUser.find(params[:id])
+        raise ActiveRecord::RecordNotFound if @test_user.nil?
+        @test_user.apply_mod_monkey_params(params[:mod_monkey_profile])
+        render :xml => @test_user.to_xml and return false
+      end
+    end  
+  end
+
+  module MonkeyController
+    def flag
+      klass = self.controller_name.singularize.camelize.constantize
+      @obj = klass.find(params[:id])
+      # we might want to pass in some more args
+      @obj.flag(params[:flag])
+      redirect_to :back
+    end
+
+    # this method is called before any update actions in your controllers
+    def mm_update
+      if params[:mod_monkey_item]
+        klass = self.controller_name.singularize.camelize.constantize
+        @obj = klass.find_by_mm_id_and_mm_key(params[:mod_monkey_item][:id], params[:mod_monkey_item][:item_key])
+        @obj.apply_mod_monkey_params( params[:mod_monkey_item] )
+        render :xml => @obj.to_xml and return false
+      end
+    end
+  end
+  
+############  MERB STUFF
+  
+  module MerbMonkeyProfileController
+    
+    def self.included(base)
+      base.show_action(:mm_profile_update)
+    end
+    
+    # this method is called before any update actions in your controllers
+    def mm_profile_update
+      if params[:mod_monkey_profile]
+        klass = self.controller_name.singularize.camelize.constantize
+        @obj = klass.find(params[:id])
+        @obj.apply_mod_monkey_params(params[:mod_monkey_profile])
+        render @obj.to_xml and throw :halt
+      end
+    end  
+  end
+  
+  module MerbMonkeyController
+    def self.included(base)
+      base.show_action("flag", "mm_update")
+    end
+    
+    def mm_update
+      if params[:mod_monkey_item]
+        klass = self.controller_name.singularize.camelize.constantize
+        @obj = klass.find_by_mm_id_and_mm_key(params[:mod_monkey_item][:id], params[:mod_monkey_item][:item_key])
+        @obj.apply_mod_monkey_params( params[:mod_monkey_item] )
+        render @obj.to_xml and throw :halt
+      end
+    end
+    
+    def flag
+      klass = self.controller_name.singularize.camelize.constantize
+      @obj = klass.find(params[:id])
+      # we might want to pass in some more args
+      @obj.flag(params[:flag])
+      if defined?(MerbHasFlash)
+        flash[:notice] = MM_FLAG_NOTICE 
+        redirect "/"
+      else
+        redirect "/", :message => {:notice => MM_FLAG_NOTICE}
+      end
+      
+    end
+  end
+end

data/lib/modmonkey_client/moderatables.rb

@@ -0,0 +1,15 @@
+module ModMonkey
+  class Moderatables
+    
+    @@moderatables = []
+    
+    def self.add(klass)
+      @@moderatables << klass unless @@moderatables.include?(klass)
+    end
+    
+    def self.moderatables
+      @@moderatables
+    end
+    
+  end
+end

data/lib/modmonkey_client/profile.rb

@@ -0,0 +1,82 @@
+module ModMonkey
+  module Profile
+    
+    BANNED_STATES = {
+      'BANNED' => 'banned',
+      'UNBANNED' => 'unbanned'
+    }
+    
+    module ActMethods
+
+      attr_accessor :mm_attr_store
+      attr_accessor :editable_attrs
+
+      def make_moderatable(options={}, &block)
+
+        # Process passed in options
+        # These 'dynamic methods' are stored either as a lambda, proc, symbol for method, or ordinary variable
+        # mm_attr_keys = [:content_type, :profile_info, :item_url]
+        # raise ArgumentError, "make_moderatable needs the following mandatory keys: #{(mm_attr_keys).join(', ')}" unless (options.keys | mm_attr_keys) == options.keys
+        # self.editable_attrs = options[:editable_attrs] || []
+        # self.mm_attr_store = options.select{|k,v| mm_attr_keys.include? k }
+        # 
+        unless included_modules.include?(Moderatable)
+        #   before_create :set_default_approval_status
+        #   after_create :create_mm_item
+        #   after_update :update_mm_item
+        #   after_destroy :destroy_mm_item
+        #   attr_accessor :mm_update
+        #   named_scope :approved, :conditions => {:mm_approved => true}
+           include Moderatable
+        #   def self.find(*args)
+        #     with_scope :find=>{:conditions=>"#{self.to_s.tableize}.mm_approved=1"} do
+        #       super
+        #     end
+        #   end
+        end
+      end
+
+    end
+
+    module Moderatable
+
+      # mod monkey
+      def apply_mod_monkey_params( params )  
+        apply_decision(params)
+        self.save!
+      end
+
+      # mod monkey callbacks
+      def ban
+        self.mm_banned = true
+        self.save
+      end
+      
+      def unban
+        self.mm_banned = false
+        self.save
+      end
+
+      private
+
+      # mod monkey
+      def apply_decision(mm_item)
+        case mm_item['status']
+        when BANNED_STATES['BANNED']
+          self.ban
+        when BANNED_STATES['UNBANNED']
+          self.unban
+        end
+      end
+
+      def update_mm_item
+        true
+      end
+
+      def destroy_mm_item
+        true
+      end
+
+    end
+  end
+end

data/spec/modmonkey_client/item_controller_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ModeratableController < ActionController::Base
+  
+  extend ModMonkey::ControllerActMethods
+  make_moderatable                                  
+  
+end
+
+describe ModeratableController do
+
+  before :each do
+    @controller = ModeratableController.new
+  end
+  
+  it "should have an update method" do
+    pending
+    @controller.should be_respond_to('update')
+  end
+  
+end

data/spec/modmonkey_client/item_model_spec.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')                                          
+
+describe TestComment do
+                                 
+  describe "making our model moderatable" do
+
+    before(:each) do
+      @test_user = TestUser.create!()
+      @default_options = { 
+        :content_type    => 'text',
+        :profile_info => {
+          :email => "fsdfs@fdsaf.com",
+          :profile_url => "localhost:3000/users/1"
+        },
+        :item_url        => '/jello',
+        :editable_attrs  => [:body] }
+    end
+
+    [:content_type, :profile_info, :item_url].each do |key|
+
+      it "should require #{key}" do
+        $key = key
+        $default_options = @default_options
+        lambda {
+          class TestComment
+            make_moderatable $default_options.reject{|k,v|k==$key}
+          end
+          }.should raise_error(ArgumentError)
+      end
+
+      it "should accept #{key} as a proc with instance as param" do
+        $key = key
+        $default_options = @default_options
+        class TestComment
+          make_moderatable $default_options.merge({ $key => Proc.new {|obj| obj.object_id } })
+        end
+        comment = TestComment.new
+        comment.mm_attrs[key].should == comment.object_id
+      end
+
+      it "should accept #{key} as a lambda with instance as param" do
+        $key = key
+        $default_options = @default_options
+        class TestComment
+          make_moderatable $default_options.merge({ $key => lambda {|obj| obj.object_id } })
+        end
+        comment = TestComment.new
+        comment.mm_attrs[key].should == comment.object_id
+      end
+
+      it "should accept #{key} as a method name and be able to call it" do
+        $key = key
+        $default_options = @default_options
+        class TestComment
+          make_moderatable $default_options.merge({ $key => :test_method })
+          def test_method; 'wassup'; end
+        end
+        comment = TestComment.new
+        comment.mm_attrs[key].should == 'wassup'
+      end
+
+    end
+      
+    it "should include the profile url" do
+      $default_options = @default_options
+      lambda {
+        $default_options[:profile_info][:profile_url] = nil
+        class TestComment
+          make_moderatable $default_options
+        end
+        }.should raise_error(ArgumentError)
+    end
+
+    it "should save editable_attrs as empty array by default" do
+      $default_options = @default_options
+      class TestComment
+        make_moderatable $default_options.reject{|k,v| k == :editable_attrs}
+      end
+      TestComment.editable_attrs.should == []
+    end
+
+    it "should return editable_attrs correctly" do
+      $default_options = @default_options
+      class TestComment
+        make_moderatable $default_options
+      end
+      TestComment.editable_attrs.should == [:body]
+    end
+
+    describe 'getting the mm attributes' do
+
+      before :each do
+        class TestComment
+          make_moderatable :content_type    => lambda{|obj| "#{obj.object_id} hello"},
+          :profile_info => {
+            :email => lambda{|obj| obj.test_user.email},  
+            :profile_url => lambda{|obj| "localhost:3000/users/#{obj.test_user.id}"},
+          },
+          :item_url        => lambda{|obj| "comments/#{obj.object_id}"},
+          :editable_attrs  => [:body, :name]
+          def mm_content
+            {:body => 'wassup', :name => 'yo'}
+          end
+        end
+        @comment = TestComment.new(:test_user => @test_user)
+      end
+
+      it 'should return the dynamically generated attributes' do
+        @comment.mm_attrs.should == { 
+        :content_type => "#{@comment.object_id} hello",
+        :profile_info => { 
+          :email => @comment.test_user.email, 
+          :profile_url => "localhost:3000/users/#{@test_user.id}"
+        },
+        :item_url => "comments/#{@comment.object_id}"}        
+      end
+
+      it 'should return the content' do
+        @comment.mm_content.should == {:body => 'wassup', :name => 'yo'}
+      end
+
+    end
+    
+    describe "destroying" do
+      before( :each ) do
+        @comment = TestComment.new(:title=>'foo', :test_user=>@test_user)
+        @comment.stub!(:create_mm_item).and_return(true)
+        @comment.stub!(:moderated?).and_return(true)
+        @comment.save
+        @mocked_resource = mock('resource')
+      end
+      
+      it "should fire a callback when destroyed" do
+        @mocked_resource.should_receive(:delete)
+        RestClient::Resource.should_receive(:new).and_return(@mocked_resource)
+        @comment.destroy
+      end
+
+      it "should use the method " do
+        @comment.should_receive(:mm_item_url).and_return('my_url')
+        @mocked_resource.stub!(:delete)
+        RestClient::Resource.stub!(:new).with('my_url').and_return(@mocked_resource)
+        @comment.destroy
+      end
+    end
+  end
+
+end
+

data/spec/modmonkey_client/moderatables_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')                                          
+require 'ostruct'
+
+describe ModMonkey::Moderatables do
+
+  describe "adding all moderatable class" do
+
+   it "should return moderatables" do
+     ModMonkey::Moderatables.moderatables.should == [TestComment]
+   end
+
+  end
+
+end

data/spec/modmonkey_client/profile_controller_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ModeratableController < ActionController::Base
+  
+  extend ModMonkey::ProfileControllerActMethods
+  make_moderatable                                  
+  
+end
+
+describe ModeratableController do
+
+  it "should have an update method" do
+    pending
+    put :update
+    response.should be_success
+  end
+
+end
+

data/spec/modmonkey_client/profile_model_spec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')                                          
+
+describe TestUser do
+
+  describe "making our profile moderatable" do
+
+    before(:each) do
+      @user = TestUser.new
+    end
+    
+    it "should have the apply_mod_monkey_params method" do
+      pending
+      @user.should be_respond_to(:apply_mod_monkey_params)
+    end
+
+
+  end
+
+end
+

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--colour
+--format=specdoc

data/spec/spec_helper.rb

@@ -0,0 +1,60 @@
+MM_API_DOMAIN   = "http://localhost:3002"
+SITE_URL        = "http://localhost:3001" 
+MM_API_KEY      = "public"
+MM_PRIOVATE_KEY = "private"
+SITE_HOSTNAME   = "localhost"
+
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'activerecord'  
+require 'action_controller'      
+require 'mocha'
+
+ActiveRecord::Base.establish_connection({
+  :adapter => 'sqlite3',
+  :database => ':memory:'
+})
+
+# define a migration
+class TestSchema < ActiveRecord::Migration
+  def self.up
+    create_table :test_comments do |t|
+      t.string :title
+      t.integer :test_user_id
+      t.string :mm_key
+      t.string :mm_approved
+      t.string :mm_id
+      t.timestamps
+    end
+    
+    create_table :test_users do |t|
+      t.text :name
+      t.string :email
+      t.boolean :banned
+      t.timestamps
+    end
+  end
+ 
+  def self.down
+    drop_table :test_users
+    drop_table :test_comments
+  end
+end
+ 
+ActiveRecord::Base.connection # this creates the DB
+# run the migration
+TestSchema.migrate(:up)
+
+require 'modmonkey_client'              
+require 'spec/test_comment'
+require 'spec/test_user'
+

data/spec/test_comment.rb

@@ -0,0 +1,17 @@
+class TestComment < ActiveRecord::Base              
+  belongs_to :test_user
+  
+  extend ModMonkey::Item::ActMethods
+  make_moderatable :content_type=>'text', 
+                   :profile_info => {
+                     :email => lambda{|obj| obj.test_user.email},
+                     :profile_url => lambda{|obj| SITE_URL+"/test_users/#{obj.test_user.id}"}
+                   }, 
+                   :item_url => lambda{|obj| SITE_URL+"/test_comments/#{obj.id}"},
+                   :editable_attrs => [:body]
+
+  def mm_content
+    { :body => self.body }
+  end
+  
+end

data/spec/test_user.rb

@@ -0,0 +1,3 @@
+class TestUser < ActiveRecord::Base
+  has_many :test_comments
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: newbamboo-modmonkey_client
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- New Bamboo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-31 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: me@mloughran.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.txt
+- VERSION.yml
+- lib/modmonkey_client
+- lib/modmonkey_client/item.rb
+- lib/modmonkey_client/mod_monkey.rb
+- lib/modmonkey_client/moderatables.rb
+- lib/modmonkey_client/profile.rb
+- lib/modmonkey_client.rb
+- spec/modmonkey_client
+- spec/modmonkey_client/item_controller_spec.rb
+- spec/modmonkey_client/item_model_spec.rb
+- spec/modmonkey_client/moderatables_spec.rb
+- spec/modmonkey_client/profile_controller_spec.rb
+- spec/modmonkey_client/profile_model_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/test_comment.rb
+- spec/test_user.rb
+has_rdoc: false
+homepage: http://github.com/newbamboo/modmonkey_client
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Client gem for modmonkey
+test_files: []
+