conversational 0.3.2 → 0.4.0

data/lib/conversational/conversation.rb

@@ -1,122 +1,98 @@
 module Conversational
   module Conversation
-    def self.included(base)
-      base.extend ClassMethods
-      ConversationDefinition.klass = base
-      if defined?(ActiveRecord::Base) && base <= ActiveRecord::Base
-        base.send(:include, ActiveRecordAdditions)
-      else
-        base.send(:include, InstanceAttributes)
-      end
-    end
 
-    # Returns the specific sublass of conversation based from the topic
-    # Example:
-    #
-    # <tt>
-    #   Class Conversation
-    #     include Conversational::Conversation
-    #   end
-    #
-    #   Class HelloConversation < Conversation
-    #   end
-    #
-    #   Class GoodbyeConversation < Conversation
-    #   end
-    #
-    #   hello = Conversation.new("someone", "hello")
-    #   hello.details => #<HelloConversation topic: "hello", with: "someone">
-    #
-    #   unknown = Conversation.new("someone", "cheese")
-    #   unknown.details => nil
-    #
-    #   Conversation.unknown_topic_subclass = HelloConversation
-    #
-    #   unknown = Conversation.new("someone", "cheese")
-    #   unknown.details => #<HelloConversation topic: "cheese", with: "someone">
-    #
-    #   blank = Conversation.new("someone")
-    #   blank.details => nil
-    #
-    #   Conversation.blank_topic_subclass = GoodbyeConversation
-    #
-    #   blank = Conversation.new("someone")
-    #   blank.details => #<GoodbyeConversation topic: nil, with: "someone">
-    #
-    #   Conversation.exclude HelloConversation
-    #
-    #   hello = Conversation.new("someone", "hello")
-    #   hello.details => nil
-    #
-    #   hello.details(:include_all => true) => #<HelloConversation topic: "hello", with: "someone">
-    #
-    # </tt>
-    def details(options = {})
-      details_subclass = ConversationDefinition.find_subclass_by_topic(
-        topic, options
-      )
-      becomes(details_subclass) if details_subclass
-    end
+    mattr_accessor :unknown_topic_subclass,
+                   :blank_topic_subclass,
+                   :parent,
+                   :class_suffix
 
-    def topic_defined?
-      details_subclass = ConversationDefinition.topic_defined?(topic)
+    def self.included(base)
+      self.parent = base
+      base.send(:include, InstanceMethods)
+      base.send(:include, InstanceAttributes)
+      base.extend ClassMethods
     end
 
-    protected
-      # Called from a subclass to deliver the message
-      def say(message)
-        ConversationDefinition.notification.call(with, message)
-      end
-
     module InstanceAttributes
-      attr_accessor :with, :topic
+      attr_accessor :topic
 
       def initialize(options = {})
-        self.with = options[:with]
         self.topic = options[:topic]
+        super
       end
+    end
 
