mithril 0.2.0

data/spec/mithril/controllers/proxy_controller_helper.rb

@@ -0,0 +1,111 @@
+# spec/mithril/controllers/proxy_controller_helper.rb
+
+require 'mithril/controllers/abstract_controller_helper'
+
+require 'mithril/controllers/abstract_controller'
+require 'mithril/controllers/proxy_controller'
+
+shared_examples_for Mithril::Controllers::ProxyController do
+  it_behaves_like Mithril::Controllers::AbstractController
+  
+  let :proxy do described_class; end
+  let :child do Class.new Mithril::Controllers::AbstractController; end
+  let :proxy_instance do proxy.new request; end
+  let :child_instance do child.new request; end
+  let :proxy_action do FactoryGirl.generate :action_key; end
+  let :child_action do FactoryGirl.generate :action_key; end
+  let :proxy_command do proxy_action.to_s.gsub('_', ' '); end
+  let :child_command do child_action.to_s.gsub('_', ' '); end
+  
+  before :each do
+    proxy.define_action proxy_action do |session, arguments|; "proxy command"; end
+    child.define_action child_action do |session, arguments|; "child command"; end
+  end # before each
+  
+  let :session   do {}; end
+  let :arguments do []; end
+  
+  specify { expect(proxy_instance).to have_action proxy_action }
+  specify { expect(child_instance).to have_action child_action }
+  specify { expect(proxy_instance).not_to have_action child_action }
+  
+  describe :allow_own_actions_while_proxied? do
+    specify { expect(proxy_instance).to respond_to(:allow_own_actions_while_proxied?).
+      with(0).arguments }
+  end # describe
+  
+  describe :proxy do
+    specify { expect(proxy_instance).to respond_to(:proxy).with(0).arguments }
+    specify { expect(proxy_instance.proxy).to be_a [Mithril::Controllers::AbstractController, nil] }
+  end # describe proxy
+  
+  describe :commands do
+    specify { expect(proxy_instance.commands).to include proxy_command }
+    specify { expect(proxy_instance.commands).not_to include child_command }
+  end # describe
+  
+  describe :has_command? do
+    specify { expect(proxy_instance).to have_command proxy_command }
+    specify { expect(proxy_instance).not_to have_command child_command }
+  end # describe
+  
+  describe :can_invoke? do
+    specify { expect(proxy_instance.can_invoke? proxy_command).to be true }
+    specify { expect(proxy_instance.can_invoke? child_command).to be false }
+  end # describe
+  
+  describe :can_invoke_on_self? do
+    specify { expect(proxy_instance).to respond_to(:can_invoke_on_self?).
+      with(1).arguments }
+    specify { expect(proxy_instance.can_invoke_on_self? proxy_command).to be true }
+    specify { expect(proxy_instance.can_invoke_on_self? child_command).to be false }
+  end # describe
+  
+  describe :invoke_command do
+    specify { expect(proxy_instance.invoke_command proxy_command).to eq "proxy command" }
+  end # describe
+  
+  context "with a proxy subject defined" do
+    before :each do proxy_instance.stub :proxy do child_instance; end; end
+    
+    specify { expect(proxy_instance.proxy).to be child_instance }
+    
+    specify { expect(proxy_instance.commands).to include child_command }
+    
+    specify { expect(proxy_instance).to have_command child_command }
+    
+    specify { expect(proxy_instance.can_invoke? child_command).to be true }
+    
+    specify { expect(proxy_instance.can_invoke_on_self? child_command).to be false }
+    
+    specify { expect(proxy_instance.invoke_command child_command).to eq "child command" }
+    
+    context "allowing own actions" do
+      before :each do proxy_instance.stub :allow_own_actions_while_proxied? do true; end; end
+      
+      specify { expect(proxy_instance.allow_own_actions_while_proxied?).to be true }
+      
+      specify { expect(proxy_instance.commands).to include proxy_command }
+
+      specify { expect(proxy_instance).to have_command proxy_command }
+
+      specify { expect(proxy_instance.can_invoke? proxy_command).to be true }
+
+      specify { expect(proxy_instance.invoke_command proxy_command).to eq "proxy command" }
+    end # context
+
+    context "allowing own actions" do
+      before :each do proxy_instance.stub :allow_own_actions_while_proxied? do false; end; end
+
+      specify { expect(proxy_instance.allow_own_actions_while_proxied?).to be false }
+
+      specify { expect(proxy_instance.commands).not_to include proxy_command }
+
+      specify { expect(proxy_instance).not_to have_command proxy_command }
+
+      specify { expect(proxy_instance.can_invoke? proxy_command).to be false }
+
+      specify { expect(proxy_instance.invoke_command proxy_command).to match /don't know how/i }
+    end # context
+  end # context
+end # shared examples

data/spec/mithril/controllers/proxy_controller_spec.rb

@@ -0,0 +1,14 @@
+# spec/mithril/controllers/proxy_controller_spec.rb
+
+require 'spec_helper'
+require 'mithril/controllers/proxy_controller_helper'
+
+require 'mithril/controllers/proxy_controller'
+
+describe Mithril::Controllers::ProxyController 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::ProxyController
+end # describe

data/spec/mithril/mixin_helper.rb

@@ -0,0 +1,54 @@
+# spec/mithril/mixin_helper.rb
+
+require 'mithril/mixin'
+
+shared_examples_for Mithril::Mixin do
+  let :ancestor_instance_method do FactoryGirl.generate(:action_key); end
+  let :ancestor_class_method do FactoryGirl.generate(:action_key); end
+  let :ancestor_module do
+    mod = Module.new
+    mod.send :extend, Mithril::Mixin
+    mod.send :define_method, ancestor_instance_method do; end
+    mod.const_set :ClassMethods, Module.new
+    mod::ClassMethods.send :define_method, ancestor_class_method do; end
+    mod
+  end # let
+  
+  let :parent_instance_method do FactoryGirl.generate(:action_key); end
+  let :parent_class_method do FactoryGirl.generate(:action_key); end
+  let :parent_module do
+    mod = Module.new
+    mod.send :extend, Mithril::Mixin
+    mod.send :mixin, ancestor_module
+    mod.send :define_method, parent_instance_method do; end
+    mod.const_set :ClassMethods, Module.new
+    mod::ClassMethods.send :define_method, parent_class_method do; end
+    mod
+  end # let
+  
+  context "with a direct mixin" do
+    before :each do described_class.send :mixin, ancestor_module; end
+    
+    describe "instance methods are mixed in" do
+      specify { expect(instance).to respond_to ancestor_instance_method }
+    end # describe
+    
+    describe "class method are mixed in" do
+      specify { expect(described_class).to respond_to ancestor_class_method }
+    end # describe
+  end # context
+  
+  context "with a cascading mixin" do
+    before :each do described_class.send :mixin, parent_module; end
+    
+    describe "instance methods are mixed in" do
+      specify { expect(instance).to respond_to ancestor_instance_method }
+      specify { expect(instance).to respond_to parent_instance_method }
+    end # describe
+    
+    describe "class method are mixed in" do
+      specify { expect(described_class).to respond_to ancestor_class_method }
+      specify { expect(described_class).to respond_to parent_class_method }
+    end # describe
+  end # context
+end # shared examples

data/spec/mithril/mixin_spec.rb

@@ -0,0 +1,17 @@
+# spec/mithril/mixin_spec.rb
+
+require 'spec_helper'
+require 'mithril/mixin_helper'
+
+require 'mithril/mixin'
+
+describe Mithril::Mixin do
+  let :described_class do
+    klass = Class.new.extend super()
+    klass.send :mixin, ancestor_module
+    klass
+  end # let
+  let :instance do described_class.new; end
+  
+  it_behaves_like Mithril::Mixin
+end # describe

data/spec/mithril/parsers/simple_parser_spec.rb

@@ -0,0 +1,85 @@
+# spec/mithril/parsers/simple_parser_spec.rb
+
+require 'spec_helper'
+
+require 'mithril/controllers/mixins/actions_base'
+require 'mithril/parsers/simple_parser'
+
+describe Mithril::Parsers::SimpleParser do
+  let :actions_source do
+    Object.new.tap do |obj| obj.stub :has_action? do false; end; end
+  end # let
+  let :instance do described_class.new actions_source; end
+  
+  describe :initialize do
+    specify { expect(described_class).to construct.with(1).arguments }
+  end # describe
+  
+  describe :preprocess_input do
+    specify { expect(instance.respond_to? :preprocess_input, true).to be true }
+    
+    specify "downcases input" do
+      clean, dirty = "lorem ipsum", "Lorem IPSuM"
+      expect(instance.send :preprocess_input, dirty).to eq clean
+    end # specify
+    
+    specify "strips leading and trailing whitespace" do
+      clean, dirty = "lorem ipsum", "\n\tlorem ipsum    \r\r"
+      expect(instance.send :preprocess_input, dirty).to eq clean
+    end # specify
+    
+    specify "normalises internal whitespace" do
+      clean, dirty = "lorem ipsum dolor sit amet", "lorem ipsum  \rdolor\n\tsit amet"
+      expect(instance.send :preprocess_input, dirty).to eq clean
+    end # specify
+    
+    specify "converts puntuation to whitespace" do
+      clean, dirty = "lorem ipsum dolor sit amet", "lorem?-\"ipsum' :: (dolor![sit]), amet;"
+      expect(instance.send :preprocess_input, dirty).to eq clean
+    end # specify
+  end # describe
+  
+  describe :wordify do
+    specify { expect(instance.respond_to? :wordify, true).to be true }
+    
+    specify "splits input on whitespace" do
+      output = %w(second star to the right and straight on till morning)
+      expect(instance.send :wordify, output.join(" ")).to eq output
+    end # specify
+  end # describe
+  
+  describe :parse_command do
+    specify { expect(instance).to respond_to(:parse_command).
+      with(1).arguments }
+    
+    specify "preprocesses the input" do
+      instance.should_receive(:preprocess_input).with("lorem ipsum").and_call_original
+      instance.parse_command "lorem ipsum"
+    end # specify
+    
+    context "with actions stubbed" do
+      before :each do
+        actions_source.stub :has_action? do |key|
+          [:do, :do_while, :do_not, :doo_wop].include? key
+        end # stub
+      end # before :each
+      
+      specify "no matching command" do
+        command, arguments = instance.parse_command "Don't stop believing!"
+        expect(command).to be nil
+      end # specify
+      
+      specify "matching a simple command" do
+        command, arguments = instance.parse_command "Do you hear the people sing?"
+        expect(command).to be :do
+        expect(arguments).to eq %w(you hear the people sing)
+      end # specify
+      
+      specify "matching a complex command" do
+        command, arguments = instance.parse_command "Do while is a useful construct."
+        expect(command).to be :do_while
+        expect(arguments).to eq %w(is a useful construct)
+      end # specify
+    end # context
+  end # describe
+end # describe

data/spec/mithril/request_spec.rb

@@ -0,0 +1,72 @@
+# spec/mithril/request_spec.rb
+
+require 'spec_helper'
+
+require 'mithril/request'
+
+describe Mithril::Request do
+  let :described_class do super(); end
+  let :instance do described_class.new; end
+  
+  describe :constructor do
+    it { expect(described_class).to construct.with(0..1).arguments }
+    
+    context "with a session argument" do
+      let :hsh_value do { :foo => :bar }; end
+      let :instance  do described_class.new hsh_value; end
+      
+      specify { expect(instance.session).to be hsh_value }
+    end # context
+  end # describe
+  
+  describe :session do
+    specify { expect(instance).to respond_to(:session).with(0).arguments }
+    
+    specify { expect(instance.session).to be_a Hash }
+  end # describe session
+  
+  describe :session= do
+    let :hsh_value do { :foo => :bar }; end
+    
+    specify { expect(instance).to respond_to(:session=).with(1).arguments }
+    
+    specify "changes value when set" do
+      instance.session = hsh_value
+      expect(instance.session).to be hsh_value
+    end # specify
+  end # describe session=
+  
+  describe :input do
+    specify { expect(instance).to respond_to(:input).with(0).arguments }
+    
+    specify { expect(instance.input).to be nil }
+  end # describe input
+  
+  describe :input= do
+    let :str_value do "string"; end
+    
+    specify { expect(instance).to respond_to(:input=).with(1).arguments }
+    
+    specify "changes value when set" do
+      instance.input = str_value
+      expect(instance.input).to eq str_value
+    end # specify
+  end # describe
+  
+  describe :output do
+    specify { expect(instance).to respond_to(:output).with(0).arguments }
+    
+    specify { expect(instance.output).to be nil }
+  end # describe
+  
+  describe :output= do
+    let :str_value do "string"; end
+    
+    specify { expect(instance).to respond_to(:output=).with(1).arguments }
+    
+    specify "changes value when set" do
+      instance.output = str_value
+      expect(instance.output).to eq str_value
+    end # specify
+  end # describe
+end # describe

data/spec/mithril_spec.rb

@@ -0,0 +1,25 @@
+# spec/mithril_spec.rb
+
+require 'spec_helper'
+
+require 'mithril'
+
+describe Mithril do
+  describe "self.logger" do
+    specify { expect(described_class).to respond_to(:logger).with(0).arguments }
+    
+    specify "has a default value" do
+      expect(described_class.logger).to respond_to :log
+    end # specify
+  end # describe
+  
+  describe "self.logger=" do
+    specify { expect(described_class).to respond_to(:logger=).with(1).arguments }
+    
+    specify "changes value when set" do
+      logger = double("logger", :log => nil)
+      described_class.logger = logger
+      expect(described_class.logger).to be logger
+    end # specify
+  end # describe
+end # describe

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# spec/spec_helper.rb
+
+require 'rspec'
+require 'factory_girl'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end # config
+
+#=# Require Factories, Custom Matchers, &c #=#
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+module Mithril
+  module Mock; end
+end # module Mithril

data/spec/support/factories/action_factory.rb

@@ -0,0 +1,7 @@
+# spec/factories/action_factory.rb
+
+require 'factory_girl'
+
+FactoryGirl.define do
+  sequence :action_key do |index| :"action_#{index}"; end
+end # define

data/spec/support/factories/request_factory.rb

@@ -0,0 +1,11 @@
+# spec/support/factories/request_factory.rb
+
+require 'factory_girl'
+
+require 'mithril/request'
+
+FactoryGirl.define do
+  factory :request, class: Mithril::Request do
+    session { Hash.new }
+  end # factory
+end # define

data/spec/support/matchers/be_kind_of.rb

@@ -0,0 +1,23 @@
+# spec/support/matchers/be_kind_of.rb
+
+require 'rspec'
+
+module RSpec::Matchers::BuiltIn
+  class BeAKindOf < BaseMatcher
+    def match(expected, actual)
+      @actual = actual
+      self.match_type? expected
+    end # method match
+    
+    def match_type?(expected)
+      case
+      when expected.nil?
+        @actual.nil?
+      when expected.respond_to?(:each)
+        expected.reduce(false) { |memo, obj| memo || match_type?(obj) }
+      else
+        @actual.kind_of? expected
+      end # case
+    end # method match_type
+  end # class
+end # module