MacSpec 0.3.1

data/lib/mac_spec/matcher_system/core/def_matcher.rb

@@ -0,0 +1,14 @@
+module MacSpec
+  module MatcherSystem
+    module DefMatcher
+      include MacSpec::MatcherSystem::MatcherBuilder
+      def def_matcher(matcher_name, &block)
+        Kernel.module_eval do
+          define_method matcher_name do |*args|
+            build_matcher(matcher_name, args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mac_spec/matcher_system/core/exceptions.rb

@@ -0,0 +1,7 @@
+module MacSpec
+  module MatcherSystem
+    module Exceptions
+      class UnsupportedMessageSentToMatcher < StandardError; end
+    end
+  end
+end

data/lib/mac_spec/matcher_system/core/expectation_builder.rb

@@ -0,0 +1,11 @@
+module MacSpec
+  module MatcherSystem
+    module ExpectationBuilder
+      def self.build_expectation(match, exp, obj)
+        return MacSpec::MatcherSystem::Expectations::OperatorExpectation.new(obj, match) unless exp
+
+        (exp.matches?(obj) != match) ? exp.fail!(match) : exp.pass!(match)
+      end
+    end
+  end
+end

data/lib/mac_spec/matcher_system/core/matcher_builder.rb

@@ -0,0 +1,53 @@
+module MacSpec
+  module MatcherSystem
+    module MatcherBuilder
+      def build_matcher(matcher_name=nil, args=[], &block)
+        match_block = lambda do |actual, matcher|
+          block.call(actual, matcher, args)
+        end
+        body = lambda do |klass|
+          include MacSpec.assertions_module
+          @matcher_name = matcher_name.to_s
+          def self.matcher_name
+            @matcher_name
+          end
+
+          attr_accessor :positive_msg, :negative_msg, :msgs
+          alias :positive_failure_message  :positive_msg
+          alias :positive_failure_message= :positive_msg=
+          alias :negative_failure_message  :negative_msg
+          alias :negative_failure_message= :negative_msg=
+          alias :chained_messages  :msgs
+          attr_reader :matcher_name
+          def initialize(match_block, test_case)
+            @match_block, @test_case = match_block, test_case
+            @matcher_name = self.class.matcher_name
+          end
+
+          def method_missing(id, *args, &block)
+            require 'ostruct'
+            (self.msgs ||= []) << OpenStruct.new( "name" => id, "args" => args, "block" => block ) 
+            self
+          end
+
+          def matches?(given)
+            @positive_msg ||= "Matching with '#{matcher_name}' failed, although it should match."
+            @negative_msg ||= "Matching with '#{matcher_name}' passed, although it should_not match."
+            @match_block.call(given, self)
+          end
+
+          def fail!(which)
+            @test_case.flunk(which ? failure_message : negative_failure_message)
+          end
+
+          def pass!(which)
+            @test_case.assert true
+          end
+          alias_method :failure_message, :positive_msg
+          alias_method :negative_failure_message, :negative_msg
+        end
+        Class.new(&body).new(match_block, self)
+      end
+    end
+  end
+end

data/lib/mac_spec/matcher_system/core/modals.rb

@@ -0,0 +1,36 @@
+module MacSpec
+  module MatcherSystem
+    module Modals
+      # Tests an expectation against the given object.
+      #
+      # ==== Examples
+      # 
+      #   "hello".should eql("hello")
+      #   13.should equal(13)
+      #   lambda { raise "u r doomed" }.should raise_error
+      #
+      def should(expectation = nil)
+        MacSpec::MatcherSystem::ExpectationBuilder.build_expectation(true, expectation, self)
+      end
+
+      alias :will :should
+
+      # Tests that an expectation doesn't match the given object.
+      #
+      # ==== Examples
+      # 
+      #   "hello".should_not eql("hi")
+      #   41.should_not equal(13)
+      #   lambda { "savd bai da bell" }.should_not raise_error
+      #
+      def should_not(expectation = nil)
+        MacSpec::MatcherSystem::ExpectationBuilder.build_expectation(false, expectation, self)
+      end
+
+      alias :will_not :should_not
+      alias :wont :should_not
+    end
+  end
+end
+
+Object.send(:include, MacSpec::MatcherSystem::Modals)

data/lib/mac_spec/mocking_framework.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require "mocking_framework/message_expectation"
+require "mocking_framework/mock"
+require "mocking_framework/extensions/kernel_extension"
+require "mocking_framework/extensions/object_extension"
+
+module MacSpec
+  module MockingFramework
+    # doc
+  end
+end

data/lib/mac_spec/mocking_framework/extensions/kernel_extension.rb

@@ -0,0 +1,14 @@
+module MacSpec
+  module MockingFramework
+    module KernelExtension
+      def mock(name, options={})
+        mock_options = {}
+        mock_options[:null_object] = options.delete(:null_object)
+        mock_options[:stubs] = options
+        MacSpec::MockingFramework::Mock.new(name,mock_options)
+      end
+    end
+  end
+end
+
+Kernel.send(:include, MacSpec::MockingFramework::KernelExtension)

data/lib/mac_spec/mocking_framework/extensions/object_extension.rb

@@ -0,0 +1,74 @@
+module MacSpec
+  module MockingFramework
+    module ObjectExtension
+      def should_receive(msg)
+        @__macspec__message_expectations ||= []
+        options = {
+          :receiver => self,
+          :positive => true,
+          :msg      => msg,
+          :stub     => false
+        }
+        message_expectation = MacSpec::MockingFramework::MessageExpectation.new(options)
+        @__macspec__message_expectations << message_expectation
+        return message_expectation
+        # @__macspec__mock ||= MacSpec::MockingFramework::Mock.new(self.to_s, :belongs_to => self)
+        # __macspec__proxy_service(@__macspec__mock.__add_positive_message_expectation(msg))
+      end
+
+      def should_not_receive(msg)
+        @__macspec__message_expectations ||= []
+        options = {
+          :receiver => self,
+          :positive => false,
+          :msg      => msg,
+          :stub     => false
+        }
+        message_expectation = MacSpec::MockingFramework::MessageExpectation.new(options)
+        @__macspec__message_expectations << message_expectation
+        return message_expectation
+      end
+      
+      def stub!(hash)
+        @__macspec__message_expectations ||= []
+        hash.each do |meth_to_stub, ret_val|
+          options = {
+            :receiver          => self,
+            :positive          => true,
+            :msg               => meth_to_stub,
+            :stub              => true,
+            :stub_return_value => ret_val
+          }
+          message_expectation = MacSpec::MockingFramework::MessageExpectation.new(options)
+          @__macspec__message_expectations << message_expectation
+        end
+      end
+
+      def __macspec__verify
+        begin
+          @__macspec__message_expectations && @__macspec__message_expectations.each do |me|
+            me && me.verify
+          end
+        ensure
+          __macspec__reset!
+        end
+      end
+      
+      def __macspec__reset!
+        @__macspec__message_expectations && @__macspec__message_expectations.each do |me|
+          if respond_to?(me.unique_alias) && respond_to?(me.msg)
+            (class<<self;self;end).instance_eval do 
+              undef_method me.msg
+              alias_method me.msg, me.unique_alias
+              undef_method me.unique_alias
+            end
+          else
+          end
+        end
+        @__macspec__message_expectations = nil
+      end
+    end
+  end
+end
+
+Object.send(:include, MacSpec::MockingFramework::ObjectExtension)

data/lib/mac_spec/mocking_framework/message_expectation.rb

@@ -0,0 +1,127 @@
+module MacSpec
+  module MockingFramework
+    class MessageExpectation
+      @register = []
+      attr_reader :msg, :return_value, :unique_alias
+      def initialize(options)
+        @receiver          = options[:receiver]
+        @msg               = options[:msg]
+        @positive          = options[:positive]
+        @stub              = options[:stub]
+        @stub_return_value = options[:stub_return_value]
+        
+        @unique_alias = "__macspec__alias_for_#{@msg}".to_sym
+        me = self
+        if respond_to?(@msg) && !respond_to?(@unique_alias)
+          # todo refactor to singletonclass.instance_eval
+          (class<<@receiver;self;end).send(:alias_method, @unique_alias, @msg)
+          (class<<@receiver;self;end).send(:define_method, @msg) do |*args|
+            received_args = args == [] ? nil : args
+            me.received_with_args!(received_args)
+            me.return_value_for_args(received_args)
+          end
+        elsif !respond_to?(@msg) && !respond_to?(@unique_alias)
+           (class<<@receiver;self;end).send(:define_method, me.msg) do |*args|
+             received_args = args == [] ? nil : args
+
+             me.received_with_args!(received_args)
+             me.return_value_for_args(received_args)
+           end
+        else
+          # 
+        end
+        MessageExpectation.register_for_verification(@receiver)
+        @return_value = {}
+        @received = {}
+        @args_expectation = :__macspec_anyargs
+      end
+      
+      def self.register_for_verification(obj)
+        @register << obj
+      end
+      
+      def self.register
+        @register
+      end
+      
+      def self.verify
+        begin
+          @register.uniq.each do |obj|
+            obj && obj.__macspec__verify
+          end
+        ensure
+          @register = []
+        end
+      end
+      
+      def verify
+        unless self.stub?
+          @return_value.each do |args,value|
+            args_string = (args == :__macspec_anyargs) ? "Any Args" : args.inspect
+            if (@received[args] && @positive) || (!@received[args] && !@positive)
+              MacSpec.assert(true)
+            elsif (!@received[args] && @positive)
+              received_with_args_string = if !@received.keys.include?(:__macspec_anyargs) 
+                 "not at all."
+               else
+                 @received.delete(:__macspec_anyargs)
+                 "#{@received.keys}"
+               end
+                
+              err_msg = """
+              '#{@receiver}' should have received '#{msg}' with '#{args_string}'.
+              But received it #{received_with_args_string}
+              """
+              MacSpec.flunk err_msg
+            elsif (@received[args] && !@positive)
+              err_msg = "'#{@receiver}' should *not* have received '#{msg}' with '#{args_string}'."
+              MacSpec.flunk err_msg
+            end
+          end
+        end
+        @return_value = {}
+      end
+      
+      def stub?
+        @stub
+      end
+      
+      def negative?
+        !@positive
+      end
+
+      def received_with_args!(args)
+        @received[args] = true unless args == nil
+        @received[:__macspec_anyargs] = true
+        @return_value[:__macspec_anyargs] ||= true
+      end
+
+      def return_value_for_args(args)
+        return @stub_return_value if stub?
+        args ||= :__macspec_anyargs
+        received_args = @return_value.keys
+        unless received_args.include?(args) || received_args.include?(:__macspec_anyargs)
+          args_string = args == :__macspec_anyargs ? "No Args" : args
+          err_msg = "Wrong Argument(s): '#{args_string}' For message '#{msg}'. Receiver: '#{@receiver}'"
+          MacSpec.flunk err_msg
+        end
+        @return_value[args]
+      end
+
+      def with(*args)
+        unless stub?
+          @args_expectation = args
+          @return_value[@args_expectation] = nil
+          self
+        end
+      end
+
+      def and_return(value)
+        unless stub? || negative?
+          @return_value[@args_expectation] = value
+          self
+        end
+      end
+    end
+  end
+end

data/lib/mac_spec/mocking_framework/mock.rb

@@ -0,0 +1,20 @@
+module MacSpec
+  module MockingFramework
+    class Mock
+      def initialize(name, options={})
+        (class<<self;self;end).instance_eval do
+          if options[:null_object]
+            define_method :method_missing do |name, *args, &block|
+              Mock.new(:null_object, :null_object => true)
+            end
+          end
+          options[:stubs] && options[:stubs].each do |stub_method, return_value|
+            define_method stub_method do |*args|
+              return_value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mac_spec/testing_framework.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+
+require "testing_framework/core/test_case_class_methods"
+require "testing_framework/core/kernel_extension"
+require "testing_framework/core/functions"
+
+module MacSpec
+  module TestingFramework
+    # todo doc
+  end
+end

data/lib/mac_spec/testing_framework/core/functions.rb

@@ -0,0 +1,26 @@
+module MacSpec
+  module TestingFramework
+    # == Temporary
+    # A temporary module that holds functionality
+    # that awaits to be refactored to the right place.
+    module Functions   
+
+      def self.string?(string)
+        string.is_a?(String) ? true : false
+      end
+
+      def self.determine_class_name(name) #:nodoc:
+        name.to_s.split(/\W+/).map { |s| s[0..0].upcase + s[1..-1] }.join 
+      end
+
+      def self.make_constantizeable(string)
+        return string unless self.string?(string)
+        string = string.gsub(/[^\w\s]/,"").gsub(/^[\d\s]*/,"")
+        raise ArgumentError.new(
+            "Invalid argument: #{string}. Must not be empty after removing '\W'-class chars."
+        ) if string.gsub(/\s/,"").empty?
+        string
+      end
+    end # Functions
+  end # TestingFramework
+end #MacSpec

data/lib/mac_spec/testing_framework/core/kernel_extension.rb

@@ -0,0 +1,27 @@
+
+module Kernel
+  def describe(*args, &block)
+    super_class = (Hash === args.last && (args.last[:type] || args.last[:testcase])) || MacSpec.test_case_class 
+    super_class.class_eval {extend MacSpec::TestingFramework::TestCaseClassMethods}
+    cls = Class.new(super_class)
+    cnst, desc = args
+    cnst = MacSpec::TestingFramework::Functions.make_constantizeable(cnst)
+    Object.const_set MacSpec::TestingFramework::Functions::determine_class_name(cnst.to_s + "Test"), cls
+    cls.desc = String === desc ? desc : cnst.to_s
+    if self.class.to_s == "Module"
+      orig_block = block
+      mod_context = self
+      #mods = self.ancestors.select {|m| m.class.to_s == "Module"}
+      block = lambda {include mod_context; instance_eval(&orig_block)}
+    end
+    cls.teardown_chained = lambda {MacSpec::MockingFramework::MessageExpectation.verify}
+    cls.macspec_superclass = super_class
+    cls.class_eval(&block)
+    cls.testcases.each do |testcase|
+      for test in cls.all_tests.reject {|t| testcase.own_tests.include?(t)}
+        testcase.send(:undef_method, test) if testcase.send(:method_defined?, test)
+      end
+    end
+  end
+  private :describe
+end # Kernel