transpec 3.0.0 → 3.0.1

data/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-# coding: utf-8
-
-RSpec.configure do |config|
-  unless ENV['TRANSPEC_TEST']
-    # Yes, I'm writing specs in should syntax intentionally!
-    config.expect_with :rspec do |c|
-      c.syntax = :should
-    end
-
-    config.mock_with :rspec do |c|
-      c.syntax = :should
-    end
-  end
-
-  config.color_enabled = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
-
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  config.before(:suite) do
-    require 'rainbow'
-    Rainbow.enabled = false
-
-    if ENV['TRAVIS']
-      system('git config --global user.email "you@example.com"')
-      system('git config --global user.name "Your Name"')
-    end
-  end
-end
-
-if ENV['TRAVIS'] || ENV['COVERAGE']
-  require 'simplecov'
-
-  if ENV['TRAVIS']
-    require 'coveralls'
-    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  end
-
-  SimpleCov.start do
-    add_filter '/spec/'
-    add_filter '/vendor/bundle/'
-  end
-end
-
-Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
-  require path
-end

data/spec/support/cache_helper.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-require 'digest/sha1'
-
-module CacheHelper
-  module_function
-
-  def with_cache(key)
-    cache_file_path = cache_file_path(key)
-
-    if File.exist?(cache_file_path)
-      load_cache(cache_file_path)
-    else
-      data = yield
-      save_cache(cache_file_path, data)
-      data
-    end
-  end
-
-  def with_cached_dir(dirname)
-    dir_path = File.join(cache_dir, dirname)
-
-    cached = Dir.exist?(dir_path)
-    FileUtils.mkdir_p(dir_path) unless cached
-
-    Dir.chdir(dir_path) do
-      yield cached
-    end
-  end
-
-  def load_cache(path)
-    File.open(path) do |file|
-      Marshal.load(file)
-    end
-  end
-
-  def save_cache(path, data)
-    File.open(path, 'w') do |file|
-      Marshal.dump(data, file)
-    end
-  end
-
-  def cache_file_path(key)
-    filename = Digest::SHA1.hexdigest(key)
-    File.join(cache_dir, filename)
-  end
-
-  def cache_dir
-    @cache_dir ||= begin
-      project_root = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
-      ruby_version = [RUBY_ENGINE, RUBY_VERSION].join('-')
-      cache_dir = File.join(project_root, '.cache', 'spec', ruby_version)
-
-      unless Dir.exist?(cache_dir)
-        require 'fileutils'
-        FileUtils.mkdir_p(cache_dir)
-      end
-
-      cache_dir
-    end
-  end
-end

data/spec/support/file_helper.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'fileutils'
-
-module FileHelper
-  module_function
-
-  def create_file(file_path, content)
-    file_path = File.expand_path(file_path)
-
-    dir_path = File.dirname(file_path)
-    FileUtils.makedirs(dir_path) unless File.exist?(dir_path)
-
-    File.open(file_path, 'w') do |file|
-      case content
-      when String
-        file.puts content
-      when Array
-        file.puts content.join("\n")
-      else
-        fail 'Unsupported type!'
-      end
-    end
-  end
-end

data/spec/support/shared_context.rb

@@ -1,84 +0,0 @@
-# coding: utf-8
-
-# This context requires `source` to be defined with #let.
-shared_context 'parsed objects' do
-  let(:source_path) { nil }
-
-  let(:processed_source) do
-    require 'transpec/processed_source'
-    Transpec::ProcessedSource.new(source, source_path)
-  end
-
-  let(:ast) do
-    processed_source.ast
-  end
-
-  let(:source_rewriter) do
-    require 'parser'
-    Parser::Source::Rewriter.new(processed_source.buffer)
-  end
-
-  let(:rewritten_source) { source_rewriter.process }
-
-  # Include 'dynamic analysis objects' after this context so that this nil will be overridden.
-  let(:runtime_data) { nil }
-
-  let(:project) do
-    require 'transpec/project'
-    Transpec::Project.new
-  end
-end
-
-# This context requires `source` to be defined with #let.
-shared_context 'dynamic analysis objects' do
-  include_context 'isolated environment'
-
-  let(:source_path) { 'spec/example_spec.rb' }
-
-  runtime_data_cache = {}
-
-  let(:runtime_data) do
-    require 'transpec/dynamic_analyzer'
-
-    if runtime_data_cache[source]
-      runtime_data_cache[source]
-    else
-      FileHelper.create_file(source_path, source)
-      dynamic_analyzer = Transpec::DynamicAnalyzer.new(silent: true)
-      runtime_data_cache[source] = dynamic_analyzer.analyze
-    end
-  end
-end
-
-# This context depends on the context 'parsed objects'.
-shared_context 'syntax object' do |syntax_class, name|
-  let(name) do
-    ast.each_node do |node|
-      syntax = syntax_class.new(node, runtime_data, project, source_rewriter)
-      return syntax if syntax.conversion_target?
-    end
-
-    fail "No #{syntax_class.name} conversion target is found!"
-  end
-end
-
-shared_context 'isolated environment' do
-  around do |example|
-    require 'tmpdir'
-    Dir.mktmpdir do |tmpdir|
-      Dir.chdir(tmpdir) do
-        example.run
-      end
-    end
-  end
-end
-
-shared_context 'inside of git repository' do
-  around do |example|
-    Dir.mkdir('repo')
-    Dir.chdir('repo') do
-      `git init`
-      example.run
-    end
-  end
-end

