conversational 0.3.0

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

data/spec/conversation_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Conversational::Conversation do
+
+  describe "#details" do
+    let(:conversation) { Class.new }
+    before {
+      conversation.extend(Conversational::Conversation)
+      conversation.stub!(:topic).and_return("something")
+    }
+    context "a subclass for this topic exists" do
+      let(:subclass) { mock("Subclass") }
+      before {
+        Conversational::ConversationDefinition.stub!(
+          :find_subclass_by_topic
+        ).and_return(subclass)
+      }
+      it "should return the instance as a subclass" do
+        conversation.should_receive(:becomes).with(subclass)
+        conversation.details
+      end
+    end
+    context "a subclass for this topic does not exist" do
+      before {
+        Conversational::ConversationDefinition.stub!(
+          :find_subclass_by_topic
+        ).and_return(nil)
+      }
+      it "should return nil" do
+        conversation.details.should be_nil
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# This file is copied to ~/spec when you run 'ruby script/generate rspec'
+# from the project root directory.
+ENV["RAILS_ENV"] ||= 'test'
+require File.dirname(__FILE__) + "/../config/environment" unless defined?(Rails)
+require 'rspec/rails'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+Rspec.configure do |config|
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # If you'd prefer not to run each of your examples within a transaction,
+  # uncomment the following line.
+  # config.use_transactional_examples = false
+end

data/spec/support/conversation.rb

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

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: conversational
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- David Wilkie
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-01 00:00:00 +07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dwilkie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- conversational.gemspec
+- features/configure_blank_topic.feature
+- features/configure_exclusion_conversations.feature
+- features/configure_unknown_topic.feature
+- features/find_existing_conversation.feature
+- features/find_or_create_with.feature
+- features/retrieve_conversation_details.feature
+- features/step_definitions/conversation_steps.rb
+- features/step_definitions/pickle_steps.rb
+- features/support/conversation.rb
+- features/support/email_spec.rb
+- features/support/env.rb
+- features/support/mail.rb
+- features/support/paths.rb
+- features/support/pickle.rb
+- features/support/sample_conversation.rb
+- lib/conversational.rb
+- lib/conversational/active_record_additions.rb
+- lib/conversational/conversation.rb
+- lib/conversational/conversation_definition.rb
+- lib/generators/conversational/migration/USAGE
+- lib/generators/conversational/migration/migration_generator.rb
+- lib/generators/conversational/migration/templates/migration.rb
+- lib/generators/conversational/skeleton/USAGE
+- lib/generators/conversational/skeleton/skeleton_generator.rb
+- lib/generators/conversational/skeleton/templates/conversation.rb
+- spec/active_record_additions_spec.rb
+- spec/conversation_definition_spec.rb
+- spec/conversation_spec.rb
+- spec/spec_helper.rb
+- spec/support/conversation.rb
+has_rdoc: true
+homepage: http://github.com/dwilkie/conversational
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Have conversations with your users over SMS
+test_files: 
+- spec/conversation_spec.rb
+- spec/active_record_additions_spec.rb
+- spec/conversation_definition_spec.rb
+- spec/spec_helper.rb
+- spec/support/conversation.rb