inertiax_rails 2.0.0

data/inertiax_rails.gemspec

@@ -0,0 +1,37 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "inertia_rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "inertiax_rails"
+  spec.version       = InertiaRails::VERSION
+  spec.authors       = ["Brian Knoles", "Brandon Shar", "Eugene Granovsky", "Stefan Buhrmester"]
+  spec.email         = ["brain@bellawatt.com", "brandon@bellawatt.com", "eugene@bellawatt.com", "stefan@buhrmi.de"]
+
+  spec.summary       = %q{Inertia adapter for Rails}
+  spec.homepage      = "https://github.com/buhrmi/inertia-rails"
+  spec.license       = "MIT"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "railties", '>= 5'
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec-rails", "~> 4.0"
+  spec.add_development_dependency "rails-controller-testing"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "responders"
+  spec.add_development_dependency "debug"
+end

data/lib/generators/inertia_rails/install/controller.rb

@@ -0,0 +1,7 @@
+class InertiaExampleController < ApplicationController
+  def index
+    render inertia: 'InertiaExample', props: {
+      name: 'World',
+    }
+  end
+end

data/lib/generators/inertia_rails/install/react/InertiaExample.jsx

@@ -0,0 +1,9 @@
+import React from 'react';
+
+const InertiaExample = ({name}) => (
+  <>
+    <h1>Hello {name}!</h1>
+  </>
+);
+
+export default InertiaExample;

data/lib/generators/inertia_rails/install/react/inertia.jsx

@@ -0,0 +1,17 @@
+import { App } from '@inertiajs/inertia-react';
+import React from 'react';
+import { render } from 'react-dom';
+import { InertiaProgress } from '@inertiajs/progress';
+
+document.addEventListener('DOMContentLoaded', () => {
+  InertiaProgress.init();
+  const el = document.getElementById('app')
+
+  render(
+    <App
+      initialPage={JSON.parse(el.dataset.page)}
+      resolveComponent={name => require(`../Pages/${name}`).default}
+    />,
+    el
+  )
+});

data/lib/generators/inertia_rails/install/svelte/InertiaExample.svelte

@@ -0,0 +1,11 @@
+<script>
+  export let name;
+</script>
+
+<style>
+  h1 { font-family: sans-serif; text-align: center; }
+</style>
+
+<h1>
+  Hello {name}!
+</h1>

data/lib/generators/inertia_rails/install/svelte/inertia.js

@@ -0,0 +1,14 @@
+import { createInertiaApp } from '@inertiajs/inertia-svelte'
+import { InertiaProgress } from '@inertiajs/progress'
+
+document.addEventListener('DOMContentLoaded', () => {
+  InertiaProgress.init()
+
+  createInertiaApp({
+    id: 'app',
+    resolve: name => import(`../Pages/${name}.svelte`),
+    setup({ el, App, props }) {
+      new App({ target: el, props })
+    },
+  })
+})

data/lib/generators/inertia_rails/install/vue/InertiaExample.vue

@@ -0,0 +1,11 @@
+<template>
+  <h1 :style="{ 'text-align': 'center' }">Hello {{name}}!</h1>
+</template>
+
+<script>
+export default {
+  props: {
+    name: { type: String, required: true },
+  },
+}
+</script>

data/lib/generators/inertia_rails/install/vue/inertia.js

@@ -0,0 +1,20 @@
+import Vue from 'vue'
+
+import { app, plugin } from '@inertiajs/inertia-vue'
+import { InertiaProgress } from '@inertiajs/progress'
+
+document.addEventListener('DOMContentLoaded', () => {
+  InertiaProgress.init();
+  const el = document.getElementById('app')
+
+  Vue.use(plugin)
+
+  new Vue({
+    render: h => h(app, {
+      props: {
+        initialPage: JSON.parse(el.dataset.page),
+        resolveComponent: name => require(`../Pages/${name}`).default,
+      },
+    }),
+  }).$mount(el)
+})

data/lib/generators/inertia_rails/install_generator.rb

