conversational 0.3.2 → 0.4.0

data/lib/conversational/active_record_additions.rb

@@ -1,121 +0,0 @@
-module Conversational
-  module ActiveRecordAdditions
-    def self.included(base)
-      base.extend ClassMethods
-    end
-    
-    module ClassMethods
-      attr_accessor :finishing_keywords
-      
-      def converser(with)
-        scoped.where("with = ?", with)
-      end
-      
-      def in_progress
-        scoped.where("state != ? OR state IS NULL", "finished")
-      end
-      
-      def recent(time = nil)
-        time ||= 24.hours.ago
-        scoped.where("updated_at > ?", time)
-      end
-
-      def with(with)
-        scoped.converser(with).in_progress.recent
-      end
-
-      # Finds an existing conversation with using the defaults or 
-      # creates a new conversation and returns the specific conversation based
-      # on the conversation topic.
-      # Example:
-      # 
-      # <tt>
-      #   Class Conversation < ActiveRecord::Base
-      #     include Conversational::Conversation
-      #   end
-      # 
-      #   Class HelloConversation < Conversation
-      #   end
-      #
-      #   Class GoodbyeConversation < Conversation
-      #   end
-      #
-      #   Conversation.create!("someone", "hello")
-      #   existing_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "goodbye"
-      #   ) => #<HelloConversation topic: "hello", with: "someone">
-      # 
-      #   Conversation.exclude HelloConversation
-      #
-      #   existing_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "goodbye"
-      #   ) => #<HelloConversation topic: "hello", with: "someone">
-      #
-      #   existing_conversation.destroy
-      # 
-      #   non_existing_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "goodbye"
-      #   ) => #<GoodbyeConversation topic: "goodbye", with: "someone">
-      #  
-      #   non_existing_conversation.destroy
-      #
-      #   Conversation.exclude GoodbyeConversation
-      #
-      #   non_existing_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "goodbye"
-      #   ) => BOOM! (Raises Error)
-      #
-      #   unknown_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "cheese"
-      #   ) => BOOM! (Raises Error)
-      #
-      #   Conversation.unknown_topic_subclass = HelloConversation
-      #
-      #   unknown_conversation = Conversation.find_or_create_with(
-      #     "someone",
-      #     "cheese"
-      #   ) => #<HelloConversation topic: "hello", with: "someone">
-      #
-      #   unknown_conversation.destroy
-      #
-      #   blank_conversation = Conversation.find_or_create_with(
-      #     "someone"
-      #   ) => BOOM! (Raises Error)
-      #
-      #   Conversation.blank_topic_subclass = GoodbyeConversation
-      #
-      #   blank_conversation = Conversation.find_or_create_with(
-      #     "someone"
-      #   ) => #<GoodbyeConversation topic: "goodbye", with: "someone">
-      #
-      # </tt>
-      def find_or_create_with(with, topic)
-        if default_find = self.with(with).last
-          default_find.details(:include_all => true)
-        else
-          subclass = ConversationDefinition.find_subclass_by_topic(topic)
-          if subclass.nil?
-            if topic && !topic.blank?
-              subclass_name = ConversationDefinition.topic_subclass_name(topic)
-              raise(
-                 ArgumentError,
-                "You have either not defined #{subclass_name} it does not subclass #{self.to_s}, or it has been excluded. You can either define #{subclass_name} as a subclass of #{self.to_s} or define an unknown_topic_subclass for #{self.to_s}"
-              )
-            else
-              raise(
-                 ArgumentError,
-                "You have not defined a blank_topic_subclass for #{self.to_s} so conversations without a topic are not allowed."
-              )
-            end
-          end
-          subclass.create!(:with => with, :topic => topic)
-        end
-      end
-    end
-  end
-end

data/lib/conversational/conversation_definition.rb

@@ -1,98 +0,0 @@
-module Conversational
-  class ConversationDefinition
-    cattr_accessor :unknown_topic_subclass
-    cattr_accessor :blank_topic_subclass
-    cattr_accessor :notification
-    cattr_writer   :klass
-
-    def self.exclude(classes)
-      if classes
-        if classes.is_a?(Array)
-          classes.each do |class_name|
-            check_exclude_options!(class_name)
-          end
-        else
-          check_exclude_options!(classes)
-        end
-      end
-      @@excluded_classes = classes
-    end
-
-    def self.find_subclass_by_topic(topic, options = {})
-      subclass = nil
-      if topic.nil? || topic.blank?
-        unless options[:exclude_blank_unknown]
-          subclass = blank_topic_subclass if blank_topic_subclass
-        end
-      else
-        project_class_name = self.topic_subclass_name(topic)
-        begin
-          project_class = project_class_name.constantize
-        rescue
-          project_class = nil
-        end
-        # the subclass has been defined
-        # check that it is a subclass klass
-        if project_class && project_class <= @@klass &&
-          (options[:include_all] || !self.exclude?(project_class))
-            subclass = project_class
-        else
-          unless options[:exclude_blank_unknown]
-            subclass = unknown_topic_subclass if unknown_topic_subclass
-          end
-        end
-      end
-      subclass
-    end
-
-    def self.topic_defined?(topic)
-      self.find_subclass_by_topic(
-        topic,
-        :exclude_blank_unknown => true
-      )
-    end
-
-    def self.topic_subclass_name(topic)
-      topic.classify + @@klass.to_s
-    end
-
-    private
-      def self.exclude?(subclass)
-        if defined?(@@excluded_classes)
-          if @@excluded_classes.is_a?(Array)
-            @@excluded_classes.each do |excluded_class|
-              break if exclude_class?(subclass)
-            end
-          else
-            exclude_class?(subclass)
-          end
-        end
-      end
-
-      def self.exclude_class?(subclass)
-        if @@excluded_classes.is_a?(Class)
-          @@excluded_classes == subclass
-        elsif @@excluded_classes.is_a?(Regexp)
-          subclass.to_s =~ @@excluded_classes
-        else
-          excluded_class = @@excluded_classes.to_s
-          begin
-            excluded_class.classify.constantize == subclass
-          rescue
-            false
-          end
-        end
-      end
-
-      def self.check_exclude_options!(classes)
-        raise(
-          ArgumentError,
-          "You must specify an Array, Symbol, Regex, String or Class or nil. You specified a #{classes.class}"
-        ) unless classes.is_a?(Symbol) ||
-            classes.is_a?(Regexp) ||
-            classes.is_a?(String) ||
-            classes.is_a?(Class)
-      end
-  end
-end
-

data/lib/generators/conversational/migration/USAGE

@@ -1,5 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

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

data/spec/active_record_additions_spec.rb

@@ -1,120 +0,0 @@
-# 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

@@ -1,248 +0,0 @@
-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

data/spec/support/conversation.rb

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