rspec-jumpstart 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72abb831cb7e020319ad9069bcdfaba93eecb595
+  data.tar.gz: 88b785a7ee71f18bfa1c6c0a4dd291d34b58001e
+SHA512:
+  metadata.gz: 8d81a980d209b1d09931775637a75bfb121ef15e9f3872960f5ec864c000ca441fa73855ae87084e52f3336be612103ab2ffad26ae8c7295bf58ae3831b5abc2
+  data.tar.gz: e52935530d0bc8bdca3b44b00f57477eb2cecb0e3d2c59b177da8f9384b85df210f4e8164935283a4a53d8b711f8b29b564e2b77ebf67b3da19e104f886c154b

data/bin/rspec-jumpstart

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+#
+# rspec-jumpstart [dir/*.rb]
+#
+
+require 'optparse'
+require 'rspec_jumpstart/version'
+require 'rspec_jumpstart/generator'
+
+print_version = false
+force_write   = false
+dry_run       = false
+rails_mode    = false
+spec_dir      = './spec'
+delta_path    = nil
+exc_spec_dir  = nil
+full_path     = nil
+
+opt = OptionParser.new
+opt.on('-f', 'Create if absent or append to the existing spec') { |_| force_write = true }
+opt.on('--force', '') { |_| force_write = true }
+
+opt.on('-n', 'Dry run mode (shows generated code to console)') { |_| dry_run = true }
+opt.on('--dry-run', '') { |_| dry_run = true }
+
+opt.on('-r', 'Run in Rails mode') { |_| rails_mode = true }
+opt.on('--rails', '') { |_| rails_mode = true }
+
+opt.on('-o VAL', 'Output directory (default: ./spec)') { |dir| spec_dir = dir }
+opt.on('--output-dir VAL', '') { |dir| spec_dir = dir }
+
+opt.on('-e VAL', 'Exclude directory (default: ./spec/no-run/**)') { |dir| exc_spec_dir = dir }
+opt.on('--exc-dir VAL', '') { |dir| exc_spec_dir = dir }
+
+opt.on('-D VAL', 'Delta template path (e.g. ./rails_controller_delta.erb)') { |path| delta_path = path }
+opt.on('--delta-template VAL', '') { |path| delta_path = path }
+
+opt.on('-F VAL', 'Full template path (e.g. ./rails_controller_full.erb)') { |path| full_path = path }
+opt.on('--full-template VAL', '') { |path| full_path = path }
+
+opt.on('-v', 'Print version') { |_| print_version = true }
+opt.on('--version', '') { |_| print_version = true }
+
+args = opt.parse(ARGV)
+
+if print_version
+  puts "rspec-jumpstart #{RSpecJumpstart::VERSION}"
+  exit 0
+end
+
+dir_or_file = args.first
+if dir_or_file.nil?
+  puts "Usage: rspec-jumpstart [dir/*.rb] -options"
+  exit 1
+end
+unless dir_or_file.match(/.rb$/)
+  dir_or_file = dir_or_file.gsub(/\/$/, '') + "/**/*.rb"
+end
+
+delta_template = nil
+if delta_path
+  if File.exist?(delta_path)
+    delta_template = File.read(delta_path)
+  else
+    puts "'#{delta_path}' is not found."
+    exit 1
+  end
+end
+
+full_template = nil
+if full_path
+  if File.exist?(full_path)
+    full_template = File.read(full_path)
+  else
+    puts "'#{full_path}' is not found."
+    exit 1
+  end
+end
+
+generator = RSpecJumpstart::Generator.new(spec_dir, delta_template, full_template)
+
+files = Dir.glob(dir_or_file)
+files -= Dir.glob(exc_spec_dir)
+
+files.each do |file_path|
+  generator.write_spec(file_path, force_write, dry_run, rails_mode)
+end
+

