transpec 3.0.0 → 3.0.1

data/spec/transpec/git_spec.rb

@@ -1,151 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/git'
-
-module Transpec
-  describe Git do
-    include_context 'isolated environment'
-
-    describe '.command_available?' do
-      subject { Git.command_available? }
-
-      context 'when git command is found in PATH' do
-        it { should be_true }
-      end
-
-      context 'when git command is not found in PATH' do
-        before { stub_const('Transpec::Git::GIT', 'non-existent-command') }
-        it { should be_false }
-      end
-    end
-
-    describe '.inside_of_repository?' do
-      subject { Git.inside_of_repository? }
-
-      context 'when git command is avaialable' do
-        context 'and the current directory is inside of git repository' do
-          include_context 'inside of git repository'
-          it { should be_true }
-        end
-
-        context 'and the current directory is not inside of git repository' do
-          it { should be_false }
-        end
-      end
-
-      context 'when git command is not avaialable' do
-        before { Git.stub(:command_available?).and_return(false) }
-
-        it 'raises error' do
-          -> { Git.inside_of_repository? }.should raise_error(/command is not available/)
-        end
-      end
-    end
-
-    describe '.clean?' do
-      subject { Git.clean? }
-
-      context 'when inside of git repository' do
-        include_context 'inside of git repository'
-
-        before do
-          File.write('foo', 'This is a sample file')
-          `git add .`
-          `git commit -m 'Initial commit'`
-        end
-
-        context 'and there are no changes' do
-          it { should be_true }
-        end
-
-        context 'and there is an untracked file' do
-          before { File.write('bar', 'This is an untracked file') }
-          it { should be_false }
-        end
-
-        context 'and there is a deleted file' do
-          before { File.delete('foo') }
-          it { should be_false }
-        end
-
-        context 'and there is a not staged change' do
-          before { File.write('foo', 'This is modified content') }
-          it { should be_false }
-        end
-
-        context 'and there is a staged change' do
-          before do
-            File.write('foo', 'This is modified content')
-            `git add .`
-          end
-
-          it { should be_false }
-        end
-      end
-
-      context 'when not inside of git repository' do
-        it 'raises error' do
-          -> { Git.clean? }.should raise_error(/is not a Git repository/)
-        end
-      end
-    end
-
-    describe '.write_commit_message' do
-      let(:message) { 'This is the commit message.' }
-
-      context 'when inside of standard git-dir (.git) repository' do
-        include_context 'inside of git repository'
-
-        context 'and the current working directory is the repository root' do
-          it 'writes the message to .git/COMMIT_EDITMSG' do
-            Git.write_commit_message(message)
-            File.read('.git/COMMIT_EDITMSG').should == message
-          end
-        end
-
-        context 'and the current working directory is not the repository root' do
-          around do |example|
-            Dir.mkdir('dir')
-            Dir.chdir('dir') do
-              example.run
-            end
-          end
-
-          it 'writes the message to .git/COMMIT_EDITMSG in the repository root' do
-            Git.write_commit_message(message)
-            File.read('../.git/COMMIT_EDITMSG').should == message
-          end
-        end
-
-        it 'returns the commit message file path' do
-          path = Git.write_commit_message(message)
-          File.read(path).should == message
-        end
-      end
-
-      context 'when inside of separated git-dir repository' do
-        around do |example|
-          Dir.mkdir('repo')
-          Dir.chdir('repo') do
-            `git init --separate-git-dir this-is-git-dir`
-            example.run
-          end
-        end
-
-        it 'writes the message to COMMIT_EDITMSG in the separated git-dir' do
-          Git.write_commit_message(message)
-          File.read('this-is-git-dir/COMMIT_EDITMSG').should == message
-        end
-      end
-
-      context 'when not inside of git repository' do
-        it 'raises error' do
-          lambda do
-            Git.write_commit_message(message)
-          end.should raise_error(/is not a Git repository/)
-        end
-      end
-    end
-  end
-end

data/spec/transpec/option_parser_spec.rb

