cicloid-conversational 0.3.2.pre

data/lib/conversational/version.rb

@@ -0,0 +1,4 @@
+module Conversational
+  VERSION = "0.3.2.pre"
+end
+

data/lib/generators/conversational/migration/USAGE

@@ -0,0 +1,5 @@
+Description:
+  Creates a migration file for when you want to use Conversation with ActiveRecord
+
+Example:
+  rails g conversation:migration

data/lib/generators/conversational/migration/migration_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+module Conversational
+  class MigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    def self.source_root
+       @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def self.next_migration_number(dirname)
+      if ActiveRecord::Base.timestamped_migrations
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      else
+        "%.3d" % (current_migration_number(dirname) + 1)
+       end
+    end
+
+    def create_migration_file
+      migration_template 'migration.rb', 'db/migrate/create_conversations.rb'
+    end
+  end
+end

data/lib/generators/conversational/migration/templates/migration.rb

@@ -0,0 +1,14 @@
+class CreateConversations < ActiveRecord::Migration
+  def self.up
+    create_table :conversations do |t|
+      t.string :with, :null => false
+      t.string :state
+      t.string :topic
+      t.timestamps
+    end
+  end
+  
+  def self.down
+    drop_table :conversations
+  end
+end

data/lib/generators/conversational/skeleton/USAGE

@@ -0,0 +1,6 @@
+Description:
+  Creates a blank Conversation class and a directory to store your conversations
+  under app/conversations
+
+Example:
+  rails g conversation:skeleton

data/lib/generators/conversational/skeleton/skeleton_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+module Conversational
+  class SkeletonGenerator < Rails::Generators::Base
+
+    def self.source_root
+       @source_root ||= File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    def create_conversations_directory
+      empty_directory "app/conversations"
+    end
+
+    def copy_conversation_file
+      copy_file "conversation.rb", "app/conversations/conversation.rb"
+    end
+  end
+end

data/lib/generators/conversational/skeleton/templates/conversation.rb

@@ -0,0 +1,3 @@
+class Conversation
+  include Conversational::Conversation
+end

data/spec/active_record_additions_spec.rb

@@ -0,0 +1,120 @@
+# See support/conversation.rb
+
+require 'spec_helper'
+
+describe Conversational::ActiveRecordAdditions do
+  let(:valid_attributes) { {:with => "someone"} }
+  describe "scopes" do
+    let!(:conversation) { Conversation.create!(valid_attributes) }
+    describe ".converser" do
+      it "should find the conversation with someone" do
+        Conversation.converser("someone").last.should == conversation
+      end
+    end
+    describe ".recent" do
+      context "the conversation was updated less than 24 hours ago" do
+        context "passing no arguments" do
+          it "should find the conversation" do
+            Conversation.recent.last.should == conversation
+          end
+        end
+      end
+      context "the conversation was updated more than 24 hours ago" do
+        before {
+          Conversation.record_timestamps = false
+          conversation.updated_at = 24.hours.ago
+          conversation.save!
+          Conversation.record_timestamps = true
+        }
+        context "passing no arguments" do
+          it "should not find the conversation" do
+            Conversation.recent.last.should be_nil
+          end
+        end
+        context "passing an argument" do
+          it "should find the conversation" do
+            Conversation.recent(25.hours.ago).last.should == conversation
+          end
+        end
+      end
+    end
+    describe ".in_progress" do
+      context "conversation is in progress" do
+        it "should find the conversation" do
+          Conversation.in_progress.last.should == conversation
+        end
+      end
+      context "conversation is finished" do
+        before {
+          conversation.state = "finished"
+          conversation.save!
+        }
+        it "should not find the conversation" do
+          Conversation.in_progress.last.should be_nil
+        end
+      end
+    end
+    describe ".with" do
+      context "conversation is in progress and recent" do
+        it "should find the conversation" do
+          Conversation.with("someone").last.should == conversation
+        end
+      end
+    end
+  end
+  
+  describe ".find_or_create_with" do
+    context "when no existing conversation exists with 'someone'" do
+      context "but a subclass for this topic exists and has not been excluded" do
+        let(:subclass) { mock("Subclass") }
+        before {
+          Conversational::ConversationDefinition.stub!(
+            :find_subclass_by_topic
+          ).with("something").and_return(subclass)
+        }
+        it "should create an instance of the subclass" do
+          subclass.should_receive(:create!).with(
+            :with => "someone", :topic => "something"
+          )
+          Conversation.find_or_create_with("someone", "something")
+        end
+      end
+      context "and a subclass for this topic also does not exist" do
+        before {
+          Conversational::ConversationDefinition.stub!(
+            :find_subclass_by_topic
+          ).and_return(nil)
+        }
+        context "and the topic is blank" do
+          it "should raise an error" do
+            lambda {
+              Conversation.find_or_create_with("someone", nil)
+            }.should raise_error(/not defined a blank_topic_subclass/)
+          end
+        end
+        context "though the topic is not blank" do
+          it "should still raise an error" do
+            lambda {
+              Conversation.find_or_create_with(
+                "someone", "something"
+              )
+            }.should raise_error(/not defined SomethingConversation/)
+          end
+        end
+      end
+    end
+    context "a conversation already exists" do
+      let(:conversation) { Conversation.new(valid_attributes) }
+      let(:defined_conversation) { mock("defined_conversation") }
+      before {
+        Conversation.stub_chain(:with, :last).and_return(conversation)
+      }
+      it "should return the conversation as an instance of the subclass" do
+        conversation.should_receive(:details).and_return(defined_conversation)
+        Conversation.find_or_create_with(
+          "someone", "something"
+        ).should == defined_conversation
+      end
+    end
+  end
+end

