keynote 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '080b3677d432939095ffd3087facd1ffd826ed3b842985109d1719bc9e183b51'
-  data.tar.gz: 9fa73d9dd1301f7518058a550a588bc7bbd1c5e67ace7254f5d1508998e9f16b
+  metadata.gz: 4a0f6c0a47e0115c3af5240175cf1f4c357df31666aef44cfe7b3f1a546e1114
+  data.tar.gz: edc7a75afe4ddda3928ea5fdd70d642ca1fe08cc76e7448dba3f209b10717820
 SHA512:
-  metadata.gz: 3f3ff1f02d8ccf004d3a735855a186ae3a115dcf46452896cbbfde2a10f46690527eaa5192a102514f2323dc5a8994bdbd11134bf1eebcb697299437122005b5
-  data.tar.gz: 42a785dd6adc4eea5547feb515f0dc9e9c1007380571ea81b6b2ea13d18b9ed1f239bf2dbbe150c1f32a421564aacf80021bdf160042f3134b115626b0a5b2bc
+  metadata.gz: 032c27e729b093dd88685231e9b3b89ba23a0340fb3f09e4fd47be0d3716c80de0061fa668579103e433d93a35e6eb449f86d79a83745355761d34b3ab2f1cf5
+  data.tar.gz: da2b02ca64b35543003b90d94ccaf47460fe4567fb47cba06433fbfaaad9adf3431e6adb65414448bbf91b1a74801a410cf6fd0f84173350e4bae3f62d0b5c51

