bogus 0.0.1

data/lib/bogus/double.rb

@@ -0,0 +1,10 @@
+class Bogus::Double < BasicObject
+  extend ::Bogus::Takes
+  takes :object, :double, :verifies_stub_definition, :records_double_interactions
+
+  def method_missing(name, *args, &block)
+    @verifies_stub_definition.verify!(@object, name, args)
+    @records_double_interactions.record(@object, name, args, &block)
+    @double.__send__(name, *args, &block)
+  end
+end

data/lib/bogus/fake.rb

@@ -0,0 +1,33 @@
+module Bogus
+  class Fake
+    include RecordInteractions
+    extend RecordInteractions
+
+    def initialize(*args)
+    end
+
+    def to_s
+      "#<#{self.class}:0x#{object_id.to_s(16)}>"
+    end
+
+    def kind_of?(klass)
+      klass == self.class.__copied_class__
+    end
+
+    def instance_of?(klass)
+      klass == self.class.__copied_class__
+    end
+
+    class << self
+      attr_accessor :__copied_class__
+
+      def name
+        __copied_class__.name
+      end
+
+      def to_s
+        name
+      end
+    end
+  end
+end

data/lib/bogus/fake_registry.rb

@@ -0,0 +1,13 @@
+class Bogus::FakeRegistry
+  def initialize
+    @registry = {}
+  end
+
+  def store(name, object)
+    @registry[object.object_id] = name
+  end
+
+  def name(object)
+    @registry[object.object_id]
+  end
+end

data/lib/bogus/injector.rb

@@ -0,0 +1,64 @@
+module Bogus
+  class Injector
+    include Dependor::AutoInject
+    look_in_modules Bogus
+
+    def configuration
+      @configuration ||= Bogus::Configuration.new
+    end
+
+    def search_modules
+      configuration.search_modules
+    end
+
+    def rr_proxy
+      Bogus::RRProxy
+    end
+
+    def fake_registry
+      @fake_registry ||= inject(Bogus::FakeRegistry)
+    end
+
+    def creates_fakes
+      creates_fakes = inject(Bogus::CreatesFakes)
+      inject(Bogus::RegistersCreatedFakes, creates_fakes: creates_fakes)
+    end
+
+    def create_stub(object)
+      stub = rr_proxy.stub(object)
+      inject(Bogus::Double, object: object, double: stub)
+    end
+
+    def create_mock(object)
+      mock = rr_proxy.mock(object)
+      inject(Bogus::Double, object: object, double: mock)
+    end
+
+    def invocation_matcher(method = nil)
+      inject(Bogus::InvocationMatcher, method: method)
+    end
+
+    def interactions_repository
+      raise "Specify either real_interactions or stubbed_interactions"
+    end
+
+    def real_interactions
+      @real_interactions ||= inject(Bogus::InteractionsRepository)
+    end
+
+    def doubled_interactions
+      @doubled_interactions ||= inject(Bogus::InteractionsRepository)
+    end
+
+    def create_proxy_class(fake_name, klass)
+      inject(Bogus::ProxyClass, fake_name: fake_name, klass: klass)
+    end
+
+    def create_recording_proxy(instance, fake_name)
+      inject(Bogus::RecordingProxy,
+        instance: instance,
+        fake_name: fake_name,
+        interactions_repository: real_interactions)
+    end
+  end
+end

data/lib/bogus/interaction.rb

@@ -0,0 +1,24 @@
+class Bogus::Interaction < Struct.new(:method, :args, :return_value, :error, :has_result)
+  def initialize(method, args, &block)
+    self.method = method
+    self.args = args
+
+    if block_given?
+      evaluate_return_value(block)
+      self.has_result = true
+    end
+  end
+
+  def ==(other)
+    return super(other) if has_result && other.has_result
+    method == other.method && args == other.args
+  end
+
+  private
+
+  def evaluate_return_value(block)
+    self.return_value = block.call
+  rescue => e
+    self.error = e.class
+  end
+end

data/lib/bogus/interaction_presenter.rb

