mithril 0.2.0

data/spec/mithril/controllers/abstract_controller_helper.rb

@@ -0,0 +1,118 @@
+# spec/mithril/controllers/abstract_controller_helper.rb
+
+require 'mithril/controllers/mixins/actions_base_helper'
+
+require 'mithril/controllers/abstract_controller'
+
+shared_examples_for Mithril::Controllers::AbstractController do
+  it_behaves_like Mithril::Controllers::Mixins::ActionsBase
+  
+  describe :constructor do
+    specify { expect(described_class).to construct.with(1).arguments }
+    specify { expect { described_class.new request }.not_to raise_error }
+  end # describe
+  
+  describe :parser do
+    specify { expect(instance).to respond_to(:parser).with(0).arguments }
+  end # describe
+  
+  describe :parse_command do
+    let :input do Object.new; end
+    
+    specify { expect(instance).to respond_to(:parse_command).with(1).arguments }
+    specify "delegates to the parser" do
+      instance.parser.should_receive(:parse_command).with(input)
+      instance.parse_command(input)
+    end # specify
+  end # describe
+  
+  describe :command_missing do
+    let :input do Object.new; end
+    
+    specify { expect(instance).to respond_to(:command_missing).with(1).arguments }
+  end # describe
+  
+  describe :commands do
+    specify { expect(instance).to respond_to(:commands).with(0).arguments }
+    specify { expect(instance.commands).to be_a Array }
+  end # describe
+  
+  describe :has_command? do
+    specify { expect(instance).to respond_to(:has_command?).with(1).arguments }
+    specify { expect(instance).not_to have_command FactoryGirl.generate :action_key }
+  end # describe
+  
+  describe :can_invoke? do
+    specify { expect(instance).to respond_to(:can_invoke?).with(1).arguments }
+    specify { expect(instance.can_invoke? FactoryGirl.generate(:action_key).to_s).
+      to eq false }
+  end # describe
+  
+  describe :invoke_command do
+    specify { expect(instance).to respond_to(:invoke_command).with(1).arguments }
+  end # describe
+  
+  context "with actions defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do described_class.define_action command do |session, args|; end; end
+    
+    specify { expect(instance.commands).to include command.to_s.gsub('_',' ') }
+    
+    specify { expect(instance).to have_action command }
+    
+    describe "inheriting defined actions" do
+      let :descendant_class do Class.new described_class; end
+      let :instance do descendant_class.new request; end
+      
+      specify { expect(instance).to have_action command }
+    end # describe
+  end # context
+  
+  describe "empty actions" do
+    describe :allow_empty_action? do
+      specify { expect(instance).to respond_to(:allow_empty_action?).with(0).arguments }
+    end # describe
+  end # describe
+end # shared examples
+
+shared_examples_for "Mithril::Controllers::AbstractController#empty_actions" do |input|
+  let :arguments do instance.parse_command(input)[1]; end
+  
+  before :each do
+    if instance.has_action? :""
+      instance.stub :_action do |session, arguments| arguments; end
+    else
+      described_class.send :define_action, :"" do |session, arguments| arguments; end
+    end # if-else
+  end # before each
+  
+  context "disallowing empty actions" do
+    before :each do instance.stub :allow_empty_action? do false; end; end
+    
+    specify { expect(instance.allow_empty_action?).to be false }
+    
+    specify "rejects arbitrary input" do
+      expect(instance.can_invoke? input).to be false
+    end # describe
+  end # context
+  
+  context "allowing empty actions" do
+    before :each do instance.stub :allow_empty_action? do true; end; end
+    
+    specify { expect(instance.allow_empty_action?).to be true }
+    
+    specify "accepts arbitrary input" do
+      expect(instance.can_invoke? input).to be true
+    end # specify
+    
+    specify "calls invoke action on empty action" do
+      instance.should_receive(:invoke_action).with(:"", arguments).and_call_original
+      instance.invoke_command input
+    end # specify
+    
+    specify "returns the input" do
+      expect(instance.invoke_command input).to eq arguments
+    end # specify
+  end # context
+end # shared examples

data/spec/mithril/controllers/abstract_controller_spec.rb

@@ -0,0 +1,15 @@
+# spec/controllers/mithril/abstract_controller_spec.rb
+
+require 'spec_helper'
+require 'mithril/controllers/_text_controller_helper'
+
+require 'mithril/controllers/abstract_controller'
+require 'mithril/parsers/simple_parser'
+
+describe Mithril::Controllers::AbstractController do
+  let :request do FactoryGirl.build :request; end
+  let :described_class do Class.new super(); end
+  let :instance do described_class.new request; end
+  
+  it_behaves_like "Mithril::Controllers::_TextController"
+end # describe

data/spec/mithril/controllers/mixins/actions_base_helper.rb

