aygabtu 0.2.0

data/lib/aygabtu/handle.rb

@@ -0,0 +1,38 @@
+require_relative 'route_wrapper'
+require_relative 'scope_actor'
+
+module Aygabtu
+  class Handle
+
+    def routes
+      @routes ||= rails_application_routes.set.map do |journey_route|
+        RouteWrapper.new(journey_route)
+      end.select(&:get?).reject(&:internal?)
+    end
+
+    def checkpoint
+      @checkpoint || 0
+    end
+
+    def generate_checkpoint
+      @checkpoint = (checkpoint + 1).tap do |new_checkpoint|
+        puts "New checkpoint #{new_checkpoint}" if verbose?
+      end
+    end
+
+    def verbose!
+      @verbose = true
+    end
+
+    def verbose?
+      !!@verbose
+    end
+
+    private
+
+    def rails_application_routes
+      @rails_application_routes ||= Rails.application.routes
+    end
+    attr_writer :rails_application_routes
+  end
+end

data/lib/aygabtu/point_of_call.rb

@@ -0,0 +1,28 @@
+require_relative 'scope/base'
+
+module Aygabtu
+
+  module PointOfCall
+    extend self
+
+    def point_of_call
+      caller.drop_while { |point| point.start_with?(PointOfCall.gem_root) }.first
+    end
+
+    def file_and_line_at_point_of_call
+      filename, line_and_context = point_of_call.split(':', 2)
+      [filename, line_and_context.to_i] # make use of the fact to_i tolerates being passed a string only _beginning_ with a number
+    end
+
+    def self.gem_root
+      return @gem_root if @gem_root
+
+      path = Pathname(__FILE__)
+      while new_path = path.parent and new_path.to_s.include?('lib/aygabtu')
+        path = new_path
+      end
+
+      @gem_root= path.to_s
+    end
+  end
+end

data/lib/aygabtu/route_mark.rb

@@ -0,0 +1,18 @@
+module Aygabtu
+
+class RouteMark
+  def initialize(action, poc, checkpoint)
+    @action, @poc, @checkpoint = action, poc, checkpoint
+  end
+  attr_reader :action, :poc, :checkpoint
+
+  def conflicting?(other)
+    !(action == :visit && other.action == :visit)
+  end
+
+  def description
+    "#{action} action at #{poc} (CP #{checkpoint})"
+  end
+end
+
+end

data/lib/aygabtu/route_wrapper.rb

@@ -0,0 +1,96 @@
+module Aygabtu
+  class RouteWrapper
+    # Wraps a Journey route
+
+    attr_reader :journey_route # ease debugging
+
+    def initialize(journey_route)
+      @journey_route = journey_route
+
+      @marks = []
+    end
+
+    def conflicting_marks(mark)
+      @marks.select { |m| m.conflicting?(mark) }
+    end
+
+    attr_reader :marks
+
+    def get?
+      @journey_route.verb.match('GET')
+    end
+
+    def internal?
+      # this particular route is hard to filter by any sensible criterion
+      @journey_route.path.to_regexp == %r{\A/assets}
+    end
+
+    # array of parameter names (symbols) required for generating URL
+    def required_parts
+      @journey_route.required_parts
+    end
+
+    def controller
+      @journey_route.requirements[:controller]
+    end
+
+    def controller_namespace
+      return @controller_namespace if defined? @controller_namespace
+      return @controller_namespace = nil unless controller
+
+      @controller_namespace = Pathname('/').join(controller).dirname.to_s[1..-1]
+      @controller_namespace = nil if @controller_namespace.empty?
+      @controller_namespace
+    end
+
+    def controller_basename
+      Pathname(controller).basename.to_s if controller
+    end
+
+    def action
+      # sanity condition needed for Rails 4.1
+      @journey_route.requirements[:action] if controller
+    end
+
+    def name
+      @journey_route.name.to_s if @journey_route.name
+    end
+
+    # def matches_string?(string)
+    #   @journey_route.path.to_regexp.match(string)
+    # end
+
+    # this assumes parameters.keys == required_parts
+    def generate_url_with_proper_parameters(parameters)
+      @journey_route.format(parameters)
+    end
+
+    def inspect
+      if @journey_route.name
+        "route named :#{@journey_route.name}"
+      else
+        "route matching #{@journey_route.path.to_regexp.inspect}"
+      end
+    end
+
+    def format(visiting_data)
+      visiting_data = visiting_data.stringify_keys
+
+      query_data = visiting_data.except(*@journey_route.parts.map(&:to_s))
+      visiting_data = visiting_data.except(*query_data.keys)
+
+      visiting_data.symbolize_keys! # format expects symbols, but we deal with strings in all other places
+      path = @journey_route.format(visiting_data)
+
+      if query_data.empty?
+        path
+      else
+        "#{path}?#{Rack::Utils.build_query(query_data)}"
+      end
+    end
+
+    def really_required_keys
+      @journey_route.path.required_names
+    end
+  end
+end