-      private
-        def becomes(klass)
-          klass_instance = klass.new
-          self.instance_variables.each do |instance_variable|
-            klass_instance.instance_variable_set(
-              instance_variable,
-              self.instance_variable_get(instance_variable)
+    module InstanceMethods
+      # Returns the specific sublass of conversation based from the topic
+      # Example:
+      #
+      # <tt>
+      #   Class Conversation
+      #     include Conversational::Conversation
+      #   end
+      #
+      #   Class HelloConversation < Conversation
+      #   end
+      #
+      #   Class GoodbyeConversation < Conversation
+      #   end
+      #
+      #   hello = Conversation.new("someone", "hello")
+      #   hello.details => #<HelloConversation topic: "hello", with: "someone">
+      #
+      #   unknown = Conversation.new("someone", "cheese")
+      #   unknown.details => nil
+      #
+      #   Conversation.unknown_topic_subclass = HelloConversation
+      #
+      #   unknown = Conversation.new("someone", "cheese")
+      #   unknown.details => #<HelloConversation topic: "cheese", with: "someone">
+      #
+      #   blank = Conversation.new("someone")
+      #   blank.details => nil
+      #
+      #   Conversation.blank_topic_subclass = GoodbyeConversation
+      #
+      #   blank = Conversation.new("someone")
+      #   blank.details => #<GoodbyeConversation topic: nil, with: "someone">
+      #
+      #   Conversation.exclude HelloConversation
+      #
+      #   hello = Conversation.new("someone", "hello")
+      #   hello.details => nil
+      #
+      #   hello.details(:include_all => true) => #<HelloConversation topic: "hello", with: "someone">
+      #
+      # </tt>
+      def details(options = {})
+        details_subclass = Conversational::Conversation.find_subclass_by_topic(
+          topic, options
+        )
+        if details_subclass
+          self.respond_to?(:becomes) ?
+            becomes(details_subclass) :
+            Conversational::Conversation.becomes(
+              details_subclass, self
             )
-          end
-          klass_instance
         end
-    end
-
-    module ClassMethods
-      def unknown_topic_subclass=(klass)
-        ConversationDefinition.unknown_topic_subclass = klass
       end
 
-      def unknown_topic_subclass
-        ConversationDefinition.unknown_topic_subclass
+      def topic_defined?
+        details_subclass = Conversational::Conversation.topic_defined?(topic)
       end
+    end
 
-      def blank_topic_subclass=(klass)
-        ConversationDefinition.blank_topic_subclass = klass
+    module ClassMethods
+      def unknown_topic_subclass(value)
+        Conversational::Conversation.unknown_topic_subclass = Conversational::Conversation.stringify(value)
       end
 
-      def blank_topic_subclass
-        ConversationDefinition.blank_topic_subclass
+      def blank_topic_subclass(value)
+        Conversational::Conversation.blank_topic_subclass = Conversational::Conversation.stringify(value)
       end
 
-      # Register a service for sending notifications
-      #
-      # Example:
-      #
-      # <tt>
-      #   Conversation.converse do |with, message|
-      #     OutgoingTextMessage.create!(with, message).send
-      #   end
-      # </tt>
-      def converse(&blk)
-        ConversationDefinition.notification = blk
+      def class_suffix(value)
+        Conversational::Conversation.class_suffix = Conversational::Conversation.stringify(value)
       end
 
       # Register classes which will not be treated as conversations
@@ -196,8 +172,111 @@ module Conversational
       # * Regexp: <tt>Conversation.exclude /abstract/i</tt>
 
       def exclude(classes)
-        ConversationDefinition.exclude(classes)
+        Conversational::Conversation.exclude(classes)
+      end
+    end
+
+    def self.topic_defined?(topic)
+      self.find_subclass_by_topic(
+        topic,
+        :exclude_blank_unknown => true
+      )
+    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.constantize 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 <= parent &&
+          (options[:include_all] || !self.exclude?(project_class))
+            subclass = project_class
+        else
+          unless options[:exclude_blank_unknown]
+            subclass = unknown_topic_subclass.constantize if unknown_topic_subclass
+          end
+        end
+      end
+      subclass
+    end
+
+    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.topic_subclass_name(topic)
+      topic.classify + (class_suffix || parent).to_s
+    end
+
+    private
+
+    def self.becomes(klass, from)
+      klass_instance = klass.new
+      from.instance_variables.each do |instance_variable|
+        klass_instance.instance_variable_set(
+          instance_variable,
+          from.instance_variable_get(instance_variable)
+        )
+      end
+      klass_instance
+    end
+
+    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?(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, Class, String 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
+
+    def self.stringify(value)
+      value.nil? ? value : value.to_s
     end
   end
 end

data/lib/conversational/version.rb

@@ -0,0 +1,4 @@
+module Conversational
+  VERSION = "0.4.0"
+end
+

data/lib/conversational.rb

@@ -1,4 +1,3 @@
-require 'conversational/conversation'
-require 'conversational/conversation_definition'
-require 'conversational/active_record_additions'
+require "active_support/core_ext"
+require "conversational/conversation"
 

data/spec/conversation_spec.rb

@@ -1,34 +1,202 @@
 require 'spec_helper'
 
+# TODO test .class_suffix
 describe Conversational::Conversation do
 
+  class Conversation
+    include Conversational::Conversation
+  end
+
+  class DrinkingConversation < Conversation
+  end
+
+  class SmokingConversation < Conversation
+  end
+
+  class DrivingBlahBlah < Conversation
+  end
+
+  class FlyingConversation
+  end
+
+  it "should respond to '.unknown_topic_subclass'" do
+    Conversation.should respond_to(:unknown_topic_subclass)
+  end
+
+  it "should respond to '.blank_topic_subclass'" do
+    Conversation.should respond_to(:blank_topic_subclass)
+  end
+
+  it "should respond to '.class_suffix'" do
+    Conversation.should respond_to(:class_suffix)
+  end
+
+  let!(:conversation) { Conversation.new }
+
+  before do
+    Conversation.exclude(nil)
+    Conversation.unknown_topic_subclass(nil)
+    Conversation.blank_topic_subclass(nil)
+    Conversation.class_suffix(nil)
+  end
+
+  describe ".exclude" do
+    it "should accept a string" do
+      lambda {
+        Conversation.exclude "something"
+        }.should_not raise_error
+    end
+    it "should accept a symbol" do
+      lambda {
+        Conversation.exclude :defined_conversation
+        }.should_not raise_error
+    end
+    it "should accept a regex" do
+      lambda {
+        Conversation.exclude /something/i
+        }.should_not raise_error
+    end
+    it "should accept a Class" do
+      lambda {
+        Conversation.exclude(DrinkingConversation)
+      }.should_not raise_error
+    end
+    it "should accept an Array where the elements are a Class, String, Symbol or Regexp" do
+      lambda {
+        Conversation.exclude ["Something", DrinkingConversation, /something/i, :something]
+        }.should_not raise_error
+    end
+    it "should accept nil" do
+      lambda {
+        Conversation.exclude nil
+        }.should_not raise_error
+    end
+    it "should not accept anything else" do
+      lambda {
+        Conversation.exclude({})
+        }.should raise_error(/You specified a Hash/)
+    end
+  end
+
+  describe "#topic" do
+    it "should set the topic" do
+      conversation.topic = "hello"
+      conversation.topic.should == "hello"
+    end
+  end
+
+  describe "#topic_defined?" do
+    shared_examples_for "#topic_defined? for an excluded class" do
+      it "should return nil" do
+        conversation.topic_defined?.should be_nil
+      end
+    end
+
+    context "a class with this topic is defined" do
+      before { conversation.topic = "drinking" }
+      it "should be true" do
+        conversation.topic_defined?.should be_true
+      end
+
+      context "but it is not a subclass of the module which includes Conversation" do
+        before { conversation.topic = "flying" }
+        it_should_behave_like "#topic_defined? for an excluded class"
+      end
+
+      context "but it has been excluded" do
+        context "by passing the class" do
+          before { Conversation.exclude(DrinkingConversation) }
+          it_should_behave_like "#topic_defined? for an excluded class"
+        end
+
+        context "by passing an Array of classes" do
+          before { Conversation.exclude([DrinkingConversation])}
+          it_should_behave_like "#topic_defined? for an excluded class"
+        end
+
+        context "by passing a regexp" do
+          before { Conversation.exclude(/^Drinking/) }
+          it_should_behave_like "#topic_defined? for an excluded class"
+        end
+
+        context "by passing a symbol" do
+          before { Conversation.exclude(:drinking_conversation) }
+          it_should_behave_like "#topic_defined? for an excluded class"
+        end
+
+        context "by passing a string" do
+          before { Conversation.exclude("DrinkingConversation") }
+          it_should_behave_like "#topic_defined? for an excluded class"
+        end
+      end
+    end
+
+    context "a conversation for this topic is not defined" do
+      before do
+        Conversation.unknown_topic_subclass(SmokingConversation)
+        conversation.topic = "drinking_tea"
+      end
+      it_should_behave_like "#topic_defined? for an excluded class"
+    end
+  end
+
   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)
-      }
+    shared_examples_for "#details for an excluded class" do
+      it "should return nil" do
+        conversation.details.should be_nil
+      end
+      context "when '.unknown_topic_subclass' is set" do
+        before {Conversation.unknown_topic_subclass(SmokingConversation)}
+        it "should return an instance of the unknown_topic_subclass" do
+          conversation.details.should be_a(SmokingConversation)
+        end
+      end
+    end
+
+    context "a conversation for this topic has been defined" do
+      before { conversation.topic = "drinking" }
       it "should return the instance as a subclass" do
