keynote 1.1.0 → 2.0.0

data/lib/keynote/inline.rb

@@ -1,7 +1,6 @@
-# encoding: UTF-8
+# frozen_string_literal: false
 
 require "action_view"
-require "thread"
 
 module Keynote
   # The `Inline` mixin lets you write inline templates as comments inside the
@@ -11,15 +10,18 @@ module Keynote
   # ## Basic usage
   #
   # After extending the `Keynote::Inline` module in your presenter class, you
-  # can generate HTML by calling the `erb` method and immediately following it
-  # with a block of comments containing your template:
+  # can generate HTML by calling the `erb` method and passing a template as a string
+  # to it:
   #
   #     def link
-  #       erb
-  #       # <%= link_to user_url(current_user) do %>
-  #       #   <%= image_tag("image1.jpg") %>
-  #       #   <%= image_tag("image2.jpg") %>
-  #       # <% end %>
+  #       erb do
+  #         <<~ERB
+  #           <%= link_to user_url(current_user) do %>
+  #             <%= image_tag("image1.jpg") %>
+  #              <%= image_tag("image2.jpg") %>
+  #           <% end %>
+  #         ERB
+  #       end
   #     end
   #
   # Calling this method renders the ERB template, including passing the calls
@@ -28,23 +30,15 @@ module Keynote
   #
   # ## Passing variables
   #
-  # There are a couple of different ways to pass local variables into an inline
-  # template. The easiest is to pass the `binding` object into the template
-  # method, giving access to all local variables:
+  # You can pass locals as keyword arguments to the `erb` method:
   #
-  #     def local_binding
+  #     def with_locals
   #       x = 1
   #       y = 2
   #
-  #       erb binding
-  #       # <%= x + y %>
-  #     end
-  #
-  # You can also pass a hash of variable names and values instead:
-  #
-  #     def local_binding
-  #       erb x: 1, y: 2
-  #       # <%= x + y %>
+  #       erb(x:, y:) do
+  #         %q(<%= x + y %>)
+  #       end
   #     end
   #
   # ## The `inline` method
@@ -83,18 +77,22 @@ module Keynote
     #     def header
     #       full_name = "#{user.first_name} #{user.last_name}"
     #
-    #       haml binding
-    #       # div#header
-    #       #   h1= full_name
-    #       #   h3= user.most_recent_status
+    #       haml(full_name:) do
+    #         <<~HAML
+    #           div#header
+    #             h1= full_name
+    #             h3= user.most_recent_status
+    #         HAML
+    #       end
     #     end
     #   end
     def inline(*formats)
       require "action_view/context"
 
       Array(formats).each do |format|
-        define_method format do |locals = {}|
-          Renderer.new(self, locals, caller(1)[0], format).render
+        define_method format do |**locals, &block|
+          raise ArgumentError, "You must pass a block to the ##{format} method" unless block
+          Renderer.new(self, locals, caller_locations(1, 1).first, block.call, format).render
         end
       end
     end
@@ -103,45 +101,39 @@ module Keynote
     # base class.
     def self.extended(base)
       base.inline :erb
+      base.include InstanceMethods
+    end
+
+    module InstanceMethods
+      # A callback for Action View: https://github.com/rails/rails/blob/a32eab53a58540b9ca57da429c5f64564db43126/actionview/lib/action_view/base.rb#L261
+      def _run(method, template, locals, buffer, add_to_stack: true, has_strict_locals: false, &block)
+        old_output_buffer, old_virtual_path, old_template = @output_buffer, @virtual_path, @current_template
+        @current_template = template if add_to_stack
+        @output_buffer = buffer
+        public_send(method, locals, buffer, &block)
+      ensure
+        @output_buffer, @virtual_path, @current_template = old_output_buffer, old_virtual_path, old_template
+      end
     end
 
     # @private
     class Renderer
-      def initialize(presenter, locals, caller_line, format)
+      def initialize(presenter, locals, loc, source, format)
         @presenter = presenter
-        @locals = extract_locals(locals)
-        @template = Cache.fetch(*parse_caller(caller_line), format, @locals)
+        @locals = locals
+        @template = Cache.fetch(loc.path, loc.lineno, source, format, locals)
       end
 
       def render
         @template.render(@presenter, @locals)
       end
-
-      private
-
-      def extract_locals(locals)
-        return locals unless locals.is_a?(Binding)
-
-        Hash[locals.eval("local_variables").map do |local|
-          [local, locals.eval(local.to_s)]
-        end]
-      end
-
-      def parse_caller(caller_line)
-        file, rest = caller_line.split ":", 2
-        line, _    = rest.split " ", 2
-
-        [file.strip, line.to_i]
-      end
     end
 
     # @private
     class Cache
