aygabtu 0.2.0

data/lib/aygabtu/scope/namespace_controller.rb

@@ -0,0 +1,50 @@
+module Aygabtu
+  module Scope
+    module NamespaceController
+      def namespace(name)
+        raise "nesting/chaining namespace in/after controller makes no sense" if @data[:controller]
+        raise "nesting/chaining namespace in/after action makes no sense" if @data[:action]
+
+        new_namespace = Pathname(@data[:namespace] || '').join(name.to_s).to_s
+        new_data = @data.dup.merge(namespace: new_namespace)
+        self.class.new(new_data)
+      end
+
+      def controller(name)
+        raise "nesting/chaining controller scopes makes no sense" if @data[:controller]
+        raise "nesting/chaining namespace in/after action makes no sense" if @data[:action]
+
+        new_controller = name.to_s
+        new_data = @data.dup.merge(controller: new_controller)
+        self.class.new(new_data)
+      end
+
+      def matches_route?(route)
+        namespace, controller = @data[:namespace], @data[:controller]
+
+        return false if (namespace || controller) && !route.controller
+        return super unless namespace || controller
+
+        namespace = Pathname(namespace || '')
+        path = namespace.join(controller || '').to_s
+        if controller
+          path == route.controller
+        else
+          controller_namespace = route.controller_namespace || ''
+          (controller_namespace + '/').start_with?(path + '/')
+        end && super
+      end
+
+      def inspect_data
+        super.merge(
+          namespace: inspected_or_nil(@data[:namespace]),
+          controller: inspected_or_nil(@data[:controller]))
+      end
+
+      def self.factory_methods
+        [ :namespace, :controller ]
+      end
+    end
+  end
+end
+

data/lib/aygabtu/scope/remaining.rb

@@ -0,0 +1,27 @@
+module Aygabtu
+  module Scope
+    module Remaining
+      def remaining_at(checkpoint)
+        new_data = @data.dup.merge(remaining_at: checkpoint)
+        self.class.new(new_data)
+      end
+
+      def matches_route?(route)
+        return super unless @data.key?(:remaining_at)
+
+        at_checkpoint = @data[:remaining_at]
+        route_touched = route.marks.any? { |mark| mark.checkpoint <= at_checkpoint }
+        !route_touched && super
+      end
+
+      def inspect_data
+        return super unless @data.key?(:remaining_at)
+        super.merge(remaining_at: "CP #{@data[:remaining_at]}")
+      end
+
+      def self.factory_methods
+        [:remaining_at]
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/requiring.rb

@@ -0,0 +1,26 @@
+module Aygabtu
+  module Scope
+    module Requiring
+      def requiring(*keys)
+        new_requiring = [*@data[:requiring], *keys]
+        new_data = @data.dup.merge(requiring: new_requiring)
+        self.class.new(new_data)
+      end
+
+      def matches_route?(route)
+        Array(@data[:requiring]).all? do |key|
+          route.really_required_keys.include?(key.to_s)
+        end && super
+      end
+
+      def inspect_data
+        return super unless @data[:requiring]
+        super.merge(requiring: @data[:requiring].inspect)
+      end
+
+      def self.factory_methods
+        [:requiring]
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/static_dynamic.rb

@@ -0,0 +1,33 @@
+module Aygabtu
+  module Scope
+    module StaticDynamic
+      def static_routes
+        new_static_dynamic_scope(false)
+      end
+
+      def dynamic_routes
+        new_static_dynamic_scope(true)
+      end
+
+      def matches_route?(route)
+        return super if @data[:dynamic].nil?
+
+        (@data[:dynamic] == route.really_required_keys.present?) && super
+      end
+
+      def inspect_data
+        super.merge(dynamic: @data[:dynamic])
+      end
+
+      def self.factory_methods
+        [ :static_routes, :dynamic_routes ]
+      end
+
+      private
+
+      def new_static_dynamic_scope(dynamic)
+        self.class.new(@data.merge(dynamic: dynamic))
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/visiting_with.rb

@@ -0,0 +1,19 @@
+module Aygabtu
+  module Scope
+    module VisitingWith
+      def visiting_with(visiting_data)
+        visiting_data = self.visiting_data.merge(visiting_data)
+        new_data = @data.dup.merge(visiting_data: visiting_data)
+        self.class.new(new_data)
+      end
+
+      def inspect_data
+        super.merge(visiting_data: inspected_or_nil(@data[:visiting_data]))
+      end
+
+      def self.factory_methods
+        [:visiting_with]
+      end
+    end
+  end
+end