data/spec/transpec/cli_spec.rb

@@ -1,341 +0,0 @@
-# coding: utf-8
-
-require 'spec_helper'
-require 'transpec/cli'
-
-module Transpec
-  describe CLI do
-    include FileHelper
-
-    subject(:cli) { CLI.new }
-
-    before do
-      cli.project.stub(:rspec_version).and_return(Transpec.required_rspec_version)
-    end
-
-    describe '.run' do
-      it 'invokes #run' do
-        args = ['foo', 'bar']
-        CLI.any_instance.should_receive(:run).with(args)
-        CLI.run(args)
-      end
-    end
-
-    describe '#run' do
-      include_context 'isolated environment'
-
-      subject { cli.run(args) }
-
-      let(:args) { [file_path] }
-      let(:file_path) { 'spec/example_spec.rb' }
-      let(:file_content) do
-        <<-END
-          describe 'something' do
-            it 'is 1' do
-              1.should == 1
-            end
-          end
-        END
-      end
-
-      before do
-        cli.stub(:puts)
-        cli.stub(:warn)
-        DynamicAnalyzer.any_instance.stub(:analyze).and_return(DynamicAnalyzer::RuntimeData.new)
-        create_file(file_path, file_content)
-      end
-
-      shared_examples 'rewrites files' do
-        it 'rewrites files' do
-          cli.should_receive(:convert_spec)
-          cli.run(args)
-        end
-
-        it 'returns true' do
-          should be_true
-        end
-      end
-
-      shared_examples 'aborts processing' do
-        it 'aborts processing' do
-          cli.should_not_receive(:convert_spec)
-          cli.run(args).should be_false
-        end
-      end
-
-      shared_examples 'generates commit message' do
-        it 'generates commit message to .git/COMMIT_EDITMSG' do
-          cli.run(args)
-          File.read('.git/COMMIT_EDITMSG').should start_with('Convert specs')
-        end
-      end
-
-      shared_examples 'does not generate commit message' do
-        it 'does not generate commit message' do
-          cli.run(args)
-          File.exist?('.git/COMMIT_EDITMSG').should be_false
-        end
-      end
-
-      context 'when git is available' do
-        before { Git.stub(:command_available?).and_return(true) }
-
-        context 'and inside of a repository' do
-          include_context 'inside of git repository'
-
-          context 'and the repository is not clean' do
-            before { Git.stub(:clean?).and_return(false) }
-
-            context 'and --force option is not specified' do
-              include_examples 'aborts processing'
-              include_examples 'does not generate commit message'
-
-              it 'warns and suggests the use of -f/--force option' do
-                cli.should_receive(:warn) do |message|
-                  message.should include('clean')
-                  message.should include('-f/--force')
-                end
-
-                cli.run(args)
-              end
-            end
-
-            context 'and --force option is specified' do
-              before { args << '--force' }
-              include_examples 'rewrites files'
-              include_examples 'generates commit message'
-            end
-          end
-
-          context 'and the repository is clean' do
-            before { Git.stub(:clean?).and_return(true) }
-
-            include_examples 'rewrites files'
-            include_examples 'generates commit message'
-
-            context 'and no conversion is done' do
-              let(:file_content) { '' }
-              include_examples 'does not generate commit message'
-            end
-          end
-        end
-
-        context 'and not inside of a repository' do
-          include_examples 'rewrites files'
-          include_examples 'does not generate commit message'
-        end
-      end
-
-      context 'when git is not available' do
-        before { Git.stub(:command_available?).and_return(false) }
-        include_examples 'rewrites files'
-        include_examples 'does not generate commit message'
-      end
-
-      context "when the project's RSpec dependency is older than the required version" do
-        before do
-          cli.project.stub(:rspec_version).and_return(RSpecVersion.new('2.13.0'))
-        end
-
-        include_examples 'aborts processing'
-
-        it 'warns to the version' do
-          cli.should_receive(:warn).with(/rspec.+dependency/i)
-          cli.run(args)
-        end
-      end
-
-      context 'when analysis error is raised in the dynamic analysis' do
-        before do
-          DynamicAnalyzer.any_instance.stub(:analyze).and_raise(DynamicAnalyzer::AnalysisError)
-        end
-
-        include_examples 'aborts processing'
-      end
-
-      context 'when a syntax error is raised while processing files' do
-        let(:args) { [invalid_syntax_file_path, valid_syntax_file_path] }
-        let(:invalid_syntax_file_path) { 'spec/invalid_example.rb' }
-        let(:valid_syntax_file_path) { 'spec/valid_example.rb' }
-
-        before do
-          create_file(invalid_syntax_file_path, 'This is invalid syntax <')
-          create_file(valid_syntax_file_path, 'this_is_valid_syntax')
-        end
-
-        it 'warns to the user' do
-          cli.should_receive(:warn)
-            .with('Syntax error at spec/invalid_example.rb:2:1. Skipping the file.')
-          cli.run(args)
-        end
-
-        it 'continues processing files' do
-          cli.should_receive(:puts).with("Converting #{invalid_syntax_file_path}")
-          cli.should_receive(:puts).with("Converting #{valid_syntax_file_path}")
-          cli.run(args)
-        end
-      end
-
-      context 'when an encoding error is raised while processing files' do
-        let(:args) { [invalid_encoding_file_path, valid_encoding_file_path] }
-        let(:invalid_encoding_file_path) { 'spec/invalid_example.rb' }
-        let(:valid_encoding_file_path) { 'spec/valid_example.rb' }
-
-        before do
-          create_file(invalid_encoding_file_path, <<-END)
-            # coding: utf-8
-            \xff
-          END
-
-          create_file(valid_encoding_file_path, 'this_is_valid_encoding')
-        end
-
-        it 'warns of the error' do
-          cli.should_receive(:warn)
-            .with('Encoding error in spec/invalid_example.rb. Skipping the file.')
-          cli.run(args)
-        end
-
-        it 'continues processing files' do
-          cli.should_receive(:puts).with("Converting #{invalid_encoding_file_path}")
-          cli.should_receive(:puts).with("Converting #{valid_encoding_file_path}")
-          cli.run(args)
-        end
-      end
-
-      context 'when any other error is raised while running' do
-        let(:args) { ['non-existent-file'] }
-
-        it 'does not catch the error' do
-          -> { cli.run(args) }.should raise_error
-        end
-      end
-
-      context 'when -s/--skip-dynamic-analysis option is specified' do
-        let(:args) { ['--skip-dynamic-analysis', file_path] }
-
-        it 'skips dynamic analysis' do
-          DynamicAnalyzer.any_instance.should_not_receive(:analyze)
-          cli.should_receive(:convert_spec)
-          cli.run(args)
-        end
-      end
-
-      context 'when -c/--rspec-command option is specified' do
-        include_context 'inside of git repository'
-
-        let(:args) { ['--force', '--rspec-command', 'rspec --profile'] }
-
-        it 'passes the command to DynamicAnalyzer' do
-          DynamicAnalyzer.should_receive(:new) do |arg|
-            arg[:rspec_command].should == 'rspec --profile'
-          end.and_call_original
-
-          cli.run(args)
-        end
-      end
-    end
-
-    describe '#convert_spec' do
-      include_context 'isolated environment'
-
-      let(:processed_source) do
-        path = 'example.rb'
-        create_file(path, source)
-        ProcessedSource.from_file(path)
-      end
-
-      let(:spec_suite) { SpecSuite.new }
-
-      before do
-        cli.stub(:puts)
-      end
-
-      context 'when the source has a monkey-patched expectation outside of example group context' do
-        let(:source) do
-          <<-END
-            describe 'example group' do
-              class Klass
-                def some_method
-                  1.should == 1
-                end
-              end
-
-              it 'is an example' do
-                Klass.new.some_method
-              end
-            end
-          END
-        end
-
-        it 'warns of the conversion error' do
-          cli.should_receive(:warn) do |message|
-            message.should =~ /cannot/i
-            message.should =~ /context/i
-          end
-
-          cli.convert_spec(processed_source, spec_suite)
-        end
-      end
-
-      context 'when it did a less accurate conversion due to a lack of runtime information' do
-        let(:source) do
-          <<-END
-            describe 'example group' do
-              it 'is an example' do
-                expect(obj).to have(2).items
-              end
-            end
-          END
-        end
-
-        it 'warns of less accurate conversion' do
-          cli.should_receive(:warn).with(/converted.+but.+incorrect/i)
-          cli.convert_spec(processed_source, spec_suite)
-        end
-      end
-
-      context 'when both conversion errors and less accurate records are reported' do
-        let(:source) do
-          <<-END
-            describe 'example group' do
-              it 'is first' do
-                expect(obj).to have(1).item
-              end
-
-              class Klass
-                def second
-                  2.should == 2
-                end
-              end
-
-              it 'is an example' do
-                Klass.new.some_method
-              end
-
-              it 'is third' do
-                expect(obj).to have(3).items
-              end
-            end
-          END
-        end
-
-        it 'displays them in order of line number' do
-          times = 1
-
-          cli.should_receive(:warn).exactly(3).times do |message|
-            line_number = case times
-                          when 1 then 3
-                          when 2 then 8
-                          when 3 then 17
-                          end
-            message.should include(":#{line_number}:")
-            times += 1
-          end
-
-          cli.convert_spec(processed_source, spec_suite)
-        end
-      end
-    end
-  end
-end