@@ -0,0 +1,84 @@
+module InertiaRails
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('./install', __dir__)
+    class_option :front_end, type: :string, default: 'react'
+
+    FRONT_END_INSTALLERS = [
+      'react',
+      'vue',
+      'svelte',
+    ]
+
+    def install
+      exit! unless installable?
+
+      install_base!
+
+      send "install_#{options[:front_end]}!"
+
+      say "You're all set! Run rails s and checkout localhost:3000/inertia-example", :green
+    end
+
+    protected
+
+    def installable?
+      unless run("./bin/rails webpacker:verify_install")
+        say "Sorry, you need to have webpacker installed for inertia_rails default setup.", :red
+        return false
+      end
+
+      unless options[:front_end].in? FRONT_END_INSTALLERS
+        say "Sorry, there is no generator for #{options[:front_end]}!\n\n", :red
+        say "If you are a #{options[:front_end]} developer, please help us improve inertia_rails by contributing an installer.\n\n"
+        say "https://github.com/inertiajs/inertia-rails/\n\n"
+
+        return false
+      end
+
+      true
+    end
+
+    def install_base!
+      say "Adding inertia pack tag to application layout", :blue
+      insert_into_file Rails.root.join("app/views/layouts/application.html.erb").to_s, after: "<%= javascript_pack_tag 'application' %>\n" do
+        "\t\t<%= javascript_pack_tag 'inertia' %>\n"
+      end
+
+      say "Installing inertia client packages", :blue
+      run "yarn add @inertiajs/inertia @inertiajs/progress"
+
+      say "Copying example files", :blue
+      template "controller.rb", Rails.root.join("app/controllers/inertia_example_controller.rb").to_s
+
+      say "Adding a route for the example inertia controller...", :blue
+      route "get 'inertia-example', to: 'inertia_example#index'"
+    end
+
+    def install_react!
+      say "Creating a React page component...", :blue
+      run 'yarn add @inertiajs/inertia-react'
+      template "react/InertiaExample.jsx", Rails.root.join("app/javascript/Pages/InertiaExample.js").to_s
+      say "Copying inertia.jsx into webpacker's packs folder...", :blue
+      template "react/inertia.jsx", Rails.root.join("app/javascript/packs/inertia.jsx").to_s
+      say "done!", :green
+    end
+
+    def install_vue!
+      say "Creating a Vue page component...", :blue
+      run 'yarn add @inertiajs/inertia-vue'
+      template "vue/InertiaExample.vue", Rails.root.join("app/javascript/Pages/InertiaExample.vue").to_s
+      say "Copying inertia.js into webpacker's packs folder...", :blue
+      template "vue/inertia.js", Rails.root.join("app/javascript/packs/inertia.js").to_s
+      say "done!", :green
+    end
+
+    def install_svelte!
+      say "Creating a Svelte page component...", :blue
+      run 'yarn add @inertiajs/inertia-svelte'
+      template "svelte/InertiaExample.svelte", Rails.root.join("app/javascript/Pages/InertiaExample.svelte").to_s
+      say "Copying inertia.js into webpacker's packs folder...", :blue
+      template "svelte/inertia.js", Rails.root.join("app/javascript/packs/inertia.js").to_s
+      say "done!", :green
+    end
+  end
+end

data/lib/inertia_rails/controller.rb

@@ -0,0 +1,110 @@
+require_relative "inertia_rails"
+
+module InertiaRails
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :inertia_headers
+
+      before_action do
+        error_sharing = proc do
+          # :inertia_errors are deleted from the session by the middleware
+          if @_request && session[:inertia_errors].present?
+            { errors: session[:inertia_errors] }
+          else
+            {}
+          end
+        end
+
+        @_inertia_shared_plain_data ||= {}
+        @_inertia_shared_blocks ||= [error_sharing]
+        @_inertia_html_headers ||= []
+      end
+
+      after_action do
+        cookies['XSRF-TOKEN'] = form_authenticity_token unless !protect_against_forgery?
+      end
+    end
+
+    module ClassMethods
+      def inertia_share(hash = nil, &block)
+        before_action do
+          @_inertia_shared_plain_data = @_inertia_shared_plain_data.merge(hash) if hash
+          @_inertia_shared_blocks = @_inertia_shared_blocks + [block] if block_given?
+        end
+      end
+
+      def use_inertia_instance_props
+        before_action do
+          @_inertia_instance_props = true
+          @_inertia_skip_props = view_assigns.keys + ['_inertia_skip_props']
+        end
+      end
+    end
+
+    def inertia_headers
+      @_inertia_html_headers.join.html_safe
+    end
+
+    def inertia_headers=(value)
+      @_inertia_html_headers = value
+    end
+
+    def default_render
+      if InertiaRails.default_render?
+        render(inertia: true)
+      else
+        super
+      end
+    end
+
+    def shared_data
+      (@_inertia_shared_plain_data || {}).merge(evaluated_blocks)
+    end
+
+    def redirect_to(options = {}, response_options = {})
+      capture_inertia_errors(response_options)
+      super(options, response_options)
+    end
+
+    def redirect_back(fallback_location:, allow_other_host: true, **options)
+      capture_inertia_errors(options)
+      super(
+        fallback_location: fallback_location,
+        allow_other_host: allow_other_host,
+        **options,
+      )
+    end
+
+    def inertia_view_assigns
+      return {} unless @_inertia_instance_props
+      view_assigns.except(*@_inertia_skip_props)
+    end
+
+    private
+
+    def inertia_layout
+      layout = ::InertiaRails.layout
+
+      # When the global configuration is not set, let Rails decide which layout
+      # should be used based on the controller configuration.
+      layout.nil? ? true : layout
+    end
+
+    def inertia_location(url)
+      headers['X-Inertia-Location'] = url
+      head :conflict
+    end
+
+    def capture_inertia_errors(options)
+      if (inertia_errors = options.dig(:inertia, :errors))
+        session[:inertia_errors] = inertia_errors
+      end
+    end
+
+    def evaluated_blocks
+      (@_inertia_shared_blocks || []).map { |block| instance_exec(&block) }.reduce(&:merge) || {}
+    end
+  end
+end

