lbenicio-minimal-v1 1.0.2 → 1.0.5

data/benchmark/schwartzian_transform.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# The Ruby documentation for #sort_by describes what's called a Schwartzian transform:
+#
+#  > A more efficient technique is to cache the sort keys (modification times in this case)
+#  > before the sort. Perl users often call this approach a Schwartzian transform, after
+#  > Randal Schwartz. We construct a temporary array, where each element is an array
+#  > containing our sort key along with the filename. We sort this array, and then extract
+#  > the filename from the result.
+#  > This is exactly what sort_by does internally.
+#
+# The well-documented efficiency of sort_by is a good reason to use it. However, when a property
+# does not exist on an item being sorted, it can cause issues (no nil's allowed!)
+# In Jekyll::Filters#sort_input, we extract the property in each iteration of #sort,
+# which is quite inefficient! How inefficient? This benchmark will tell you just how, and how much
+# it can be improved by using the Schwartzian transform. Thanks, Randall!
+
+require 'benchmark/ips'
+require 'minitest'
+require File.expand_path('../lib/jekyll', __dir__)
+
+def site
+  @site ||= Jekyll::Site.new(
+    Jekyll.configuration('source' => File.expand_path('../docs', __dir__))
+  ).tap(&:reset).tap(&:read)
+end
+
+def site_docs
+  site.collections['docs'].docs.dup
+end
+
+def sort_by_property_directly(docs, meta_key)
+  docs.sort! do |apple, orange|
+    apple_property = apple[meta_key]
+    orange_property = orange[meta_key]
+
+    if !apple_property.nil? && !orange_property.nil?
+      apple_property <=> orange_property
+    elsif !apple_property.nil? && orange_property.nil?
+      -1
+    elsif apple_property.nil? && !orange_property.nil?
+      1
+    else
+      apple <=> orange
+    end
+  end
+end
+
+def schwartzian_transform(docs, meta_key)
+  docs.collect! do |d|
+    [d[meta_key], d]
+  end.sort! do |apple, orange|
+    if !apple[0].nil? && !orange[0].nil?
+      apple.first <=> orange.first
+    elsif !apple[0].nil? && orange[0].nil?
+      -1
+    elsif apple[0].nil? && !orange[0].nil?
+      1
+    else
+      apple[-1] <=> orange[-1]
+    end
+  end.collect! { |d| d[-1] }
+end
+
+# Before we test efficiency, do they produce the same output?
+class Correctness
+  include Minitest::Assertions
+
+  define_method :mu_pp, &:pretty_inspect
+
+  attr_accessor :assertions
+
+  def initialize(docs, property)
+    @assertions = 0
+    @docs = docs
+    @property = property
+  end
+
+  def assert!
+    assert sort_by_property_directly(@docs, @property).is_a?(Array), 'sort_by_property_directly must return an array'
+    assert schwartzian_transform(@docs, @property).is_a?(Array), 'schwartzian_transform must return an array'
+    assert_equal sort_by_property_directly(@docs, @property),
+                 schwartzian_transform(@docs, @property)
+    puts "Yeah, ok, correctness all checks out for property #{@property.inspect}"
+  end
+end
+
+Correctness.new(site_docs, 'redirect_from').assert!
+Correctness.new(site_docs, 'title').assert!
+
+def property(property, meta_key)
+  Benchmark.ips do |x|
+    x.config(time: 10, warmup: 5)
+    x.report("sort_by_property_directly with #{property} property") do
+      sort_by_property_directly(site_docs, meta_key)
+    end
+    x.report("schwartzian_transform with #{property} property") do
+      schwartzian_transform(site_docs, meta_key)
+    end
+    x.compare!
+  end
+end
+
+# First, test with a property only a handful of documents have.
+test_property('sparse', 'redirect_from')
+
+# Next, test with a property they all have.
+test_property('non-sparse', 'title')

data/benchmark/sequential-assignment

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report('parallel assignment') do
+    a = 1
+    b = 2
+  end
+  x.report('multi-line assignment') do
+    a = 1
+    b = 2
+  end
+end

data/benchmark/static-drop-vs-forwarded.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'colorator'
+require 'liquid'
+require 'benchmark/ips'
+require 'memory_profiler'
+
+# Set up (memory) profiler
+
+class Profiler
+  def self.run
+    yield new(ARGV[0] || 10_000)
+  end
+
+  def initialize(count)
+    @count = count.to_i
+  end
+
+  def report(label, color, &block)
+    prof_report = MemoryProfiler.report { @count.to_i.times(&block) }
+
+    allocated_memory  = prof_report.scale_bytes(prof_report.total_allocated_memsize)
+    allocated_objects = prof_report.total_allocated
+    retained_memory   = prof_report.scale_bytes(prof_report.total_retained_memsize)
+    retained_objects  = prof_report.total_retained
+
+    puts <<~MSG.send(color)
+      With #{label} calls
+
+      Total allocated: #{allocated_memory} (#{allocated_objects} objects)
+      Total retained:  #{retained_memory} (#{retained_objects} objects)
+    MSG
+  end
+end
+
+# Set up stage
+
+class Drop < Liquid::Drop
+  def initialize(obj)
+    @obj = obj
+  end
+end
+
+class ForwardDrop < Drop
+  extend Forwardable
+  def_delegators :@obj, :name
+end
+
+class StaticDrop < Drop
+  def name
+    @obj.name
+  end
+end
+
+class Document
+  def name
+    'lipsum'
+  end
+end
+
+# Set up actors
+
+document = Document.new
+alpha    = ForwardDrop.new(document)
+beta     = StaticDrop.new(document)
+count    = ARGV[0] || 10_000
+
+# Run profilers
+puts "\nMemory profiles for #{count} calls to invoke drop key:"
+Profiler.run do |x|
+  x.report('forwarded', :cyan) { alpha['name'] }
+  x.report('static', :green) { beta['name'] }
+end
+
+# Benchmark
+puts "\nBenchmarking the two scenarios..."
+Benchmark.ips do |x|
+  x.report('forwarded'.cyan) { alpha['name'] }
+  x.report('static'.green) { beta['name'] }
+  x.compare!
+end

