frails 0.1.0 → 0.3.0

data/lib/frails/helper.rb

@@ -1,21 +1,88 @@
 # frozen_string_literal: true
 
 module Frails::Helper
+  def render(options = {}, locals = {}, &block)
+    case options
+    when Hash
+      if Rails::VERSION::MAJOR >= 6
+        in_rendering_context(options) do |_renderer|
+          if block_given?
+            # MONKEY PATCH! simply renders the component with the given block.
+            return view_renderer.render_component(self, options, &block) if options.key?(:component)
+
+            view_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
+          else
+            view_renderer.render(self, options)
+          end
+        end
+      else
+        if block_given?
+          # MONKEY PATCH! simply renders the component with the given block.
+          return view_renderer.render_component(self, options, &block) if options.key?(:component)
+
+          view_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
+        else
+          view_renderer.render(self, options)
+        end
+      end
+    else
+      view_renderer.render_partial(self, partial: options, locals: locals, &block)
+    end
+  end
+
   def javascript_pack_tag(*names, **options)
-    javascript_include_tag(*sources_from_manifest_entries(names, :javascript), **options)
+    return if Rails.env.test?
+
+    @included_javascripts ||= []
+
+    soft_lookup = options.delete(:soft_lookup) { false }
+    sources = sources_from_manifest_entries(names, :javascript, manifest: options.delete(:manifest),
+                                                                soft_lookup: soft_lookup)
+
+    # Make sure that we don't include an asset that has already been included.
+    sources -= @included_javascripts
+    sources.compact!
+
+    # Concatenate the sources to be included to those already included.
+    @included_javascripts.concat sources
+
+    sources.empty? ? nil : javascript_include_tag(*sources, **options)
   end
 
   def stylesheet_pack_tag(*names, **options)
-    stylesheet_link_tag(*sources_from_manifest_entries(names, :stylesheet), **options)
+    return if Rails.env.test?
+
+    soft_lookup = options.delete(:soft_lookup) { false }
+    sources = sources_from_manifest_entries(names, :stylesheet, manifest: options.delete(:manifest),
+                                                                soft_lookup: soft_lookup)
+
+    sources.compact!
+    stylesheet_link_tag(*sources, **options)
+  end
+
+  def image_pack_tag(name, **options)
+    return if Rails.env.test?
+
+    image_tag(pack_path("images/#{name}", manifest: options.delete(:manifest)), **options)
+  end
+
+  def pack_path(name, type: nil, manifest: nil)
+    manifest_manager[manifest].lookup! name, type: type
   end
 
   private
 
-    def sources_from_manifest_entries(names, type)
-      names.map { |name| frails_instance.manifest.lookup!(name, type: type) }.flatten
+    def sources_from_manifest_entries(names, type, manifest: nil, soft_lookup: false)
+      names.map do |name|
+        if soft_lookup
+          manifest_manager[manifest].lookup name, type: type
+        else
+          manifest_manager[manifest].lookup! name, type: type
+        end
+      end.flatten
     end
 
-    def frails_instance
-      Frails.instance
+    def manifest_manager
+      Frails.manifest
     end
 end

data/lib/frails/log_subscriber.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module Frails
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    VIEWS_PATTERN = %r{^app/views/}.freeze
+
+    def render_side_loaded_assets(event)
+      return if (asset_types = event.payload[:asset_types]).empty?
+
+      identifier_from_root = from_rails_root(event.payload[:identifier])
+
+      info do
+        message = +"  Side loaded #{asset_types.join(',')} for #{identifier_from_root}"
+        message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
+      end
+    end
+
+    private
+
+      EMPTY = ''
+      def from_rails_root(string)
+        string = string.sub(rails_root, EMPTY)
+        string.sub!(VIEWS_PATTERN, EMPTY)
+        string
+      end
+
+      def rails_root
+        @root ||= "#{Rails.root}/"
+      end
+  end
+end
+
+Frails::LogSubscriber.attach_to :action_view

data/lib/frails/manifest.rb

@@ -1,8 +1,21 @@
 # frozen_string_literal: true
 
+require 'open-uri'
+
 class Frails::Manifest
+  class MissingManifestError < StandardError; end
   class MissingEntryError < StandardError; end
 
+  attr_reader :manifest_path
+
+  def initialize(path)
+    @manifest_path = Rails.public_path.join(Frails.public_output_path, path)
+
+    return if @manifest_path.exist?
+
+    raise Frails::Manifest::MissingManifestError, "Frails can't find manifest #{manifest_path}"
+  end
+
   def refresh
     @data = load
   end