-      COMMENTED_LINE = /^\s*#(.*)$/
-
-      def self.fetch(source_file, line, format, locals)
+      def self.fetch(source_file, line, source, format, locals)
         instance = (Thread.current[:_keynote_template_cache] ||= Cache.new)
-        instance.fetch(source_file, line, format, locals)
+        instance.fetch(source_file, line, source, format, locals)
       end
 
       def self.reset
@@ -152,18 +144,17 @@ module Keynote
         @cache = {}
       end
 
-      def fetch(source_file, line, format, locals)
+      def fetch(source_file, line, source, format, locals)
         local_names = locals.keys.sort
-        cache_key   = ["#{source_file}:#{line}", *local_names].freeze
-        new_mtime   = File.mtime(source_file).to_f
+        cache_key = ["#{source_file}:#{line}", *local_names].freeze
+        new_mtime = File.mtime(source_file).to_f
 
         template, mtime = @cache[cache_key]
 
         if new_mtime != mtime
-          source = read_template(source_file, line)
-
+          source = unindent(source.chomp)
           template = Template.new(source, cache_key[0],
-            handler_for_format(format), locals: local_names)
+            handler_for_format(format), format:, locals: local_names)
 
           @cache[cache_key] = [template, new_mtime]
         end
@@ -173,20 +164,6 @@ module Keynote
 
       private
 
-      def read_template(source_file, line_num)
-        result = ""
-
-        File.foreach(source_file).drop(line_num).each do |line|
-          if line =~ COMMENTED_LINE
-            result << $1 << "\n"
-          else
-            break
-          end
-        end
-
-        unindent result.chomp
-      end
-
       def handler_for_format(format)
         ActionView::Template.handler_for_extension(format.to_s)
       end
@@ -203,39 +180,12 @@ module Keynote
           end
         end
 