@@ -0,0 +1,121 @@
+# spec/mithril/controllers/mixins/actions_base_helper.rb
+
+require 'mithril/controllers/mixins/actions_base'
+require 'mithril/request'
+
+shared_examples_for Mithril::Controllers::Mixins::ActionsBase do
+  let :command do FactoryGirl.generate :action_key; end
+  
+  specify { expect(instance).not_to respond_to :"action_#{command}" }
+  
+  describe "self.define_action" do
+    specify { expect(described_class).to respond_to(:define_action).
+      with(1..2).arguments.and.a_block }
+  end # describe
+  
+  describe "self.actions" do
+    specify { expect(described_class).to respond_to(:actions).with(0..1).arguments }
+    
+    specify { expect(described_class.actions).to be_a Hash }
+  end # describe
+  
+  describe :request do
+    specify { expect(instance).to respond_to(:request).with(0).arguments }
+    specify { expect(instance.request).to be_a [Mithril::Request, nil] }
+  end # describe
+  
+  describe :actions do
+    specify { expect(instance).to respond_to(:actions).with(0..1).arguments }
+    specify { expect(instance.actions).to be_a Hash }
+  end # describe
+  
+  describe :has_action? do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    specify { expect(instance).to respond_to(:has_action?).with(1..2).arguments }
+    specify { expect(instance.has_action? command).to be false }
+    specify { expect(instance.has_action? command, true).to be false }
+  end # describe
+  
+  describe :invoke_action do
+    specify { expect(instance).to respond_to(:invoke_action).with(2..3).arguments }
+  end # describe
+  
+  context "with an action defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do
+      described_class.define_action command do |session, arguments| arguments.join(" "); end
+    end # before each
+    
+    specify { expect(described_class.actions).to have_key command }
+    specify { expect(described_class.actions true).to have_key command }
+    
+    specify { expect(instance.actions).to have_key command }
+    specify { expect(instance.actions true).to have_key command }
+    
+    specify { expect(instance).to have_action command }
+    specify { expect(instance).to have_action command, true }
+    
+    describe :invoke_action do
+      let :request do defined?(super) ? super() : FactoryGirl.build(:request); end
+      let :arguments do %w(some args); end
+      let :output do arguments.join(" "); end
+      
+      before :each do instance.stub :request do request; end; end
+      
+      specify "calls the defined method" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments
+      end # specify
+      
+      specify "calls the defined method as private" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments, true
+      end # specify
+      
+      specify { instance.invoke_action(command, arguments).should eq output }
+      specify { instance.invoke_action(command, arguments, true).should eq output }
+    end # describe
+  end # context
+  
+  describe "with a private action defined" do
+    let :command do FactoryGirl.generate :action_key; end
+    
+    before :each do
+      described_class.define_action command, :private => true do |session, arguments|
+        arguments.join(" ")
+      end # define action
+    end # before each
+    
+    specify { expect(described_class.actions).not_to have_key command }
+    specify { expect(described_class.actions true).to have_key command }
+    
+    specify { expect(instance.actions).not_to have_key command }
+    specify { expect(instance.actions true).to have_key command }
+    
+    specify { expect(instance).not_to have_action command }
+    specify { expect(instance).to have_action command, true }
+    
+    describe :invoke_action do
+      let :request do defined?(super) ? super() : FactoryGirl.build(:request); end
+      let :arguments do %w(some args); end
+      let :output do arguments.join(" "); end
+      
+      before :each do instance.stub :request do request; end; end
+      
+      specify "calls the defined method" do
+        instance.should_not_receive(:"action_#{command}")
+        instance.invoke_action command, arguments
+      end # specify
+      
+      specify "calls the defined method as private" do
+        instance.should_receive(:"action_#{command}").with(request.session, arguments)
+        instance.invoke_action command, arguments, true
+      end # specify
+      
+      specify { instance.invoke_action(command, arguments).should be nil }
+      specify { instance.invoke_action(command, arguments, true).should eq output }
+    end # describe
+  end # describe
+end # shared_examples

data/spec/mithril/controllers/mixins/actions_base_spec.rb

@@ -0,0 +1,18 @@
+# spec/mithril/controllers/mixins/actions_base_spec.rb
+
+require 'spec_helper'
+require 'mithril/controllers/mixins/actions_base_helper'
+
+require 'mithril/controllers/mixins/actions_base'
+require 'mithril/controllers/mixins/mixin_with_actions'
+
+describe Mithril::Controllers::Mixins::ActionsBase do
+  let :described_class do
+    klass = Class.new.extend Mithril::Controllers::Mixins::MixinWithActions
+    klass.send :mixin, super()
+    klass
+  end # let
+  let :instance do described_class.new; end
+  
+  it_behaves_like Mithril::Controllers::Mixins::ActionsBase
+end # describe

data/spec/mithril/controllers/mixins/help_actions_helper.rb

