mithril 0.2.0

data/lib/mithril/mixin.rb

@@ -0,0 +1,33 @@
+# lib/mithril/mixin.rb
+
+module Mithril
+  # Implements module-based inheritance of both class- and instance-level
+  # methods.
+  module Mixin
+    def mixins
+      @mixins ||= []
+    end # accessor mixins
+  
+    def mixins=(ary)
+      @mixins = ary
+    end # mutator mixins
+  
+  private
+    # Alternative to Module.extend that also provides inheritance of class-level
+    # methods defined through an (optional) ClassMethods module.
+    def mixin(source_module) # :doc:
+      include source_module
+    
+      return unless source_module.respond_to? :mixins
+    
+      self.mixins = source_module.mixins.dup || []
+      self.mixins << source_module
+    
+      self.mixins.each do |mixin|
+        if mixin.const_defined? :ClassMethods
+          extend mixin::ClassMethods
+        end # if
+      end # each
+    end # method mixin
+  end # module Mixin
+end # module

data/lib/mithril/parsers.rb

@@ -0,0 +1,7 @@
+# lib/mithril/parsers.rb
+
+require 'mithril'
+
+module Mithril
+  module Parsers; end
+end # module

data/lib/mithril/parsers/simple_parser.rb

@@ -0,0 +1,57 @@
+# lib/mithril/parsers/simple_parser.rb
+
+require 'mithril/parsers'
+
+module Mithril::Parsers
+  class SimpleParser
+    def initialize(actions)
+      @actions = actions
+    end # method initialize
+    
+    # Takes a string input and separates into words, then identifies a matching
+    # action (if any) and remaining arguments. Returns both the command and the
+    # arguments array, so usage can be as follows:
+    # 
+    # @example With a "say" command:
+    #   command, args = parse_command("say Greetings programs!")
+    #     #=> command = :say, args = ["greetings", "programs"]
+    # @example With no "hello" command:
+    #   command, args = parse_command("Hello world")
+    #     #=> command = nil, args = ["hello", "world"]
+    # 
+    # @param [String] text Expects a string composed of one or more words,
+    #   separated by whitespace or hyphens.
+    # @return [Array] A two-element array consisting of the command and an
+    #   array of the remaining text arguments (if any), or [nil, args] if no
+    #   matching action was found.
+    def parse_command(text)
+      words = wordify preprocess_input text
+      
+      key  = nil
+      args = []
+      
+      while 0 < words.count
+        key = words.join('_').intern
+        
+        return key, args if @actions.has_action? key
+        
+        args.unshift words.pop
+      end # while
+      
+      return nil, args
+    end # method parse_command
+    
+  private
+    # @!visibility public
+    def preprocess_input(text)
+      text.downcase.
+        gsub(/[\"?!\-',.:\(\)\[\]\;]/, ' ').
+        gsub(/(\s+)/, ' ').strip
+    end # method preprocess_input
+    
+    # @!visibility public
+    def wordify(text)
+      text.split(/\s+/)
+    end # method wordify
+  end # class
+end # module

data/lib/mithril/request.rb

@@ -0,0 +1,11 @@
+# lib/mithril/request.rb
+
+module Mithril
+  class Request
+    def initialize(session = {})
+      @session = session
+    end # constructor
+    
+    attr_accessor :session, :input, :output
+  end # class Request
+end # module

data/lib/mithril/version.rb

@@ -0,0 +1,5 @@
+# lib/mithril/version.rb
+
+module Mithril
+  VERSION = '0.2.0'
+end # module Mithril

data/spec/matchers/be_kind_of_spec.rb

@@ -0,0 +1,50 @@
+# spec/matchers/be_kind_of_spec.rb
+
+require 'spec_helper'
+
+describe RSpec::Matchers::BuiltIn::BeAKindOf do
+  let :custom_module do Module.new; end
+  let :custom_class do Class.new.tap { |c| c.send :include, custom_module }; end
+  let :custom_subclass do Class.new custom_class; end
+  
+  let :string do "string"; end
+  let :module_instance do Object.new.extend custom_module; end
+  let :class_instance do custom_class.new; end
+  let :subclass_instance do custom_subclass.new; end
+  
+  describe "with type" do
+    specify { expect(nil).to be_a NilClass }
+    specify { expect(nil).not_to be_a String }
+    
+    specify { expect(string).to be_a String }
+    specify { expect(string).not_to be_a custom_class }
+    
+    specify { expect(module_instance).to be_a custom_module }
+    specify { expect(module_instance).not_to be_a custom_class }
+    
+    specify { expect(class_instance).to be_a custom_module }
+    specify { expect(class_instance).to be_a custom_class }
+    specify { expect(class_instance).not_to be_a String }
+    
+    specify { expect(subclass_instance).to be_a custom_module }
+    specify { expect(subclass_instance).to be_a custom_class }
+    specify { expect(subclass_instance).to be_a custom_subclass }
+    specify { expect(subclass_instance).not_to be_a String }
+  end # describe
+  
+  describe "with nil" do
+    specify { expect(nil).to be_a nil }
+    specify { expect(string).not_to be_a nil }
+  end # describe
+  
+  describe "with array of types" do
+    specify { expect(nil).to be_a [String, nil] }
+    specify { expect(nil).not_to be_a [custom_class, String] }
+    
+    specify { expect(string).to be_a [custom_module, String, nil] }
+    specify { expect(string).not_to be_a [custom_subclass, nil] }
+    
+    specify { expect(subclass_instance).to be_a [custom_class, String] }
+    specify { expect(subclass_instance).not_to be_a [nil, String] }
+  end # describe
+end # describe

data/spec/matchers/construct_spec.rb

@@ -0,0 +1,49 @@
+# spec/matchers/construct_spec.rb
+
+require 'spec_helper'
+
+describe "construct matcher" do
+  let :class_with_no_arguments do Class.new; end
+  let :class_with_arguments do
+    Class.new do def initialize(a, b, c = nil); end; end
+  end # let
+  let :not_a_class do Object.new; end
+  
+  specify { expect(class_with_no_arguments).to construct }
+  specify { expect(class_with_arguments).to construct }
+  specify { expect(not_a_class).not_to construct }
+  
+  describe "with a fixed number of arguments" do
+    specify { expect(class_with_no_arguments).to construct.
+      with(0).arguments }
+    specify { expect(class_with_no_arguments).not_to construct.
+      with(1).arguments }
+    
+    specify { expect(class_with_arguments).not_to construct.
+      with(1).arguments }
+    specify { expect(class_with_arguments).to construct.
+      with(2).arguments }
+    specify { expect(class_with_arguments).to construct.
+      with(3).arguments }
+    specify { expect(class_with_arguments).not_to construct.
+      with(4).arguments }
+  end # describe
+  
+  describe "with a range of arguments" do
+    specify { expect(class_with_no_arguments).to construct.
+      with(0..0).arguments }
+    specify { expect(class_with_no_arguments).not_to construct.
+      with(0..1).arguments }
+    specify { expect(class_with_no_arguments).not_to construct.
+      with(1..2).arguments }
+    
+    specify { expect(class_with_arguments).not_to construct.
+      with(1..4).arguments }
+    specify { expect(class_with_arguments).not_to construct.
+      with(1..3).arguments }
+    specify { expect(class_with_arguments).not_to construct.
+      with(2..4).arguments }
+    specify { expect(class_with_arguments).to construct.
+      with(2..3).arguments }
+  end # describe
+end # describe

data/spec/matchers/respond_to_spec.rb

@@ -0,0 +1,158 @@
+# spec/matchers/respond_to_spec.rb
+
+require 'spec_helper'
+
+describe RSpec::Matchers::BuiltIn::RespondTo do
+  let :described_class do
+    Class.new do
+      def method_with_no_arguments; end
+      
+      def method_with_required_arguments(a, b, c); end
+      
+      def method_with_optional_arguments(a, b, c = nil, d = nil); end
+      
+      def method_with_variadic_arguments(a, b, c, *rest); end
+      
+      def method_with_mixed_arguments(a, b, c = nil, d = nil, *rest); end
+      
+      def method_with_yield; yield; end
+      
+      def method_with_block_argument(&block); end
+      
+      def method_with_block_and_mixed_arguments(a, b = nil, *rest, &block); end
+    end # class
+  end # let
+  let :instance do described_class.new; end
+  
+  specify { expect(instance).to respond_to :method_with_no_arguments }
+  specify { expect(instance).to respond_to :method_with_required_arguments }
+  specify { expect(instance).to respond_to :method_with_optional_arguments }
+  specify { expect(instance).to respond_to :method_with_variadic_arguments }
+  specify { expect(instance).to respond_to :method_with_yield }
+  specify { expect(instance).to respond_to :method_with_mixed_arguments }
+  specify { expect(instance).to respond_to :method_with_block_argument }
+  
+  specify { expect(instance).not_to respond_to :not_a_method }
+  
+  describe "with a fixed number of arguments" do
+    specify { expect(instance).to respond_to(:method_with_no_arguments).
+      with(0).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_no_arguments).
+      with(1).arguments }
+    
+    specify { expect(instance).not_to respond_to(:method_with_required_arguments).
+      with(2).arguments }
+    specify { expect(instance).to respond_to(:method_with_required_arguments).
+      with(3).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_required_arguments).
+      with(4).arguments }
+    
+    specify { expect(instance).not_to respond_to(:method_with_optional_arguments).
+      with(1).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(2).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(3).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(4).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_optional_arguments).
+      with(5).arguments }
+      
+    specify { expect(instance).not_to respond_to(:method_with_variadic_arguments).
+      with(2).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(3).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(4).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(9001).arguments } # IT'S OVER NINE THOUSAND!
+    
+    specify { expect(instance).not_to respond_to(:method_with_mixed_arguments).
+      with(1).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(2).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(3).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(4).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(9001).arguments } # WHAT?! NINE THOUSAND!
+  end # describe
+  
+  describe "with a range of arguments" do
+    specify { expect(instance).to respond_to(:method_with_no_arguments).
+      with(0..0).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_no_arguments).
+      with(0..1).arguments }
+    
+    specify { expect(instance).not_to respond_to(:method_with_required_arguments).
+      with(0..3).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_required_arguments).
+      with(2..3).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_required_arguments).
+      with(3..4).arguments }
+    specify { expect(instance).to respond_to(:method_with_required_arguments).
+      with(3..3).arguments }
+    
+    specify { expect(instance).not_to respond_to(:method_with_optional_arguments).
+      with(0..4).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_optional_arguments).
+      with(2..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(2..2).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(2..3).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(2..4).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(3..4).arguments }
+    specify { expect(instance).to respond_to(:method_with_optional_arguments).
+      with(4..4).arguments }
+      
+    specify { expect(instance).not_to respond_to(:method_with_variadic_arguments).
+      with(0..4).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_variadic_arguments).
+      with(2..4).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(3..4).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(5..9).arguments }
+    specify { expect(instance).to respond_to(:method_with_variadic_arguments).
+      with(3..9001).arguments } # VEGETA, WHAT DOES...NEVER MIND, JOKE'S OVER
+    
+    specify { expect(instance).not_to respond_to(:method_with_mixed_arguments).
+      with(0..5).arguments }
+    specify { expect(instance).not_to respond_to(:method_with_mixed_arguments).
+      with(1..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(2..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(3..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(4..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(5..5).arguments }
+    specify { expect(instance).to respond_to(:method_with_mixed_arguments).
+      with(2..9001).arguments } # THERE'S NO WAY THAT CAN BE RIGHT. CAN IT?!?
+  end # describe
+  
+  describe "with a block" do
+    specify { expect(instance).not_to respond_to(:method_with_no_arguments).
+      with.a_block }
+    
+    specify { expect(instance).not_to respond_to(:method_with_yield).
+      with.a_block }
+    
+    specify { expect(instance).to respond_to(:method_with_block_argument).
+      with.a_block }
+    specify { expect(instance).to respond_to(:method_with_block_argument).
+      with(0).arguments.and.a_block }
+    
+    specify { expect(instance).to respond_to(:method_with_block_and_mixed_arguments).
+      with.a_block }
+    specify { expect(instance).to respond_to(:method_with_block_and_mixed_arguments).
+      with(2..9001).arguments.and.a_block } # FINE, FINE. KILLJOYS.
+  end # describe
+end # describe

data/spec/mithril/controllers/_text_controller_helper.rb

@@ -0,0 +1,81 @@
+# spec/controllers/text_controller_helper.rb
+
+require 'mithril/controllers/abstract_controller_helper'
+
+shared_examples_for "Mithril::Controllers::_TextController" do
+  it_behaves_like Mithril::Controllers::AbstractController
+  
+  let :input do "text input"; end
+  
+  describe :parser do
+    specify { expect(instance.parser).to be_a Mithril::Parsers::SimpleParser }
+  end # describe
+
+  describe :parse_command do
+    specify { expect(instance.parse_command input).to be_a Array }
+
+    specify "returns nil" do
+      command, args = instance.parse_command input
+      expect(command).to be nil
+    end # specify
+  end # describe
+  
+  describe :command_missing do
+    specify "returns the text with a helpful message" do
+      output = instance.command_missing input
+      expect(output).to match /don't know how/
+      expect(output).to match /#{input}/
+    end # specify
+  end # describe
+  
+  describe :invoke_command do
+    specify "returns the text with a helpful message" do
+      output = instance.invoke_command input
+      expect(output).to match /don't know how/
+      expect(output).to match /#{input}/
+    end # specify
+  end # describe
+  
+  context "with actions defined" do
+    let :command   do FactoryGirl.generate :action_key; end
+    let :arguments do %w(arguments for command); end
+    
+    before :each do
+      described_class.define_action command do |session, args| args.join(' '); end
+    end # before each
+    
+    specify { expect(instance.can_invoke? command.to_s).to be true }
+    
+    describe :invoke_command do
+      let :text do "#{command} #{arguments.join(' ')}"; end
+      
+      specify "invokes matching action" do
+        instance.should_receive(:invoke_action).with(command, arguments).and_call_original
+        instance.should_receive(:"action_#{command}").with(request.session, arguments).and_call_original
+        instance.invoke_command text
+      end # specify
+      
+      specify { expect(instance.invoke_command text).to eq arguments.join(' ') }
+      
+      context "with a non-matching command" do
+        let :non_matching do FactoryGirl.generate :action_key; end
+        
+        specify { expect(instance.invoke_command non_matching.to_s).to match /don't know how/i }
+      end # context
+    end # describe
+  end # context
+  
+  describe "empty actions" do
+    def self.input
+      chars, words = [*"a".."z", *"0".."9"], [""] * 5
+      5.times do |i|
+        word = ""
+        (6 + rand(10)).times do word << chars[rand(36)]; end
+        words[i] = word
+      end # times
+      words.join " "
+    end # helper input
+    
+    it_behaves_like "Mithril::Controllers::AbstractController#empty_actions", input
+  end # describe
+end # describe