data/lib/rspec_jumpstart.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rspec_jumpstart/generator'
+require 'rspec_jumpstart/config'
+require 'rspec_jumpstart/version'
+
+#
+# RSpecJumpstart Facade
+#
+module RSpecJumpstart
+  class << self
+    # Returns RSpecJumpstart's configuration object.
+    # @api private
+    def config
+      @config ||= RSpecJumpstart::Config.instance
+      yield @config if block_given?
+      @config
+    end
+    alias configure config
+
+    def version
+      VERSION
+    end
+  end
+
+  def self.write_spec(file_path, spec_dir = './spec', force_write = false, dry_run = false)
+    generator = RSpecJumpstart::Generator.new(spec_dir)
+    generator.write_spec(file_path, force_write, dry_run)
+  end
+end

data/lib/rspec_jumpstart/config.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module RSpecJumpstart
+  # Global configuration affecting all threads.
+  class Config
+    include Singleton
+
+    attr_accessor :behaves_like_exclusions
+
+    def initialize
+      @behaves_like_exclusions = []
+    end
+  end
+end

data/lib/rspec_jumpstart/erb_factory.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'rspec_jumpstart'
+require 'rspec_jumpstart/erb_templates'
+
+#
+# ERB instance provider
+#
+module RSpecJumpstart
+  class ERBFactory
+
+    def initialize(custom_template)
+      @custom_template = custom_template
+    end
+
+    #
+    # Returns ERB instance for creating new spec
+    #
+    def get_instance_for_new_spec(rails_mode, target_path)
+      template = get_erb_template(@custom_template, true, rails_mode, target_path)
+      ERB.new(template, nil, '-', '_new_spec_code')
+    end
+
+    #
+    # Returns ERB instance for appending lacking tests
+    #
+    def get_instance_for_appending(rails_mode, target_path)
+      template = get_erb_template(@custom_template, false, rails_mode, target_path)
+      ERB.new(template, nil, '-', '_additional_spec_code')
+    end
+
+    private
+
+    #
+    # Returns ERB template
+    #
+    def get_erb_template(custom_template, is_full, rails_mode, target_path)
+      if custom_template
+        custom_template
+      elsif rails_mode && target_path.match(/controllers/)
+        get_rails_controller_template(is_full)
+      elsif rails_mode && target_path.match(/models/)
+        get_rails_model_template(is_full)
+      elsif rails_mode && target_path.match(/helpers/)
+        get_rails_helper_template(is_full)
+      else
+        get_basic_template(is_full)
+      end
+    end
+
+    def get_rails_controller_template(is_full)
+      if is_full
+        RSpecJumpstart::ERBTemplates::RAILS_CONTROLLER_NEW_SPEC_TEMPLATE
+      else
+        RSpecJumpstart::ERBTemplates::RAILS_CONTROLLER_METHODS_PART_TEMPLATE
+      end
+    end
+
+    def get_rails_model_template(is_full)
+      if is_full
+        RSpecJumpstart::ERBTemplates::RAILS_MODEL_NEW_SPEC_TEMPLATE
+      else
+        RSpecJumpstart::ERBTemplates::RAILS_MODEL_METHODS_PART_TEMPLATE
+      end
+    end
+
+    def get_rails_helper_template(is_full)
+      if is_full
+        RSpecJumpstart::ERBTemplates::RAILS_HELPER_NEW_SPEC_TEMPLATE
+      else
+        RSpecJumpstart::ERBTemplates::RAILS_HELPER_METHODS_PART_TEMPLATE
+      end
+    end
+
+    def get_basic_template(is_full)
+      if is_full
+        RSpecJumpstart::ERBTemplates::BASIC_NEW_SPEC_TEMPLATE
+      else
+        RSpecJumpstart::ERBTemplates::BASIC_METHODS_PART_TEMPLATE
+      end
+    end
+
+  end
+end

