superview 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a8124e9df0a2fcaed7dd467327cedc7a676117a54c47896ba436c7f6cdc97c4
-  data.tar.gz: 65bfc7d730a19ae0107519207dc4078a17772465305195186ddd5b3b152f6edb
+  metadata.gz: 185e73cab73c23d8de233721cde393cb453868e1cf3a6f5ef8b322b9b613ff32
+  data.tar.gz: 6bca9e94731ecd625cf20f904f0cac42fe969ac63ac72913de75f6a176f18a1e
 SHA512:
-  metadata.gz: 8ca5b6d4459efebc79bc12dd3a4e99d39c14a200a4ad56d998bc784658d770526c78687121320b70a2a67beebe641d8ee247c149861205df7d60a3f59c640130
-  data.tar.gz: 3e6c2af610a5b8a7f6952425bef2c9be9d5e39a49fd6f0128f73923737fea2b6fc70954883e79a17e48534047512d17aae26da1b3adc6a4511efa079bd7073d0
+  metadata.gz: a4dfdc42e1697576ac22f8af14c0d6f75be71b198b19a5c6e3097c895db0eb114401af25cf30c39e3615999f4bb41907bde50bc70e22aa6520c1c9805a8eb230
+  data.tar.gz: d00f990562345a341b69ac4c86ef72bf0deef57defbe4dcdfdfa0b9759079f8e43f57005d59c8058cec368fefa886090814517de823efc2dd7b94b84601dd896

data/Gemfile

@@ -9,4 +9,4 @@ gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
 
-gem "rails", "~> 7.0"
+gem "rails", "~> 7.0"

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    superview (0.1.0)
+    superview (0.1.2)
       phlex-rails (~> 1.0)
