specify 0.10.2 → 1.0.0

data/Rakefile

@@ -1,21 +1,25 @@
 #!/usr/bin/env rake
-require 'bundler/gem_tasks'
-require 'rdoc/task'
-require 'rubocop/rake_task'
-require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+require "rdoc/task"
+require "rubocop/rake_task"
+require "rspec/core/rake_task"
 
 RuboCop::RakeTask.new
 
+RSpec::Core::RakeTask.new(:spec)
+
 namespace :spec do
   desc 'Clean all generated reports'
   task :clean do
     system('rm -rf spec/reports')
+    system('rm -rf spec/coverage')
   end
 
   RSpec::Core::RakeTask.new(all: :clean) do |config|
-    options  = %w(--color)
-    options += %w(--format documentation)
-    options += %w(--format html --out spec/reports/unit-test-report.html)
+    options  = %w[--color]
+    options += %w[--format documentation]
+    options += %w[--format html --out spec/reports/test-report.html]
 
     config.rspec_opts = options
   end

data/bin/console

@@ -1,10 +1,7 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup'
-require 'specify'
+require "bundler/setup"
+require "specify"
 
-require 'pry'
+require "pry"
 Pry.start
-
-# require 'irb'
-# IRB.start

data/bin/setup

@@ -1,5 +1,8 @@
-#!/bin/bash
+#!/usr/bin/env bash
 set -euo pipefail
 IFS=$'\n\t'
+set -vx
 
 bundle install
+
+# Do any other automated setup that you need to do here

data/lib/specify.rb

@@ -1,47 +1,36 @@
-require 'rspec/core'
-require 'rspec/core/world'
-require 'rspec/core/reporter'
-require 'rspec/core/formatters'
-require 'rspec/core/example_group'
-require 'rspec/core/formatters/console_codes'
-require 'rspec/core/formatters/documentation_formatter'
-
-require 'specify/spec'
-require 'specify/version'
-require 'specify/rspec/world'
-require 'specify/rspec/reporter'
-require 'specify/rspec/notification'
-require 'specify/rspec/example_group'
-require 'specify/rspec/documentation_formatter'
-
-RSpec::Core::ExampleGroup.send :include, RSpec::Specify::ExampleGroup
-RSpec::Core::Reporter.send :include, RSpec::Specify::Reporter
-RSpec::Core::World.send :include, RSpec::Specify::World
-
-RSpec::Core::Formatters::DocumentationFormatter.send :include, RSpec::Specify::DocumentationFormatter
-
-formatter = RSpec.world.reporter.find_registered_formatter(RSpec::Core::Formatters::DocumentationFormatter)
-RSpec.world.reporter.register_listener(
-  formatter,
-  :example_started,
-  :example_step_passed,
-  :example_step_pending,
-  :example_step_failed,
-) if formatter
-
-RSpec::Core::ExampleGroup.define_example_method :Scenario, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :Condition, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :Behavior, with_steps: true
-
-RSpec::Core::ExampleGroup.define_example_method :Step, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :Test, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :Rule, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :Fact, with_steps: true
-
-RSpec::Core::ExampleGroup.define_example_method :steps, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :rules, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :tests, with_steps: true
-RSpec::Core::ExampleGroup.define_example_method :facts, with_steps: true
-
-require 'specify/rspec/shared_steps'
-include RSpec::Specify::SharedSteps
+require "specify/version"
+
+require "specify/spec"
+require "specify/rspec/world"
+require "specify/rspec/reporter"
+require "specify/rspec/formatter"
+require "specify/rspec/notification"
+require "specify/rspec/example_group"
+
+require "specify/rspec/shared_steps"
+
+module Specify
+  include RSpec::Specify::SharedSteps
+
+  ::RSpec::Core::ExampleGroup.define_example_method :Scenario, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :Condition, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :Behavior, has_steps: true
+
+  ::RSpec::Core::ExampleGroup.define_example_method :scenario, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :condition, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :behavior, has_steps: true
+
+  ::RSpec::Core::ExampleGroup.define_example_method :Steps, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :Tests, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :Rules, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :Facts, has_steps: true
+
+  ::RSpec::Core::ExampleGroup.define_example_method :steps, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :rules, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :tests, has_steps: true
+  ::RSpec::Core::ExampleGroup.define_example_method :facts, has_steps: true
+
+  ::RSpec::Core::ExampleGroup.send :include, RSpec::Specify::ExampleGroup
+  ::RSpec::Core::Reporter.send :include, RSpec::Specify::Reporter
+  ::RSpec::Core::World.send :include, RSpec::Specify::World
+end

data/lib/specify/rspec/example_group.rb

@@ -1,85 +1,92 @@
 module RSpec
   module Specify
     module ExampleGroup
-      # In Rspec, example group bodies are delimited by 'describe' and
-      # 'context' methods. These encapsulate examples, which are
-      # delimited by 'it' methods. Example groups are evaluated in the
-      # context of an ExampleGroup instance. Individual examples are
-      # evaluated in the context of an instance of the ExampleGroup
-      # to which they belong.
-
       def include_steps(*args)
         name = args.shift