data/lib/aygabtu/scope_actor.rb

@@ -0,0 +1,104 @@
+require_relative 'point_of_call'
+require_relative 'route_mark'
+require_relative 'generator'
+
+module Aygabtu
+  class ScopeActor
+    def initialize(scope, example_group)
+      @scope, @example_group = scope, example_group
+    end
+
+    def self.actions
+      [:visit_with, :visit, :pend, :ignore, :covered!]
+    end
+
+    def visit_with(visiting_data)
+      each_empty_scope_segment do |scope, generator|
+        generator.generate_no_match_failing_example(:visit)
+      end
+
+      each_scope_segment_and_route do |scope, generator, route|
+        visiting_data = @scope.visiting_data.merge(visiting_data)
+
+        mark_route(route, :visit)
+        generator.generate_example(route, visiting_data)
+      end
+    end
+
+    def visit
+      visit_with({})
+    end
+
+    def ignore(reason)
+      raise "Reason for ignoring must be a string" unless reason.is_a?(String)
+
+      each_empty_scope_segment do |scope, generator|
+        generator.generate_no_match_failing_example(:ignore)
+      end
+
+      each_scope_segment_and_route do |scope, generator, route|
+        mark_route(route, :ignore)
+      end
+    end
+
+    def covered!
+      ignore "this is already covered by a non-aygabtu feature"
+    end
+
+    def pend(reason)
+      each_empty_scope_segment do |scope, generator|
+        generator.generate_no_match_failing_example(:pend)
+      end
+
+      each_scope_segment_and_route do |scope, generator, route|
+        mark_route(route, :pend)
+        generator.generate_pending_example(route, reason)
+      end
+    end
+
+    private
+
+    def mark_route(route, action)
+      checkpoint = @example_group.aygabtu_handle.generate_checkpoint
+      mark = RouteMark.new(action, PointOfCall.point_of_call, checkpoint)
+
+      conflicting_marks = route.conflicting_marks(mark)
+      if conflicting_marks.any?
+        conflict_strings = conflicting_marks.map(&:description)
+        raise "Action #{action} for #{route.inspect} conflicts with #{conflict_strings.join ", "}"
+      else
+        route.marks.push mark
+      end
+    end
+
+    def route_action_valid?(route, action)
+      previous_actions_considered = route.marks.keys
+      previous_actions_considered.delete(:visit) if action == :visit # creating more than one :visit example per route is allowed
+      route.marks.values_at(*previous_actions_considered).all?(&:empty?)
+    end
+
+    def each_scope_segment_and_route
+      segments_generators_routes.each do |segment, generator, routes|
+        routes.each { |route| yield segment, generator, route }
+      end
+    end
+
+    def each_empty_scope_segment
+      segments_generators_routes.each do |segment, generator, routes|
+        next unless routes.empty?
+
+        yield segment, generator
+      end
+    end
+
+    def segments_generators_routes
+      @segments_and_generators ||= @scope.segments.map do |segment|
+        generator = Generator.new(segment, @example_group)
+
+        routes = @example_group.aygabtu_matching_routes(segment)
+
+        [segment, generator, routes]
+      end
+    end
+  end
+end

data/lib/aygabtu/scope_chain.rb

@@ -0,0 +1,39 @@
+require_relative 'scope/base'
+require_relative 'scope_actor'
+
+module Aygabtu
+  class ScopeChain
+    def initialize(example_group, scope)
+      @example_group = example_group
+      @scope = scope
+    end
+
+    attr_reader :scope
+
+    Scope::Base.factory_methods.each do |factory_method|
+      define_method(factory_method) do |*args, &block|
+        new_scope = @scope.public_send(factory_method, *args)
+
+        result = self.class.new(@example_group, new_scope)
+
+        @example_group.aygabtu_enter_context(block, new_scope) if block
+
+        result
+      end
+    end
+
+    def remaining(&block)
+      remaining_at(@example_group.aygabtu_handle.checkpoint, &block)
+    end
+
+    def self.scope_methods
+      [:remaining, *Scope::Base.factory_methods]
+    end
+
+    ScopeActor.actions.each do |action|
+      define_method(action) do |*args|
+        @example_group.aygabtu_action(action, @scope, *args)
+      end
+    end
+  end
+end

