transpec 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c98c4880892b0c69338d5a58b145fb47e6efbc14
+  data.tar.gz: 27d7e201e95c233d9e13887a9d22642e99034952
+SHA512:
+  metadata.gz: 265a268cf2858c97c587c561c58cb0b129951d6f8b69acec44ac652457ad9eb11ff01e25d506914f34661239e792c37b0e9443448a92f5587a219b43af37e4cd
+  data.tar.gz: 901f0dcc5290387aec5377f3514c61134199351000621520090d35aecd46be78063239a47c66f7ca3cd414ef6182f7aba845b067761cce0ee6774e999bc4aef3

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+vendor/bundle

data/.rubocop.yml

@@ -0,0 +1,13 @@
+
+LineLength:
+  Max: 100
+
+MethodLength:
+  Max: 20
+
+WordArray:
+  Enabled: false
+
+# TODO
+Documentation:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+script: bundle exec rake all

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'coveralls',      '~> 0.6'
+  gem 'simplecov-rcov', '~> 0.2'
+  gem 'ci_reporter',    '~> 1.8'
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, all_after_pass: true, all_on_start: true, keep_failed: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})        { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')     { "spec" }
+  watch(%r{^spec/support/.+\.rb$}) { "spec" }
+end
+
+guard :rubocop do
+  watch(%r{.+\.rb$})
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Yuji Nakayama
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Transpec
+
+**Transpec** automatically converts your specs into latest [RSpec](http://rspec.info/) syntax with static analysis.
+
+See the following pages for new RSpec syntax:
+
+* [Myron Marston » RSpec's New Expectation Syntax](http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax)
+* [RSpec's new message expectation syntax - Tea is awesome.](http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/)
+* [Myron Marston » The Plan for RSpec 3](http://myronmars.to/n/dev-blog/2013/07/the-plan-for-rspec-3)
+
+## Installation
+
+```bash
+$ gem install transpec
+```
+
+## Basic Usage
+
+Run `transpec` with no arguments in your project directory:
+
+```bash
+$ transpec
+```
+
+This will inspect and overwrite all spec files in the `spec` directory.
+
+For more information, please see the help with `--help` option.
+
+**TODO:** Add more description
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,27 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :ci do
+  desc "#{Rake::Task['spec'].comment} for CI environment"
+  task :spec do
+    ENV['CI'] = 'true'
+
+    ENV['CI_REPORTS'] = 'spec/reports'
+    require 'ci/reporter/rake/rspec'
+    Rake::Task['ci:setup:rspec'].invoke
+
+    Rake::Task['spec'].invoke
+  end
+end
+
+desc 'Check code style with RuboCop'
+task :style do
+  sh('rubocop')
+end
+
+desc 'Run RSpec and RuboCop'
+task all: [:spec, :style]
+
+task default: :all

data/bin/transpec

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'transpec'
+
+result = Transpec::CLI.run
+exit(result ? 0 : 1)

data/lib/transpec/ast/scanner.rb

@@ -0,0 +1,51 @@
+# coding: utf-8
+
+module Transpec
+  module AST
+    class Scanner
+      SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
+
+      attr_reader :scope_stack
+
+      def self.scan(origin_node, &block)
+        instance = new(&block)
+        instance.scan(origin_node, true)
+      end
+
+      def initialize(&block)
+        @callback = block
+        @ancestor_nodes = []
+        @scope_stack = ScopeStack.new
+      end
+
+      def scan(origin_node, yield_origin_node = false)
+        return unless origin_node
+
+        yield_node(origin_node) if yield_origin_node
+
+        @ancestor_nodes.push(origin_node)
+        @scope_stack.push_scope(origin_node) if scope_node?(origin_node)
+
+        origin_node.children.each_with_index do |child, index|
+          next unless child.is_a?(Parser::AST::Node)
+          node = child
+          yield_node(node)
+          scan(node)
+        end
+
+        @scope_stack.pop_scope if scope_node?(origin_node)
+        @ancestor_nodes.pop
+      end
+
+      private
+
+      def yield_node(node)
+        @callback.call(node, @ancestor_nodes, @scope_stack.in_example_group_context?)
+      end
+
+      def scope_node?(node)
+        SCOPE_TYPES.include?(node.type)
+      end
+    end
+  end
+end

data/lib/transpec/ast/scope_stack.rb

@@ -0,0 +1,76 @@
+# coding: utf-8
+
+module Transpec
+  module AST
+    class ScopeStack < Array
+      EXAMPLE_GROUP_METHOD_NAMES = [
+        :describe, :context,
+        :shared_examples, :shared_context, :share_examples_for, :shared_examples_for
+      ].freeze
+
+      def push_scope(node)
+        push(scope_type(node))
+      end
+
+      def pop_scope
+        pop
+      end
+
+      def in_example_group_context?
+        if include?(:example_group)
+          scopes_in_example_group = inner_scopes_in_scope(:example_group)
+          return false if include_class_scope?(scopes_in_example_group)
+          include_method_or_block_scope?(scopes_in_example_group)
+        elsif include?(:rspec_configure)
+          scopes_in_rspec_configure = inner_scopes_in_scope(:rspec_configure)
+          return false if include_class_scope?(scopes_in_rspec_configure)
+          include_method_or_block_scope?(scopes_in_rspec_configure)
+        elsif first == :def
+          scopes_in_method = self[1..-1]
+          !include_class_scope?(scopes_in_method)
+        elsif include?(:module)
+          scopes_in_module = inner_scopes_in_scope(:module)
+          return false if include_class_scope?(scopes_in_module)
+          scopes_in_module.include?(:def)
+        else
+          false
+        end
+      end
+
+      private
+
+      def scope_type(node)
+        return node.type unless node.type == :block
+
+        send_node = node.children.first
+        receiver_node, method_name, *_ = *send_node
+
+        if Util.const_name(receiver_node) == 'RSpec' && method_name == :configure
+          :rspec_configure
+        elsif receiver_node
+          node.type
+        elsif EXAMPLE_GROUP_METHOD_NAMES.include?(method_name)
+          :example_group
+        else
+          node.type
+        end
+      end
+
+      def inner_scopes_in_scope(scope_type)
+        index = rindex(scope_type)
+        return nil unless index
+        self[Range.new(index + 1, -1)]
+      end
+
+      def include_class_scope?(scopes)
+        !(scopes & [:class, :sclass]).empty?
+      end
+
+      def include_method_or_block_scope?(scopes)
+        # TODO: Should validate whether the method taking the block is RSpec's
+        #   special method. (e.g. #subject, #let, #before, #after)
+        !(scopes & [:def, :block]).empty?
+      end
+    end
+  end
+end

data/lib/transpec/cli.rb

@@ -0,0 +1,162 @@
+# coding: utf-8
+
+require 'optparse'
+require 'find'
+
+module Transpec
+  class CLI
+    CONFIG_ATTRS_FOR_CLI_TYPES = {
+      expect_to_matcher: :convert_to_expect_to_matcher=,
+      expect_to_receive: :convert_to_expect_to_receive=,
+       allow_to_receive: :convert_to_allow_to_receive=,
+             deprecated: :replace_deprecated_method=
+    }
+
+    attr_reader :configuration, :forced
+    alias_method :forced?, :forced
+
+    def self.run(args = ARGV)
+      new.run(args)
+    end
+
+    def initialize
+      @configuration = Configuration.new
+      @forced = false
+    end
+
+    def run(args)
+      non_option_args = parse_options(args)
+
+      fail_if_should_not_continue!
+
+      paths = non_option_args
+
+      if paths.empty?
+        if Dir.exists?('spec')
+          paths = ['spec']
+        else
+          fail ArgumentError, 'Specify target files or directories.'
+        end
+      end
+
+      target_files(paths).each do |file_path|
+        puts "Processing #{file_path}"
+        rewriter = Rewriter.new(@configuration)
+        rewriter.rewrite_file!(file_path)
+      end
+
+      # TODO: Print summary
+
+      true
+    rescue => error
+      warn error.message
+      false
+    end
+
+    # rubocop:disable MethodLength
+    def parse_options(args)
+      parser = OptionParser.new
+      parser.banner = "Usage: transpec [options] [files or directories]\n\n"
+
+      parser.on(
+        '--force',
+        'Force processing even if the current Git',
+        'repository is not clean.'
+      ) do
+        @forced = true
+      end
+
+      parser.on(
+        '-d', '--disable TYPE[,TYPE...]',
+        'Disable specific conversions.',
+        'Available conversion types:',
+        '  expect_to_matcher (from `should`)',
+        '  expect_to_receive (from `should_receive`)',
+        '  allow_to_receive  (from `stub`)',
+        '  deprecated (e.g. from `stub!` to `stub`)',
+        'These are all enabled by default.'
+      ) do |types|
+        types.split(',').each do |type|
+          config_attr = CONFIG_ATTRS_FOR_CLI_TYPES[type.to_sym]
+          fail ArgumentError, "Unknown conversion type #{type.inspect}" unless config_attr
+          @configuration.send(config_attr, false)
+        end
+      end
+
+      parser.on(
+        '-n', '--negative-form FORM',
+        'Specify negative form of `to` that is used',
+        'in `expect(...).to` syntax.',
+        'Either `not_to` or `to_not`.',
+        'Default: not_to'
+      ) do |form|
+        @configuration.negative_form_of_to = form
+      end
+
+      parser.on(
+        '-p', '--no-parentheses-matcher-arg',
+        'Suppress parenthesizing argument of matcher',
+        'when converting operator to non-operator',
+        'in `expect` syntax. Note that it will be',
+        'parenthesized even if this option is',
+        'specified when parentheses are necessary to',
+        'keep the meaning of the expression.',
+        'By default, arguments of the following',
+        'operator matchers will be parenthesized.',
+        '  `== 10` to `eq(10)`',
+        '  `=~ /pattern/` to `match(/pattern/)`',
+        '  `=~ [1, 2]` to `match_array([1, 2])`'
+      ) do
+        @configuration.parenthesize_matcher_arg = false
+      end
+
+      parser.on('--version', 'Show Transpec version.') do
+        puts Version.to_s
+        exit
+      end
+
+      args = args.dup
+      parser.parse!(args)
+      args
+    end
+    # rubocop:enable MethodLength
+
+    def target_files(paths)
+      paths.reduce([]) do |file_paths, path|
+        if File.directory?(path)
+          file_paths.concat(ruby_files_in_directory(path))
+        elsif File.file?(path)
+          file_paths << path
+        elsif !File.exists?(path) # rubocop:disable FavorUnlessOverNegatedIf
+          fail ArgumentError, "No such file or directory #{path.inspect}"
+        end
+      end
+    end
+
+    private
+
+    def ruby_files_in_directory(directory_path)
+      ruby_file_paths = []
+
+      Find.find(directory_path) do |path|
+        next unless File.file?(path)
+        next unless File.extname(path) == '.rb'
+        ruby_file_paths << path
+      end
+
+      ruby_file_paths
+    end
+
+    def fail_if_should_not_continue!
+      return if forced?
+
+      # TODO: Check each repository of target files / directories,
+      #   not only the current working directory.
+      return unless Git.command_available?
+      return unless Git.inside_of_repository?
+      return if Git.clean?
+
+      fail 'The current Git repository is not clean. Aborting.'
+    end
+  end
+end

data/lib/transpec/configuration.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+module Transpec
+  class Configuration
+    NEGATIVE_FORMS_OF_TO = ['not_to', 'to_not'].freeze
+
+    PREDICATES = [
+      :convert_to_expect_to_matcher,
+      :convert_to_expect_to_receive,
+      :convert_to_allow_to_receive,
+      :replace_deprecated_method,
+      :parenthesize_matcher_arg
+    ].freeze
+
+    PREDICATES.each do |predicate|
+      attr_accessor predicate
+      alias_method predicate.to_s + '?', predicate
+    end
+
+    attr_accessor :negative_form_of_to
+
+    def initialize
+      PREDICATES.each do |predicate|
+        instance_variable_set('@' + predicate.to_s, true)
+      end
+
+      self.negative_form_of_to = 'not_to'
+    end
+
+    def negative_form_of_to=(form)
+      unless NEGATIVE_FORMS_OF_TO.include?(form.to_s)
+        message = 'Negative form of "to" must be either '
+        message << NEGATIVE_FORMS_OF_TO.map(&:inspect).join(' or ')
+        fail ArgumentError, message
+      end
+
+      @negative_form_of_to = form.to_s.freeze
+    end
+  end
+end

data/lib/transpec/git.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+module Transpec
+  module Git
+    GIT = 'git'
+
+    module_function
+
+    def command_available?
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |path|
+        git_path = File.join(path, GIT)
+        File.exists?(git_path)
+      end
+    end
+
+    def inside_of_repository?
+      system("#{GIT} rev-parse --is-inside-work-tree > /dev/null 2> /dev/null")
+    end
+
+    def clean?
+      `#{GIT} status --porcelain`.empty?
+    end
+  end
+end

data/lib/transpec/rewriter.rb

@@ -0,0 +1,109 @@
+# coding: utf-8
+
+require 'parser'
+require 'parser/current'
+
+module Transpec
+  class Rewriter
+    def initialize(configuration = Configuration.new)
+      @configuration = configuration
+    end
+
+    def rewrite_file!(file_path)
+      source = File.read(file_path)
+      rewritten_source = rewrite(source, file_path)
+      File.write(file_path, rewritten_source)
+    end
+
+    def rewrite(source, name = '(string)')
+      source_buffer = create_source_buffer(source, name)
+      ast = parse(source_buffer)
+
+      @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
+      failed_overlapping_rewrite = false
+      @source_rewriter.diagnostics.consumer = proc { failed_overlapping_rewrite = true }
+
+      AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
+        dispatch_node(node, ancestor_nodes, in_example_group_context)
+      end
+
+      rewritten_source = @source_rewriter.process
+
+      if failed_overlapping_rewrite
+        rewriter = self.class.new(@configuration)
+        rewritten_source = rewriter.rewrite(rewritten_source, name)
+      end
+
+      rewritten_source
+    end
+
+    def create_source_buffer(source, name)
+      source_buffer = Parser::Source::Buffer.new(name)
+      source_buffer.source = source
+      source_buffer
+    end
+
+    def parse(source_buffer)
+      parser = Parser::CurrentRuby.new
+      ast = parser.parse(source_buffer)
+      ast
+    end
+
+    def dispatch_node(node, ancestor_nodes, in_example_group_context)
+      Syntax.all.each do |syntax_class|
+        next unless syntax_class.target_node?(node)
+
+        syntax = syntax_class.new(
+          node,
+          ancestor_nodes,
+          in_example_group_context,
+          @source_rewriter
+        )
+
+        handler_name = "process_#{syntax_class.snake_case_name}"
+        send(handler_name, syntax)
+
+        break
+      end
+    rescue Syntax::NotInExampleGroupContextError => error
+      warn_not_in_example_group_context_error(error)
+    end
+
+    def warn_not_in_example_group_context_error(error)
+      warn error.message
+      warn format(
+        '%s:%d:%s',
+        error.source_buffer.name,
+        error.source_range.line,
+        error.source_range.source_line
+      )
+    end
+
+    def process_should(should)
+      if @configuration.convert_to_expect_to_matcher?
+        should.expectize!(
+          @configuration.negative_form_of_to,
+          @configuration.parenthesize_matcher_arg?
+        )
+      end
+    end
+
+    def process_should_receive(should_receive)
+      if @configuration.convert_to_expect_to_receive?
+        should_receive.expectize!(@configuration.negative_form_of_to)
+      end
+    end
+
+    def process_double(double)
+      double.replace_deprecated_method! if @configuration.replace_deprecated_method?
+    end
+
+    def process_method_stub(method_stub)
+      if @configuration.convert_to_allow_to_receive?
+        method_stub.allowize!
+      elsif @configuration.replace_deprecated_method?
+        method_stub.replace_deprecated_method!
+      end
+    end
+  end
+end

data/lib/transpec/syntax/double.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    class Double < Syntax
+      include SendNodeSyntax
+
+      def self.target_node?(node)
+        return false unless node.type == :send
+        receiver_node, method_name, *_ = *node
+        return false if receiver_node
+        [:double, :mock, :stub].include?(method_name)
+      end
+
+      def replace_deprecated_method!
+        return if method_name == :double
+        @source_rewriter.replace(selector_range, 'double')
+      end
+    end
+  end
+end