@@ -0,0 +1,29 @@
+module Bogus
+  class InteractionPresenter
+    extend Bogus::Takes
+
+    takes :interaction
+
+    def to_s
+      "##{interaction.method}(#{args})#{result}"
+    end
+
+    private
+
+    def args
+      interaction.args.map(&:inspect).join(', ')
+    end
+
+    def result
+      error || return_value
+    end
+
+    def return_value
+      " => #{interaction.return_value.inspect}" if interaction.has_result
+    end
+
+    def error
+      " !! #{interaction.error}" if interaction.error
+    end
+  end
+end

data/lib/bogus/interactions_repository.rb

@@ -0,0 +1,19 @@
+module Bogus
+  class InteractionsRepository
+    def initialize
+      @interactions = Hash.new { |hash, fake_name| hash[fake_name] = [] }
+    end
+
+    def record(fake_name, method, *args, &block)
+      @interactions[fake_name] << Interaction.new(method, args, &block)
+    end
+
+    def recorded?(fake_name, interaction)
+      @interactions[fake_name].include?(interaction)
+    end
+
+    def for_fake(fake_name)
+      @interactions[fake_name]
+    end
+  end
+end

data/lib/bogus/invocation_matcher.rb

@@ -0,0 +1,27 @@
+require 'rr'
+
+module Bogus
+  class InvocationMatcher < RR::Adapters::Rspec::InvocationMatcher
+    def initialize(method, verifies_stub_definition, records_double_interactions)
+      super(method)
+      @verifies_stub_definition = verifies_stub_definition
+      @records_double_interactions = records_double_interactions
+      @stubbed_method_calls = []
+    end
+
+    def matches?(subject)
+      @stubbed_method_calls.each do |name, args|
+        @verifies_stub_definition.verify!(subject, name, args)
+        @records_double_interactions.record(subject, name, args)
+      end
+
+      return super(subject.__inner_object__) if subject.respond_to?(:__inner_object__)
+      return super(subject)
+    end
+
+    def method_missing(name, *args, &block)
+      @stubbed_method_calls << [name, args]
+      super
+    end
+  end
+end

data/lib/bogus/method_stringifier.rb

@@ -0,0 +1,31 @@
+module Bogus
+  class MethodStringifier
+
+    def stringify(method, body)
+      <<-RUBY
+      def #{method.name}(#{arguments_as_string(method.parameters)})
+        #{body}
+      end
+      RUBY
+    end
+
+    def arguments_as_string(arguments)
+      arguments.map{|type, name| argument_to_string(name, type) }.compact.join(', ')
+    end
+
+    def argument_to_string(name, type)
+      if type == :req
+        name
+      elsif type == :rest
+        "*#{name}"
+      elsif type == :block
+        "&#{name}"
+      elsif type == :opt
+        "#{name} = {}"
+      else
+        raise "unknown argument type: #{type}"
+      end
+    end
+
+  end
+end

data/lib/bogus/overwrites_classes.rb

@@ -0,0 +1,9 @@
+class Bogus::OverwritesClasses
+  def overwrite(klass, new_klass)
+    modules = klass.name.split('::')
+    klass_name = modules.pop
+    parent_module = modules.reduce(Object) { |mod, name| mod.const_get(name) }
+    parent_module.send(:remove_const, klass_name)
+    parent_module.const_set(klass_name, new_klass)
+  end
+end

data/lib/bogus/proxy_class.rb

@@ -0,0 +1,22 @@
+class Bogus::ProxyClass
+  def initialize(fake_name, klass, create_recording_proxy)
+    @fake_name = fake_name
+    @klass = klass
+    @create_recording_proxy = create_recording_proxy
+
+    @recording_proxy = @create_recording_proxy.call(@klass, @fake_name)
+  end
+
+  def new(*args, &block)
+    instance = @klass.new(*args, &block)
+    @create_recording_proxy.call(instance, @fake_name)
+  end
+
+  def method_missing(name, *args, &block)
+    @recording_proxy.__send__(name, *args, &block)
+  end
+
+  def respond_to?(name)
+    @recording_proxy.respond_to?(name)
+  end
+end

data/lib/bogus/public_methods.rb