data/lib/aygabtu/version.rb

@@ -0,0 +1,3 @@
+module Aygabtu
+  VERSION = "0.2.0"
+end

data/spec/actions_spec.rb

@@ -0,0 +1,152 @@
+require 'support/invokes_rspec'
+require 'support/matcher_shims'
+
+describe "actions" do
+  include InvokesRspec
+  include MatcherShims
+
+  def rspec_file_preamble
+    %{
+require 'rails_application_helper'
+
+require 'aygabtu/rspec'
+
+Rails.application.routes.draw do
+  get 'bogus', to: 'bogus#visited', as: :named
+  get 'bogus', to: 'bogus#pended'
+  get 'bogus', to: 'bogus#ignored'
+
+  get 'bogus', to: 'bogus#doubly_pended'
+  get 'bogus', to: 'bogus#doubly_ignored'
+  get 'bogus', to: 'bogus#pended_and_ignored'
+  get 'bogus', to: 'bogus#visited_and_ignored'
+  get 'bogus', to: 'bogus#visited_and_pended'
+end
+    }
+  end
+
+  def rspec_file_content
+    rspec_file_preamble + get_rspec_file_main_content
+  end
+
+  def get_rspec_file_main_content
+    start_line = method(:rspec_file_main_content).source_location[1]
+    File.open(__FILE__) do |file|
+      lines = file.each_line.to_a.drop(start_line - 1)
+      whitespace = lines.first[/^\s*/]
+      slices = lines.slice_before do |line|
+        line.start_with?(whitespace + 'end')
+      end
+
+      # return only the method body
+      slices.first.drop(1).join('')
+    end
+  end
+
+  context "when visit is used and a route matches" do
+    def rspec_file_main_content
+      describe "aygabtu examples" do
+        include Aygabtu::RSpec.example_group_module
+
+        def visit(*)
+        end
+
+        def aygabtu_assertions
+        end
+
+        action(:visited).visit
+        named(:named).visit
+      end
+    end
+
+    it "generates examples being exercised" do
+      expect(rspec_result.examples).to \
+        contain_exactly(be_passed, be_passed)
+    end
+  end
+
+  context "when pend is used and a route matches" do
+    def rspec_file_main_content
+      describe "aygabtu examples" do
+        include Aygabtu::RSpec.example_group_module
+
+        action(:pended).pend "bogus reason"
+      end
+    end
+
+    it "generates examples which are pending" do
+      expect(rspec_result.examples).to \
+        contain_exactly(be_pending)
+    end
+  end
+
+  context "when ignore is used and a route matches" do
+    def rspec_file_main_content
+      describe "aygabtu examples" do
+        include Aygabtu::RSpec.example_group_module
+
+        action(:ignored).ignore "bogus reason"
+      end
+    end
+
+    it "does not generate examles" do
+      expect(rspec_result.examples).to be_empty
+    end
+  end
+
+  context "when using an action when no route matches" do
+    def rspec_file_main_content
+      describe "aygabtu examples" do
+        include Aygabtu::RSpec.example_group_module
+
+        action(:nonexiting).visit
+        action(:nonexiting).pend "bogus reason"
+        action(:nonexiting).ignore "bogus reason"
+      end
+    end
+
+    it "generates failing examples" do
+      expect(rspec_result.examples).to \
+        contain_exactly(be_failed, be_failed, be_failed)
+    end
+  end
+
+  context "when passing multiple arguments to a splitting scope, one argument not matching a route" do
+    def rspec_file_main_content
+      describe "aygabtu examples" do
+        include Aygabtu::RSpec.example_group_module
+
+        def visit(*)
+        end
+
+        def aygabtu_assertions
+        end
+
+        action(:visited, :nonexisting).visit
+        named(:named, :nonexisting).visit
+      end
+    end
+
+    it "generates a failing example besides what the action produces for the other arguments" do
+      examples_grouped_by_line = rspec_result.examples.group_by(&:line_number).values
+
+      expect(
+        examples_grouped_by_line
+      ).to all(
+        include(be_passed).and include(be_failed) # <3 <3 <3
+      )
+
+      # sanity check
+      expect(examples_grouped_by_line.length).to be == 2
+    end
+  end
+
+  context "when calling pend matching the same route a second time" do
+    pending "currently raises an exception at load time"
+  end
+
+  context "when calling ignore matching the same route a second time" do
+    pending "currently raises an exception at load time"
+  end
+end
+