table_beet2 0.0.4

data/lib/table_beet/formatters/oneline_formatter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'table_beet/formatters/base_formatter.rb'
+
+module TableBeet
+  module Formatters
+    class OnelineFormatter < BaseFormatter
+      def flush
+        @scopes.each do |name, steps|
+          steps.each do |step|
+            puts "[@#{name}] #{step.name} at:#{step.file}:#{step.lineno}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/table_beet/formatters/text_formatter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'table_beet/formatters/base_formatter.rb'
+
+module TableBeet
+  module Formatters
+    class TextFormatter < BaseFormatter
+      def flush
+        @scopes.each do |name, steps|
+          puts name
+          steps.each do |step|
+            puts "- #{step.name}\tfile://#{step.file}:#{step.lineno}"
+          end
+          puts
+        end
+      end
+    end
+  end
+end

data/lib/table_beet/loader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module TableBeet
+  class Loader
+    def initialize(config = {})
+      @suffix = config[:suffix] || '_steps.rb'
+      @directory = config[:path] || './spec'
+    end
+
+    #
+    # @return  Integer  Size of loaded file
+    #
+    def load
+      # https://github.com/jnicklas/turnip#where-to-place-steps
+      paths.each { |f| Kernel.load(f, true) }
+      paths.length
+    end
+
+    def paths
+      Pathname.glob(pattern)
+    end
+
+    def display_pattern
+      pattern
+    end
+
+    private
+
+    def glob
+      '**/*' + @suffix
+    end
+
+    def pattern
+      File.join(@directory, glob)
+    end
+  end
+end

data/lib/table_beet/reporter.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'table_beet/world'
+require 'table_beet/formatters/text_formatter'
+require 'table_beet/formatters/oneline_formatter'
+require 'table_beet/formatters/html_formatter'
+
+module TableBeet
+  class Reporter
+    #
+    # @param  [Hash]  config
+    #                   :format => [Symbol] Output format
+    #                                         :t or :text is plain text
+    #                                         otherwise HTML
+    #
+    #                   :output => [String] Directory to output'
+    #
+    def self.build(config = {})
+      type   = config[:format]
+      output = config[:output] || './stepdoc'
+      formatter(type).new(TableBeet::World.scopes, output).flush
+    end
+
+    def self.formatter(type)
+      case type
+      when :t, :text
+        TableBeet::Formatters::TextFormatter
+      when :s, :oneline
+        TableBeet::Formatters::OnelineFormatter
+      else
+        TableBeet::Formatters::HTMLFormatter
+      end
+    end
+  end
+end

data/lib/table_beet/runner.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'table_beet/reporter'
+require 'table_beet/loader'
+
+module TableBeet
+  class Runner
+    def initialize(config = {})
+      @config = config
+    end
+
+    def run
+      loader = TableBeet::Loader.new(@config)
+      number_of_load = loader.load
+
+      # TOOD logger..?
+      if number_of_load.zero?
+        puts '[warn] There are no loaded file with specified option.'
+        puts "    finder => #{loader.display_pattern}"
+      end
+
+      TableBeet::Reporter.build(@config)
+    end
+  end
+end

data/lib/table_beet/step.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'method_source'
+
+module TableBeet
+  class Step
+    attr_reader :name, :file, :lineno
+
+    def initialize(method)
+      @method = method
+      @name   = method.name.to_s
+      @file, @lineno = method.source_location
+    end
+
+    def id
+      @method.hash
+    end
+
+    def source
+      @method.comment + @method.source
+    end
+
+    def location
+      File.expand_path(@file) + ':' + @lineno.to_s
+    end
+  end
+end

data/lib/table_beet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TableBeet
+  VERSION = '0.0.4'
+end