@@ -0,0 +1,111 @@
+# spec/mithril/controllers/mixins/help_actions_helper.rb
+
+require 'mithril/controllers/mixins/actions_base_helper'
+
+require 'mithril/controllers/mixins/help_actions'
+
+shared_examples_for Mithril::Controllers::Mixins::HelpActions do
+  it_behaves_like Mithril::Controllers::Mixins::ActionsBase
+  
+  describe :help_message do
+    specify { expect(instance).to respond_to(:help_message).with(0).arguments }
+    specify { expect(instance.help_message).to be_a String }
+  end # describe
+  
+  describe "help action" do
+    specify { expect(instance).to have_action :help }
+    
+    context "with a help string defined" do
+      let :arguments do %w(); end
+      
+      before :each do
+        instance.stub :help_message do
+          "You put your left foot in, you take your left foot out."
+        end # stub
+      end # before each
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /put your left foot in/i }
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /following commands are available/i }
+    end # context
+    
+    describe "with no arguments" do
+      let :arguments do %w(); end
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /following commands are available/i }
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /help/i }
+    end # context
+    
+    describe "with help" do
+      let :arguments do %w(help); end
+      
+      specify { expect(instance.invoke_action :help, arguments).
+        to match /the help command/i }
+    end # describe
+  end # describe
+  
+  context "with additional actions defined" do
+    let :action_keys do
+      [].tap do |ary|
+        1.times do ary << FactoryGirl.generate(:action_key); end
+      end # tap
+    end # let
+    
+    before :each do
+      action_keys.each do |key|
+        described_class.send :define_action, key do |session, arguments|; end
+      end # each
+    end # before each
+    
+    describe "help action" do
+      specify "lists available commands" do
+        (action_keys << :help).each do |key|
+          command = key.to_s.gsub('_',' ')
+          expect(instance.invoke_action :help, %w()).to match /#{command}/
+        end # each
+      end # specify
+      
+      specify "invokes the command with help" do
+        session = instance.request ? (instance.request.session || {}) : {}
+        action_keys.each do |key|
+          command = key.to_s.gsub('_',' ')
+          instance.should_receive(:"action_#{key}").with(session, %w(help))
+          instance.invoke_action :help, command.split(' ')
+        end # each
+      end # specify
+    end # describe
+  end # context
+  
+  context "with additional commands defined" do
+    let :commands do
+      [].tap do |ary|
+        1.times do ary << FactoryGirl.generate(:action_key).to_s.gsub('_', ' '); end
+      end # tap
+    end # let
+    
+    before :each do
+      instance.stub :commands do commands; end
+      instance.stub :has_command? do |command| commands.include? command; end
+    end # before each
+    
+    describe "help action" do
+      specify "lists available commands" do
+        (commands << "help").each do |command|
+          expect(instance.invoke_action :help, %w()).to match /#{command}/
+        end # each
+      end # specify
+      
+      specify "invokes the command with help" do
+        session = instance.request ? (instance.request.session || {}) : {}
+        commands.each do |command|
+          instance.should_receive(:invoke_command).with("#{command} help")
+          instance.invoke_action :help, [command]
+        end # each
+      end # specify
+    end # describe
+  end # context
+end # shared examples

data/spec/mithril/controllers/mixins/help_actions_spec.rb

@@ -0,0 +1,19 @@
+# spec/mithril/controllers/mixins/help_actions_spec.rb
+
+require 'spec_helper'
+require 'mithril/controllers/mixins/help_actions_helper'
+
+require 'mithril/controllers/mixins/help_actions'
+require 'mithril/controllers/mixins/mixin_with_actions'
+
+describe Mithril::Controllers::Mixins::HelpActions do
+  let :described_class do
+    klass = Class.new
+    klass.send :extend, Mithril::Controllers::Mixins::MixinWithActions
+    klass.send :mixin, super();
+    klass
+  end # let
+  let :instance do described_class.new; end
+  
+  it_behaves_like Mithril::Controllers::Mixins::HelpActions
+end # describe

data/spec/mithril/controllers/mixins/mixin_with_actions_spec.rb

@@ -0,0 +1,44 @@
+# spec/mithril/controllers/mixins/action_mixin_spec.rb
+
+require 'spec_helper'
+require 'mithril/mixin_helper'
+
+require 'mithril/controllers/mixins/mixin_with_actions'
+
+describe Mithril::Controllers::Mixins::MixinWithActions do
+  let :described_class do
+    klass = Class.new.extend super()
+    klass.instance_eval do def actions; @actions; end; end
+    klass.send :mixin, ancestor_module
+    klass
+  end # let
+  let :instance do described_class.new; end
+  
+  it_behaves_like Mithril::Mixin
+  
+  let :ancestor_actions do
+    hsh = {}
+    5.times do hsh[FactoryGirl.generate(:action_key)] = true; end
+    hsh
+  end # let
+  let :ancestor_module do
+    mod = Module.new
+    mod.send :extend, Mithril::Controllers::Mixins::MixinWithActions
+    mod.instance_eval do def actions; @actions; end; end
+    mod.instance_variable_set :@actions, ancestor_actions
+    mod
+  end # let
+  
+  context "with a direct mixin" do
+    before :each do
+      described_class.send :mixin, ancestor_module
+      described_class.instance_eval do def actions; @actions; end; end
+    end # before each
+    
+    specify "actions are inherited" do
+      ancestor_actions.each_key do |action|
+        expect(described_class.actions).to have_key action
+      end # each
+    end # specify
+  end # context
+end # describe