data/lib/inertia_rails/engine.rb

@@ -0,0 +1,16 @@
+require_relative "middleware"
+require_relative "controller"
+
+module InertiaRails
+  class Engine < ::Rails::Engine
+    initializer "inertia_rails.configure_rails_initialization" do |app|
+      app.middleware.use ::InertiaRails::Middleware
+    end
+
+    initializer "inertia_rails.action_controller" do
+      ActiveSupport.on_load(:action_controller_base) do
+        include ::InertiaRails::Controller
+      end
+    end
+  end
+end

data/lib/inertia_rails/inertia_rails.rb

@@ -0,0 +1,52 @@
+# Needed for `thread_mattr_accessor`
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+require 'inertia_rails/lazy'
+
+module InertiaRails
+  def self.configure
+    yield(Configuration)
+  end
+
+  def self.version
+    Configuration.evaluated_version
+  end
+
+  def self.layout
+    Configuration.layout
+  end
+
+  def self.ssr_enabled?
+    Configuration.ssr_enabled
+  end
+
+  def self.ssr_url
+    Configuration.ssr_url
+  end
+
+  def self.default_render?
+    Configuration.default_render
+  end
+
+  def self.deep_merge_shared_data?
+    Configuration.deep_merge_shared_data
+  end
+
+  def self.lazy(value = nil, &block)
+    InertiaRails::Lazy.new(value, &block)
+  end
+
+  private
+
+  module Configuration
+    mattr_accessor(:layout) { nil }
+    mattr_accessor(:version) { nil }
+    mattr_accessor(:ssr_enabled) { false }
+    mattr_accessor(:ssr_url) { 'http://localhost:13714' }
+    mattr_accessor(:default_render) { false }
+    mattr_accessor(:deep_merge_shared_data) { false }
+
+    def self.evaluated_version
+      self.version.respond_to?(:call) ? self.version.call : self.version
+    end
+  end
+end

data/lib/inertia_rails/lazy.rb

@@ -0,0 +1,28 @@
+module InertiaRails
+  class Lazy
+    def initialize(value = nil, &block)
+      @value = value
+      @block = block
+    end
+
+    def call
+      to_proc.call
+    end
+
+    def to_proc
+      # This is called by controller.instance_exec, which changes self to the
+      # controller instance. That makes the instance variables unavailable to the
+      # proc via closure. Copying the instance variables to local variables before
+      # the proc is returned keeps them in scope for the returned proc.
+      value = @value
+      block = @block
+      if value.respond_to?(:call)
+        value
+      elsif value
+        Proc.new { value }
+      else
+        block
+      end
+    end
+  end
+end

data/lib/inertia_rails/middleware.rb