+      zeitwerk (~> 2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -96,6 +97,7 @@ GEM
     marcel (1.0.2)
     method_source (1.0.0)
     mini_mime (1.1.5)
+    mini_portile2 (2.8.5)
     minitest (5.19.0)
     net-imap (0.3.7)
       date
@@ -107,7 +109,8 @@ GEM
     net-smtp (0.3.3)
       net-protocol
     nio4r (2.5.9)
-    nokogiri (1.15.4-arm64-darwin)
+    nokogiri (1.15.4)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     phlex (1.8.1)
       concurrent-ruby (~> 1.2)
@@ -174,6 +177,8 @@ GEM
 
 PLATFORMS
   arm64-darwin-22
+  arm64-darwin-23
+  x86_64-linux
 
 DEPENDENCIES
   rails (~> 7.0)

data/README.md

@@ -1,10 +1,6 @@
 # Superview
 
-Include in controllers to map action names to class names. This makes it possible to embed Phlex components directly into Rails controllers without having to go through other templating systems like Erb.
-
-Instance methods will be assigned to views that have `attr_accessor` methods.
-
-Consider a blog post controller:
+Build Rails applications, from the ground up, using [Phlex](https://www.phlex.fun/) components, like this.
 
 ```ruby
 class PostsController < ApplicationController
@@ -28,7 +24,10 @@ class PostsController < ApplicationController
 end
 ```
 
-The `@post` variable gets set in the `Show` view class via `Show#post=`.
+Read more about it at:
+
+* [Component driven development on Rails with Phlex](https://fly.io/ruby-dispatch/component-driven-development-on-rails-with-phlex/)
+* [Hacking Rails Implicit Rendering for View Components & Fun](https://fly.io/ruby-dispatch/hacking-rails-implicit-rendering-for-view-components/)
 
 ## Installation
 
@@ -42,25 +41,109 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-Install `phlex-rails` in your application.
+Install `phlex-rails` in your Rails application.
 
     $ bin/rails generate phlex:install
 
-Then include the following any controller you'd like to render Phlex components.
+Then add `include Superview::Actions` to any controllers you'd like to render Phlex components.
+
+```ruby
+class PostsController < ApplicationController
+  include Superview::Actions
+
+  before_action :load_post
+
+  class Show < ApplicationComponent
+    attr_accessor :post
+
+    def template(&)
+      h1 { @post.title }
+      div(class: "prose") { @post.body }
+    end
+  end
+
+  private
+    def load_post
+      @post = Post.find(params[:id])
+    end
+end
+```
+
+The `Show` class will render when the `PostsController#show` action is called. To use along side other formats or render manually, you can define the `PostsController#show` as you'd expect:
 
 ```ruby
 class PostsController < ApplicationController
   include Superview::Actions
 
+  before_action :load_post
+
+  class Show < ApplicationComponent
+    attr_accessor :post
+
+    def template(&)
+      h1 { @post.title }
+      div(class: "prose") { @post.body }
+    end
+  end
+
+  def show
+    respond_to do |format|
+      format.html { render Show.new.tap { _1.post = @post } }
+      format.json { render json: @post }
+    end
+  end
+
+  private
+    def load_post
+      @post = Post.find(params[:id])
+    end
+end
+```
+
+### Extracting inline views into the `./app/views` folder
+
+Inline views are an amazingly productive way of prototyping apps, but as it matures you might be inclined to extract these views into the `./app/views` folders for organizational purposes or so you can share them between controllers.
+
+First let's extract the `Show` class into `./app/views/posts/show.rb`
+
+```ruby
+# ./app/views/posts/show.rb
+module Posts
   class Show < ApplicationComponent
+    attr_accessor :post
+
     def template(&)
-      h1 { "Hello World" }
+      h1 { @post.title }
+      div(class: "prose") { @post.body }
+    end
+  end
+end
+```
+
+Then include the `Posts` module in the controllers you'd like to use the views:
+
+```ruby
+class PostsController < ApplicationController
+  include Superview::Actions
+  include Posts # Add this to your controller 🚨
+
+  before_action :load_post
+
+  def show
+    respond_to do |format|
+      format.html { render Show.new.tap { _1.post = @post } }
+      format.json { render json: @post }
     end
   end
+
+  private
+    def load_post
+      @post = Post.find(params[:id])
+    end
 end
 ```
 
-The `Show` class will render when the `PostsController#show` action is called.
+That's it! Ruby includes all the classes in the `Posts` module, which Superview picks up and renders in the controller. If you have an `Index`, `Edit`, `New`, etc. class in the `Posts` namespace, those would be implicitly rendered for their respective action.
 
 ## Development
 
@@ -70,7 +153,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/superview. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/superview/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubymonolith/superview. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/rubymonolith/superview/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -78,4 +161,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Superview project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/superview/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the Superview project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/rubymonolith/superview/blob/main/CODE_OF_CONDUCT.md).

data/lib/superview/actions.rb

@@ -0,0 +1,86 @@
+module Superview
+  # Include in controllers to map action names to class names. This makes it possible to
+  # embed Phlex components directly into Rails controllers without having to go through
+  # other templating systems like Erb.
+  #
+  # Instance methods will be assigned to views that have `attr_accessor` methods.
+  #
+  # Consider a blog post controller:
+  #
+  # ```ruby
+  # class PostsController < ApplicationController
+  #   include Superview::Actions
+  #
+  #   before_action :load_post
+  #
+  #   class Show < ApplicationComponent
+  #     attr_accessor :post
+  #
+  #     def template(&)
+  #       h1 { @post.title }
+  #       div(class: "prose") { @post.body }
+  #     end
+  #   end
+  #
+  #   private
+  #     def load_post
+  #       @post = Post.find(params[:id])
+  #     end
+  # end
+  # ```
+  #
+  # The `@post` variable gets set in the `Show` view class via `Show#post=`.
+  module Actions
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Finds a class on the controller with the same name as the action. For example,
+      # `def index` would find the `Index` constant on the controller class to render
+      # for the action `index`.
+      def phlex_action_class(action:)
+        action_class = action.to_s.camelcase
+        const_get action_class if const_defined? action_class
+      end
+    end
+
+    protected
+
+    # Assigns the instance variables that are set in the controller to setter method
+    # on Phlex. For example, if a controller defines @users and a Phlex class has
+    # `attr_writer :users`, `attr_accessor :user`, or `def users=`, it will be automatically
+    # set by this method.
+    def assign_phlex_accessors(phlex_view)
+      phlex_view.tap do |view|
+        view_assigns.each do |variable, value|
+          attr_writer_name = "#{variable}="
+          view.send attr_writer_name, value if view.respond_to? attr_writer_name
+        end
+      end
+    end
+
+    # Initializers a Phlex view based on the action name, then assigns `view_assigns`
+    # to the view.
+    def phlex_action(action)
+      assign_phlex_accessors self.class.phlex_action_class(action: action).new
+    end
+
+    # Phlex action for the current action.
+    def phlex
+      phlex_action(action_name)
+    end
+
+    # Try rendering with the regular Rails rendering methods; if those don't work
+    # then try finding the Phlex class that corresponds with the action_name. If that's
+    # found then tell Rails to call `default_phlex_render`.
+    def method_for_action(action_name)
+      super || if self.class.phlex_action_class action: action_name
+                          "default_phlex_render"
+      end
+    end
+
+    # Renders a Phlex view for the given action, if it's present.
+    def default_phlex_render
+      render phlex
+    end
+  end
+end

data/lib/superview/assignable.rb

@@ -0,0 +1,159 @@
+module Superview
+  module Assignable
+    # Include in RESTful Rails controllers to assign instance variables ActiveRecord scopes
+    # without all the boiler plate.
+    #
+    # Let's start with the most simple example
+    #
+    # ```ruby
+    # ./app/controllers/blog/posts_controller.rb
+    # class BlogsController < ApplicationController
+    #   assign :blog
+    # end
+    # ```
+    #
+    # This would load the `Blog` scope for `collection` routes, like `index`, as `@blogs` and
+    # load `Blog.find(params[:id])` for `member` routes, like `show`, `edit`, `update`, etc.
+    # as `@blog`.
+    #
+    # Most applications need to load stuff from a user that's logged in, which is what the `from:`
+    # key makes possible.
+    #
+    # ```ruby
+    # ./app/controllers/blog/posts_controller.rb
+    # class BlogsController < ApplicationController
+    #   assign :blog, from: :current_user
+    # end
+    # ```
+    #
+    # This assumes the controller has a `current_user` method defined in the controller that returns
+    # a `User` model with the relationship `has_many :blogs`. It loads the blog via
+    # `current_user.blogs.find(params[:id]).
+    #
+    # A blog has many posts, so how would we assign a post through a blog from the current user?
+    #
+    # ```ruby
+    # ./app/controllers/blog/posts_controller.rb
+    # class Blog::PostsController < ApplicationController
+    #   assign :post, through: :blog, from: :current_user
+    # end
+    # ```
+    #
+    # This does not work like the `through:` ActiveRecord key, so pay attention ya know it all! This
+    # follows the idea of nested REST routes in Rails. In this case the `Blog` is the "parent resource"
+    # and the `Post` is the resource. How does is that queried? Glad you asked!
+    #
+    # First the specific blog is loaded via `@blog = current_user.blogs.find(params[:blog_id])` to set the
+    # parent model. Next the `Post` scope is set via `@posts = @blog.posts`. `@posts` for collection routes.
+    # Finally `@post = @posts.find(params[:id])` is set for member routes.
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :model, :parent_model, :context_method_name
+
+      before_action :assign_parent_collection, if: :has_parent_model?
+      before_action :assign_parent_member, if: :has_parent_model?
+      before_action :assign_collection
+      before_action :assign_member
+    end
+
+    protected
+
+    def assign_collection
+      instance_variable_set "@#{model.model_name.plural}", model_scope
+    end
+
+    def assign_parent_collection
+      instance_variable_set "@#{parent_model.model_name.plural}", parent_model_scope
+    end
+
+    def model_scope
+      if has_parent_model?
+        parent_model_instance.association(model.model_name.collection)
+      elsif has_assignable_context?
+        assignable_context.association(model.model_name.collection).scope
+      else
+        model.scope_for_association
+      end
+    end
+
+    def parent_model_scope
+      if has_assignable_context?
+        assignable_context.association(parent_model.model_name.collection)
+      else
+        parent_model.scope_for_association
+      end
+    end
+
+    def parent_model_instance
+      parent_model_scope.find(params.fetch(parent_model_param_key))
+    end
+
+    def assign_parent_member
+      instance_variable_set "@#{parent_model.model_name.singular}", parent_model_instance
+    end
+
+    def has_parent_model?
+      parent_model.present?
+    end
+
+    def assign_member
+      instance_variable_set "@#{model.model_name.singular}", model_instance
+    end
+
+    def model_instance
+      if member?
+        model_scope.find params.fetch(model_param_key)
+      else
+        model_scope.build.tap do |post|
+          # # Blog is a reflection of User
+          # # Get the name of the `user` association.
+          # parent_from_association = parent_model_scope.reflection.inverse_of
+
+          # if model.reflect_on_association(parent_from_association.name)
+          #   similar_association = model.association parent_from_association.name
+          #   # Now let's see if that association exists on the current_model ..
+          #   #
+          #   # This isn't setting the foreign key ... errrggggg.
+          #   raise 'hell'
+
+          #   # post.association(association_name).target = parent_model_scope.owner
+          # end
+        end
+      end
+    end
+
+    def member?
+      params.key? model_param_key
+    end
+
+    def model_param_key
+      :id
+    end
+
+    def parent_model_param_key
+      "#{parent_model.model_name.singular}_id".to_sym
+    end
+
+    def assignable_context
+      self.send self.class.context_method_name
+    end
+
+    def has_assignable_context?
+      !!self.class.context_method_name
+    end
+
+    class_methods do
+      def assign(scope, through: nil, from: nil)
+        self.model = Assignable.find_scope scope
+        self.parent_model = Assignable.find_scope through
+        self.context_method_name = from
+      end
+    end
+
+    def self.find_scope(name)
+      name.to_s.singularize.camelize.constantize if name
+    end
+  end
+end

data/lib/superview/components/table_component.rb

@@ -0,0 +1,78 @@
+module Superview::Components
+  # Renders an HTML table for a collection. Each item is passed into the
+  # collection of the table.
+  #
+  # ```ruby
+  # render TableComponent.new(items: @posts) do |table|
+  #   # This is how you'd usually render a table.
+  #   table.column("Title") { show(_1, :title) }
+  #
+  #   # If you need to render HTML in the title, add a `column` argument
+  #   # to the block and call `title` or `item` on it.
+  #   table.column do |column|
+  #     # Titles might not always be text, so we need to handle rendering
+  #     # Phlex markup within.
+  #     column.title do
+  #       link_to(user_blogs_path(@current_user)) { "Blogs" }
+  #     end
+  #     column.item { show(_1.blog, :title) }
+  #   end
+  # end
+  # ```
+  class TableComponent < ApplicationComponent
+    include Phlex::DeferredRender
+
+    class Column
+      attr_accessor :title_template, :item_template
+
+      def title(&block)
+        @title_template = block
+      end
+
+      def item(&block)
+        @item_template = block
+      end
+
+      def self.build(title:, &block)
+        new.tap do |column|
+          column.title { title }
+          column.item(&block)
+        end
+      end
+    end
+
+    def initialize(items: [])
+      @items = items
+      @columns = []
+    end
+
+    def template(&)
+      table do
+        thead do
+          tr do
+            @columns.each do |column|
+              th(&column.title_template)
+            end
+          end
+        end
+        tbody do
+          @items.each do |item|
+            tr do
+              @columns.each do |column|
+                td { column.item_template.call(item) }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def column(title = nil, &block)
+      @columns << if title
+        Column.build(title: title, &block)
+      else
+        Column.new.tap(&block)
+      end
+    end
+  end
+end

data/lib/superview/helpers/links.rb

@@ -0,0 +1,82 @@
+module Superview
+  module Helpers
+    # RESTful links for creating Superviews in applications. For example, given a
+    # blog application, we might have links like:
+    #
+    # ```ruby
+    # create(Post) { "New Blog Post" }
+    # create(Post.new) { "New Blog Post" }
+    # ```
+    #
+    # Which generateds the html `<a href="/posts/new">New Blog Post</a>` and
+    #
+    # ```ruby
+    # show(@post) { @post.title }
+    # ```
+    #
+    # generates the html `<a href="/posts/1">My First Post</a>`. An attribute
+    # can be passed in as a second argument, which calls the method on the object
+    # passed into the link helper.
+    #
+    # ```ruby
+    # show(@post, :title)
+    # ```
+    #
+    # generates `<a href="/posts/new">New Blog Post</a>`.
+    #
+    # Link helpers are available per RESTful action.
+    #
+    # ```ruby
+    # delete(@post)
+    # edit(@post)
+    # ```
+    module Links
+      # Give us some sane link helpers to work with in Phlex. They kind
+      # of mimic Rails helpers, but are "Phlexable".
+      def link_to(target = nil, method: nil, **attributes, &)
+        url = case target
+        when URI
+          target.to_s
+        when NilClass
+          url_for(attributes)
+        else
+          url_for(target)
+        end
+        a(href: url, data_turbo_method: method, **attributes, &)
+      end
+
+      def show(model, attribute = nil, *args, **kwargs, &content)
+        content ||= Proc.new { model.send(attribute) }
+        link_to(model, *args, **kwargs, &content)
+      end
+
+      def edit(model, *args, **kwargs, &content)
+        content ||= Proc.new { "Edit #{model.class.model_name}" }
+        link_to([:edit, model],  *args, **kwargs, &content)
+      end
+
+      def delete(model, *args, confirm: nil, **kwargs, &content)
+        content ||= Proc.new { "Delete #{model.class.model_name}" }
+        link_to(model, *args, method: :delete, data_turbo_confirm: confirm, **kwargs, &content)
+      end
+
+      def create(scope = nil, *args, **kwargs, &content)
+        target = if scope.respond_to? :proxy_association
+          owner = scope.proxy_association.owner
+          model = scope.proxy_association.reflection.klass.model_name
+          element = scope.proxy_association.reflection.klass.model_name.element.to_sym
+          [:new, owner, element]
+        elsif scope.respond_to? :model
+          model = scope.model
+          [:new, model.model_name.singular_route_key.to_sym]
+        elsif scope.respond_to? :model_name
+          [:new, scope.model_name.singular_route_key.to_sym]
+        end
+
+        content ||= Proc.new { "Create #{model}" }
+
+        link_to(target, *args, **kwargs, &content)
+      end
+    end
+  end
+end

data/lib/superview/helpers/turbo/meta_tags.rb

@@ -0,0 +1,48 @@
+module Superview
+  module Helpers
+    module Turbo
+      # Renders the metatags for setting up Turbo Drive.
+      class MetaTags < ApplicationComponent
+        attr_accessor \
+          :method,
+          :scroll,
+          :exempts_page_from_cache,
+          :exempts_page_from_preview,
+          :page_requires_reload
+
+        METHOD = :replace
+        SCROLL = :reset
+
+        def initialize(method: METHOD, scroll: SCROLL, exempts_page_from_preview: nil, exempts_page_from_cache: nil, page_requires_reload: nil)
+          refreshes_with method: method, scroll: scroll
+          @exempts_page_from_cache = exempts_page_from_cache
+          @exempts_page_from_preview = exempts_page_from_preview
+          @page_requires_reload = page_requires_reload
+        end
+
+        def template
+          meta(name: "turbo-refresh-method", content: @method)
+          meta(name: "turbo-refresh-scroll", content: @scroll)
+          meta(name: "turbo-cache-control", content: "no-cache") if @exempts_page_from_cache
+          meta(name: "turbo-cache-control", content: "no-preview") if @exempts_page_from_preview
+          meta(name: "turbo-visit-control", content: "reload") if @page_requires_reload
+        end
+
+        def refreshes_with(method: METHOD, scroll: SCROLL)
+          self.method = method
+          self.scroll = scroll
+        end
+
+        def method=(value)
+          raise ArgumentError, "Invalid refresh option '#{value}'" unless value.in?(%i[ replace morph ])
+          @method = value
+        end
+
+        def scroll=(value)
+          raise ArgumentError, "Invalid scroll option '#{value}'" unless value.in?(%i[ reset preserve ])
+          @scroll = value
+        end
+      end
+    end
+  end
+end

data/lib/superview/helpers/turbo.rb

@@ -0,0 +1,39 @@
+module Superview
+  module Helpers
+    module Turbo
+      extend ActiveSupport::Concern
+
+      included do
+        register_element :turbo_cable_stream_source
+      end
+
+      class_methods do
+        def turbo(*args, **kwargs, &block)
+          @turbo_meta_tags = MetaTags.new(*args, **kwargs)
+          define_method(:turbo, &block) if block
+        end
+
+        def turbo_meta_tags
+          @turbo_meta_tags ||= MetaTags.new
+        end
+      end
+
+      def turbo_stream_from(*streamables, **attributes)
+        attributes[:channel] = attributes[:channel]&.to_s || "Turbo::StreamsChannel"
+        attributes[:"signed-stream-name"] = ::Turbo::StreamsChannel.signed_stream_name(streamables)
+        turbo_cable_stream_source **attributes, class: "hidden", style: "display: none;"
+      end
+
+      def stream_from(*streamables)
+        streamables.each do |streamable|
+          case streamable
+            in association: ActiveRecord::Relation
+              association.each { turbo_stream_from streamable }
+            else
+              turbo_stream_from streamable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superview/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Superview
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/superview.rb

@@ -2,91 +2,13 @@
 
 require_relative "superview/version"
 require "active_support/concern"
+require "zeitwerk"
 
 module Superview
-  class Error < StandardError; end
-  # Include in controllers to map action names to class names. This makes it possible to
-  # embed Phlex components directly into Rails controllers without having to go through
-  # other templating systems like Erb.
-  #
-  # Instance methods will be assigned to views that have `attr_accessor` methods.
-  #
-  # Consider a blog post controller:
-  #
-  # ```ruby
-  # class PostsController < ApplicationController
-  #   include Superview::Actions
-  #
-  #   before_action :load_post
-  #
-  #   class Show < ApplicationComponent
-  #     attr_accessor :post
-  #
-  #     def template(&)
-  #       h1 { @post.title }
-  #       div(class: "prose") { @post.body }
-  #     end
-  #   end
-  #
-  #   private
-  #     def load_post
-  #       @post = Post.find(params[:id])
-  #     end
-  # end
-  # ```
-  #
-  # The `@post` variable gets set in the `Show` view class via `Show#post=`.
-  module Actions
-    extend ActiveSupport::Concern
-
-    class_methods do
-      # Finds a class on the controller with the same name as the action. For example,
-      # `def index` would find the `Index` constant on the controller class to render
-      # for the action `index`.
-      def phlex_action_class(action:)
-        action_class = action.to_s.camelcase
-        const_get action_class if const_defined? action_class
-      end
-    end
-
-    protected
-
-    # Assigns the instance variables that are set in the controller to setter method
-    # on Phlex. For example, if a controller defines @users and a Phlex class has
-    # `attr_writer :users`, `attr_accessor :user`, or `def users=`, it will be automatically
-    # set by this method.
-    def assign_phlex_accessors(phlex_view)
-      phlex_view.tap do |view|
-        view_assigns.each do |variable, value|
-          attr_writer_name = "#{variable}="
-          view.send attr_writer_name, value if view.respond_to? attr_writer_name
-        end
-      end
-    end
-
-    # Initializers a Phlex view based on the action name, then assigns `view_assigns`
-    # to the view.
-    def phlex_action(action)
-      assign_phlex_accessors self.class.phlex_action_class(action: action).new
-    end
-
-    # Phlex action for the current action.
-    def phlex
-      phlex_action(action_name)
-    end
-
-    # Try rendering with the regular Rails rendering methods; if those don't work
-    # then try finding the Phlex class that corresponds with the action_name. If that's
-    # found then tell Rails to call `default_phlex_render`.
-    def method_for_action(action_name)
-      super || if self.class.phlex_action_class action: action_name
-                          "default_phlex_render"
-      end
-    end
-
-    # Renders a Phlex view for the given action, if it's present.
-    def default_phlex_render
-      render phlex
-    end
+  Loader = Zeitwerk::Loader.for_gem.tap do |loader|
+    loader.ignore "#{__dir__}/generators"
+    loader.setup
   end
+
+  class Error < StandardError; end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: superview
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Brad Gessler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2024-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex-rails
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: Build Rails applications entirely out of Phlex components.
 email:
 - bradgessler@gmail.com
@@ -40,6 +54,12 @@ files:
 - README.md
 - Rakefile
 - lib/superview.rb
+- lib/superview/actions.rb
+- lib/superview/assignable.rb
+- lib/superview/components/table_component.rb
+- lib/superview/helpers/links.rb
+- lib/superview/helpers/turbo.rb
+- lib/superview/helpers/turbo/meta_tags.rb
 - lib/superview/version.rb
 - sig/superview.rbs
 homepage: https://github.com/rubymonolith/superview
@@ -65,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Build Rails applications entirely out of Phlex components.