+
         shared_block = ::RSpec.world.shared_example_steps[name]
-        shared_block || raise(ArgumentError, "Could not find shared steps #{name.inspect}")
+        shared_block || raise(ArgumentError,
+          "Unable to find shared steps '#{name.inspect}'")
+
         instance_exec(*args, &shared_block)
       end
 
+      # rubocop:disable Naming/MethodName
       def Given(message, options = {}, &block)
-        Action :given, message, options, &block
+        run_example_step(:given, message, options, &block)
       end
 
       def When(message, options = {}, &block)
-        Action :when, message, options, &block
+        run_example_step(:when, message, options, &block)
       end
 
       def Then(message, options = {}, &block)
-        Action :then, message, options, &block
+        run_example_step(:then, message, options, &block)
       end
 
       def And(message, options = {}, &block)
-        Action :and, message, options, &block
+        run_example_step(:and, message, options, &block)
       end
 
       def But(message, options = {}, &block)
-        Action :but, message, options, &block
+        run_example_step(:but, message, options, &block)
       end
+      # rubocop:enable Naming/MethodName
 
-      def it(message, options = {}, &block)
-        Action :it, message, options, &block
+      def rule(message, options = {}, &block)
+        run_example_step(:rule, message, options, &block)
       end
 
-      def specify(message, options = {}, &block)
-        Action :specify, message, options, &block
+      def fact(message, options = {}, &block)
+        run_example_step(:fact, message, options, &block)
       end
 
-      def example(message, options = {}, &block)
-        Action :example, message, options, &block
+      def test(message, options = {}, &block)
+        run_example_step(:test, message, options, &block)
       end
 
-      def rule(message, options = {}, &block)
-        Action :rule, message, options, &block
+      def step(message, options = {}, &block)
+        run_example_step(:step, message, options, &block)
       end
 
-      def fact(message, options = {}, &block)
-        Action :fact, message, options, &block
+      def it(message, options = {}, &block)
+        run_example_step(:it, message, options, &block)
       end
 
-      def test(message, options = {}, &block)
-        Action :test, message, options, &block
+      def specify(message, options = {}, &block)
+        run_example_step(:specify, message, options, &block)
       end
 
-      def step(message, options = {}, &block)
-        Action :step, message, options, &block
+      def example(message, options = {}, &block)
+        run_example_step(:example, message, options, &block)
       end
 
       private
 
-      def Action(type, message, options = {}, &_block)
-        ::RSpec.world.reporter.example_step_started(self, type, message, options)
-        options = { pending: true } if options == :pending
-
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            ::RSpec.world.reporter.example_step_failed(self, type, message, options)
-            raise e
-          end
-          ::RSpec.world.reporter.example_step_passed(self, type, message, options)
+      def run_example_step(type, msg, opts = {}, &block)
+        ::RSpec.world.reporter.example_step_started(self, type, msg, opts)
+
+        opts = { pending: true } if opts == :pending
+
+        if block_given? && !opts[:pending]
+          execute_step(type, msg, opts, &block)
         else
-          ::RSpec.world.reporter.example_step_pending(self, type, message, options)
+          ::RSpec.world.reporter.example_step_pending(
+            self, type, msg, opts
+          )
+        end
+      end
+
+      def execute_step(type, msg, opts, &_block)
+        begin
+          yield
+        # rubocop:disable Lint/RescueException
+        rescue Exception => e
+          ::RSpec.world.reporter.example_step_failed(self, type, msg, opts)
+          raise e
         end
+        # rubocop:enable Lint/RescueException
+        ::RSpec.world.reporter.example_step_passed(self, type, msg, opts)
       end
     end
   end

data/lib/specify/rspec/formatter.rb

@@ -0,0 +1,72 @@
+require "rspec/core/formatters/console_codes"
+require "rspec/core/formatters/documentation_formatter"
+
+module RSpec
+  module Specify
+    class Formatter < ::RSpec::Core::Formatters::DocumentationFormatter
+      ::RSpec::Core::Formatters.register(
+        self,
+        :example_started, :example_passed,
+        :example_step_passed, :example_step_failed,
+        :example_step_pending
+      )
+
+      def example_started(notification)
+        return unless notification.example.metadata[:has_steps]
+
+        indentation = current_indentation
+        description = notification.example.description
+
+        full_message = "#{indentation}#{description}"
+        output.puts(
+          ::RSpec::Core::Formatters::ConsoleCodes.wrap(full_message, :default)
+        )
+      end
+
+      def example_passed(notification)
+        super unless notification.example.metadata[:has_steps]
+      end
+
+      def example_step_passed(notification)
+        indentation = current_indentation
+        step_type = notification.type.to_s.capitalize
+        step_message = notification.message
+
+        full_message = "#{indentation}  #{step_type} #{step_message}"
+        output.puts(
+          ::RSpec::Core::Formatters::ConsoleCodes.wrap(full_message, :success)
+        )
+      end
+
+      def example_step_failed(notification)
+        indentation = current_indentation
+        step_type = notification.type.to_s.capitalize
+        step_message = notification.message
+
+        full_message = "#{indentation}  #{step_type} #{step_message} (FAILED)"
+        output.puts(
+          ::RSpec::Core::Formatters::ConsoleCodes.wrap(full_message, :failure)
+        )
+      end
+
+      def example_step_pending(notification)
+        indentation = current_indentation
+        step_type = notification.type.to_s.capitalize
+        step_message = notification.message
+
+        full_message = "#{indentation}  #{step_type} #{step_message}"
+
+        full_message << if notification.options[:pending] &&
+                           notification.options[:pending] != true
+                          " (PENDING: #{notification.options[:pending]})"
+                        else
+                          " (PENDING)"
+                        end
+
+        output.puts(
+          ::RSpec::Core::Formatters::ConsoleCodes.wrap(full_message, :pending)
+        )
+      end
+    end
+  end
+end