@@ -11,7 +24,7 @@ class Frails::Manifest
   # returns nil.
   #
   # Example:
-  #   Frails.manifest.lookup('calendar.js') # => "/packs/calendar-1016838bab065ae1e122.js"
+  #   Frails.manifest.lookup('calendar.js') # => "/assets/calendar-1016838bab065ae1e122.js"
   def lookup(name, type: nil)
     # When using SplitChunks or RuntimeChunks the manifest hash will contain an extra object called
     # "entrypoints". When the entrypoints key is not present in the manifest, or the name is not
@@ -32,12 +45,36 @@ class Frails::Manifest
     lookup(name, type: type) || handle_missing_entry(name)
   end
 
-  def manifest_path
-    @manifest_path ||= Rails.root.join('public', 'packs', 'manifest.json')
+  def read!(name, type)
+    sources = *lookup!(name, type: type)
+    sources.map do |path|
+      yield path, read_source(path)
+    end
+  end
+
+  def read(name, type)
+    sources = *lookup(name, type: type)
+    sources.map do |path|
+      yield path, read_source(path)
+    end
   end
 
   private
 
+    def read_source(path)
+      unless Frails.dev_server.running?
+        host = ActionController::Base.helpers.compute_asset_host
+        new_path = host && path.start_with?(host) ? path.delete_prefix(host) : path
+        return Rails.public_path.join(new_path.gsub(%r{^\/}, '')).read
+      end
+
+      begin
+        open("http://#{Frails.dev_server.host_with_port}#{path}").read
+      rescue OpenURI::HTTPError => e
+        handle_missing_entry path
+      end
+    end
+
     def load
       manifest_path.exist? ? JSON.parse(manifest_path.read) : {}
     end

data/lib/frails/manifest_manager.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'frails/manifest'
+
+class Frails::ManifestManager
+  delegate :lookup, :lookup!, :read, :read!, to: :default_instance
+
+  def initialize
+    @instances = {}
+  end
+
+  def [](path = nil)
+    path ||= Frails.manifest_path
+    @instances[path] ||= Frails::Manifest.new(path)
+  end
+
+  private
+
+    def default_instance
+      @instances[Frails.manifest_path] ||= Frails::Manifest.new(Frails.manifest_path)
+    end
+end

data/lib/frails/monkey/action_view/abstract_renderer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Frails
+  module Monkey
+    module ActionView
+      module AbstractRenderer
+        def side_load_assets(view, tpl)
+          path = tpl.short_identifier.delete_prefix('app/').delete_suffix('.html.erb')
+
+          instrument :side_loaded_assets, identifier: tpl.identifier, asset_types: [] do |payload|
+            side_load_javascript path, view, payload
+            side_load_stylesheet path, view, payload
+          end
+
+          path
+        end
+
+        def side_load_javascript(path, view, payload)
+          # Render the JS - if any.
+          view.content_for :side_loaded_js do
+            view.javascript_pack_tag(path, soft_lookup: true).tap do |tag|
+              !tag.nil? && (payload[:asset_types] << :js)
+            end
+          end
+        end
+
+        def side_load_stylesheet(path, view, payload)
+          loaded = side_loaded_stylesheets(view)
+
+          # Don't inline the styles if already inlined.
+          return if loaded.include?(path)
+
+          # Render the CSS inline - if any.
+          Frails.manifest.read(path, :stylesheet) do |href, src|
+            view.content_for :side_loaded_css do
+              view.content_tag :style, src, { data: { href: href } }, false
+            end
+
+            loaded << path
+            payload[:asset_types] << :css
+          end
+        end
+
+        def side_loaded_stylesheets(view)
+          if view.instance_variable_defined?(:@side_loaded_stylesheets)
+            view.instance_variable_get(:@side_loaded_stylesheets)
+          else
+            view.instance_variable_set :@side_loaded_stylesheets, []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/frails/monkey/action_view/partial_renderer.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Frails
+  module Monkey
+    module ActionView
+      module PartialRenderer
+        def render_partial(view, template)
+          # Side load partial assets - if any.
+          @asset_path = side_load_assets(view, template)
+
+          super
+        end
+
+        def build_rendered_template(content, template, layout = nil)
+          content = transform_css_modules(content).html_safe
+          ::ActionView::AbstractRenderer::RenderedTemplate.new content, layout, template
+        end
+
+        def transform_css_modules(content)
+          doc = Nokogiri::HTML::DocumentFragment.parse(content)
+
+          return content if (modules = doc.css('[css_module]')).empty?
+
+          modules.each do |ele|
+            classes = class_name_for_style(ele.delete('css_module'))
+            ele['class'] = (ele['class'].nil? ? classes : classes << ele['class']).join(' ')
+          end
+
+          doc.to_html
+        end
+
+        def class_name_for_style(class_names)
+          class_names.to_s.split.map { |class_name| build_ident class_name }
+        end
+
+        def build_ident(local_name)
+          path = Rails.root.join('app', "#{@asset_path}.css").relative_path_from(Rails.root)
+          hash_digest = Digest::MD5.hexdigest("#{path}+#{local_name}")[0, 6]
+
+          return "#{local_name}-#{hash_digest}" unless Frails.dev_server.running?
+
+          name = path.basename.sub(path.extname, '').sub('.', '-')
+          ident = +"#{name}__#{local_name}___#{hash_digest}"
+          ident.prepend("#{path.dirname.to_s.tr('/', '-')}-")
+          ident
+        end
+      end
+    end
+  end
+end