@@ -0,0 +1,97 @@
+module InertiaRails
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      InertiaRailsRequest.new(@app, env)
+                         .response
+    end
+
+    class InertiaRailsRequest
+      def initialize(app, env)
+        @app = app
+        @env = env
+      end
+
+      def response
+        copy_xsrf_to_csrf!
+        status, headers, body = @app.call(@env)
+        request = ActionDispatch::Request.new(@env)
+
+        # Inertia errors are added to the session via redirect_to
+        request.session.delete(:inertia_errors) unless keep_inertia_errors?(status)
+
+        status = 303 if inertia_non_post_redirect?(status)
+
+        stale_inertia_get? ? force_refresh(request) : [status, headers, body]
+      end
+
+      private
+
+      def keep_inertia_errors?(status)
+        redirect_status?(status) || stale_inertia_request?
+      end
+
+      def stale_inertia_request?
+        inertia_request? && version_stale?
+      end
+
+      def redirect_status?(status)
+        [301, 302].include? status
+      end
+
+      def non_get_redirectable_method?
+        ['PUT', 'PATCH', 'DELETE'].include? request_method
+      end
+
+      def inertia_non_post_redirect?(status)
+        inertia_request? && redirect_status?(status) && non_get_redirectable_method?
+      end
+
+      def stale_inertia_get?
+        get? && stale_inertia_request?
+      end
+
+      def get?
+        request_method == 'GET'
+      end
+
+      def request_method
+        @env['REQUEST_METHOD']
+      end
+
+      def inertia_version
+        @env['HTTP_X_INERTIA_VERSION']
+      end
+
+      def inertia_request?
+        @env['HTTP_X_INERTIA'].present?
+      end
+
+      def version_stale?
+        sent_version != saved_version
+      end
+
+      def sent_version
+        return nil if inertia_version.nil?
+
+        InertiaRails.version.is_a?(Numeric) ? inertia_version.to_f : inertia_version
+      end
+
+      def saved_version
+        InertiaRails.version.is_a?(Numeric) ? InertiaRails.version.to_f : InertiaRails.version
+      end
+
+      def force_refresh(request)
+        request.flash.keep
+        Rack::Response.new('', 409, {'X-Inertia-Location' => request.original_url}).finish
+      end
+
+      def copy_xsrf_to_csrf!
+        @env['HTTP_X_CSRF_TOKEN'] = @env['HTTP_X_XSRF_TOKEN'] if @env['HTTP_X_XSRF_TOKEN'] && inertia_request?
+      end
+    end
+  end
+end

data/lib/inertia_rails/renderer.rb

@@ -0,0 +1,92 @@
+require_relative "inertia_rails"
+
+module InertiaRails
+  class Renderer
+    attr_reader :component, :view_data
+
+    def initialize(component, controller, request, response, render_method, props: nil, view_data: nil, deep_merge: nil)
+      @component = component.is_a?(TrueClass) ? "#{controller.controller_path}/#{controller.action_name}" : component
+      @controller = controller
+      @request = request
+      @response = response
+      @render_method = render_method
+      @props = props ? props : controller.inertia_view_assigns
+      @view_data = view_data || {}
+      @deep_merge = !deep_merge.nil? ? deep_merge : InertiaRails.deep_merge_shared_data?
+    end
+
+    def render
+      if @request.headers['X-Inertia']
+        @response.set_header('Vary', 'X-Inertia')
+        @response.set_header('X-Inertia', 'true')
+        @render_method.call json: page, status: @response.status, content_type: Mime[:json]
+      else
+        return render_ssr if ::InertiaRails.ssr_enabled? rescue nil
+        @render_method.call template: 'inertia', layout: layout, locals: (view_data).merge({page: page})
+      end
+    end
+
+    private
+
+    def render_ssr
+      uri = URI("#{::InertiaRails.ssr_url}/render")
+      res = JSON.parse(Net::HTTP.post(uri, page.to_json, 'Content-Type' => 'application/json').body)
+
+      @controller.inertia_headers = res['head']
+      @render_method.call template: 'inertia_ssr', layout: layout, locals: (view_data).merge({page: page, html: res['body'].html_safe,})
+    end
+
+    def layout
+      @controller.send(:inertia_layout)
+    end
+
+    def computed_props
+      # Cast props to symbol keyed hash before merging so that we have a consistent data structure and
+      # avoid duplicate keys after merging.
+      #
+      # Functionally, this permits using either string or symbol keys in the controller. Since the results
+      # is cast to json, we should treat string/symbol keys as identical.
+      _props = @controller.shared_data.merge.deep_symbolize_keys.send(prop_merge_method, @props.deep_symbolize_keys).select do |key, prop|
+        if rendering_partial_component?
+          key.in? partial_keys
+        else
+          !prop.is_a?(InertiaRails::Lazy)
+        end
+      end
+
+      deep_transform_values(
+        _props,
+        lambda do |prop|
+          prop.respond_to?(:call) ? @controller.instance_exec(&prop) : prop
+        end
+      )
+    end
+
+    def page
+      {
+        component: component,
+        props: computed_props,
+        url: @request.original_fullpath,
+        version: ::InertiaRails.version,
+      }
+    end
+
+    def deep_transform_values(hash, proc)
+      return proc.call(hash) unless hash.is_a? Hash
+
+      hash.transform_values {|value| deep_transform_values(value, proc)}
+    end
+
+    def partial_keys
+      (@request.headers['X-Inertia-Partial-Data'] || '').split(',').compact.map(&:to_sym)
+    end
+
+    def rendering_partial_component?
+      @request.inertia_partial? && @request.headers['X-Inertia-Partial-Component'] == component
+    end
+
+    def prop_merge_method
+      @deep_merge ? :deep_merge : :merge
+    end
+  end
+end