data/lib/.rbnext/3.1/keynote/inline.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: false
+
+require "action_view"
+
+module Keynote
+  # The `Inline` mixin lets you write inline templates as comments inside the
+  # body of a presenter method. You can use any template language supported by
+  # Rails.
+  #
+  # ## Basic usage
+  #
+  # After extending the `Keynote::Inline` module in your presenter class, you
+  # can generate HTML by calling the `erb` method and passing a template as a string
+  # to it:
+  #
+  #     def link
+  #       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
+  # to `link_to`, `user_url`, `current_user`, and `image_tag` back to the
+  # presenter object (and then to the view).
+  #
+  # ## Passing variables
+  #
+  # You can pass locals as keyword arguments to the `erb` method:
+  #
+  #     def with_locals
+  #       x = 1
+  #       y = 2
+  #
+  #       erb(x:, y:) do
+  #         %q(<%= x + y %>)
+  #       end
+  #     end
+  #
+  # ## The `inline` method
+  #
+  # If you want to use template languages other than ERB, you have to define
+  # methods for them by calling the {Keynote::Inline#inline} method on a
+  # presenter class:
+  #
+  #     class MyPresenter < Keynote::Presenter
+  #       extend Keynote::Inline
+  #       presents :user, :account
+  #       inline :haml
+  #     end
+  #
+  # This defines a `#haml` instance method on the `MyPresenter` class.
+  #
+  # If you want to make inline templates available to all of your presenters,
+  # you can add an initializer like this to your application:
+  #
+  #     class Keynote::Presenter
+  #       extend Keynote::Inline
+  #       inline :haml, :slim
+  #     end
+  #
+  # This will add `#erb`, `#haml`, and `#slim` instance methods to all of your
+  # presenters.
+  module Inline
+    # For each template format given as a parameter, add an instance method
+    # that can be called to render an inline template in that format. Any
+    # file extension supported by Rails is a valid parameter.
+    # @example
+    #   class UserPresenter < Keynote::Presenter
+    #     presents :user
+    #     inline :haml
+    #
+    #     def header
+    #       full_name = "#{user.first_name} #{user.last_name}"
+    #
+    #       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, &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
+
+    # Extending `Keynote::Inline` automatically creates an `erb` method on the
+    # 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, loc, source, format)
+        @presenter = presenter
+        @locals = locals
+        @template = Cache.fetch(loc.path, loc.lineno, source, format, locals)
+      end
+
+      def render
+        @template.render(@presenter, @locals)
+      end
+    end
+
+    # @private
+    class Cache
+      def self.fetch(source_file, line, source, format, locals)
+        instance = (Thread.current[:_keynote_template_cache] ||= Cache.new)
+        instance.fetch(source_file, line, source, format, locals)
+      end
+
+      def self.reset
+        Thread.current[:_keynote_template_cache] = nil
+      end
+
+      def initialize
+        @cache = {}
+      end
+
+      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
+
+        template, mtime = @cache[cache_key]
+
+        if new_mtime != mtime
+          source = unindent(source.chomp)
+          template = Template.new(source, cache_key[0],
+            handler_for_format(format), format: format, locals: local_names)
+
+          @cache[cache_key] = [template, new_mtime]
+        end
+
+        template
+      end
+
+      private
+
+      def handler_for_format(format)
+        ActionView::Template.handler_for_extension(format.to_s)
+      end
+
+      # Borrowed from Pry, which borrowed it from Python.
+      def unindent(text, left_padding = 0)
+        margin = text.scan(/^[ \t]*(?=[^ \t\n])/).inject do |current_margin, next_indent|
+          if next_indent.start_with?(current_margin)
+            current_margin
+          elsif current_margin.start_with?(next_indent)
+            next_indent
+          else
+            ""
+          end
+        end
+
+        text.gsub(/^#{margin}/, " " * left_padding)
+      end
+    end
+
+    # @private
+    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
+      # and therefore sticks around between presenter instances.
+      def compile!(view)
+        return if @compiled
+
+        @compile_mutex.synchronize do
+          return if @compiled
+
+          compile(view.class)
+
+          @source = nil if defined?(@virtual_path) && @virtual_path
+          @compiled = true
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/3.4/keynote/presenter.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Keynote
+  # Keynote::Presenter is a base class for presenters, objects that encapsulate
+  # view logic.
+  #
+  # @see file:README.md
+  class Presenter
+    include Keynote::Rumble
+
+    class << self
+      attr_writer :object_names
+
+      # Define the names and number of the objects presented by this class.
+      # This replaces the default one-parameter constructor with one that takes
+      # an extra parameter for each presented object.
+      #
+      # @param [Array<Symbol>] objects One symbol for each of the models that
+      #   will be required to instantiate this presenter. Each symbol will be
+      #   used as the accessor and instance variable name for its associated
+      #   parameter, but an object of any class can be given for any parameter.
+      #
+      # @example
+      #   class PostPresenter
+      #     presents :blog_post, :author
+      #   end
+      #
+      #   # In a view
+      #   presenter = k(:post, @some_post, @some_user)
+      #   presenter.blog_post # == @some_post
+      #   presenter.author    # == @some_user
+      #
+      def presents(*objects)
+        self.object_names = objects.dup
+
+        objects.unshift :view
+        attr_reader(*objects)
+
+        param_list = objects.join(", ")
+        ivar_list = objects.map { it = _1;"@#{it}" }.join(", ")
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def initialize(#{param_list})  # def initialize(view, foo)
+            #{ivar_list} = #{param_list} #   @view, @foo = view, foo
+          end                            # end
+        RUBY
+      end
+
+      # 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)
+
+      # List the object names this presenter wraps. The default is an empty
+      # array; calling `presents :foo, :bar` in the presenter's class body will
+      # cause `object_names` to return `[:foo, :bar]`.
+      # @return [Array<Symbol>]
+      def object_names
+        @object_names ||= []
+      end
+    end
+
+    # @private (used by Keynote::Cache to keep the view context up-to-date)
+    attr_writer :view
+
+    # Create a presenter. The default constructor takes one parameter, but
+    # calling `presents` replaces it with a generated constructor.
+    # @param [ActionView::Base] view_context
+    # @see Keynote::Presenter.presents
+    def initialize(view_context)
+      @view = view_context
+    end
+
+    # Instantiate another presenter.
+    # @see Keynote.present
+    def present(...)
+      Keynote.present(@view, ...)
+    end
+    alias_method :k, :present
+
+    # @private
+    def inspect
+      objects = self.class.object_names
+      render = proc { |name| "#{name}: #{send(name).inspect}" }
+
+      if objects.any?
+        "#<#{self.class} #{objects.map(&render).join(", ")}>"
+      else
+        "#<#{self.class}>"
+      end
+    end
+
+    # @private
+    def respond_to_missing?(method_name, include_private = true)
+      @view.respond_to?(method_name, true)
+    end
+
+    # Presenters proxy unknown method calls to the view context, allowing you
+    # to call `h`, `link_to`, and anything else defined in a helper module.
+    #
+    # @example
+    #   def title_link
+    #     link_to blog_post_url(blog_post) do
+    #       "#{h author.name} &mdash; #{h blog_post.title}".html_safe
+    #     end
+    #   end
+    def method_missing(method_name, ...)
+      if @view.respond_to?(method_name, true)
+        @view.send(method_name, ...)
+      else
+        super
+      end
+    end
+
+    # @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
+
+    private
+
+    # We have to explicitly proxy `#capture` because ActiveSupport creates a
+    # `Kernel#capture` method.
+    def capture(...) = @view.capture(...)
+  end
+end

data/lib/keynote/version.rb

@@ -2,5 +2,5 @@
 
 module Keynote
   # @private
-  VERSION = "2.0.2"
+  VERSION = "2.0.3"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: keynote
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Ryan Fitzgerald
 - Vladimir Dementyev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -207,6 +206,8 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- lib/.rbnext/3.1/keynote/inline.rb
+- lib/.rbnext/3.4/keynote/presenter.rb
 - lib/generators/presenter_generator.rb
 - lib/generators/templates/keynote_mini_test_spec.rb.tt
 - lib/generators/templates/keynote_mini_test_unit.rb.tt
@@ -235,7 +236,6 @@ metadata:
   documentation_uri: https://rubydoc.info/gems/keynote
   homepage_uri: https://github.com/evilmartians/keynote
   source_code_uri: https://github.com/evilmartians/keynote
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -250,8 +250,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Flexible presenters for Rails
 test_files: []