data/lib/frails/monkey/action_view/renderer.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Frails
+  module Monkey
+    module ActionView
+      module Renderer
+        def render_to_object(context, options) # :nodoc:
+          if options.key?(:partial)
+            render_partial_to_object(context, options)
+          elsif options.key?(:component)
+            render_component_to_object(context, options)
+          else
+            render_template_to_object(context, options)
+          end
+        end
+
+        # Direct access to partial rendering.
+        def render_component(context, options, &block) #:nodoc:
+          render_component_to_object(context, options, &block).body
+        end
+
+        def render_component_to_object(context, options, &block)
+          component = options[:component].to_s
+
+          result = if Rails.root.join('app', 'components', component, 'index.entry.jsx').exist?
+                     Frails::Component::ReactComponentRenderer.new.render(context, options, &block)
+                   else
+                     options[:partial] = "#{component}/index"
+                     Frails::Component::ComponentRenderer.new(@lookup_context)
+                                                         .render(context, options, &block)
+                   end
+
+          ::ActionView::AbstractRenderer::RenderedTemplate.new result, nil, nil
+        end
+      end
+    end
+  end
+end

data/lib/frails/monkey/action_view/template_renderer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Frails
+  module Monkey
+    module ActionView
+      module TemplateRenderer
+        def render_template(view, template, layout_name, locals)
+          return super if template.type != :html
+
+          # Side load layout assets - if any.
+          if layout_name
+            layout = find_layout(layout_name, locals.keys, [formats.first])
+            layout && side_load_assets(view, layout)
+          end
+
+          # Side load view assets - if any.
+          side_load_assets view, template
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/frails/railtie.rb

@@ -1,24 +1,32 @@
 # frozen_string_literal: true
 
 require 'rails/railtie'
-
 require 'frails/helper'
 require 'frails/dev_server_proxy'
 
 class Frails::Engine < ::Rails::Engine
-  # Allows Webpacker config values to be set via Rails env config files
-  config.frails = ActiveSupport::OrderedOptions.new
-
-  initializer 'frails.default_config' do |app|
-    assign_config app, :public_output_path, '/assets'
-    assign_config app, :dev_server_port, 8080
-    assign_config app, :dev_server_host, 'localhost'
-  end
-
   initializer 'frails.proxy' do |app|
     app.middleware.insert_before 0, Frails::DevServerProxy, ssl_verify_none: true
   end
 
+  initializer 'frails.rendering' do |_conf|
+    ActiveSupport.on_load :action_controller do
+      ActionController::Base.prepend_view_path Rails.root.join('app', 'components')
+    end
+
+    ActiveSupport.on_load :action_view do
+      require 'frails/monkey/action_view/abstract_renderer'
+      require 'frails/monkey/action_view/template_renderer'
+      require 'frails/monkey/action_view/partial_renderer'
+      require 'frails/monkey/action_view/renderer'
+
+      ActionView::AbstractRenderer.send :prepend, Frails::Monkey::ActionView::AbstractRenderer
+      ActionView::TemplateRenderer.send :prepend, Frails::Monkey::ActionView::TemplateRenderer
+      ActionView::PartialRenderer.send :prepend, Frails::Monkey::ActionView::PartialRenderer
+      ActionView::Renderer.send :prepend, Frails::Monkey::ActionView::Renderer
+    end
+  end
+
   initializer 'frails.helper' do
     ActiveSupport.on_load :action_controller do
       ActionController::Base.helper Frails::Helper
@@ -29,7 +37,3 @@ class Frails::Engine < ::Rails::Engine
     end
   end
 end
-
-def assign_config(app, name, default_value)
-  app.config.frails[name] = app.config.frails.fetch(name, default_value)
-end

data/lib/frails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Frails
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end