data/lib/table_beet/world.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module TableBeet
+  class World
+    #
+    # @return  [Hash]  The hash that { scope name => Array of ::TableBeet:Step }
+    #
+    def self.scopes
+      scopes = Hash.new { |hash, key| hash[key] = [] }
+
+      include_modules.each do |mod, tags|
+        space = Space.new(mod)
+        step_names = space.define_steps
+        next if step_names.empty?
+
+        scope_name = tags.keys.first
+
+        step_names.each do |name|
+          scopes[scope_name] << Step.new(space.method(name))
+        end
+      end
+
+      scopes
+    end
+
+    def self.include_modules
+      RSpec.configuration.instance_variable_get(:@include_modules).items_and_filters
+    end
+
+    class Space
+      def initialize(mod)
+        extend(mod)
+      end
+
+      def define_steps
+        methods.grep(/^match: (?<name>.+)/) { $LAST_MATCH_INFO[:name] }
+      end
+    end
+  end
+end

data/spec/fixtures/steps/global_steps.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+step "Are you talking about :name !!!!!" do |name|
+  expect(name).to eq("Kuririn")
+end
+
+step "When you give up, that's when the game is over." do
+  expect(true).to be true
+end

data/spec/fixtures/steps/test_steps.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+steps_for :test do
+  REQUIRE_TEST = %w[cola pizza].freeze
+
+  #
+  # When to run the test:
+  #   | cola  |
+  #   | pizza |
+  #
+  step "To run the test:" do |table|
+    @tests << table.to_a.flatten
+  end
+
+  #
+  # When to run the test:
+  #   | cola   |
+  #   | report |
+  # Then The test is insufficient
+  #
+  step "the test is insufficient" do
+    expect(@tests).not_to include(*REQUIRE_TEST)
+  end
+end

data/spec/formatters/html_formatter_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'erb'
+
+describe TableBeet::Formatters::HTMLFormatter do
+  before do
+    mock_load
+    scopes = TableBeet::World.scopes
+    directory = OUTPUT_PATH
+    formatter = TableBeet::Formatters::HTMLFormatter.new(scopes, directory)
+    formatter.flush
+  end
+
+  let(:file) do
+    File.readlines(OUTPUT_PATH + '/index.html').join
+  end
+
+  context 'not loaded steps', before_load: true do
+    let(:mock_load) { nil }
+
+    describe '.flush' do
+      it 'should make html that has no scopes and steps' do
+        expect(file).not_to include('<a href="' + ERB::Util.h('#turnip') + '">' + ERB::Util.h('turnip') + '</a>')
+        expect(file).not_to include('<a href="' + ERB::Util.h('#test')   + '">' + ERB::Util.h('test')   + '</a>')
+        expect(file).not_to include(ERB::Util.h('Are you talking about :name !!!!!'))
+        expect(file).not_to include(ERB::Util.h('the test is insufficient'))
+        expect(file).not_to include(ERB::Util.h('To run the test:'))
+        expect(file).not_to include(ERB::Util.h("When you give up, that's when the game is over."))
+      end
+    end
+  end
+
+  context 'not loaded steps' do
+    let(:mock_load) { TableBeet::Loader.new(path: FIXTURES_PATH).load }
+
+    describe '.flush' do
+      it 'should make html that has scopes and steps' do
+        expect(file).to include('<a href="' + ERB::Util.h('#turnip') + '">' + ERB::Util.h('turnip') + '</a>')
+        expect(file).to include('<a href="' + ERB::Util.h('#test')   + '">' + ERB::Util.h('test')   + '</a>')
+        expect(file).to include('<th class="step_name">' + ERB::Util.h('Are you talking about :name !!!!!') + '</th>')
+        expect(file).to include('<th class="step_name">' + ERB::Util.h('the test is insufficient') + '</th>')
+        expect(file).to include('<th class="step_name">' + ERB::Util.h('To run the test:') + '</th>')
+        expect(file).to include('<th class="step_name">' + ERB::Util.h("When you give up, that's when the game is over.") + '</th>')
+      end
+    end
+  end
+end