data/spec/conversation_definition_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+describe Conversational::ConversationDefinition do
+  def define_conversation(params=nil)
+    defined_conversation = {}
+    unless params && (params[:blank] || params[:unknown])
+      defined_conversation[:class] = mock("DefinedConversation")
+      defined_conversation[:instance] = mock("defined_conversation")
+      topic = "defined"
+      topic.stub!(:+).and_return(topic)
+      topic.stub!(:classify).and_return(topic)
+      topic.stub!(:constantize).and_return(defined_conversation[:class])
+      defined_conversation[:topic] = topic
+      defined_conversation[:class].stub!(:<=).and_return(true)
+    else
+      if params[:unknown]
+        defined_conversation[:class] = mock("UnknownConversation")
+        defined_conversation[:instance] = mock("unknown_conversation")
+        Conversational::ConversationDefinition.unknown_topic_subclass = defined_conversation[:class]
+      end
+      if params[:blank]
+        defined_conversation[:class] = mock("BlankConversation")
+        defined_conversation[:instance] = mock("blank_conversation")
+        Conversational::ConversationDefinition.blank_topic_subclass = defined_conversation[:class]
+      end
+    end
+    defined_conversation
+  end
+
+  describe ".exclude" do
+    it "should accept a string" do
+      lambda {
+        Conversational::ConversationDefinition.exclude "something"
+        }.should_not raise_error
+    end
+    it "should accept a symbol" do
+      lambda {
+        Conversational::ConversationDefinition.exclude :defined_conversation
+        }.should_not raise_error
+    end
+    it "should accept a regex" do
+      lambda {
+        Conversational::ConversationDefinition.exclude /something/i
+        }.should_not raise_error
+    end
+    it "should accept a Class" do
+      some_class = mock("SomeClass", :superclass => Class)
+      some_class.stub!(:is_a?).with(Class).and_return(true)
+      lambda {
+        Conversational::ConversationDefinition.exclude some_class
+        }.should_not raise_error
+    end
+    it "should accept an Array where the elements are a Class, String, Symbol or Regexp" do
+      some_class = mock("SomeClass", :superclass => Class)
+      some_class.stub!(:is_a?).with(Class).and_return(true)
+      lambda {
+        Conversational::ConversationDefinition.exclude ["Something", some_class, /something/i, :something]
+        }.should_not raise_error
+    end
+    it "should accept nil" do
+      lambda {
+        Conversational::ConversationDefinition.exclude nil
+        }.should_not raise_error
+    end
+    it "should not accept anything else" do
+      some_class = mock("SomeClass")
+      lambda {
+        Conversational::ConversationDefinition.exclude some_class
+        }.should raise_error(/You specified a /)
+    end
+  end
+
+  describe ".find_subclass_by_topic" do
+    context "a conversation definition with this topic has been defined" do
+      let(:defined_conversation) { define_conversation }
+      context "and it subclasses conversation" do
+        before {
+          defined_conversation[:class].stub!(:<=).and_return(true)
+        }
+        context "and it has not been excluded" do
+          before {
+            Conversational::ConversationDefinition.exclude nil
+          }
+          it "should return the conversation definition class" do
+            Conversational::ConversationDefinition.find_subclass_by_topic(
+              defined_conversation[:topic]
+            ).should == defined_conversation[:class]
+          end
+        end
+        context "but it has been excluded" do
+          before {
+            Conversational::ConversationDefinition.stub!(:exclude?).and_return(true)
+          }
+          context "and it has not been explicitly included" do
+            context "and an unknown topic subclass has been defined" do
+              let!(:unknown_conversation) { define_conversation(:unknown => true) }
+              it "should return the unknown conversation subclass" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                   defined_conversation[:topic]
+                ).should == unknown_conversation[:class]
+              end
+            end
+            context "and an unknown topic subclass has not been defined" do
+              before {
+                Conversational::ConversationDefinition.unknown_topic_subclass = nil
+              }
+              it "should return nil" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                  defined_conversation[:topic]
+                ).should be_nil
+              end
+            end
+          end
+          context "but it was explicitly included for this query" do
+            it "should return the conversation definition class" do
+              Conversational::ConversationDefinition.find_subclass_by_topic(
+                defined_conversation[:topic], :include_all => true
+              ).should == defined_conversation[:class]
+            end
+          end
+        end
+        context "and an unknown topic subclass has not been defined" do
+          before {
+            Conversational::ConversationDefinition.unknown_topic_subclass = nil
+          }
+          context "and the conversation has been excluded" do
+            context "by setting Conversation.exclude 'defined_conversation'" do
+              before {
+                excluded_class = "defined_conversation"
+                excluded_class.stub_chain(
+                  :classify,
+                  :constantize).and_return(
+                  defined_conversation[:class]
+                )
+                Conversational::ConversationDefinition.exclude excluded_class
+              }
+              it "should return nil" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                  defined_conversation[:topic]
+                ).should be_nil
+              end
+            end
+            context "by setting Conversation.exclude DefinedConversation" do
+              before {
+                excluded_class = defined_conversation[:class]
+                defined_conversation[:class].stub!(:superclass).and_return(Class)
+                defined_conversation[:class].stub!(:is_a?).with(
+                  Class
+                  ).and_return(true)
+                Conversational::ConversationDefinition.exclude(
+                  defined_conversation[:class]
+                )
+              }
+              it "should return nil" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                  defined_conversation[:topic]
+                ).should be_nil
+              end
+            end
+            context "by setting Conversation.exclude /defined/i" do
+              before {
+                Conversational::ConversationDefinition.exclude /defined/i
+              }
+              it "should return nil" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                  defined_conversation[:topic]
+                ).should be_nil
+              end
+            end
+            context "by setting Conversation.exclude [/defined/i]" do
+              before {
+                Conversational::ConversationDefinition.exclude [/defined/i]
+              }
+              it "should return nil" do
+                Conversational::ConversationDefinition.find_subclass_by_topic(
+                  defined_conversation[:topic]
+                ).should be_nil
+              end
+            end
+          end
+        end
+      end
+      context "but it is not a type of conversation" do
+        before {
+          defined_conversation[:class].stub!(:<=).and_return(false)
+        }
+        context "but an unknown topic subclass has been defined" do
+          let!(:unknown_conversation) { define_conversation(:unknown => true) }
+          it "should return the unknown conversation subclass" do
+            Conversational::ConversationDefinition.find_subclass_by_topic(
+              defined_conversation[:topic]
+            ).should == unknown_conversation[:class]
+          end
+        end
+        context "and an unknown topic subclass has not been defined" do
+          before {
+            Conversational::ConversationDefinition.unknown_topic_subclass = nil
+          }
+          it "should return nil" do
+            Conversational::ConversationDefinition.find_subclass_by_topic(
+              defined_conversation[:topic]
+            ).should be_nil
+          end
+        end
+      end
+    end
+    context "and a conversation definition with this topic has not been defined" do
+      context "but an unknown conversation definition has been defined" do
+        let!(:unknown_conversation) { define_conversation(:unknown => true) }
+        it "should return the unknown conversation subclass" do
+          Conversational::ConversationDefinition.find_subclass_by_topic(
+            "something"
+          ).should == unknown_conversation[:class]
+        end
+      end
+      context "and an unknown conversation definition has not been defined" do
+        before {
+          Conversational::ConversationDefinition.unknown_topic_subclass = nil
+        }
+        it "should return nil" do
+          Conversational::ConversationDefinition.find_subclass_by_topic(
+            "someone"
+          ).should be_nil
+        end
+      end
+    end
+    context "and the topic for conversation is blank" do
+      context "but a blank conversation definition has been defined" do
+        let!(:blank_conversation) { define_conversation(:blank => true) }
+        it "should return the blank conversation subclass" do
+          Conversational::ConversationDefinition.find_subclass_by_topic(
+            nil
+          ).should == blank_conversation[:class]
+        end
+      end
+      context "and a blank conversation definition has not been defined" do
+        before(:each) do
+          Conversational::ConversationDefinition.blank_topic_subclass = nil
+        end
+        it "should return nil" do
+          Conversational::ConversationDefinition.find_subclass_by_topic(
+            nil
+          ).should be_nil
+        end
+      end
+    end
+  end
+end