lita-wizard 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88dc590dd6d02e8573709bc1036263435ae94e3e
-  data.tar.gz: 1d67f3027b98a6306684bf240a18a61bc2bbc674
+  metadata.gz: ab9acf73075c026c14e907ded9fd64e07c9cdd4d
+  data.tar.gz: 134919eb9e5f687814242df8f0bc000b99ea2ca2
 SHA512:
-  metadata.gz: 3ebb360390d5e265a5ad3cab2c0e31e56c79360fc46571b1da14138d96f33270e50268e66c2b5cad30a13d9845c0370203e817223e9754dd2d7855cf9923a6fd
-  data.tar.gz: 12b092bb719569d7a7df2f63c4def931f549e4e41e77561a002053abae2dc3a12d61b471a4b3f6e0b1b9b36c8bf835e061138face5cc2dfb742d789c5aa2476a
+  metadata.gz: 640902ef6a1478b404041d1542ed22b62da9368f58883ac8a2a847c90afd2a504b972ca9648a545d3eaaac4710583a14ed701bcecbe5d0b1e7b672f46056d4d7
+  data.tar.gz: 3342bc3bc7e9f7d8e60cd67790917a9dad3c7b0a3ec01cb29cf9c63821985dab25bbd7eac0e5a5782674cd550c433a7188ae1379b7c317ae1a54b31ddf4aa624

data/lib/lita/extensions/wizard.rb

@@ -1,23 +1,59 @@
 module Lita
   module Extensions
     class Wizard
+      attr_reader :message, :route, :robot
+
       def self.call(payload)
-        message = payload[:message]
-        route = payload[:route]
-        robot = payload[:robot]
+        new(payload).call
+      end
 
-        # mark message as processed and return next time
-        return true if message.extensions[:processed_by_wizard]
+      def initialize(payload)
+        @message = payload[:message]
+        @route = payload[:route]
+        @robot = payload[:robot]
+        Lita.logger.debug "Initializing Lita::Extensions::Wizard with:\nMessage: #{message.body}\nRoute: #{route.inspect}"
+      end
+
+      def call
+        process_message if should_process_message?
+        Lita.logger.debug "Handled by wizard: #{!!message.extensions[:handled_by_wizard]}"
+        Lita.logger.debug "Dummy route: #{route.extensions[:dummy] == true}"
+        ret = compute_return_value
+        Lita.logger.debug "Returning #{ret.inspect}"
+        ret
+      end
+
+      protected
+
+      def process_message
+        Lita.logger.debug "Processing message"
         message.extensions[:processed_by_wizard] = true
+        message.extensions[:handled_by_wizard] = Lita::Wizard.handle_message(robot, message)
+        Lita.logger.debug "Message processed: #{message.extensions.inspect}"
+      end
 
-        # if private messages and user has a pending wizard handle the message
-        if message.private_message? && Lita::Wizard.pending_wizard?(message.user.id)
-          handled = Lita::Wizard.handle_message(robot, message)
-          return true if handled
-        end
+      def should_process_message?
+        !already_processed? && private_message? && user_has_pending_wizard?
+      end
+
+      def already_processed?
+        message.extensions[:processed_by_wizard]
+      end
+
+      def private_message?
+        message.private_message?
+      end
+
+      def user_has_pending_wizard?
+        Lita::Wizard.pending_wizard?(message.user.id)
+      end
 
-        # return
-        !(route.extensions[:dummy] == true)
+      def compute_return_value
+        if message.extensions[:handled_by_wizard]
+          route.extensions[:dummy] == true
+        else
+          !route.extensions[:dummy]
+        end
       end
 
       Lita.register_hook(:validate_route, self)

data/lib/lita/handlers/wizard.rb

@@ -1,10 +1,12 @@
 module Lita
   module Handlers
     class Wizard < Handler
+
       route(/.*/, nil, dummy: true) do |response|
       end
 
       Lita.register_handler(self)
+
     end
   end
 end

data/lib/lita/wizard.rb

@@ -165,9 +165,11 @@ class Lita::Wizard
       wizard = restore(robot, message)
       if wizard
         wizard.handle_message
-        return true
+        true
+      else
+        cancel_wizard(message.user.id)
+        false
       end
-      false
     end
 
     def restore(robot, message)

data/lita-wizard.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-wizard"
-  spec.version       = "1.0.1"
+  spec.version       = "1.0.2"
   spec.authors       = ["Cristian Bica"]
   spec.email         = ["cristian.bica@gmail.com"]
   spec.description   = "A lita extension to build wizards"

data/spec/lita/extensions/wizard_spec.rb

@@ -17,48 +17,112 @@ describe Lita::Extensions::Wizard, lita: true do
       route: route
     }
   end
+  subject { described_class.new(payload) }
 
-  it "should stop if message has already been processed" do
-    message.extensions[:processed_by_wizard] = true
-    expect(message.extensions).to receive(:[]=).never
-    described_class.call(payload)
-  end
+  context "deciding if it should process the message" do
+    it "shouldn't process the message if it was already processed" do
+      allow(subject).to receive(:private_message?).and_return(true)
+      allow(subject).to receive(:user_has_pending_wizard?).and_return(true)
+      message.extensions[:processed_by_wizard] = true
+      expect(subject).to receive(:process_message).never
+      subject.call
+    end
 