data/benchmark/string-concat

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+url = 'https://jekyllrb.com'
+
+Benchmark.ips do |x|
+  x.report('+=') { url += '/' }
+  x.report('<<') { url << '/' }
+end

data/benchmark/string-replacement

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+def str
+  'http://baruco.org/2014/some-talk-with-some-amount-of-value'
+end
+
+Benchmark.ips do |x|
+  x.report('#tr')    { str.tr('some', 'a')    }
+  x.report('#gsub')  { str.gsub('some', 'a')  }
+  x.report('#gsub!') { str.gsub!('some', 'a') }
+  x.report('#sub')   { str.sub('some', 'a')   }
+  x.report('#sub!')  { str.sub!('some', 'a')  }
+end

data/benchmark/symbol-to-proc

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report('block')  { (1..100).map(&:to_s) }
+  x.report('&:to_s') { (1..100).map(&:to_s) }
+end

data/rubocop/jekyll/assert_equal_literal_actual.rb

@@ -0,0 +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

data/rubocop/jekyll/no_p_allowed.rb

@@ -0,0 +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

data/rubocop/jekyll/no_puts_allowed.rb

@@ -0,0 +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

data/rubocop/jekyll.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lbenicio-minimal-v1
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.5
 platform: ruby
 authors:
 - Leonardo Benicio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-03 00:00:00.000000000 Z
+date: 2022-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll-seo-tag
@@ -156,8 +156,72 @@ email:
 executables: []
 extensions: []
 extra_rdoc_files: []
-files: []
-homepage: https://github.com/lbenicio/lbenicio-minimal1
+files:
+- ".rubocop.yml"
+- _includes/analytics.html
+- _includes/anchor_headings.html
+- _includes/blog-navigation.html
+- _includes/conclusion.html
+- _includes/footer.html
+- _includes/fork.html
+- _includes/head.html
+- _includes/navigation.html
+- _includes/pagination.html
+- _includes/postList.html
+- _layouts/autopage_category.html
+- _layouts/autopage_collection.html
+- _layouts/autopage_tags.html
+- _layouts/default.html
+- _layouts/home.html
+- _layouts/posts.html
+- assets/favicon.ico
+- assets/monokai.scss
+- assets/postStyle.scss
+- assets/profile.jpg
+- assets/style.scss
+- assets/vendor/all.min.css
+- assets/webfonts/fa-brands-400.eot
+- assets/webfonts/fa-brands-400.svg
+- assets/webfonts/fa-brands-400.ttf
+- assets/webfonts/fa-brands-400.woff
+- assets/webfonts/fa-brands-400.woff2
+- assets/webfonts/fa-regular-400.eot
+- assets/webfonts/fa-regular-400.svg
+- assets/webfonts/fa-regular-400.ttf
+- assets/webfonts/fa-regular-400.woff
+- assets/webfonts/fa-regular-400.woff2
+- assets/webfonts/fa-solid-900.eot
+- assets/webfonts/fa-solid-900.svg
+- assets/webfonts/fa-solid-900.ttf
+- assets/webfonts/fa-solid-900.woff
+- assets/webfonts/fa-solid-900.woff2
+- benchmark/capture-assign.rb
+- benchmark/conditional_liquid.rb
+- benchmark/end-with-vs-regexp
+- benchmark/file-dir-ensure-trailing-slash
+- benchmark/find-filter-vs-where-first-filters.rb
+- benchmark/flat-map
+- benchmark/hash-fetch
+- benchmark/jekyll-sanitize-path
+- benchmark/local-require
+- benchmark/native-vs-pathutil-relative
+- benchmark/parse-date
+- benchmark/parse-include-tag-params.rb
+- benchmark/path-manager.rb
+- benchmark/proc-call-vs-yield
+- benchmark/regexp-vs-include.rb
+- benchmark/sanitize-url.rb
+- benchmark/schwartzian_transform.rb
+- benchmark/sequential-assignment
+- benchmark/static-drop-vs-forwarded.rb
+- benchmark/string-concat
+- benchmark/string-replacement
+- benchmark/symbol-to-proc
+- rubocop/jekyll.rb
+- rubocop/jekyll/assert_equal_literal_actual.rb
+- rubocop/jekyll/no_p_allowed.rb
+- rubocop/jekyll/no_puts_allowed.rb
+homepage: https://github.com/lbenicio/lbenicio-minimal-v1
 licenses:
 - GPL-3.0
 metadata: {}