-        conversation.should_receive(:becomes).with(subclass)
-        conversation.details
+        conversation.details.should be_a(DrinkingConversation)
+      end
+
+      context "but it is not a subclass of the module which includes Conversation" do
+        before { conversation.topic = "flying" }
+        it_should_behave_like "#details for an excluded class"
       end
+
+      context "but it has been excluded" do
+        before { Conversation.exclude(DrinkingConversation) }
+        it_should_behave_like "#details for an excluded class"
+      end
+    end
+
+    context "a conversation for this topic has not been defined" do
+      before { conversation.topic = "drinking_tea" }
+      it_should_behave_like "#details for an excluded class"
     end
-    context "a subclass for this topic does not exist" do
-      before {
-        Conversational::ConversationDefinition.stub!(
-          :find_subclass_by_topic
-        ).and_return(nil)
-      }
+
+    shared_examples_for "#details for a blank or nil topic" do
       it "should return nil" do
         conversation.details.should be_nil
       end
+
+      context "'.blank_topic_subclass' is set" do
+        before {Conversation.blank_topic_subclass(FlyingConversation)}
+        it "should return an instance of the blank_topic_subclass" do
+          conversation.details.should be_a(FlyingConversation)
+        end
+      end
+    end
+
+    context "the conversation has a blank topic" do
+      before { conversation.topic = "" }
+      it_should_behave_like "#details for a blank or nil topic"
+    end
+
+    context "the conversation has no topic" do
+      before { conversation.topic = nil }
+      it_should_behave_like "#details for a blank or nil topic"
     end
   end
 end
+

data/spec/spec_helper.rb

@@ -1,24 +1,4 @@
-# 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'
+require 'simplecov'
+SimpleCov.start
+require "conversational"
 
-# 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