muack 1.2.0 → 1.5.0

data/task/README.md

@@ -4,16 +4,16 @@
 
 Provided tasks:
 
-    rake clean        # Remove ignored files
+    rake clean        # Trash ignored files
     rake gem:build    # Build gem
     rake gem:install  # Install gem
     rake gem:release  # Release gem
     rake gem:spec     # Generate gemspec
-    rake test         # Run tests in memory
+    rake test         # Run tests
 
 ## REQUIREMENTS:
 
-* Tested with MRI (official CRuby) 1.9.3, 2.0.0, Rubinius and JRuby.
+* Tested with MRI (official CRuby) and JRuby.
 
 ## INSTALLATION:
 
@@ -23,13 +23,13 @@ And in Rakefile:
 
 ``` ruby
 begin
-  require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+  require "#{__dir__}/task/gemgem"
 rescue LoadError
-  sh 'git submodule update --init'
+  sh 'git submodule update --init --recursive'
   exec Gem.ruby, '-S', $PROGRAM_NAME, *ARGV
 end
 
-Gemgem.init(dir) do |s|
+Gemgem.init(__dir__, :submodules => %w[your-dep]) do |s|
   s.name    = 'your-gem'
   s.version = '0.1.0'
 end
@@ -37,9 +37,9 @@ end
 
 ## LICENSE:
 
-Apache License 2.0
+Apache License 2.0 (Apache-2.0)
 
-Copyright (c) 2011-2013, Lin Jen-Shin (godfat)
+Copyright (c) 2011-2019, Lin Jen-Shin (godfat)
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/task/gemgem.rb

@@ -1,7 +1,7 @@
 
 module Gemgem
   class << self
-    attr_accessor :dir, :spec, :spec_create
+    attr_accessor :dir, :spec, :submodules, :spec_create
   end
 
   module_function
@@ -11,12 +11,14 @@ module Gemgem
   def pkg_dir    ; "#{dir}/pkg"                       ; end
   def escaped_dir; @escaped_dir ||= Regexp.escape(dir); end
 
-  def init dir, &block
+  def init dir, options={}, &block
     self.dir = dir
-    $LOAD_PATH.unshift("#{dir}/lib")
     ENV['RUBYLIB'] = "#{dir}/lib:#{ENV['RUBYLIB']}"
     ENV['PATH']    = "#{dir}/bin:#{ENV['PATH']}"
+    self.submodules  = options[:submodules] || []
     self.spec_create = block
+
+    $LOAD_PATH.unshift("#{dir}/lib", *submodules_libs)
   end
 
   def create
@@ -26,7 +28,7 @@ module Gemgem
 
       s.description = description.join
       s.summary     = description.first
-      s.license     = readme['LICENSE'].sub(/.+\n\n/, '').lines.first.strip
+      s.license     = license
 
       s.date        = Time.now.strftime('%Y-%m-%d')
       s.files       = gem_files
@@ -79,6 +81,11 @@ module Gemgem
   end
 
   def gem_check
+    unless git('status', '--porcelain').empty?
+      puts("\e[35mWorking copy is not clean.\e[0m")
+      exit(3)
+    end
+
     ver = spec.version.to_s
 
     if ENV['VERSION'].nil?
@@ -110,6 +117,7 @@ module Gemgem
       SimpleCov.start do
         add_filter('test/')
         add_filter('test.rb')
+        submodules_libs.each(&method(:add_filter))
       end
     end
 
@@ -154,11 +162,15 @@ module Gemgem
   end
 
   def strip_home_path path
-    path.sub(ENV['HOME'], '~')
+    path.sub(/\A#{Regexp.escape(ENV['HOME'])}\//, '~/')
   end
 
   def strip_cwd_path path
-    path.sub(Dir.pwd, '.')
+    path.sub(/\A#{Regexp.escape(Dir.pwd)}\//, '')
+  end
+
+  def submodules_libs
+    submodules.map{ |path| "#{dir}/#{path}/lib" }
   end
 
   def git *args
@@ -196,6 +208,11 @@ module Gemgem
     @description ||= (readme['DESCRIPTION']||'').sub(/.+\n\n/, '').lines.to_a
   end
 
+  def license
+    readme['LICENSE'].sub(/.+\n\n/, '').lines.first.
+      split(/[()]/).map(&:strip).reject(&:empty?).last
+  end
+
   def all_files
     @all_files ||= fold_files(glob).sort
   end
@@ -216,7 +233,8 @@ module Gemgem
 
   def gem_files
     @gem_files ||= all_files.reject{ |f|
-      f =~ ignored_pattern && !git_files.include?(f)
+      f =~ submodules_pattern ||
+        (f =~ ignored_pattern && !git_files.include?(f))
     }
   end
 
@@ -248,6 +266,15 @@ module Gemgem
                          end
   end
 
+  def submodules_pattern
+    @submodules_pattern ||= if submodules.empty?
+                              /^$/
+                            else
+                              Regexp.new(submodules.map{ |path|
+                                "^#{Regexp.escape(path)}/" }.join('|'))
+                            end
+  end
+
   def expand_patterns pathes
     # http://git-scm.com/docs/gitignore
     pathes.flat_map{ |path|

data/test/test_any_instance_of.rb

@@ -57,8 +57,8 @@ describe Muack::AnyInstanceOf do
   end
 
   would 'mock with multiple any_instance_of call' do
-    any_instance_of(klass){ |inst| mock(inst).f(is_a(Fixnum)){ |i| i+1 } }
-    any_instance_of(klass){ |inst| mock(inst).f(is_a(Fixnum)){ |i| i+2 } }
+    any_instance_of(klass){ |inst| mock(inst).f(is_a(Integer)){ |i| i+1 } }
+    any_instance_of(klass){ |inst| mock(inst).f(is_a(Integer)){ |i| i+2 } }
     obj = klass.new
     obj.f(2).should.eq 3
     obj.f(2).should.eq 4
@@ -112,4 +112,18 @@ describe Muack::AnyInstanceOf do
 
     obj.f.should.eq 0
   end
+
+  # Brought from rspec-mocks and it's currently failing on rspec-mocks
+  would 'stub any_instance_of on module extending it self' do
+    mod = Module.new {
+      extend self
+      def hello; :hello; end
+    }
+
+    any_instance_of(mod){ |inst| stub(inst).hello{ :stub } }
+
+    expect(mod.hello).eq(:stub)
+    expect(Muack.verify)
+    expect(mod.hello).eq(:hello)
+  end
 end

data/test/test_from_readme.rb

@@ -2,8 +2,7 @@
 require 'muack/test'
 
 describe 'from README.md' do
-  readme = File.read(
-             "#{File.dirname(File.expand_path(__FILE__))}/../README.md")
+  readme = File.read("#{__dir__}/../README.md")
   codes  = readme.scan(/``` ruby(.+?)```/m).map(&:first)
 
   after{ Muack.reset }
@@ -12,21 +11,20 @@ describe 'from README.md' do
     include Muack::API
 
     def describe desc, &block
-      @executor.describe(desc, &block)
-      @executor.execute(@stat)
+      @suite.describe(desc, &block)
+      Pork::Executor.execute(:stat => @stat, :suite => @suite)
     end
 
     def results; @results ||= []; end
     def p res  ; results << res ; end
 
     def verify expects
-      return if results.empty?
       results.zip(expects).each do |(res, exp)|
         next if exp == 'ok'
         if exp.start_with?('raise')
           res.should.kind_of? eval(exp.sub('raise', ''))
         else
-          res.should.eq eval(exp)
+          res.should.eq instance_eval(exp)
         end
       end
     end
@@ -34,10 +32,10 @@ describe 'from README.md' do
 
   codes.each.with_index do |code, index|
     would 'pass from README.md #%02d' % index do
-      executor, stat = Class.new(self.class){ init }, pork_stat
+      suite, stat = Class.new(self.class){ init }, pork_stat
       context = Module.new do
         extend Context
-        @executor, @stat = executor, stat
+        @suite, @stat = suite, stat
       end
       begin
         context.instance_eval(code, 'README.md', 0)

data/test/test_keyargs.rb

@@ -0,0 +1,111 @@
+
+require 'muack/test'
+
+describe Muack::Mock do
+  after do
+    Muack.verify.should.eq true
+    Muack::EnsureReset.call
+  end
+
+  describe 'passing single hash' do
+    would 'hash literal' do
+      mock(Obj).say({}, &:itself)
+
+      expect(Obj.say({})).eq({})
+    end
+
+    would 'hash literal with satisfying check' do
+      mock(Obj).say(is_a(Hash), &:itself)
+
+      expect(Obj.say({})).eq({})
+    end
+
+    would 'hash value' do
+      arg = {}
+
+      mock(Obj).say(arg, &:itself)
+
+      expect(Obj.say(arg)).eq(arg)
+    end
+
+    would 'non-empty hash' do
+      mock(Obj).say(a: 0, &:itself)
+
+      expect(Obj.say(a: 0)).eq(a: 0)
+    end
+
+    would 'non-empty hash with satisfying check' do
+      mock(Obj).say(where(a: 0), &:itself)
+
+      expect(Obj.say(a: 0)).eq(a: 0)
+    end
+  end
+
+  describe 'keyargs mock' do
+    copy :tests do
+      would 'local block' do
+        mock(obj).say.with_any_args.returns{ |a:| a }
+
+        expect(instance.say(a: 0)).eq(0)
+      end
+
+      would 'instance method' do
+        mock(obj).bonjour(a: 0, b: 1)
+
+        expect(instance.bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+
+      would 'prepended method' do
+        mock(obj).prepend_bonjour(a: 0, b: 1)
+
+        expect(instance.prepend_bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+    end
+
+    describe 'with direct mock' do
+      def obj
+        Obj
+      end
+
+      def instance
+        obj
+      end
+
+      paste :tests
+
+      would 'singleton method' do
+        mock(obj).single_bonjour(a: 0, b: 1)
+
+        expect(instance.single_bonjour(a: 0, b: 1)).eq([0, 1])
+      end
+    end
+
+    describe 'with any_instance_of' do
+      def obj
+        any_instance_of(Cls)
+      end
+
+      def instance
+        @instance ||= Cls.new
+      end
+
+      paste :tests
+    end
+
+    would 'peek_args' do
+      mock(Obj).say.with_any_args.
+        peek_args{ |a:| [{a: a.succ}] }.
+        returns{ |a:| a.succ }
+
+      expect(Obj.say(a: 0)).eq(2)
+    end
+
+    would 'peek_args with instance_exec' do
+      mock(Obj).say.with_any_args.
+        peek_args(instance_exec: true){ |a:| [{a: object_id}] }.
+        returns{ |a:| a }
+
+      expect(Obj.say(a: 0)).eq(Obj.object_id)
+    end
+  end
+end

data/test/test_modifier.rb

@@ -37,19 +37,19 @@ describe Muack::Modifier do
 
   describe 'peek_args' do
     would 'with lexical scope' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i.peek_args{16}
       str.to_i.should.eq 255
     end
 
     would 'with dynamic scope' do
-      str = '16'
+      str = String.new('16')
       stub(str).to_i.peek_args(:instance_exec => true){Integer(self)}
       str.to_i.should.eq 22
     end
 
     would 'modify' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i(is_a(Integer)).peek_args{ |radix| radix * 2 }
       str.to_i(8).should.eq 255
     end
@@ -82,19 +82,19 @@ describe Muack::Modifier do
 
   describe 'peek_return' do
     would 'with lexical scope' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i.peek_return{16}
       str.to_i.should.eq 16
     end
 
     would 'with dynamic scope' do
-      str = '16'
+      str = String.new('16')
       stub(str).to_i.peek_return(:instance_exec => true){Integer(self)+1}
       str.to_i.should.eq 17
     end
 
     would 'modify' do
-      str = 'ff'
+      str = String.new('ff')
       stub(str).to_i(is_a(Integer)).peek_return{ |result| result * 2 }
       str.to_i(16).should.eq 510
     end

data/test/test_prepend.rb

@@ -0,0 +1,121 @@
+
+require 'muack/test'
+
+describe 'mock with prepend' do
+  after do
+    verify
+  end
+
+  def verify
+    expect(Muack.verify).eq true
+  end
+
+  def generate
+    klass = Class.new do
+      def greet
+        'hi'
+      end
+    end
+
+    mod = Module.new do
+      def greet
+        hello
+      end
+
+      def hello
+        'hello'
+      end
+      private :hello
+    end
+
+    perform(klass, mod)
+  end
+
+  copy :test do
+    would 'mock' do
+      obj = generate
+
+      mock(obj).hello{'mocked'}
+
+      expect(obj.greet).eq 'mocked'
+      verify
+      expect(obj.greet).eq 'hello'
+      expect(obj).not.respond_to? :hello
+    end
+
+    would 'mock proxy' do
+      obj = generate
+
+      mock(obj).hello
+
+      expect(obj.greet).eq 'hello'
+      verify
+      expect(obj.greet).eq 'hello'
+      expect(obj).not.respond_to? :hello
+    end
+  end
+
+  describe 'prepend on class mock with object' do
+    def perform(klass, mod)
+      klass.prepend(mod)
+      klass.new
+    end
+
+    paste :test
+  end
+
+  describe 'extend on object mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.extend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  describe 'include on singleton_class mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.singleton_class.include(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  describe 'prepend on singleton_class mock with object' do
+    def perform(klass, mod)
+      obj = klass.new
+      obj.singleton_class.prepend(mod)
+      obj
+    end
+
+    paste :test
+  end
+
+  # Brought from rspec-mocks and it's currently failing on rspec-mocks
+  # See https://github.com/rspec/rspec-mocks/pull/1218
+  would "handle stubbing prepending methods that were only defined on the prepended module" do
+    to_be_prepended = Module.new do
+      def value
+        "#{super}_prepended".to_sym
+      end
+
+      def value_without_super
+        :prepended
+      end
+    end
+
+    object = Object.new
+    object.singleton_class.send(:prepend, to_be_prepended)
+    expect(object.value_without_super).eq :prepended
+
+    stub(object).value_without_super{ :stubbed }
+
+    expect(object.value_without_super).eq :stubbed
+
+    expect(Muack.verify)
+    expect(object.value_without_super).eq :prepended
+  end
+end