rails_edge_test 2.1.0 → 3.0.0

data/lib/rails_edge_test/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsEdgeTest
   class Configuration
     attr_accessor :elm_path, :edge_root_path, :printer
@@ -35,23 +37,17 @@ module RailsEdgeTest
     end
 
     def wrap_suite_execution(&block)
-      @before_suite_blocks.each do |before_suit_block|
-        before_suit_block.call
-      end
+      @before_suite_blocks.each(&:call)
 
       block.call
     end
 
     def wrap_edge_execution(&edge)
-      @before_each_blocks.each do |before_each_block|
-        before_each_block.call
-      end
+      @before_each_blocks.each(&:call)
 
       edge.call
 
-      @after_each_blocks.each do |after_each_block|
-        after_each_block.call
-      end
+      @after_each_blocks.each(&:call)
     end
   end
 end

data/lib/rails_edge_test/dsl/action.rb

@@ -1,49 +1,53 @@
-module RailsEdgeTest::Dsl
-  Action = Struct.new(:name, :controller) do
-    def initialize(*args)
-      super
-      @edges = {}
-      @let_handler = LetHandler.new
-    end
+# frozen_string_literal: true
 
-    def edge(description, &block)
-      edge = Edge.new(description, self)
-      @edges[edge] = block
-    end
+module RailsEdgeTest
+  module Dsl
+    Action = Struct.new(:name, :controller) do
+      def initialize(*args)
+        super
+        @edges = {}
+        @let_handler = LetHandler.new
+      end
 
-    def let(title, &block)
-      @let_handler.add_definition(title, &block)
-    end
+      def edge(description, &block)
+        edge = Edge.new(description, self)
+        @edges[edge] = block
+      end
 
-    def generate(title, &block)
-      @let_handler.add_definition("generate_#{title}", &block)
-    end
+      def let(title, &block)
+        @let_handler.add_definition(title, &block)
+      end
 
-    def __edges
-      @edges
-    end
+      def generate(title, &block)
+        @let_handler.add_definition("generate_#{title}", &block)
+      end
 
-    def __let_handler
-      @let_handler
-    end
+      def __edges
+        @edges
+      end
 
-    def controller_class
-      controller.controller_class
-    end
+      def __let_handler
+        @let_handler
+      end
 
-    # support calling methods defined in controller
-    def method_missing(method_name, *arguments, &block)
-      if controller.respond_to?(method_name)
-        controller.public_send(method_name, *arguments, &block)
-      else
-        super
+      def controller_class
+        controller.controller_class
+      end
+
+      # support calling methods defined in controller
+      def method_missing(method_name, ...)
+        if controller.respond_to?(method_name)
+          controller.public_send(method_name, ...)
+        else
+          super
+        end
       end
-    end
 
-    # always define respond_to_missing? when defining method_missing:
-    # https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
-    def respond_to_missing?(method_name, include_private = false)
-      controller.respond_to?(method_name) || super
+      # always define respond_to_missing? when defining method_missing:
+      # https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
+      def respond_to_missing?(method_name, include_private = false)
+        controller.respond_to?(method_name) || super
+      end
     end
   end
 end

data/lib/rails_edge_test/dsl/controller.rb

@@ -1,27 +1,31 @@
-module RailsEdgeTest::Dsl
-  Controller = Struct.new(:controller_class) do
-    def initialize(*args)
-      super
-      @actions = []
-      @let_handler = LetHandler.new
-    end
+# frozen_string_literal: true
 
-    def action(name, &block)
-      new_action = Action.new(name, self)
-      new_action.instance_exec(&block)
-      @actions << new_action
-    end
+module RailsEdgeTest
+  module Dsl
+    Controller = Struct.new(:controller_class) do
+      def initialize(*args)
+        super
+        @actions = []
+        @let_handler = LetHandler.new
+      end
 
-    def let(title, &block)
-      @let_handler.add_definition(title, &block)
-    end
+      def action(name, &block)
+        new_action = Action.new(name, self)
+        new_action.instance_exec(&block)
+        @actions << new_action
+      end
 
-    def __actions
-      @actions
-    end
+      def let(title, &block)
+        @let_handler.add_definition(title, &block)
+      end
+
+      def __actions
+        @actions
+      end
 
-    def __let_handler
-      @let_handler
+      def __let_handler
+        @let_handler
+      end
     end
   end
 end

data/lib/rails_edge_test/dsl/edge.rb

@@ -1,146 +1,147 @@
+# frozen_string_literal: true
+
 require 'action_dispatch'
 require 'action_controller'
 require 'action_controller/test_case'
 
-module RailsEdgeTest::Dsl
-  Edge = Struct.new(:description, :action) do
-
-    def initialize(*args)
-      super
-      @let_cache = {}
-    end
-
-    delegate :controller_class, to: :action
-    delegate :session, to: :request
-
-    def request
-      @request ||= ActionController::TestRequest.create(controller_class)
-    end
-
-    # In the context of the edge, we want `controller` to be the rails controller
-    # instead of our own RailsEdgeTest::Dsl::Controller. In this way the user can
-    # directly access the rails controller within their edge.
-    def controller
-      @controller ||= controller_class.new
-    end
-
-    def response
-      @response
-    end
+module RailsEdgeTest
+  module Dsl
+    Edge = Struct.new(:description, :action) do
+      def initialize(*args)
+        super
+        @let_cache = {}
+      end
 
-    def perform_get(parameters={})
-      process(parameters)
-    end
+      delegate :controller_class, to: :action
+      delegate :session, to: :request
 
-    def perform_post(parameters={})
-      request.instance_variable_set(:@method, "POST")
-      request.env['REQUEST_METHOD'] = "POST"
-      process(parameters)
-    end
+      def request
+        @request ||= ActionController::TestRequest.create(controller_class)
+      end
 
-    def perform_delete(parameters={})
-      request.instance_variable_set(:@method, "DELETE")
-      request.env['REQUEST_METHOD'] = "DELETE"
-      process(parameters)
-    end
+      # In the context of the edge, we want `controller` to be the rails controller
+      # instead of our own RailsEdgeTest::Dsl::Controller. In this way the user can
+      # directly access the rails controller within their edge.
+      def controller
+        @controller ||= controller_class.new
+      end
 
-    def set_authenticity_token
-      r = request
-      controller.instance_eval { @_request = r }
-      request.headers['X-CSRF-Token'] = controller.send :form_authenticity_token
-    end
+      def response
+        @response
+      end
 
-    def process(parameters={})
-      request.assign_parameters(
-        ::Rails.application.routes,
-        controller_class.controller_path,
-        action.name.to_s,
-        parameters.stringify_keys!,
-        '',
-        ''
-      )
-
-      response = ActionDispatch::Response.new.tap do |res|
-        res.request = request
+      def perform_get(parameters = {})
+        process(parameters)
       end
 
-      @response = controller.dispatch(action.name, request, response)
-    end
+      def perform_post(parameters = {})
+        request.instance_variable_set(:@method, 'POST')
+        request.env['REQUEST_METHOD'] = 'POST'
+        process(parameters)
+      end
 
-    def produce_elm_file(module_name, ivar: nil)
-      json = produce_json(ivar: ivar)
-      json = json.gsub("\\", "\\\\\\\\") # unbelievably, this replaces \ with \\
+      def perform_delete(parameters = {})
+        request.instance_variable_set(:@method, 'DELETE')
+        request.env['REQUEST_METHOD'] = 'DELETE'
+        process(parameters)
+      end
 
-      filepath = File.join(
-        RailsEdgeTest.configuration.elm_path,
-        'Edge',
-        controller_class.name.gsub('::','/')
-      )
+      def set_authenticity_token
+        r = request
+        controller.instance_eval { @_request = r }
+        request.headers['X-CSRF-Token'] = controller.send :form_authenticity_token
+      end
 
-      full_module_name =
-        "#{controller_class.name.gsub('::','.')}.#{module_name}"
+      def process(parameters = {})
+        request.assign_parameters(
+          ::Rails.application.routes,
+          controller_class.controller_path,
+          action.name.to_s,
+          parameters.stringify_keys!,
+          '',
+          ''
+        )
+
+        response = ActionDispatch::Response.new.tap do |res|
+          res.request = request
+        end
+
+        @response = controller.dispatch(action.name, request, response)
+      end
 
-      data = <<~ELM
-        module Edge.#{full_module_name} exposing (json)
+      def produce_elm_file(module_name, ivar: nil)
+        json = produce_json(ivar: ivar)
+        json = json.gsub('\\', '\\\\\\\\') # unbelievably, this replaces \ with \\
 
+        filepath = File.join(
+          RailsEdgeTest.configuration.elm_path,
+          'Edge',
+          controller_class.name.gsub('::', '/')
+        )
 
-        json : String
-        json =
-            """
-        #{json}
-            """
-      ELM
+        full_module_name =
+          "#{controller_class.name.gsub('::', '.')}.#{module_name}"
 
-      write_file(filepath, module_name+'.elm', data)
-    end
+        data = <<~ELM
+          module Edge.#{full_module_name} exposing (json)
 
-    private
 
-    def produce_json(ivar: nil)
-      unless response
-        fail "Must perform a request (for example `perform_get`) before attempting to produce a json file."
-      end
+          json : String
+          json =
+              """
+          #{json}
+              """
+        ELM
 
-      if response.is_a?(Array) && response[0] >= 300
-        fail "Request did not result in a successful (2xx) response!"
+        write_file(filepath, "#{module_name}.elm", data)
       end
 
-      ActiveSupport::JSON::Encoding.escape_html_entities_in_json = false
-      if ivar
-        value = controller.send(:instance_variable_get, ivar)
-        JSON.pretty_unparse(value.as_json)
-      elsif response[1]['Content-Type']&.starts_with?('application/json')
-        value = JSON.parse(response[2].body)
-        JSON.pretty_unparse(value)
-      else
-        response[2].body
+      private
+
+      def produce_json(ivar: nil)
+        unless response
+          raise 'Must perform a request (for example `perform_get`) before attempting to produce a json file.'
+        end
+
+        raise 'Request did not result in a successful (2xx) response!' if response.is_a?(Array) && response[0] >= 300
+
+        ActiveSupport::JSON::Encoding.escape_html_entities_in_json = false
+        if ivar
+          value = controller.send(:instance_variable_get, ivar)
+          JSON.pretty_unparse(value.as_json)
+        elsif response[1]['Content-Type']&.starts_with?('application/json')
+          value = JSON.parse(response[2].body)
+          JSON.pretty_unparse(value)
+        else
+          response[2].body
+        end
       end
-    end
 
-    def write_file(filepath, filename, data)
-      FileUtils.mkdir_p(filepath)
+      def write_file(filepath, filename, data)
+        FileUtils.mkdir_p(filepath)
 
-      filepath = File.join(filepath, filename)
+        filepath = File.join(filepath, filename)
 
-      File.open(filepath, 'w') do |f|
-        f.write(data)
-        f.flush
+        File.open(filepath, 'w') do |f|
+          f.write(data)
+          f.flush
+        end
       end
-    end
 
-    # support calling methods defined in action
-    def method_missing(method_name, *arguments, &block)
-      if action.respond_to?(method_name)
-        action.public_send(method_name, *arguments, &block)
-      else
-        super
+      # support calling methods defined in action
+      def method_missing(method_name, ...)
+        if action.respond_to?(method_name)
+          action.public_send(method_name, ...)
+        else
+          super
+        end
       end
-    end
 