data/lib/specify/rspec/notification.rb

@@ -1,8 +1,5 @@
 module RSpec
   module Specify
-    # In RSpec, notifications are value objects that are passed to formatters
-    # to provide those formatters with information about a particular event.
-
     Notification = Struct.new(:example, :type, :message, :options)
   end
 end

data/lib/specify/rspec/reporter.rb

@@ -1,31 +1,24 @@
 module RSpec
   module Specify
     module Reporter
-      # An RSpec reporter sends notifications to listeners. The listeners
-      # are usually formatters for a specific test run.
-
       def example_step_started(example, type, message, options)
-        notify :example_step_started, Notification.new(example, type, message, options)
+        notify :example_step_started,
+          Notification.new(example, type, message, options)
       end
 
       def example_step_passed(example, type, message, options)
-        notify :example_step_passed, Notification.new(example, type, message, options)
+        notify :example_step_passed,
+          Notification.new(example, type, message, options)
       end
 
       def example_step_failed(example, type, message, options)
-        notify :example_step_failed, Notification.new(example, type, message, options)
+        notify :example_step_failed,
+          Notification.new(example, type, message, options)
       end
 
       def example_step_pending(example, type, message, options)
-        notify :example_step_pending, Notification.new(example, type, message, options)
-      end
-
-      def registered_formatters
-        @listeners.values.map(&:to_a).flatten.uniq
-      end
-
-      def find_registered_formatter(cls)
-        registered_formatters.detect { |formatter| formatter.class == cls }
+        notify :example_step_pending,
+          Notification.new(example, type, message, options)
       end
     end
   end

data/lib/specify/rspec/shared_steps.rb

@@ -10,10 +10,8 @@ module RSpec
 
       def ensure_shared_example_steps_name_not_taken(name)
         return unless ::RSpec.world.shared_example_steps.key?(name)
+
         raise(ArgumentError, "Shared step '#{name}' already exists")
-        # if ::RSpec.world.shared_example_steps.key?(name)
-        #  raise ArgumentError.new("Shared step '#{name}' already exists")
-        # end
       end
     end
   end

data/lib/specify/rspec/world.rb

@@ -1,9 +1,6 @@
 module RSpec
   module Specify
     module World
-      # RSpec's world is an internal container for global
-      # non-configuration data.
-
       def shared_example_steps
         @shared_example_steps ||= {}
       end

data/lib/specify/spec.rb

@@ -1,39 +1,45 @@
 module Specify
   module Spec
-    def self.included(base)
-      base.instance_eval do
-        alias :Background :before
-        alias :Setup      :before
-        alias :Teardown   :after
-
+    # rubocop:disable Metrics/MethodLength
+    def self.included(caller)
+      caller.instance_eval do
         alias :Feature    :context
+        alias :feature    :context
         alias :Ability    :context
-        alias :Story      :context
+        alias :ability    :context
         alias :Component  :context
+        alias :component  :context
         alias :Workflow   :context
+        alias :workflow   :context
+        alias :Service    :context
+        alias :service    :context
+
+        alias :Background :before
+        alias :Setup      :before
+        alias :Teardown   :after
+        alias :Cleanup    :after
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end
 
+# rubocop:disable Naming/MethodName
 def self.Feature(*args, &block)
-  describe(*args, &block)
+  RSpec.describe(*args, &block)
 end
 
-def self.Ability(*args, &block)
-  describe(*args, &block)
+def self.feature(*args, &block)
+  RSpec.describe(*args, &block)
 end
 
 def self.Story(*args, &block)
-  describe(*args, &block)
-end
-
-def self.Component(*args, &block)
-  describe(*args, &block)
+  RSpec.describe(*args, &block)
 end
 
-def self.Workflow(*args, &block)
-  describe(*args, &block)
+def self.story(*args, &block)
+  RSpec.describe(*args, &block)
 end
+# rubocop:enable Naming/MethodName
 
 RSpec.configuration.include Specify::Spec