data/spec/loader_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'pathname'
+
+describe TableBeet::Loader do
+  context 'when not specify in the constructor argument', before_load: true do
+    let(:loader) do
+      TableBeet::Loader.new
+    end
+
+    describe '#display_pattern' do
+      it 'should return default glob pattern' do
+        expect(loader.display_pattern).to eq('./spec/**/*_steps.rb')
+      end
+    end
+  end
+
+  context 'when specify pattern that does not exist', before_load: true do
+    let(:loader) do
+      TableBeet::Loader.new(suffix: '__hoge.rb', path: '/tmp')
+    end
+
+    describe '#display_pattern' do
+      it 'should return glob pattern' do
+        expect(loader.display_pattern).to eq('/tmp/**/*__hoge.rb')
+      end
+    end
+
+    describe '#paths' do
+      it 'should return empty array' do
+        expect(loader.paths).to be_empty
+      end
+    end
+
+    describe '#load' do
+      it 'should return zero' do
+        expect(loader.load).to be_zero
+      end
+    end
+  end
+
+  context 'when specify exist pattern' do
+    let(:loader) do
+      TableBeet::Loader.new(path: FIXTURES_PATH)
+    end
+
+    describe '#paths' do
+      it 'should return load files' do
+        files = Pathname.glob(FIXTURES_PATH + '/*_steps.rb')
+        expect(loader.paths).to eq(files)
+      end
+    end
+
+    describe '#load' do
+      it 'should return number of steps file' do
+        count = Pathname.glob(FIXTURES_PATH + '/*_steps.rb').size
+        expect(loader.load).to eq(count)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'coveralls'
+require 'rspec/core/sandbox'
+require 'table_beet'
+Coveralls.wear!
+
+FIXTURES_PATH = File.dirname(__FILE__) + '/fixtures/steps'
+OUTPUT_PATH = File.dirname(__FILE__) + '/stepdoc'
+
+RSpec.configure do |c|
+  c.around(:each) do |ex|
+    #
+    # Reset the added steps
+    #   on https://github.com/jnicklas/turnip/blob/v1.2.4/lib/turnip/dsl.rb#L21
+    #
+    RSpec::Core::Sandbox.sandboxed do |config|
+      #
+      # Sandbox config does not included Turnip::Steps yet.
+      #
+      config.include Turnip::Steps, turnip: true
+
+      ex.run
+
+      #
+      # Reset the addes 'global' steps
+      #
+      Turnip::Steps.instance_methods.each do |method|
+        Turnip::Steps.module_eval { undef_method method }
+      end
+    end
+  end
+end

data/spec/step_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe TableBeet::Step do
+  let(:step) do
+    TableBeet::Loader.new(path: FIXTURES_PATH).load
+    TableBeet::World.scopes[:turnip].first
+  end
+
+  describe '#id' do
+    it 'should return method id' do
+      expect(step.id).to be_instance_of(Integer).or be_instance_of(Fixnum)
+    end
+  end
+
+  describe '#source' do
+    it 'should return step source' do
+      expect(step.source).to include('expect(name).to eq("Kuririn")')
+    end
+  end
+
+  describe '#location' do
+    it 'should return location of source' do
+      expect(step.location).to include('global_steps.rb:3')
+      expect(step.location).to include(FIXTURES_PATH)
+    end
+  end
+end

data/spec/world_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'pathname'
+
+describe TableBeet::World do
+  let(:scopes) do
+    mock_loader
+    TableBeet::World.scopes
+  end
+
+  context 'before load steps', before_load: true do
+    let(:mock_loader) { nil }
+
+    describe '.scopes' do
+      it 'should return empty hash' do
+        expect(scopes).to be_empty
+      end
+    end
+  end
+
+  context 'after load steps' do
+    let(:mock_loader) { TableBeet::Loader.new(path: FIXTURES_PATH).load }
+
+    describe '.scopes' do
+      it 'should return hash of steps' do
+        expect(scopes.keys.sort).to eq(%i[test turnip].sort)
+      end
+    end
+  end
+end