@@ -0,0 +1,46 @@
+module Bogus
+  module PublicMethods
+
+    def fake_for(*args, &block)
+      inject.creates_fakes.create(*args, &block)
+    end
+
+    def record_calls_for(name)
+      inject.adds_recording.add(name)
+    end
+
+    def verify_contract!(fake_name)
+      inject.verifies_contracts.verify(fake_name)
+    end
+
+    def configure(&block)
+      config.tap(&block)
+    end
+
+    def config
+      inject.configuration
+    end
+
+    def reset!
+      @injector = Bogus::Injector.new
+    end
+
+    def create_stub(object)
+      inject.create_stub(object)
+    end
+
+    def create_mock(object)
+      inject.create_mock(object)
+    end
+
+    def have_received(method = nil)
+      inject.invocation_matcher(method)
+    end
+
+    private
+
+    def inject
+      @injector ||= Bogus::Injector.new
+    end
+  end
+end

data/lib/bogus/record_interactions.rb

@@ -0,0 +1,17 @@
+module Bogus
+  module RecordInteractions
+    def __inner_object__
+      @__inner_object__ ||= Object.new
+    end
+
+    def __stub__
+      @__stub__ ||= RRProxy.stub(__inner_object__)
+    end
+
+    def __record__(method, *args, &block)
+      __stub__.__send__(method, *args)
+      __inner_object__.__send__(method, *args, &block)
+      self
+    end
+  end
+end

data/lib/bogus/recording_proxy.rb

@@ -0,0 +1,18 @@
+class Bogus::RecordingProxy < BasicObject
+  extend ::Bogus::Takes
+  takes :instance, :fake_name, :interactions_repository
+
+  def method_missing(name, *args, &block)
+    returned_value = @instance.__send__(name, *args, &block)
+    @interactions_repository.record(@fake_name, name, *args) { returned_value }
+    returned_value
+  rescue => e
+    @interactions_repository.record(@fake_name, name, *args) { ::Kernel.raise(e) }
+    ::Kernel.raise
+  end
+
+  def respond_to?(name)
+    @instance.respond_to?(name)
+  end
+end
+

data/lib/bogus/records_double_interactions.rb

@@ -0,0 +1,11 @@
+class Bogus::RecordsDoubleInteractions
+  extend Bogus::Takes
+
+  takes :doubled_interactions, :fake_registry
+
+  def record(object, method_name, args, &block)
+    fake_name = fake_registry.name(object)
+    doubled_interactions.record(fake_name, method_name, *args, &block) if fake_name
+  end
+
+end

data/lib/bogus/registers_created_fakes.rb

@@ -0,0 +1,11 @@
+class Bogus::RegistersCreatedFakes
+  extend Bogus::Takes
+
+  takes :creates_fakes, :fake_registry
+
+  def create(name, opts = {}, &block)
+    fake = creates_fakes.create(name, opts, &block)
+    fake_registry.store(name, fake)
+    fake
+  end
+end

data/lib/bogus/rr_proxy.rb

@@ -0,0 +1,5 @@
+require 'rr'
+
+class Bogus::RRProxy
+  extend RR::Adapters::RRMethods
+end

data/lib/bogus/rspec.rb

@@ -0,0 +1,4 @@
+RSpec.configure do |config|
+  config.extend Bogus::RSpecExtensions
+  config.include Bogus::MockingDSL
+end

data/lib/bogus/rspec_extensions.rb

@@ -0,0 +1,32 @@
+module Bogus
+  module RSpecExtensions
+    def fake(name, opts = {}, &block)
+      let(name) { Bogus.fake_for(name, opts, &block) }
+    end
+
+    def verify_contract(name)
+      before do
+        Bogus.record_calls_for(name)
+      end
+
+      RSpec.configure do |config|
+        config.after(:suite) { Bogus.verify_contract!(name) }
+      end
+    end
+  end
+
+  module MockingDSL
+    def stub(object)
+      Bogus.create_stub(object)
+    end
+
+    def have_received(method = nil)
+      Bogus.have_received(method)
+    end
+
+    def mock(object)
+      Bogus.create_mock(object)
+    end
+  end
+end
+