-        text.gsub(/^#{margin}/, ' ' * left_padding)
+        text.gsub(/^#{margin}/, " " * left_padding)
       end
     end
 
     # @private
-    class TemplateFor41AndLower < ActionView::Template
-      # Older versions of Rails don't have this mutex, but we probably want it,
-      # so let's make sure it's there.
-      def initialize(*)
-        super
-        @compile_mutex = Mutex.new
-      end
-
-      # The only difference between this #compile! and the normal one is that
-      # we call `view.class` instead of `view.singleton_class`, so that the
-      # template method gets defined as an instance method on the presenter
-      # and therefore sticks around between presenter instances.
-      def compile!(view)
-        return if @compiled
-
-        @compile_mutex.synchronize do
-          return if @compiled
-
-          compile(view, view.class)
-
-          @source = nil if defined?(@virtual_path) && @virtual_path
-          @compiled = true
-        end
-      end
-    end
-
-    # @private
-    class TemplateFor42AndHigher < ActionView::Template
+    class Template < ActionView::Template
       # The only difference between this #compile! and the normal one is that
       # we call `view.class` instead of `view.singleton_class`, so that the
       # template method gets defined as an instance method on the presenter
@@ -253,13 +203,5 @@ module Keynote
         end
       end
     end
-
-    if Rails.version.to_f < 4.2
-      # @private
-      Template = TemplateFor41AndLower
-    else
-      # @private
-      Template = TemplateFor42AndHigher
-    end
   end
 end

data/lib/keynote/presenter.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Keynote
   # Keynote::Presenter is a base class for presenters, objects that encapsulate
@@ -36,10 +36,10 @@ module Keynote
         objects.unshift :view
         attr_reader(*objects)
 
-        param_list = objects.join(', ')
-        ivar_list  = objects.map { |o| "@#{o}" }.join(', ')
+        param_list = objects.join(", ")
+        ivar_list = objects.map { "@#{it}" }.join(", ")
 
-        class_eval <<-RUBY
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def initialize(#{param_list})  # def initialize(view, foo)
             #{ivar_list} = #{param_list} #   @view, @foo = view, foo
           end                            # end
@@ -48,9 +48,7 @@ module Keynote
 
       # Define a more complete set of HTML5 tag methods. The extra tags are
       # listed in {Keynote::Rumble::COMPLETE}.
-      def use_html_5_tags
-        Rumble.use_html_5_tags(self)
-      end
+      def use_html_5_tags = Rumble.use_html_5_tags(self)
 
       # List the object names this presenter wraps. The default is an empty
       # array; calling `presents :foo, :bar` in the presenter's class body will
@@ -74,15 +72,15 @@ module Keynote
 
     # Instantiate another presenter.
     # @see Keynote.present
-    def present(*objects, &blk)
-      Keynote.present(@view, *objects, &blk)
+    def present(...)
+      Keynote.present(@view, ...)
     end
-    alias k present
+    alias_method :k, :present
 
     # @private
     def inspect
       objects = self.class.object_names
-      render  = proc { |name| "#{name}: #{send(name).inspect}" }
+      render = proc { |name| "#{name}: #{send(name).inspect}" }
 
       if objects.any?
         "#<#{self.class} #{objects.map(&render).join(", ")}>"
@@ -105,9 +103,9 @@ module Keynote
     #       "#{h author.name} &mdash; #{h blog_post.title}".html_safe
     #     end
     #   end
-    def method_missing(method_name, *args, &block)
+    def method_missing(method_name, ...)
       if @view.respond_to?(method_name, true)
-        @view.send(method_name, *args, &block)
+        @view.send(method_name, ...)
       else
         super
       end
@@ -116,16 +114,12 @@ module Keynote
     # @private
     # We have to make a logger method available so that ActionView::Template
     # can safely treat a presenter as a view object.
-    def logger
-      Rails.logger
-    end
+    def logger = Rails.logger
 
     private
 
     # We have to explicitly proxy `#capture` because ActiveSupport creates a
     # `Kernel#capture` method.
-    def capture(*args, &block)
-      @view.capture(*args, &block)
-    end
+    def capture(...) = @view.capture(...)
   end
 end

data/lib/keynote/railtie.rb

@@ -1,12 +1,11 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
-require 'rails/railtie'
+require "rails/railtie"
 
 module Keynote
   # @private
   class Railtie < Rails::Railtie
     config.after_initialize do |app|
-      add_presenters_to_paths(app)
       load_test_integration
     end
 
@@ -22,31 +21,15 @@ module Keynote
       include Keynote::Controller
     end
 
-    rake_tasks do
-      if defined?(MiniTest::Rails)
-        load File.expand_path("../testing/minitest_rails.rake", __FILE__)
-      end
-    end
-
-    def self.add_presenters_to_paths(app)
-      if ::Rails.version.to_f >= 4
-        app.config.paths.add 'app/presenters'
-      else
-        app.config.paths.add 'app/presenters', :eager_load => true
-      end
-    end
-
     def self.load_test_integration
       if defined?(RSpec::Rails)
-        require 'keynote/testing/rspec'
-      end
-
-      if defined?(MiniTest::Rails)
-        require 'keynote/testing/minitest_rails'
+        require "keynote/testing/rspec"
       end
 
-      if !defined?(MiniTest::Rails)
-        require "keynote/testing/test_unit"
+      begin
+        ::ActionView::TestCase # rubocop:disable Lint/Void
+        require "keynote/testing/minitest"
+      rescue
       end
     end
   end

data/lib/keynote/rumble.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: false
 
 module Keynote
   # HTML markup in Ruby.
@@ -189,7 +189,7 @@ module Keynote
       tags.each do |tag|
         sc = SELFCLOSING.include?(tag).inspect
 
-        base.class_eval <<-RUBY
+        base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{tag}(*args, &blk)                   # def a(*args, &blk)
             rumble_tag :#{tag}, #{sc}, *args, &blk  #   rumble_tag :a, false, *args, &blk
           end                                       # end
@@ -243,17 +243,19 @@ module Keynote
         end
       end
 
+      def respond_to_missing?(name, include_private = false)
+        true
+      end
+
       def method_missing(name, content = nil, attrs = nil, &blk)
         name = name.to_s
 
-        if name[-1] == ?!
+        if name[-1] == "!"
           attributes[:id] = name[0..-2]
+        elsif attributes.has_key?(:class)
+          attributes[:class] += " #{name}"
         else
-          if attributes.has_key?(:class)
-            attributes[:class] += " #{name}"
-          else
-            attributes[:class] = name
-          end
+          attributes[:class] = name
         end
 
         insert(content, attrs, &blk)
@@ -292,8 +294,13 @@ module Keynote
         raise $!
       end
 
-      def to_ary; nil end
-      def to_str; to_s end
+      def to_ary
+        nil
+      end
+
+      def to_str
+        to_s
+      end
 
       def html_safe?
         true
@@ -313,7 +320,9 @@ module Keynote
         end
       end
 
-      def inspect; to_s.inspect end
+      def inspect
+        to_s.inspect
+      end
 
       private
 
@@ -339,12 +348,12 @@ module Keynote
             if value.is_a?(Array)
               value.map { |val| Rumble.html_escape(val) }.join(" ")
             elsif value == true
-              name
+              name.to_s
             else
               Rumble.html_escape(value)
             end
 
-          res << " #{name}=\"#{value.gsub('"'.freeze, '&quot;'.freeze)}\""
+          res << " #{name}=\"#{value.gsub('"', "&quot;")}\""
           res
         end
       end

data/lib/keynote/testing/{minitest_rails.rb → minitest.rb}

@@ -1,10 +1,9 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 # Mutually exclusive with the Keynote::TestCase defined in
 # keynote/testing/test_unit. This is kind of icky but consistent with how
 # MT::R itself replaces the Rails test case classes.
 
-require "minitest/rails"
 require "keynote/testing/test_present_method"
 
 module Keynote

data/lib/keynote/testing/rspec.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require "rspec/core"
 require "keynote/testing/test_present_method"
@@ -16,11 +16,11 @@ end
 RSpec.configure do |config|
   if RSpec::Core::Version::STRING.starts_with?("3")
     config.include Keynote::ExampleGroup,
-      :type => :presenter,
-      :file_path => %r/spec.presenters/
+      type: :presenter,
+      file_path: %r{spec.presenters}
   else
     config.include Keynote::ExampleGroup,
-      :type => :presenter,
-      :example_group => { :file_path => %r/spec.presenters/ }
+      type: :presenter,
+      example_group: {file_path: %r{spec.presenters}}
   end
 end

data/lib/keynote/testing/test_present_method.rb

@@ -1,10 +1,10 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Keynote
   module TestPresentMethod
     def present(*objects, &blk)
       Keynote.present(view, *objects, &blk)
     end
-    alias k present
+    alias_method :k, :present
   end
 end

data/lib/keynote/testing/test_unit.rb

@@ -1,4 +1,4 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 require "keynote/testing/test_present_method"
 

data/lib/keynote/version.rb

@@ -1,6 +1,6 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
 module Keynote
   # @private
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/lib/keynote.rb

@@ -1,73 +1,15 @@
-# encoding: UTF-8
+# frozen_string_literal: true
 
+require "ruby-next"
+require "ruby-next/language/setup"
+RubyNext::Language.setup_gem_load_path(transpile: true)
+
+require "keynote/core"
 require "keynote/version"
 require "keynote/rumble"
 require "keynote/inline"
 require "keynote/presenter"
 require "keynote/controller"
 require "keynote/helper"
-require "keynote/railtie"
+require "keynote/railtie" if defined?(Rails::Railtie)
 require "keynote/cache"
-
-# Keynote is a library for defining and instantiating presenters,
-# objects that encapsulate view logic.
-#
-# @see file:README.md
-module Keynote
-  class << self
-    # Create or retrieve a presenter wrapping zero or more objects.
-    # If a block is given, yield the presenter into it.
-    #
-    # The first parameter is a Rails view context, but you'll usually access
-    # this method through `Keynote::Helper#present`,
-    # `Keynote::Controller#present`, or `Keynote::Presenter#present`, all of
-    # which handle the view context parameter automatically.
-    #
-    # @see Keynote::Helper#present
-    # @see Keynote::Controller#present
-    # @see Keynote::Presenter#present
-    #
-    # @overload present(view, *objects)
-    #   Return a presenter wrapping the given objects. The type of the
-    #   presenter will be inferred from the type of the first object.
-    #   @example
-    #     present(view, MyModel.new)           # => #<MyModelPresenter:0x0001>
-    #   @param [ActionView::Base] view
-    #   @param [Array] objects
-    #   @return [Keynote::Presenter]
-    #
-    # @overload present(view, presenter_name, *objects)
-    #   Return a presenter wrapping the given objects. The type of the
-    #   presenter is specified in underscore form by the first parameter.
-    #   @example
-    #     present(view, :foo_bar, MyModel.new) # => #<FooBarPresenter:0x0002>
-    #   @param [ActionView::Base] view
-    #   @param [Symbol, String] presenter_name
-    #   @param [Array] objects
-    #   @return [Keynote::Presenter]
-    #
-    def present(view, *objects)
-      if objects[0].is_a?(Symbol) || objects[0].is_a?(String)
-        name = objects.shift
-      else
-        name = presenter_name_from_object(objects[0])
-      end
-
-      Cache.fetch(name, view, *objects) do
-        presenter_from_name(name).new(view, *objects).tap do |presenter|
-          yield presenter if block_given?
-        end
-      end
-    end
-
-    private
-
-    def presenter_name_from_object(object)
-      object.class.to_s.underscore
-    end
-
-    def presenter_from_name(name)
-      "#{name.to_s.camelize}Presenter".constantize
-    end
-  end
-end