data/lib/aygabtu/rspec.rb

@@ -0,0 +1,119 @@
+require_relative 'handle'
+require_relative 'scope/base'
+require_relative 'scope_chain'
+require_relative 'point_of_call'
+
+module Aygabtu
+  module RSpec
+
+    module ExampleGroupMethods
+      delegate(*ScopeChain.scope_methods, to: :aygabtu_scope_chain)
+
+      def aygabtu_scope
+        @aygabtu_scope ||= if superclass.respond_to?(:aygabtu_scope)
+          superclass.aygabtu_scope
+        else
+          Scope::Base.blank_slate
+        end
+      end
+
+      def aygabtu_scope_chain
+        @aygabtu_scope_chain ||= ScopeChain.new(self, aygabtu_scope)
+      end
+
+      def aygabtu_enter_context(block, scope)
+        context "Context defined at #{PointOfCall.point_of_call}" do
+          self.aygabtu_scope = scope
+          class_exec(&block)
+        end
+      end
+
+      def aygabtu_action(action, scope, *args)
+        puts "Action #{action} after checkpoint #{aygabtu_handle.checkpoint} from #{PointOfCall.point_of_call}" if aygabtu_handle.verbose?
+        ScopeActor.new(scope, self).public_send(action, *args)
+      end
+
+      def aygabtu_handle
+        if superclass.respond_to?(:aygabtu_handle)
+          superclass.aygabtu_handle
+        else
+          @_aygabtu_handle ||= Handle.new
+        end
+      end
+
+      def aygabtu_matching_routes(scope = aygabtu_scope)
+        scope = scope.scope if scope.respond_to?(:scope) # a scope chain can be pased as well
+        aygabtu_handle.routes.select do |route|
+          scope.matches_route?(route)
+        end
+      end
+
+      ScopeActor.actions.each do |action|
+        define_method(action) do |*args|
+          aygabtu_action(action, aygabtu_scope, *args)
+        end
+      end
+
+      private
+
+      attr_writer :aygabtu_scope
+    end
+
+    module ExampleGroupModule
+      def self.included(group)
+        group.extend ExampleGroupMethods
+      end
+
+      def aygabtu_example_for(path)
+        visit path
+        aygabtu_assertions
+      end
+
+      attr_accessor :aygabtu_path_to_visit
+
+      def aygabtu_pass_to_route(id, visiting_data)
+        route = self.class.aygabtu_handle.routes.find { |a_route| a_route.object_id == id }
+
+        visiting_data = visiting_data.clone
+        visiting_data.keys.each do |key|
+          value = visiting_data[key]
+          visiting_data[key] = aygabtu_fetch_symbolic_pass_value(value) if value.is_a?(Symbol)
+        end
+
+        missing_keys = route.really_required_keys - visiting_data.keys.map(&:to_s)
+
+        if missing_keys.empty?
+          route.format(visiting_data)
+        else
+          raise "Route is missing required key(s) #{missing_keys.map(&:inspect).join(', ')}"
+        end
+      end
+
+      def aygabtu_fetch_symbolic_pass_value(symbol)
+        raise "Symbolic pass value #{symbol} given, but no such method defined" unless respond_to?(symbol)
+        send(symbol)
+      end
+
+      def aygabtu_assert_status_success
+        expect(page.status_code).to be 200
+      end
+
+      def aygabtu_assert_not_redirected_away # @TODO create custom rspec matcher to provide cleaner error messages
+        uri = URI(current_url)
+        uri.host = nil
+        uri.scheme = nil
+        expect(uri.to_s).to be == aygabtu_path_to_visit
+      end
+
+      def aygabtu_assertions
+        raise "Hey aygabtu user, please implement this yourself by overriding the aygabtu_assertions method!"
+      end
+    end
+
+    class << self
+      def example_group_module
+        ExampleGroupModule
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/action.rb