@@ -1,275 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/option_parser'
-
-module Transpec
-  describe OptionParser do
-    subject(:parser) { OptionParser.new(config) }
-    let(:config) { Config.new }
-
-    describe '#parse' do
-      subject { parser.parse(args) }
-      let(:args) { ['some_file', '--negative-form', 'to_not', 'some_dir'] }
-
-      it 'return non-option arguments' do
-        should == ['some_file', 'some_dir']
-      end
-
-      it 'does not mutate the passed array' do
-        parser.parse(args)
-        args.should == ['some_file', '--negative-form', 'to_not', 'some_dir']
-      end
-
-      describe '-f/--force option' do
-        let(:args) { ['--force'] }
-
-        it 'sets Config#forced? true' do
-          parser.parse(args)
-          config.forced?.should be_true
-        end
-      end
-
-      describe '-s/--skip-dynamic-analysis option' do
-        let(:args) { ['--skip-dynamic-analysis'] }
-
-        it 'sets Config#skip_dynamic_analysis? true' do
-          parser.parse(args)
-          config.skip_dynamic_analysis?.should be_true
-        end
-      end
-
-      describe '-k/--keep option' do
-        [
-          ['should',         :convert_should?],
-          ['oneliner',       :convert_oneliner?],
-          ['should_receive', :convert_should_receive?],
-          ['stub',           :convert_stub?],
-          ['have_items',     :convert_have_items?],
-          ['its',            :convert_its?],
-          ['pending',        :convert_pending?],
-          ['deprecated',     :convert_deprecated_method?]
-        ].each do |cli_type, config_attr|
-          context "when #{cli_type.inspect} is specified" do
-            let(:args) { ['--keep', cli_type] }
-
-            it "sets Config##{config_attr} false" do
-              parser.parse(args)
-              config.send(config_attr).should be_false
-            end
-          end
-        end
-
-        context 'when multiple types are specified with comma' do
-          let(:args) { ['--keep', 'should_receive,deprecated'] }
-
-          it 'handles all of them' do
-            parser.parse(args)
-            config.convert_should_receive?.should be_false
-            config.convert_deprecated_method?.should be_false
-          end
-        end
-
-        context 'when unknown type is specified' do
-          let(:args) { ['--keep', 'unknown'] }
-
-          it 'raises error' do
-            -> { parser.parse(args) }.should raise_error(ArgumentError) { |error|
-              error.message.should == 'Unknown syntax type "unknown"'
-            }
-          end
-        end
-      end
-
-      describe '-v/--convert option' do
-        [
-          ['example_group',  :convert_example_group?],
-          ['hook_scope',     :convert_hook_scope?],
-          ['stub_with_hash', :convert_stub_with_hash_to_allow_to_receive_and_return?]
-        ].each do |cli_type, config_attr|
-          context "when #{cli_type.inspect} is specified" do
-            let(:args) { ['--convert', cli_type] }
-
-            it "sets Config##{config_attr} true" do
-              parser.parse(args)
-              config.send(config_attr).should be_true
-            end
-          end
-        end
-
-        context 'when unknown type is specified' do
-          let(:args) { ['--convert', 'unknown'] }
-
-          it 'raises error' do
-            -> { parser.parse(args) }.should raise_error(ArgumentError) { |error|
-              error.message.should == 'Unknown syntax type "unknown"'
-            }
-          end
-        end
-      end
-
-      describe '-n/--negative-form option' do
-        ['not_to', 'to_not'].each do |form|
-          context "when #{form.inspect} is specified" do
-            let(:args) { ['--negative-form', form] }
-
-            it "sets Config#negative_form_of_to #{form.inspect}" do
-              parser.parse(args)
-              config.negative_form_of_to.should == form
-            end
-          end
-        end
-      end
-
-      describe '-b/--boolean-matcher option' do
-        [
-          ['truthy,falsey', :conditional, 'be_falsey'],
-          ['truthy,falsy',  :conditional, 'be_falsy'],
-          ['true,false',    :exact,       'be_falsey']
-        ].each do |cli_type, config_type, form_of_be_falsey|
-          context "when #{cli_type.inspect} is specified" do
-            let(:args) { ['--boolean-matcher', cli_type] }
-
-            it "sets Config#boolean_matcher_type #{config_type.inspect}" do
-              parser.parse(args)
-              config.boolean_matcher_type.should == config_type
-            end
-
-            it "sets Config#form_of_be_falsey #{form_of_be_falsey.inspect}" do
-              parser.parse(args)
-              config.form_of_be_falsey.should == form_of_be_falsey
-            end
-          end
-        end
-
-        ['', 'truthy', 'true', 'foo'].each do |cli_type|
-          context "when #{cli_type.inspect} is specified" do
-            let(:args) { ['--boolean-matcher', cli_type] }
-
-            it 'raises error' do
-              -> { parser.parse(args) }.should raise_error(/must be any of/)
-            end
-          end
-        end
-      end
-
-      describe '-a/--no-yield-any-instance option' do
-        let(:args) { ['--no-yield-any-instance'] }
-
-        it 'sets Config#add_receiver_arg_to_any_instance_implementation_block? false' do
-          parser.parse(args)
-          config.add_receiver_arg_to_any_instance_implementation_block?
-            .should be_false
-        end
-      end
-
-      describe '-e/--explicit-spec-type option' do
-        let(:args) { ['--explicit-spec-type'] }
-
-        it 'sets Config#add_explicit_type_metadata_to_example_group? true' do
-          parser.parse(args)
-          config.add_explicit_type_metadata_to_example_group?.should be_true
-        end
-      end
-
-      describe '-p/--no-parens-matcher-arg option' do
-        let(:args) { ['--no-parens-matcher-arg'] }
-
-        it 'sets Config#parenthesize_matcher_arg? false' do
-          parser.parse(args)
-          config.parenthesize_matcher_arg.should be_false
-        end
-      end
-
-      describe '--no-parentheses-matcher-arg option' do
-        let(:args) { ['--no-parentheses-matcher-arg'] }
-
-        before do
-          parser.stub(:warn)
-        end
-
-        it 'sets Config#parenthesize_matcher_arg? false' do
-          parser.parse(args)
-          config.parenthesize_matcher_arg.should be_false
-        end
-
-        it 'is deprecated' do
-          parser.should_receive(:warn) do |message|
-            message.should =~ /--no-parentheses-matcher-arg.+deprecated/i
-          end
-
-          parser.parse(args)
-        end
-      end
-
-      describe '--no-color option' do
-        before do
-          Rainbow.enabled = true
-        end
-
-        let(:args) { ['--no-color'] }
-
-        it 'disables color in the output' do
-          parser.parse(args)
-          Rainbow.enabled.should be_false
-        end
-      end
-
-      describe '--version option' do
-        before do
-          parser.stub(:puts)
-          parser.stub(:exit)
-        end
-
-        let(:args) { ['--version'] }
-
-        it 'shows version' do
-          parser.should_receive(:puts).with(Version.to_s)
-          parser.parse(args)
-        end
-
-        it 'exits' do
-          parser.should_receive(:exit)
-          parser.parse(args)
-        end
-      end
-    end
-
-    describe 'help text' do
-      subject(:help_text) do
-        parser.help
-      end
-
-      it 'does not exceed 100 characters in each line' do
-        help_text.each_line do |line|
-          line.chomp.length.should <= 100
-        end
-      end
-
-      def description_for_option(option)
-        description_lines = parser.send(:descriptions)[option]
-        description_lines.map { |line| parser.send(:highlight_text, line) }
-      end
-
-      def conversion_types_for_option(option)
-        section = description_for_option(option)
-
-        section.each_with_object([]) do |line, types|
-          match = line.match(/^[ ]{2}([a-z_]+)/)
-          next unless match
-          types << match.captures.first
-        end
-      end
-
-      it 'describes all conversion types for -k/--keep option' do
-        conversion_types = conversion_types_for_option('-k')
-        conversion_types.should =~ OptionParser::CONFIG_ATTRS_FOR_KEEP_TYPES.keys.map(&:to_s)
-      end
-
-      it 'describes all conversion types for -v/--convert option' do
-        conversion_types = conversion_types_for_option('-v')
-        conversion_types.should =~ OptionParser::CONFIG_ATTRS_FOR_CONVERT_TYPES.keys.map(&:to_s)
-      end
-    end
-  end
-end