-  it "should mark the message as processed" do
-    expect(message.extensions).to receive(:[]=).with(:processed_by_wizard, true)
-    described_class.call(payload)
-  end
+    it "shouldn't process the message if it's a public message" do
+      allow(subject).to receive(:already_processed?).and_return(false)
+      allow(subject).to receive(:user_has_pending_wizard?).and_return(true)
+      expect(subject).to receive(:process_message).never
+      subject.call
+    end
 
-  it "should check if the message is private" do
-    expect(message).to receive(:private_message?)
-    described_class.call(payload)
-  end
+    it "shouldn't process the message if the user doesn't have a pending wizard" do
+      allow(subject).to receive(:already_processed?).and_return(false)
+      allow(subject).to receive(:private_message?).and_return(true)
+      Lita::Wizard.cancel_wizard("42")
+      expect(subject).to receive(:process_message).never
+      subject.call
+    end
 
-  it "shouldn't check if the user has a pending message if the message is public" do
-    allow(message).to receive(:private_message?).and_return(false)
-    expect(Lita::Wizard).to receive(:pending_wizard?).never
-    described_class.call(payload)
-  end
+    it "should process the message only once" do
+      allow(subject).to receive(:private_message?).and_return(true)
+      allow(subject).to receive(:user_has_pending_wizard?).and_return(true)
+      expect(Lita::Wizard).to receive(:handle_message).once
+      subject.call
+      subject.call
+    end
 
-  it "should check if the user has a pending message" do
-    allow(message).to receive(:private_message?).and_return(true)
-    expect(Lita::Wizard).to receive(:pending_wizard?)
-    described_class.call(payload)
+    it "should process the message if not processed, private message and user has pending wizard" do
+      message.extensions.delete :processed_by_wizard
+      message.source.private_message!
+      allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
+      expect(subject).to receive(:process_message).once
+      subject.call
+    end
   end
 
-  it "try to handle the message if private message and has pending wizard" do
-    allow(message).to receive(:private_message?).and_return(true)
-    allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
-    expect(Lita::Wizard).to receive(:handle_message)
-    described_class.call(payload)
-  end
+  context "processing the message" do
+    before { allow(subject).to receive(:should_process_message?).and_return(true) }
 
-  it "should return false if dummy route matched" do
-    route.extensions[:dummy] = true
-    expect(described_class.call(payload)).to be_falsey
+    it "should mark the message as processed" do
+      allow(Lita::Wizard).to receive(:handle_message)
+      subject.call
+      expect(message.extensions[:processed_by_wizard]).to be_truthy
+    end
+
+    it "should set on the message the return value from handle_message" do
+      allow(Lita::Wizard).to receive(:handle_message).and_return("42")
+      subject.call
+      expect(message.extensions[:handled_by_wizard]).to eq("42")
+    end
   end
 
-  it "should return true if dummy route didn't match" do
-    expect(described_class.call(payload)).to be_truthy
+  context "return value" do
+    it "should return true if the message is not processable for a non dummy route" do
+      allow(subject).to receive(:should_process_message?).and_return(false)
+      expect(subject.call).to be_truthy
+    end
+
+    it "should return false if the message is not processable for a dummy route" do
+      allow(subject).to receive(:should_process_message?).and_return(false)
+      route.extensions[:dummy] = true
+      expect(subject.call).to be_falsey
+    end
+
+    it "should return false if called on a processable and handled message for a non dummy route" do
+      message.extensions.delete :processed_by_wizard
+      message.source.private_message!
+      allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
+      expect(Lita::Wizard).to receive(:handle_message).once.and_return(true)
+      expect(subject.call).to be_falsey
+      expect(subject.call).to be_falsey
+    end
+
+    it "should return true if called on a processable and handled message for a dummy route" do
+      message.extensions.delete :processed_by_wizard
+      message.source.private_message!
+      allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
+      expect(Lita::Wizard).to receive(:handle_message).once.and_return(true)
+      route.extensions[:dummy] = true
+      expect(subject.call).to be_truthy
+    end
+
+    it "should return true if the message couldn't be handled by the wizard for a non dummy route" do
+      message.extensions.delete :processed_by_wizard
+      message.source.private_message!
+      allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
+      expect(Lita::Wizard).to receive(:handle_message).once.and_return(false)
+      expect(subject.call).to be_truthy
+    end
+
+    it "should return false if the message couldn't be handled by the wizard for a dummy route" do
+      message.extensions.delete :processed_by_wizard
+      message.source.private_message!
+      allow(Lita::Wizard).to receive(:pending_wizard?).and_return(true)
+      expect(Lita::Wizard).to receive(:handle_message).once.and_return(false)
+      route.extensions[:dummy] = true
+      expect(subject.call).to be_falsey
+    end
   end
+
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-wizard
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Cristian Bica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-23 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita