jekyll 4.2.0 → 4.2.1

data/rubocop/jekyll/assert_equal_literal_actual.rb

@@ -1,149 +1,149 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Jekyll
-      # Checks for `assert_equal(exp, act, msg = nil)` calls containing literal values as
-      # second argument. The second argument should ideally be a method called on the tested
-      # instance.
-      #
-      # @example
-      #   # bad
-      #   assert_equal @foo.bar, "foobar"
-      #   assert_equal @alpha.beta, { "foo" => "bar", "lorem" => "ipsum" }
-      #   assert_equal @alpha.omega, ["foobar", "lipsum"]
-      #
-      #   # good
-      #   assert_equal "foobar", @foo.bar
-      #
-      #   assert_equal(
-      #     { "foo" => "bar", "lorem" => "ipsum" },
-      #     @alpha.beta
-      #   )
-      #
-      #   assert_equal(
-      #     ["foobar", "lipsum"],
-      #     @alpha.omega
-      #   )
-      #
-      class AssertEqualLiteralActual < Cop
-        MSG = "Provide the 'expected value' as the first argument to `assert_equal`.".freeze
-
-        SIMPLE_LITERALS = %i(
-          true
-          false
-          nil
-          int
-          float
-          str
-          sym
-          complex
-          rational
-          regopt
-        ).freeze
-
-        COMPLEX_LITERALS = %i(
-          array
-          hash
-          pair
-          irange
-          erange
-          regexp
-        ).freeze
-
-        def_node_matcher :literal_actual?, <<-PATTERN
-          (send nil? :assert_equal $(send ...) $#literal?)
-        PATTERN
-
-        def_node_matcher :literal_actual_with_msg?, <<-PATTERN
-          (send nil? :assert_equal $(send ...) $#literal? $#opt_msg?)
-        PATTERN
-
-        def on_send(node)
-          return unless literal_actual?(node) || literal_actual_with_msg?(node)
-          add_offense(node, location: :expression)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement(node))
-          end
-        end
-
-        private
-
-        def opt_msg?(node)
-          node&.source
-        end
-
-        # This is not implement using a NodePattern because it seems
-        # to not be able to match against an explicit (nil) sexp
-        def literal?(node)
-          node && (simple_literal?(node) || complex_literal?(node))
-        end
-
-        def simple_literal?(node)
-          SIMPLE_LITERALS.include?(node.type)
-        end
-
-        def complex_literal?(node)
-          COMPLEX_LITERALS.include?(node.type) &&
-            node.each_child_node.all?(&method(:literal?))
-        end
-
-        def replacement(node)
-          _, _, first_param, second_param, optional_param = *node
-
-          replaced_text = \
-            if second_param.type == :hash
-              replace_hash_with_variable(first_param.source, second_param.source)
-            elsif second_param.type == :array && second_param.source != "[]"
-              replace_array_with_variable(first_param.source, second_param.source)
-            else
-              replace_based_on_line_length(first_param.source, second_param.source)
-            end
-
-          return "#{replaced_text}, #{optional_param.source}" if optional_param
-          replaced_text
-        end
-
-        def replace_based_on_line_length(first_expression, second_expression)
-          result = "assert_equal #{second_expression}, #{first_expression}"
-          return result if result.length < 80
-
-          # fold long lines independent of Rubocop configuration for better readability
-          <<~TEXT
-            assert_equal(
-              #{second_expression},
-              #{first_expression}
-            )
-          TEXT
-        end
-
-        def replace_hash_with_variable(first_expression, second_expression)
-          expect_expression = if second_expression.start_with?("{")
-                                second_expression
-                              else
-                                "{#{second_expression}}"
-                              end
-          <<~TEXT
-            expected = #{expect_expression}
-            assert_equal expected, #{first_expression}
-          TEXT
-        end
-
-        def replace_array_with_variable(first_expression, second_expression)
-          expect_expression = if second_expression.start_with?("%")
-                                second_expression
-                              else
-                                Array(second_expression)
-                              end
-          <<~TEXT
-            expected = #{expect_expression}
-            assert_equal expected, #{first_expression}
-          TEXT
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Jekyll
+      # Checks for `assert_equal(exp, act, msg = nil)` calls containing literal values as
+      # second argument. The second argument should ideally be a method called on the tested
+      # instance.
+      #
+      # @example
+      #   # bad
+      #   assert_equal @foo.bar, "foobar"
+      #   assert_equal @alpha.beta, { "foo" => "bar", "lorem" => "ipsum" }
+      #   assert_equal @alpha.omega, ["foobar", "lipsum"]
+      #
+      #   # good
+      #   assert_equal "foobar", @foo.bar
+      #
+      #   assert_equal(
+      #     { "foo" => "bar", "lorem" => "ipsum" },
+      #     @alpha.beta
+      #   )
+      #
+      #   assert_equal(
+      #     ["foobar", "lipsum"],
+      #     @alpha.omega
+      #   )
+      #
+      class AssertEqualLiteralActual < Cop
+        MSG = "Provide the 'expected value' as the first argument to `assert_equal`.".freeze
+
+        SIMPLE_LITERALS = %i(
+          true
+          false
+          nil
+          int
+          float
+          str
+          sym
+          complex
+          rational
+          regopt
+        ).freeze
+
+        COMPLEX_LITERALS = %i(
+          array
+          hash
+          pair
+          irange
+          erange
+          regexp
+        ).freeze
+
+        def_node_matcher :literal_actual?, <<-PATTERN
+          (send nil? :assert_equal $(send ...) $#literal?)
+        PATTERN
+
+        def_node_matcher :literal_actual_with_msg?, <<-PATTERN
+          (send nil? :assert_equal $(send ...) $#literal? $#opt_msg?)
+        PATTERN
+
+        def on_send(node)
+          return unless literal_actual?(node) || literal_actual_with_msg?(node)
+          add_offense(node, location: :expression)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement(node))
+          end
+        end
+
+        private
+
+        def opt_msg?(node)
+          node&.source
+        end
+
+        # This is not implement using a NodePattern because it seems
+        # to not be able to match against an explicit (nil) sexp
+        def literal?(node)
+          node && (simple_literal?(node) || complex_literal?(node))
+        end
+
+        def simple_literal?(node)
+          SIMPLE_LITERALS.include?(node.type)
+        end
+
+        def complex_literal?(node)
+          COMPLEX_LITERALS.include?(node.type) &&
+            node.each_child_node.all?(&method(:literal?))
+        end
+
+        def replacement(node)
+          _, _, first_param, second_param, optional_param = *node
+
+          replaced_text = \
+            if second_param.type == :hash
+              replace_hash_with_variable(first_param.source, second_param.source)
+            elsif second_param.type == :array && second_param.source != "[]"
+              replace_array_with_variable(first_param.source, second_param.source)
+            else
+              replace_based_on_line_length(first_param.source, second_param.source)
+            end
+
+          return "#{replaced_text}, #{optional_param.source}" if optional_param
+          replaced_text
+        end
+
+        def replace_based_on_line_length(first_expression, second_expression)
+          result = "assert_equal #{second_expression}, #{first_expression}"
+          return result if result.length < 80
+
+          # fold long lines independent of Rubocop configuration for better readability
+          <<~TEXT
+            assert_equal(
+              #{second_expression},
+              #{first_expression}
+            )
+          TEXT
+        end
+
+        def replace_hash_with_variable(first_expression, second_expression)
+          expect_expression = if second_expression.start_with?("{")
+                                second_expression
+                              else
+                                "{#{second_expression}}"
+                              end
+          <<~TEXT
+            expected = #{expect_expression}
+            assert_equal expected, #{first_expression}
+          TEXT
+        end
+
+        def replace_array_with_variable(first_expression, second_expression)
+          expect_expression = if second_expression.start_with?("%")
+                                second_expression
+                              else
+                                Array(second_expression)
+                              end
+          <<~TEXT
+            expected = #{expect_expression}
+            assert_equal expected, #{first_expression}
+          TEXT
+        end
+      end
+    end
+  end
+end

data/rubocop/jekyll/no_p_allowed.rb

@@ -1,23 +1,23 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Jekyll
-      class NoPAllowed < Cop
-        MSG = "Avoid using `p` to print things. Use `Jekyll.logger` instead.".freeze
-
-        def_node_search :p_called?, <<-PATTERN
-        (send _ :p _)
-        PATTERN
-
-        def on_send(node)
-          if p_called?(node)
-            add_offense(node, :location => :selector)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Jekyll
+      class NoPAllowed < Cop
+        MSG = "Avoid using `p` to print things. Use `Jekyll.logger` instead.".freeze
+
+        def_node_search :p_called?, <<-PATTERN
+        (send _ :p _)
+        PATTERN
+
+        def on_send(node)
+          if p_called?(node)
+            add_offense(node, :location => :selector)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop/jekyll/no_puts_allowed.rb

@@ -1,23 +1,23 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-module RuboCop
-  module Cop
-    module Jekyll
-      class NoPutsAllowed < Cop
-        MSG = "Avoid using `puts` to print things. Use `Jekyll.logger` instead.".freeze
-
-        def_node_search :puts_called?, <<-PATTERN
-        (send nil? :puts _)
-        PATTERN
-
-        def on_send(node)
-          if puts_called?(node)
-            add_offense(node, :location => :selector)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Jekyll
+      class NoPutsAllowed < Cop
+        MSG = "Avoid using `puts` to print things. Use `Jekyll.logger` instead.".freeze
+
+        def_node_search :puts_called?, <<-PATTERN
+        (send nil? :puts _)
+        PATTERN
+
+        def on_send(node)
+          if puts_called?(node)
+            add_offense(node, :location => :selector)
+          end
+        end
+      end
+    end
+  end
+end

data/rubocop/jekyll.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
-
-Dir[File.join(File.expand_path("jekyll", __dir__), "*.rb")].each do |ruby_file|
-  require ruby_file
-end
+# frozen_string_literal: true
+
+Dir[File.join(File.expand_path("jekyll", __dir__), "*.rb")].each do |ruby_file|
+  require ruby_file
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jekyll
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 4.2.1
 platform: ruby
 authors:
 - Tom Preston-Werner
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-14 00:00:00.000000000 Z
+date: 2021-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -364,7 +364,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.7.0
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.28
 signing_key:
 specification_version: 4
 summary: A simple, blog aware, static site generator.