@@ -0,0 +1,38 @@
+module Aygabtu
+  module Scope
+    module Action
+      def action(*actions)
+        raise "nesting/chaining action scopes makes no sense" if @data[:action]
+
+        new_data = @data.dup.merge(actions: actions.map(&:to_s))
+        self.class.new(new_data)
+      end
+
+      def matches_route?(route)
+        if @data[:actions]
+          @data[:actions].include?(route.action)
+        else
+          true
+        end && super
+      end
+
+      def segments_split_once
+        return super unless Array(@data[:actions]).length > 1
+
+        @data[:actions].map do |action|
+          new_data = @data.merge(actions: [action])
+          self.class.new(new_data)
+        end
+      end
+
+      def inspect_data
+        return super unless actions = @data[:actions]
+        super.merge(action: actions.map(&:inspect).join('; '))
+      end
+
+      def self.factory_methods
+        [:action]
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/base.rb

@@ -0,0 +1,85 @@
+require_relative 'namespace_controller'
+require_relative 'action'
+require_relative 'named'
+require_relative 'visiting_with'
+require_relative 'requiring'
+require_relative 'static_dynamic'
+require_relative 'remaining'
+
+module Aygabtu
+  module Scope
+    class Base
+      def initialize(data)
+        @data = data
+      end
+
+      def visiting_data
+        @data.fetch(:visiting_data, {})
+      end
+
+      def self.blank_slate
+        new(filters: [])
+      end
+
+      COMPONENTS = [
+        NamespaceController,
+        Action,
+        Named,
+        VisitingWith,
+        Requiring,
+        StaticDynamic,
+        Remaining
+      ]
+
+      module BasicBehaviour
+        # defines methods below COMPONENTS in the inheritance chain
+        # so components can override and call super
+
+        def matches_route?(route)
+          true
+        end
+
+        def segments_split_once
+        end
+
+        def inspect_data
+          {}
+        end
+      end
+      include BasicBehaviour
+
+      include(*COMPONENTS)
+
+      def segments
+        if split_once = segments_split_once
+          split_once.map(&:segments).reduce(:+)
+        else
+          [self]
+        end
+      end
+
+      def inspect
+        data = inspect_data
+        data.keys.each { |key| data.delete(key) if data[key].nil? }
+        message = if data.empty?
+          "nothing specified"
+        else
+          data.map { |key, value| "#{key}: #{value}" }.join(', ')
+        end
+        "\#<Aygabtu scope (#{message})>"
+      end
+
+      @factory_methods = COMPONENTS.map(&:factory_methods).reduce([], :+)
+
+      class << self
+        attr_reader :factory_methods
+      end
+
+      private
+
+      def inspected_or_nil(obj)
+        obj.inspect unless obj.nil?
+      end
+    end
+  end
+end

data/lib/aygabtu/scope/named.rb

@@ -0,0 +1,38 @@
+module Aygabtu
+  module Scope
+    module Named
+      def named(*names)
+        raise "nesting/chaining named in/after named makes no sense" if @data[:names]
+
+        new_data = @data.dup.merge(names: names.map(&:to_s))
+        self.class.new(new_data)
+      end
+
+      def matches_route?(route)
+        if @data[:names]
+          @data[:names].include?(route.name)
+        else
+          true
+        end && super
+      end
+
+      def segments_split_once
+        return super unless Array(@data[:names]).length > 1
+
+        @data[:names].map do |name|
+          new_data = @data.merge(names: [name])
+          self.class.new(new_data)
+        end
+      end
+
+      def inspect_data
+        return super unless names = @data[:names]
+        super.merge(name: names.map(&:inspect).join('; '))
+      end
+
+      def self.factory_methods
+        [:named]
+      end
+    end
+  end
+end