-    # always define respond_to_missing? when defining method_missing:
-    # https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
-    def respond_to_missing?(method_name, include_private = false)
-      action.respond_to?(method_name) || super
+      # always define respond_to_missing? when defining method_missing:
+      # https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
+      def respond_to_missing?(method_name, include_private = false)
+        action.respond_to?(method_name) || super
+      end
     end
   end
 end

data/lib/rails_edge_test/dsl/let_handler.rb

@@ -1,22 +1,24 @@
-module RailsEdgeTest::Dsl
-  class LetHandler
-    attr_reader :let_blocks
+# frozen_string_literal: true
 
-    def initialize
-      @let_blocks = {}
-    end
+module RailsEdgeTest
+  module Dsl
+    class LetHandler
+      attr_reader :let_blocks
 
-    def add_definition(title, &block)
-      @let_blocks[title] = block
-    end
+      def initialize
+        @let_blocks = {}
+      end
 
-    def execute(title)
-      block = @let_blocks[title]
-      unless block
-        fail NoMethodError, "no method or let block defined with name #{title}"
+      def add_definition(title, &block)
+        @let_blocks[title] = block
       end
 
-      block.call
+      def execute(title)
+        block = @let_blocks[title]
+        raise NoMethodError, "no method or let block defined with name #{title}" unless block
+
+        block.call
+      end
     end
   end
 end

data/lib/rails_edge_test/dsl.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RailsEdgeTest
   module Dsl
     def controller(controller_class, &block)
@@ -16,7 +18,6 @@ module RailsEdgeTest
         printer.begin_suite
 
         RailsEdgeTest.configuration.wrap_suite_execution do
-
           @controllers.each do |controller|
             printer.begin_controller(controller)
 
@@ -40,7 +41,6 @@ module RailsEdgeTest
 
             printer.end_controller
           end
-
         end
         printer.end_suite
       end

data/lib/rails_edge_test/printers/boring.rb

@@ -1,39 +1,39 @@
-module RailsEdgeTest::Printers
-  class Boring
-    def initialize
-      @count = 0
-    end
+# frozen_string_literal: true
 
-    def begin_suite
-      puts ""
-    end
+module RailsEdgeTest
+  module Printers
+    class Boring
+      def initialize
+        @count = 0
+      end
 
-    def end_suite
-      puts "\n#{@count} edge specs executed."
-    end
+      def begin_suite
+        puts ''
+      end
 
-    def begin_controller(_controller)
-      print "."
-    end
+      def end_suite
+        puts "\n#{@count} edge specs executed."
+      end
 
-    def end_controller
+      def begin_controller(_controller)
+        print '.'
+      end
 
-    end
+      def end_controller; end
 
-    def begin_action(_action)
-      print "."
-    end
-
-    def end_action
+      def begin_action(_action)
+        print '.'
+      end
 
-    end
+      def end_action; end
 
-    def begin_edge(_edge)
-      print "."
-    end
+      def begin_edge(_edge)
+        print '.'
+      end
 
-    def end_edge
-      @count += 1
+      def end_edge
+        @count += 1
+      end
     end
   end
 end

data/lib/rails_edge_test/printers/silent.rb

@@ -1,27 +1,23 @@
-module RailsEdgeTest::Printers
-  class Silent
-    def begin_suite
-    end
+# frozen_string_literal: true
 
-    def end_suite
-    end
+module RailsEdgeTest
+  module Printers
+    class Silent
+      def begin_suite; end
 
-    def begin_controller(_controller)
-    end
+      def end_suite; end
 
-    def end_controller
-    end
+      def begin_controller(_controller); end
 
-    def begin_action(_action)
-    end
+      def end_controller; end
 
-    def end_action
-    end
+      def begin_action(_action); end
 
-    def begin_edge(_edge)
-    end
+      def end_action; end
+
+      def begin_edge(_edge); end
 
-    def end_edge
+      def end_edge; end
     end
   end
 end