data/lib/rspec_jumpstart/erb_templates.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'rspec_jumpstart'
+
+#
+# ERB templates
+#
+module RSpecJumpstart
+  module ERBTemplates
+
+    BASIC_METHODS_PART_TEMPLATE = <<~SPEC
+      <%- methods_to_generate.map { |method| %>
+        # TODO: auto-generated
+        describe '<%= decorated_name(method) %>' do
+          it '<%= method.name %>' do
+      <%- if get_instantiation_code(c, method)      -%><%= get_instantiation_code(c, method) %><%- end -%>
+      <%- if get_params_initialization_code(method) -%><%= get_params_initialization_code(method) %><%- end -%>
+            result = <%= get_method_invocation_code(c, method).sub(c.to_s,'described_class') %>
+
+            expect(result).not_to be_nil
+          end
+        end
+      <% } %>
+SPEC
+
+    BASIC_NEW_SPEC_TEMPLATE = <<~SPEC
+      # frozen_string_literal: true
+
+      <% if rails_mode then %>require 'rails_helper'
+      <% else -%>require 'spec_helper'
+      <% end -%>
+      <% unless rails_mode then %>require '<%= self_path %>'
+      <% end -%>
+
+      RSpec.describe <%= to_string_namespaced_path_whole(file_path) %> do
+      <%= ERB.new(BASIC_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
+      end
+SPEC
+
+    RAILS_CONTROLLER_METHODS_PART_TEMPLATE = <<~SPEC
+      <%- methods_to_generate.map { |method| %>
+        # TODO: auto-generated
+        describe '<%= decorated_name(method) %>' do
+          it '<%= get_rails_http_method(method.name).upcase %> <%= method.name %>' do
+            <%= get_rails_http_method(method.name) %> :<%= method.name %>, {}, {}
+
+            expect(response).to have_http_status(:ok)
+          end
+        end
+      <% } %>
+SPEC
+
+    RAILS_CONTROLLER_NEW_SPEC_TEMPLATE = <<~SPEC
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe <%= (to_string_namespaced_path(self_path) + get_complete_class_name(c)).split('::').uniq.join('::') %>, type: :controller do
+      <%= ERB.new(RAILS_CONTROLLER_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
+      end
+SPEC
+
+    RAILS_MODEL_METHODS_PART_TEMPLATE = <<~SPEC
+      <%= ERB.new(RAILS_MODEL_SCOPE_PART_TEMPLATE, nil, '-').result(binding) -%>
+      <%- methods_to_generate.map { |method| %>
+        # TODO: auto-generated
+        describe '<%= decorated_name(method) %>' do
+          it '<%= method.name %>' do
+      <%- if get_instantiation_code(c, method)      -%><%= get_instantiation_code(c, method) %><%- end -%>
+      <%- if get_params_initialization_code(method) -%><%= get_params_initialization_code(method) %><%- end -%>
+            result = <%= get_method_invocation_code(c, method).sub(c.to_s,'described_class') %>
+
+            expect(result).not_to be_nil
+          end
+        end
+      <% } %>
+SPEC
+
+    RAILS_MODEL_SCOPE_PART_TEMPLATE = <<~SPEC
+      <%- scope_methods_to_generate.map { |method| %>
+        # TODO: auto-generated
+        describe '.<%= method %>' do # scope test
+          it 'supports named scope <%= method %>' do
+            expect(described_class.limit(3).<%= method %>).to all(be_a(described_class))
+          end
+        end<% } %>
+SPEC
+
+    RAILS_MODEL_NEW_SPEC_TEMPLATE = <<~SPEC
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+      require 'shared_model_stuff'
+
+      RSpec.describe <%= (to_string_namespaced_path(self_path) + get_complete_class_name(c)).split('::').uniq.join('::') %>, type: :model do
+        it_behaves_like 'real_model'
+      <%= ERB.new(RAILS_MODEL_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
+      end
+SPEC
+
+    RAILS_HELPER_METHODS_PART_TEMPLATE = <<~SPEC
+      <%- methods_to_generate.map { |method| %>
+        # TODO: auto-generated
+        describe '<%= decorated_name(method) %>' do
+          it 'works' do
+            result = <%= get_rails_helper_method_invocation_code(method) %>
+
+            expect(result).not_to be_nil
+          end
+        end
+      <% } %>
+SPEC
+
+    RAILS_HELPER_NEW_SPEC_TEMPLATE = <<~SPEC
+      # frozen_string_literal: true
+
+      require 'rails_helper'
+
+      RSpec.describe <%= (to_string_namespaced_path(self_path) + get_complete_class_name(c)).split('::').uniq.join('::') %>, type: :helper do
+      <%= ERB.new(RAILS_HELPER_METHODS_PART_TEMPLATE, nil, '-').result(binding) -%>
+      end
+SPEC
+
+  end
+end

data/lib/rspec_jumpstart/generator.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+require 'rdoc'
+require 'rspec_jumpstart'
+require 'rspec_jumpstart/erb_factory'
+require 'rspec_jumpstart/erb_templates'
+require 'rspec_jumpstart/rdoc_factory'
+
+#
+# RSpec Code Generator
+#
+module RSpecJumpstart
+  class Generator
+    include RSpecJumpstart::ERBTemplates
+
+    attr_accessor :spec_dir, :delta_template, :full_template
+
+    def initialize(spec_dir = './spec', delta_template = nil, full_template = nil)
+      @spec_dir       = spec_dir.gsub(/\/$/, '')
+      @delta_template = delta_template
+      @full_template  = full_template
+    end
+
+    #
+    # Writes new spec or appends to the existing spec.
+    #
+    def write_spec(file_path, force_write = false, dry_run = false, rails_mode = false)
+      begin
+        code            = ''
+        class_or_module = RSpecJumpstart::RDocFactory.get_rdoc_class_or_module(file_path)
+        if class_or_module
+          spec_path = get_spec_path(file_path)
+
+          code = if force_write && File.exist?(spec_path)
+                   append_to_existing_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
+                 else
+                   create_new_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
+                 end
+        else
+          puts red("#{file_path} skipped (Class/Module not found).")
+        end
+      rescue Exception => e
+        puts red("#{file_path} aborted - #{e.message}")
+      end
+
+      code
+    end
+
+    #
+    # Gets the complete class name from RDoc::NormalClass/RDoc::NormalModule instance.
+    #
+    def get_complete_class_name(class_or_module, name = class_or_module.name)
+      if class_or_module.parent.name && class_or_module.parent.is_a?(RDoc::NormalModule)
+        get_complete_class_name(class_or_module.parent, "#{class_or_module.parent.name}::#{name}")
+      else
+        name
+      end
+    end
+
+    def to_string_namespaced_path(self_path)
+      path = self_path.split('/').map { |x| camelize(x) }[1..-2].uniq.join('::')
+      path.empty? ? '' : path + '::'
+    end
+
+    def to_string_namespaced_path_whole(self_path)
+      self_path.
+        sub('.rb', '').
+        split('/').
+        map { |x| camelize(x) }[2..-1].
+        uniq.
+        join('::')
+    end
+
+    def decorated_name(method)
+      (method.singleton ? '.' : '#') + method.name
+    end
+
+    #
+    # Returns spec file path.
+    # e.g. "lib/foo/bar_baz.rb" -> "spec/foo/bar_baz_spec.rb"
+    #
+    def get_spec_path(file_path)
+      spec_dir + '/' + file_path.
+        gsub(/^\.\//, '').
+        gsub(%r{^(lib/)|(app/)}, '').
+        sub(/\.rb$/, '_spec.rb')
+    end
+
+    #
+    # Returns string value to require.
+    # e.g. "lib/foo/bar_baz.rb" -> "foo/bar_baz"
+    #
+    def to_string_value_to_require(file_path)
+      file_path.gsub(%r{^(lib/)|(app/)}, '').gsub(/\.rb$/, '')
+    end
+
+    #
+    # Returns snake_case name.
+    # e.g. FooBar -> "foo_bar"
+    #
+    def instance_name(c)
+      c.name.
+        gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr('-', '_').
+        downcase
+    end
+
+    #
+    # Extracts parameter names as an *Array*.
+    # e.g. "()" -> []
+    # e.g. "(a, b = 'foo')" -> ["a", "b"]
+    #
+    def to_param_names_array(params)
+      params.
+        split(',').
+        map { |p| p.gsub(/[()\s]/, '').gsub(/=.+$/, '') }.
+        reject { |p| p.nil? || p.empty? }
+    end
+
+    #
+    # Returns params part
+    # e.g. ["a","b"] -> "(a, b)"
+    # e.g. [] -> ""
+    #
+    def to_params_part(params)
+      param_csv = to_param_names_array(params).join(', ')
+      param_csv.empty? ? '' : "(#{param_csv})"
+    end
+
+    #
+    # Creates new spec.
+    #
+    # rubocop:disable Metrics/AbcSize
+    def create_new_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
+      # These names are used in ERB template, don't delete.
+      methods_to_generate       = public_methods_found(class_or_module)
+      scope_methods_to_generate = scopes(class_or_module, file_path, spec_path)
+      c                         = class_or_module
+      self_path                 = to_string_value_to_require(file_path)
+      # rubocop:enable Lint/UselessAssignment
+
+      erb  = RSpecJumpstart::ERBFactory.
+        new(@full_template).
+        get_instance_for_new_spec(rails_mode, file_path)
+      code = erb.result(binding)
+
+      if dry_run
+        puts "----- #{spec_path} -----"
+        puts code
+      elsif File.exist?(spec_path)
+        # puts yellow("#{spec_path} already exists.")
+      else
+        FileUtils.mkdir_p(File.dirname(spec_path))
+        File.open(spec_path, 'w') { |f| f.write(code) }
+        puts green("#{spec_path} created.")
+      end
+
+      code
+    end
+
+    def public_methods_found(class_or_module)
+      class_or_module.method_list.select do |m|
+        m.visibility.equal?(:public) && m.name != 'new'
+      end
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    #
+    # Appends new tests to the existing spec.
+    #
+    # rubocop:disable Metrics/AbcSize
+    def append_to_existing_spec(class_or_module, dry_run, rails_mode, file_path, spec_path)
+      existing_spec = File.read(spec_path)
+      if skip?(existing_spec)
+        return
+      end
+      lacking_methods = public_methods_found(class_or_module).
+        reject { |m| existing_spec.match(signature(m)) }
+
+      scope_methods_to_generate = scopes(class_or_module, file_path, spec_path)
+      if lacking_methods.empty? && scope_methods_to_generate.empty?
+        # puts yellow("#{spec_path} skipped.")
+      else
+        # These names are used in ERB template, don't delete.
+        methods_to_generate = lacking_methods
+        c                   = class_or_module
+        # rubocop:enable Lint/UselessAssignment
+
+        erb             = RSpecJumpstart::ERBFactory.new(@delta_template).get_instance_for_appending(rails_mode, spec_path)
+        additional_spec = erb.result(binding)
+
+        last_end_not_found = true
+        code               = existing_spec.split("\n").reverse.reject do |line|
+          before_modified    = last_end_not_found
+          last_end_not_found = line.gsub(/#.+$/, '').strip != 'end' if before_modified
+          before_modified
+        end.reverse.join("\n") + "\n" + additional_spec + "\nend\n"
+
+        if dry_run
+          puts "----- #{spec_path} -----"
+          puts code
+        else
+          File.open(spec_path, 'w') { |f| f.write(code) }
+        end
+        puts green("#{spec_path} modified.")
+      end
+
+      code
+    end
+
+    def skip?(text)
+      RSpecJumpstart.config.behaves_like_exclusions.each do |exclude_pattern|
+          return true if text.match(exclude_pattern)
+      end
+
+      false
+    end
+
+    # rubocop:enable Metrics/AbcSize
+
+    # -----
+    # Code generation
+    # -----
+
+    #
+    # e.g.
+    #     a = double('a')
+    #     b = double('b')
+    #     bar_baz = BarBaz.new(a, b)
+    #
+    def get_instantiation_code(c, method)
+      if method.singleton
+        ''
+      else
+        constructor = c.method_list.find { |m| m.name == 'new' }
+        if constructor.nil?
+          "      #{instance_name(c)} = described_class.new\n"
+        else
+          get_params_initialization_code(constructor) +
+            "      #{instance_name(c)} = described_class.new#{to_params_part(constructor.params)}\n"
+        end
+      end
+    end
+
+    #
+    # e.g.
+    #     a = double('a')
+    #     b = double('b')
+    #
+    def get_params_initialization_code(method)
+      code = to_param_names_array(method.params).map do |p|
+        x = p.sub('*', '').sub('&', '')
+        "      #{x} = double('#{x}')" unless x.empty?
+      end.compact.join("\n")
+      code.empty? ? '' : "#{code}\n"
+    end
+
+    #
+    # e.g. BarBaz.do_something(a, b) { |c| }
+    #
+    def get_method_invocation_code(c, method)
+      target = method.singleton ? 'described_class' : instance_name(c)
+      "#{target}.#{method.name}#{to_params_part(method.params)}#{get_block_code(method)}"
+    end
+
+    #
+    # e.g. do_something(a, b) { |c| }
+    #
+    def get_rails_helper_method_invocation_code(method)
+      "#{method.name}#{to_params_part(method.params)}#{get_block_code(method)}"
+    end
+
+    #
+    # e.g. { |a, b| }
+    #
+    def get_block_code(method)
+      if method.block_params.nil? || method.block_params.empty?
+        ''
+      else
+        " { |#{method.block_params}| }"
+      end
+    end
+
+    def get_rails_http_method(method_name)
+      RAILS_RESOURCE_METHOD_AND_HTTP_METHOD[method_name] || 'get'
+    end
+
+    private
+
+    def parse_sexp(sexp, scopes, methods, stack = [])
+      case sexp[0]
+        when :module
+          parse_sexp(sexp[2], scopes, methods, stack + [sexp[0], sexp[1][1][1]])
+
+        when :vcall
+          name = sexp[1][1]
+          return if name.eql?('private')
+
+        when :command
+          if sexp[1][0] == :@ident && sexp[1][1] == 'scope'
+            name = sexp[2][1][0][1][1][1]
+            scopes << name
+          end
+
+        when :class
+          parse_sexp(sexp[3], scopes, methods, stack + [sexp[0], sexp[1][1][1]])
+
+        when :def
+          name = sexp[1][1]
+          # line_number = sexp[1][2][0]
+
+          parse_sexp(sexp[3], scopes, methods, stack + [sexp[0], sexp[1][1]])
+
+          # puts "#{line_number}: Method: #{stack.last}##{name}\n"
+          methods << name
+        else
+          if sexp.is_a?(Array)
+            sexp.each { |s| parse_sexp(s, scopes, methods, stack) if s.is_a?(Array) }
+          end
+      end
+    end
+
+    require 'ripper'
+
+    def scopes(_klass, file_path, spec_path)
+      content      = File.read(file_path)
+      spec_content = (
+      begin
+        File.read(spec_path)
+      rescue
+        ''
+      end)
+      sexp         = Ripper.sexp(content)
+      methods      = []
+      scopes       = []
+
+      parse_sexp(sexp, scopes, methods)
+
+      scope_methods = []
+      scopes.each do |method|
+        unless spec_content.include?("'.#{method}'")
+          scope_methods << method
+        end
+      end
+
+      scope_methods
+    end
+
+    def signature(method)
+      "'#{decorated_name(method).sub('?', '\?').gsub('[', '\[').gsub(']', '\]')}'"
+    end
+
+    def colorize(text, color_code)
+      "#{color_code}#{text}\033[0m"
+    end
+
+    def red(text)
+      colorize(text, "\033[31m")
+    end
+
+    def green(text)
+      colorize(text, "\033[32m")
+    end
+
+    def blue(text)
+      colorize(text, "\033[34m")
+    end
+
+    def yellow(text)
+      colorize(text, "\033[33m")
+    end
+
+    def camelize(str)
+      str.split('_').map { |w| w.capitalize }.join
+    end
+
+    RAILS_RESOURCE_METHOD_AND_HTTP_METHOD = {
+      'index'   => 'get',
+      'new'     => 'get',
+      'create'  => 'post',
+      'show'    => 'get',
+      'edit'    => 'get',
+      'update'  => 'patch',
+      'destroy' => 'delete'
+    }.freeze
+
+  end
+end
+

data/lib/rspec_jumpstart/rdoc_factory.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'rdoc'
+require 'rdoc/generator'
+require 'rdoc/options'
+require 'rdoc/parser/ruby'
+require 'rdoc/stats'
+require 'rspec_jumpstart'
+
+#
+# RDoc instance factory
+#
+module RSpecJumpstart
+  class RDocFactory
+
+    #
+    # Returns RDoc::NormalClass/RDoc::NormalModule instance.
+    #
+    def self.get_rdoc_class_or_module(file_path)
+      top_level = get_ruby_parser(file_path).scan
+      extract_target_class_or_module(top_level)
+    end
+
+    #
+    # Creates new RDoc::Parser::Ruby instance.
+    #
+    def self.get_ruby_parser(file_path)
+      top_level = RDoc::TopLevel.new(file_path)
+      if RUBY_VERSION.to_f < 2.0
+        # reset is removed since 2.0
+        RDoc::TopLevel.reset
+      end
+
+      # RDoc::Stats initialization
+      if defined?(RDoc::Store)
+        # RDoc 4.0.0 requires RDoc::Store internally.
+        store = RDoc::Store.new
+        top_level.store = store
+        stats = RDoc::Stats.new(store, 1)
+      else
+        stats = RDoc::Stats.new(1)
+      end
+
+      RDoc::Parser::Ruby.new(
+        top_level,
+        file_path,
+        File.read(file_path),
+        RDoc::Options.new,
+        stats
+      )
+    end
+
+    #
+    # Extracts RDoc::NormalClass/RDoc::NormalModule from RDoc::TopLevel.
+    #
+    def self.extract_target_class_or_module(top_level)
+      c = top_level.classes.first
+      if c.nil?
+        m = top_level.modules.first
+        if m.nil?
+          top_level.is_a?(RDoc::NormalModule) ? top_level : nil
+        else
+          extract_target_class_or_module(m)
+        end
+      else
+        c
+      end
+    end
+
+  end
+end

data/lib/rspec_jumpstart/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+#
+# Gem version
+#
+module RSpecJumpstart
+  VERSION = '1.1.1'
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: rspec-jumpstart
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Timothy Chambers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-05 00:00:00.000000000 Z
+dependencies: []
+description: rspec-jumpstart supports you writing tests for existing code.
+email:
+- tim@possibilogy.com
+executables:
+- rspec-jumpstart
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/rspec-jumpstart
+- lib/rspec_jumpstart.rb
+- lib/rspec_jumpstart/config.rb
+- lib/rspec_jumpstart/erb_factory.rb
+- lib/rspec_jumpstart/erb_templates.rb
+- lib/rspec_jumpstart/generator.rb
+- lib/rspec_jumpstart/rdoc_factory.rb
+- lib/rspec_jumpstart/version.rb
+homepage: https://github.com/tjchambers/rspec-jumpstart
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: rspec-jumpstart supports you writing tests for existing code.
+test_files: []