data/spec/transpec/processed_source_spec.rb

@@ -1,93 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/processed_source'
-
-module Transpec
-  describe ProcessedSource do
-    describe '.parse_file' do
-      include FileHelper
-      include_context 'isolated environment'
-
-      let(:spec_path) { 'spec/example_spec.rb' }
-
-      before do
-        create_file(spec_path, "puts 'foo'")
-      end
-
-      it 'parses the file and returns processed source' do
-        processed_source = ProcessedSource.from_file(spec_path)
-        processed_source.path.should == spec_path
-        processed_source.ast.should_not be_nil
-      end
-    end
-
-    subject(:processed_source) { ProcessedSource.new(source) }
-
-    describe '#ast' do
-      let(:source) { "puts 'foo'" }
-
-      it 'returns the root node of AST' do
-        processed_source.ast.should be_a(Parser::AST::Node)
-      end
-    end
-
-    describe '#path' do
-      let(:source) { "puts 'foo'" }
-
-      context 'when a file path is passed to .new' do
-        subject(:processed_source) { ProcessedSource.new(source, '/path/to/file') }
-
-        it 'returns the path' do
-          processed_source.path.should == '/path/to/file'
-        end
-      end
-
-      context 'when no file path is passed to .new' do
-        it 'returns nil' do
-          processed_source.path.should be_nil
-        end
-      end
-    end
-
-    describe '#syntax_error' do
-      context 'when the source is valid' do
-        let(:source) { "puts 'foo'" }
-
-        it 'returns nil' do
-          processed_source.error.should be_nil
-        end
-      end
-
-      context 'when the source is invalid' do
-        let(:source) { '<' }
-
-        it 'returns syntax error' do
-          processed_source.error.should be_a(Parser::SyntaxError)
-        end
-      end
-
-      context 'when the source includes invalid byte sequence for the encoding' do
-        it 'returns encoding error' do
-          processed_source = ProcessedSource.new(<<-END)
-            # coding: utf-8
-            \xff
-          END
-          processed_source.error.should be_a(EncodingError)
-        end
-      end
-    end
-
-    describe '#to_s' do
-      it 'returns the original source' do
-        source = [
-          "puts 'foo'",
-          "puts 'bar'"
-        ].join("\n")
-
-        processed_source = ProcessedSource.new(source)
-        processed_source.to_s.should == source
-      end
-    end
-  end
-end