inch 0.5.0.rc5 → 0.5.0.rc6

data/test/integration/cli/command/suggest_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/../../../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../../../test_helper')
 require 'inch/utils/buffered_ui'
 
 describe ::Inch::CLI::Command::Suggest do
@@ -7,39 +7,39 @@ describe ::Inch::CLI::Command::Suggest do
     @command = ::Inch::CLI::Command::Suggest
   end
 
-  it "should run without args" do
+  it 'should run without args' do
     out, err = capture_io do
       @command.run
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
-    assert_match /\bFoo::Bar#method_with_wrong_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_rdoc_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_unstructured_doc\b/, out
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
+    assert_match(/\bFoo::Bar#method_with_wrong_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_rdoc_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_unstructured_doc\b/, out)
   end
 
-  it "should run with --pedantic switch" do
+  it 'should run with --pedantic switch' do
     out, err = capture_io do
-      @command.run("--pedantic")
+      @command.run('--pedantic')
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should run with filelist in args" do
+  it 'should run with filelist in args' do
     out, err = capture_io do
-      @command.run("lib/**/*.rb", "app/**/*.rb")
+      @command.run('lib/**/*.rb', 'app/**/*.rb')
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
-    assert_match /\bFoo::Bar#method_with_wrong_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_rdoc_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_unstructured_doc\b/, out
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
+    assert_match(/\bFoo::Bar#method_with_wrong_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_rdoc_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_unstructured_doc\b/, out)
   end
 
-  it "should run with non-existing filelist in args" do
+  it 'should run with non-existing filelist in args' do
     _out, _err = capture_io do
-      @command.run("app/**/*.rb")
+      @command.run('app/**/*.rb')
     end
     # TODO: not sure what should actually happen here:
     #   no output or error message?
@@ -47,68 +47,77 @@ describe ::Inch::CLI::Command::Suggest do
     # assert err.empty?, "there should be no errors"
   end
 
-  it "should run with --objects switch" do
+  it 'should run with --objects switch' do
     out, err = capture_io do
-      @command.run("lib/**/*.rb", "app/**/*.rb", "--objects=30")
+      @command.run('lib/**/*.rb', 'app/**/*.rb', '--objects=30')
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
-    assert_match /\bFoo::Bar#method_with_wrong_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_rdoc_doc\b/, out
-    assert_match /\bFoo::Bar#method_with_unstructured_doc\b/, out
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
+    assert_match(/\bFoo::Bar#method_with_wrong_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_rdoc_doc\b/, out)
+    assert_match(/\bFoo::Bar#method_with_unstructured_doc\b/, out)
   end
 
-  it "should give error when run with --unknown-switch" do
+  it 'should give error when run with --unknown-switch' do
     _out, _err = capture_io do
-      assert_raises(SystemExit) { @command.run("--unknown-switch") }
+      assert_raises(SystemExit) { @command.run('--unknown-switch') }
     end
   end
 
-  it "should output info when run with --help" do
+  it 'should output info when run with --help' do
     out, err = capture_io do
-      assert_raises(SystemExit) { @command.run("--help") }
+      assert_raises(SystemExit) { @command.run('--help') }
     end
-    refute out.empty?, "there should be some output"
-    assert_match /\bUsage\b.+suggest/, out
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be some output'
+    assert_match(/\bUsage\b.+suggest/, out)
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should output version when run with --version" do
+  it 'should output version when run with --version' do
     out, err = capture_io do
-      assert_raises(SystemExit) { @command.run("--version") }
+      assert_raises(SystemExit) { @command.run('--version') }
     end
-    refute out.empty?, "there should be some output"
-    assert_match /inch\ \d\.\d\.\d/, out
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be some output'
+    assert_match(/inch\ \d\.\d\.\d/, out)
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should not output anything to stdout when used with BufferedUI" do
+  it 'should not output anything to stdout when used with BufferedUI' do
     ui = ::Inch::Utils::BufferedUI.new
     out, err = capture_io do
       @command.run(:ui => ui)
     end
-    assert out.empty?, "there should be no output"
-    assert err.empty?, "there should be no errors"
+    assert out.empty?, 'there should be no output'
+    assert err.empty?, 'there should be no errors'
   end
 
   # Edge case: Really good codebase
 
-  it "should run without args on really good fixture" do
+  it 'should run without args on really good fixture' do
     out, err = capture_io do
       Dir.chdir fixture_path(:ruby, :really_good)
       @command.run
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
   end
 
-  it "should run with --pedantic switch" do
+  it 'should run with --pedantic switch' do
     out, err = capture_io do
       Dir.chdir fixture_path(:ruby, :really_good)
-      @command.run("--pedantic")
+      @command.run('--pedantic')
     end
-    refute out.empty?, "there should be some output"
-    assert err.empty?, "there should be no errors"
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
+  end
+
+  it 'should run on elixir codebase with --read-from-dump' do
+    out, err = capture_io do
+      Dir.chdir fixture_path(:elixir, :simple)
+      @command.run('--language=elixir', '--read-from-dump=all.json')
+    end
+    refute out.empty?, 'there should be some output'
+    assert err.empty?, 'there should be no errors'
   end
 
 end

data/test/integration/stats_options_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 #
 # These format tests also broke things in the regular testsuite.
@@ -9,25 +9,25 @@ require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
 describe ::Inch::CLI::Command::List do
   before do
     Dir.chdir fixture_path(:ruby, :simple)
-    @command = "bundle exec inch stats"
+    @command = 'bundle exec inch stats'
   end
 
   def assert_parsed_output(parsed)
     assert parsed.size > 0
-    assert parsed["grade_lists"]
-    assert parsed["scores"]
-    assert parsed["priorities"]
+    assert parsed['grade_lists']
+    assert parsed['scores']
+    assert parsed['priorities']
   end
 
-  it "should run with --no-private switch" do
+  it 'should run with --no-private switch' do
     out = `#{@command} --format json`
-    refute out.empty?, "there should be some output"
+    refute out.empty?, 'there should be some output'
     assert_parsed_output JSON[out]
   end
 
-  it "should run with --no-protected switch" do
+  it 'should run with --no-protected switch' do
     out = `#{@command} --format yaml`
-    refute out.empty?, "there should be some output"
+    refute out.empty?, 'there should be some output'
     assert_parsed_output YAML.load(out)
   end
 

data/test/integration/visibility_options_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 describe ::Inch::CLI::Command do
   before do
@@ -6,81 +6,85 @@ describe ::Inch::CLI::Command do
     @command = ::Inch::CLI::Command::List
   end
 
-  it "should run without visibility switches" do
+  it 'should run without visibility switches' do
     out, _err = capture_io do
-      @command.run("--all")
+      @command.run('--all')
     end
-    refute out.empty?, "there should be some output"
-    assert_match /\bFoo#public_method\b/, out
-    assert_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has @private tag
+    refute out.empty?, 'there should be some output'
+    assert_match(/\bFoo#public_method\b/, out)
+    assert_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    refute_match(/\bFoo#method_with_private_tag\b/, out) # has @private tag
   end
 
-  it "should run with --no-protected switch" do
+  it 'should run with --no-protected switch' do
     out, _err = capture_io do
-      @command.run("--all", "--no-protected")
+      @command.run('--all', '--no-protected')
     end
-    refute out.empty?, "there should be some output"
-    assert_match /\bFoo#public_method\b/, out
-    refute_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has @private tag
+    refute out.empty?, 'there should be some output'
+    assert_match(/\bFoo#public_method\b/, out)
+    refute_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    refute_match(/\bFoo#method_with_private_tag\b/, out) # has @private tag
   end
 
-  it "should run with --no-public switch" do
+  it 'should run with --no-public switch' do
     out, _err = capture_io do
       @command.run(*%w(--all --no-public))
     end
-    refute out.empty?, "there should be some output"
-    refute_match /\bFoo#public_method\b/, out
-    assert_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has @private tag
+    refute out.empty?, 'there should be some output'
+    refute_match(/\bFoo#public_method\b/, out)
+    assert_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    refute_match(/\bFoo#method_with_private_tag\b/, out) # has @private tag
   end
 
-  it "should run with --no-public --no-protected switch" do
+  it 'should run with --no-public --no-protected switch' do
     out, _err = capture_io do
       @command.run(*%w(--all --no-public --no-protected))
     end
-    assert out.empty?, "there should be no output"
-    refute_match /\bFoo#public_method\b/, out
-    refute_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has a @private tag, but is really :public
+    assert out.empty?, 'there should be no output'
+    refute_match(/\bFoo#public_method\b/, out)
+    refute_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    # has a @private tag, but is really :public
+    refute_match(/\bFoo#method_with_private_tag\b/, out)
   end
 
-  it "should run with --no-public --no-protected --private switch" do
+  it 'should run with --no-public --no-protected --private switch' do
     out, _err = capture_io do
       @command.run(*%w(--all --no-public --no-protected --private))
     end
-    refute out.empty?, "there should be some output"
-    refute_match /\bFoo#public_method\b/, out
-    refute_match /\bFoo#protected_method\b/, out
-    assert_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has a @private tag, but is really :public
+    refute out.empty?, 'there should be some output'
+    refute_match(/\bFoo#public_method\b/, out)
+    refute_match(/\bFoo#protected_method\b/, out)
+    assert_match(/\bFoo#private_method\b/, out) # has @private tag
+    # has a @private tag, but is really :public
+    refute_match(/\bFoo#method_with_private_tag\b/, out)
   end
 
-  it "should run with --no-public switch" do
+  it 'should run with --no-public switch' do
     out, _err = capture_io do
       @command.run(*%w(--all --no-public))
     end
-    refute out.empty?, "there should be some output"
-    refute_match /\bFoo#public_method\b/, out
-    assert_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has a @private tag, but is really :public
+    refute out.empty?, 'there should be some output'
+    refute_match(/\bFoo#public_method\b/, out)
+    assert_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    # has a @private tag, but is really :public
+    refute_match(/\bFoo#method_with_private_tag\b/, out)
   end
 
-  it "should run with --no-protected switch" do
+  it 'should run with --no-protected switch' do
     out, _err = capture_io do
       @command.run(*%w(--all --no-protected))
     end
-    refute out.empty?, "there should be some output"
-    assert_match /\bFoo#public_method\b/, out
-    refute_match /\bFoo#protected_method\b/, out
-    refute_match /\bFoo#private_method\b/, out # has @private tag
-    refute_match /\bFoo#method_with_private_tag\b/, out # has a @private tag, but is really :public
+    refute out.empty?, 'there should be some output'
+    assert_match(/\bFoo#public_method\b/, out)
+    refute_match(/\bFoo#protected_method\b/, out)
+    refute_match(/\bFoo#private_method\b/, out) # has @private tag
+    # has a @private tag, but is really :public
+    refute_match(/\bFoo#method_with_private_tag\b/, out)
   end
 
 end

data/test/shared/base_list.rb

@@ -2,73 +2,73 @@ module Shared
   module BaseList
     extend Minitest::Spec::DSL
 
-    it "should give error when run with --unknown-switch" do
+    it 'should give error when run with --unknown-switch' do
       _out, _err = capture_io do
         assert_raises(SystemExit) do
-          @command.run("lib/foo.rb", "--unknown-switch")
+          @command.run('lib/foo.rb', '--unknown-switch')
         end
       end
     end
 
-    it "should run with --depth switch" do
+    it 'should run with --depth switch' do
       out, err = capture_io do
-        @command.run("lib/foo.rb", "--depth=2")
+        @command.run('lib/foo.rb', '--depth=2')
       end
-      refute out.empty?, "there should be some output"
-      assert err.empty?, "there should be no errors"
-      assert_match /\bFoo\b/, out
-      assert_match /\bFoo::Bar\b/, out
-      refute_match /\bFoo::Bar#method_with_full_doc\b/, out
-      refute_match /\bFoo::Bar#method_with_code_example\b/, out
+      refute out.empty?, 'there should be some output'
+      assert err.empty?, 'there should be no errors'
+      assert_match(/\bFoo\b/, out)
+      assert_match(/\bFoo::Bar\b/, out)
+      refute_match(/\bFoo::Bar#method_with_full_doc\b/, out)
+      refute_match(/\bFoo::Bar#method_with_code_example\b/, out)
     end
 
-    it "should run with --only-namespaces switch" do
+    it 'should run with --only-namespaces switch' do
       out, err = capture_io do
-        @command.run("lib/foo.rb", "--only-namespaces")
+        @command.run('lib/foo.rb', '--only-namespaces')
       end
-      refute out.empty?, "there should be some output"
-      assert err.empty?, "there should be no errors"
-      assert_match /\bFoo\s/, out
-      assert_match /\bFoo::Bar\s/, out
-      refute_match /\bFoo::Bar\./, out
-      refute_match /\bFoo::Bar#/, out
+      refute out.empty?, 'there should be some output'
+      assert err.empty?, 'there should be no errors'
+      assert_match(/\bFoo\s/, out)
+      assert_match(/\bFoo::Bar\s/, out)
+      refute_match(/\bFoo::Bar\./, out)
+      refute_match(/\bFoo::Bar#/, out)
     end
 
-    it "should run with --no-namespaces switch" do
+    it 'should run with --no-namespaces switch' do
       out, err = capture_io do
-        @command.run("lib/foo.rb", "--no-namespaces")
+        @command.run('lib/foo.rb', '--no-namespaces')
       end
-      refute out.empty?, "there should be some output"
-      assert err.empty?, "there should be no errors"
-      refute_match /\bFoo\s/, out
-      refute_match /\bFoo::Bar\s/, out
-      assert_match /\bFoo::Bar#/, out
+      refute out.empty?, 'there should be some output'
+      assert err.empty?, 'there should be no errors'
+      refute_match(/\bFoo\s/, out)
+      refute_match(/\bFoo::Bar\s/, out)
+      assert_match(/\bFoo::Bar#/, out)
     end
 
-    it "should run with --only-undocumented switch" do
+    it 'should run with --only-undocumented switch' do
       skip
       out, err = capture_io do
-        @command.run("lib/foo.rb", "--all", "--only-undocumented")
+        @command.run('lib/foo.rb', '--all', '--only-undocumented')
       end
-      refute out.empty?, "there should be some output"
-      assert err.empty?, "there should be no errors"
-      refute_match /\bFoo\s/, out
-      refute_match /\bFoo::Bar#method_with_full_doc\b/, out
-      assert_match /\bFoo::Bar\s/, out
-      assert_match /\bFoo::Bar#method_without_doc\b/, out
+      refute out.empty?, 'there should be some output'
+      assert err.empty?, 'there should be no errors'
+      refute_match(/\bFoo\s/, out)
+      refute_match(/\bFoo::Bar#method_with_full_doc\b/, out)
+      assert_match(/\bFoo::Bar\s/, out)
+      assert_match(/\bFoo::Bar#method_without_doc\b/, out)
     end
 
-    it "should run with --no-undocumented switch" do
+    it 'should run with --no-undocumented switch' do
       skip
       out, err = capture_io do
-        @command.run("lib/foo.rb", "--all", "--no-undocumented")
+        @command.run('lib/foo.rb', '--all', '--no-undocumented')
       end
-      refute out.empty?, "there should be some output"
-      assert err.empty?, "there should be no errors"
-      assert_match /\bFoo\s/, out
-      assert_match /\bFoo::Bar#method_with_full_doc\b/, out
-      refute_match /\bFoo::Bar\s/, out
-      refute_match /\bFoo::Bar#method_without_doc\b/, out
+      refute out.empty?, 'there should be some output'
+      assert err.empty?, 'there should be no errors'
+      assert_match(/\bFoo\s/, out)
+      assert_match(/\bFoo::Bar#method_with_full_doc\b/, out)
+      refute_match(/\bFoo::Bar\s/, out)
+      refute_match(/\bFoo::Bar#method_without_doc\b/, out)
     end
   end
 end