frails 0.4.0 → 0.8.0

data/lib/frails/helper.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
 module Frails::Helper
-  def render(options = {}, locals = {}, &block)
+  # rubocop:disable Metrics/AbcSize
+  def render(options = {}, *locals, &block)
+    sload_assets = respond_to?(:side_load_assets?) ? side_load_assets? : false
+
     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)
+      in_rendering_context(options) do
+        return view_renderer.render_component(self, options, &block) if options.key?(:component)
 
+        options[:side_load_assets] = sload_assets
+        if block_given?
           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)
+      if options.is_a?(Class) && options < Frails::Component::Base
+        return view_renderer.render_component(self, { component: options, locals: locals }, &block)
+      end
+
+      view_renderer.render_partial(self, side_load_assets: sload_assets, partial: options,
+                                         locals: locals.extract_options!, &block)
     end
   end
+  # rubocop:enable Metrics/AbcSize
 
   def javascript_pack_tag(*names, **options)
     return if Rails.env.test?

data/lib/frails/log_subscriber.rb

@@ -27,7 +27,7 @@ module Frails
       end
 
       def rails_root
-        @root ||= "#{Rails.root}/"
+        @rails_root ||= "#{Rails.root}/"
       end
   end
 end

data/lib/frails/manifest.rb

@@ -62,15 +62,11 @@ class Frails::Manifest
   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
+      return Rails.public_path.join(path.gsub(%r{^\/}, '')).read unless Frails.dev_server.running?
 
       begin
-        open("http://#{Frails.dev_server.host_with_port}#{path}").read
-      rescue OpenURI::HTTPError => e
+        URI.open("http://#{Frails.dev_server.host_with_port}#{path}").read
+      rescue OpenURI::HTTPError
         handle_missing_entry path
       end
     end

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

@@ -5,8 +5,6 @@ module Frails
     module ActionView
       module AbstractRenderer
         def side_load_assets(view, tpl)
-          return unless view.controller._side_load_assets?
-
           path = tpl.short_identifier.delete_prefix('app/').delete_suffix('.html.erb')
 
           instrument :side_loaded_assets, identifier: tpl.identifier, asset_types: [] do |payload|

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

@@ -4,9 +4,22 @@ module Frails
   module Monkey
     module ActionView
       module PartialRenderer
+        def render_collection(view, template)
+          # Side load partial assets - if any.
+          @asset_path = @side_load_assets && side_load_assets(view, template)
+
+          super
+        end
+
         def render_partial(view, template)
           # Side load partial assets - if any.
-          @asset_path = side_load_assets(view, template)
+          @asset_path = @side_load_assets && side_load_assets(view, template)
+
+          super
+        end
+
+        def setup(context, options, as, block)
+          @side_load_assets = options.key?(:side_load_assets) ? options[:side_load_assets] : false
 
           super
         end
@@ -20,21 +33,21 @@ module Frails
           doc = Nokogiri::HTML::DocumentFragment.parse(content)
 
           return content if (modules = doc.css('[css_module]')).empty?
+          return content unless (path = stylesheet_path_for_ident)
 
           modules.each do |ele|
-            classes = class_name_for_style(ele.delete('css_module'))
+            classes = class_name_for_style(ele.delete('css_module'), path)
             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 }
+        def class_name_for_style(class_names, path)
+          class_names.to_s.split.map { |class_name| build_ident class_name, path }
         end
 
-        def build_ident(local_name)
-          path = Rails.root.join('app', "#{@asset_path}.css").relative_path_from(Rails.root)
+        def build_ident(local_name, path)
           hash_digest = Digest::MD5.hexdigest("#{path}+#{local_name}")[0, 6]
 
           return "#{local_name}-#{hash_digest}" unless Frails.dev_server.running?
@@ -44,6 +57,12 @@ module Frails
           ident.prepend("#{path.dirname.to_s.tr('/', '-')}-")
           ident
         end
+
+        def stylesheet_path_for_ident
+          return if (globs = Rails.root.glob("app/#{@asset_path}.{css,scss,sass,less}")).empty?
+
+          globs.first.relative_path_from(Rails.root)
+        end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module Frails
   module Monkey
     module ActionView
       module Renderer
-        def render_to_object(context, options) # :nodoc:
+        def render_to_object(context, options)
           if options.key?(:partial)
             render_partial_to_object(context, options)
           elsif options.key?(:component)
@@ -15,19 +15,18 @@ module Frails
         end
 
         # Direct access to partial rendering.
-        def render_component(context, options, &block) #:nodoc:
+        def render_component(context, options, &block)
           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)
+          result = if Frails.components_path.join(component, 'index.entry.jsx').exist?
+                     Frails::Component::ReactRenderer.new.render(context, options, &block)
                    else
-                     options[:partial] = "#{component}/index"
-                     Frails::Component::ComponentRenderer.new(@lookup_context)
-                                                         .render(context, options, &block)
+                     Frails::Component::Renderer.new(@lookup_context)
+                                                .render(context, options, &block)
                    end
 
           ::ActionView::AbstractRenderer::RenderedTemplate.new result, nil, nil

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

@@ -4,8 +4,15 @@ module Frails
   module Monkey
     module ActionView
       module TemplateRenderer
+        def render(context, options)
+          # See Frails::SideLoadAssets
+          @side_load_assets = options.key?(:side_load_assets) ? options[:side_load_assets] : false
+
+          super
+        end
+
         def render_template(view, template, layout_name, locals)
-          return super if template.type != :html
+          return super if !@side_load_assets || template.type != :html
 
           # Side load layout assets - if any.
           if layout_name

data/lib/frails/railtie.rb

@@ -9,7 +9,7 @@ class Frails::Engine < ::Rails::Engine
     app.middleware.insert_before 0, Frails::DevServerProxy, ssl_verify_none: true
   end
 
-  initializer 'frails.rendering' do
+  initializer 'frails' do
     ActiveSupport.on_load :action_controller do
       require 'frails/side_load_assets'
 
@@ -28,19 +28,11 @@ class Frails::Engine < ::Rails::Engine
       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
-    end
+      ActionView::AbstractRenderer.prepend Frails::Monkey::ActionView::AbstractRenderer
+      ActionView::TemplateRenderer.prepend Frails::Monkey::ActionView::TemplateRenderer
+      ActionView::PartialRenderer.prepend Frails::Monkey::ActionView::PartialRenderer
+      ActionView::Renderer.prepend Frails::Monkey::ActionView::Renderer
 
-    ActiveSupport.on_load :action_view do
       include Frails::Helper
     end
   end

data/lib/frails/side_load_assets.rb

@@ -4,12 +4,15 @@ module Frails::SideLoadAssets
   extend ActiveSupport::Concern
 
   included do
-    class_attribute :_side_load_assets, default: false
+    class_attribute :side_load_assets, default: false
+    helper_method :side_load_assets?
   end
 
-  class_methods do
-    def side_load_assets
-      self._side_load_assets = true
-    end
+  # Add _side_load_assets flag to the options hash, which will be available in TemplateRenderer,
+  # allowing us control if views/layouts are side loaded.
+  def _normalize_options(options)
+    super
+    options[:side_load_assets] = side_load_assets
+    options
   end
 end

data/lib/frails/utils.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Frails
+  module Utils
+    def self.camelize(term, first_letter = :upper, convert_slashes: true)
+      # If we are not converting slashes, and `first_letter` is `:lower`, this ensures that the
+      # first letter after a slash is not capitalized.
+      string = if !convert_slashes && first_letter == :lower
+                 term.split('/').map { |str| str.camelize :lower }.join('/')
+               else
+                 term.camelize first_letter
+               end
+
+      # Reverses the effect of ActiveSupport::Inflector.camelize converting slashes into `::`. If
+      # the keyword argument `convert_slashes:` is false (default: true), we can avoid
+      # converting slashes to `::`.
+      string.gsub!('::', '/') unless convert_slashes
+
+      string
+    end
+  end
+end

data/lib/frails/version.rb

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

data/lib/tasks/frails.rake

@@ -16,12 +16,7 @@ namespace :frails do
     puts 'Compiling Webpack...'
 
     ENV['RAILS_ENV'] ||= 'development'
-    env = {
-      'RAILS_ASSET_HOST' => ActionController::Base.helpers.compute_asset_host,
-      'RAILS_RELATIVE_URL_ROOT' => ActionController::Base.relative_url_root
-    }
-
-    stdout, sterr, status = Open3.capture3(env, "yarn webpack --env #{ENV['RAILS_ENV']}")
+    stdout, sterr, status = Open3.capture3({}, "yarn webpack --env #{ENV['RAILS_ENV']}")
 
     if sterr == '' && status.success?
       puts 'Frails successfully compiled 🎉'

data/package.json

@@ -3,14 +3,24 @@
   "version": "0.3.0",
   "description": "A Modern [F]ront End on [Rails] and Webpack",
   "main": "index.js",
-  "files": [
-    "package"
-  ],
   "repository": "git@github.com:joelmoss/frails.git",
   "author": "Joel Moss <joel@developwithstyle.com>",
   "license": "MIT",
+  "scripts": {
+    "test": "jest"
+  },
+  "jest": {
+    "clearMocks": true,
+    "testEnvironment": "node"
+  },
   "dependencies": {
     "glob": "^7.1.4",
     "lodash.has": "^4.5.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.10.2",
+    "@babel/preset-env": "^7.10.2",
+    "babel-jest": "^26.0.1",
+    "jest": "^26.2.2"
   }
 }

data/package/__snapshots__/config.test.js.snap

@@ -0,0 +1,10 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`config config 1`] = `
+Object {
+  "absolutePublicPath": "/Users/joelmoss/dev/frails/test/dummy/public/frails",
+  "appPath": "/Users/joelmoss/dev/frails/test/dummy/app",
+  "publicOutputPath": "frails",
+  "rootPath": "/Users/joelmoss/dev/frails/test/dummy",
+}
+`;

data/package/components.js

@@ -1,47 +1,57 @@
-const glob = require('glob')
-const path = require('path')
-const fs = require('fs')
+const glob = require("glob");
+const path = require("path");
+const fs = require("fs");
 
-const appPath = path.join(process.cwd(), 'app')
+const appPath = path.join(process.cwd(), "app");
 
 // Build entry points for HTML based components (components with an index.html.erb and index.css).
 //
 // NOTE: Adding new files will require a rebuild!
 const buildComponents = () => {
-  const result = {}
+  const result = {};
 
   // Find HTML partials and add its corresponding index.css as an entry point if it exists.
-  glob.sync(path.join(appPath, 'components/**/_index.html.erb')).forEach(paf => {
-    paf = paf.replace('_index.html.erb', 'index.css')
+  glob
+    .sync(path.join(appPath, "components/**/_index.html.erb"))
+    .forEach(paf => {
+      paf = paf.replace("_index.html.erb", "index.css");
 
-    if (!fs.existsSync(paf)) return
+      if (!fs.existsSync(paf)) return;
 
-    const namespace = path.relative(path.join(appPath), path.dirname(paf))
-    const name = path.join(namespace, path.basename(paf, path.extname(paf)))
+      const namespace = path.relative(path.join(appPath), path.dirname(paf));
+      const name = path.join(namespace, path.basename(paf, path.extname(paf)));
 
-    result[name] = paf
-  })
+      result[name] = paf;
+    });
 
   // Find components with no JSX and HTML index files, and add its corresponding index.css as an
   // entry point if it exists. These will be components that render from within the Ruby class
   // itself.
-  glob.sync(path.join(appPath, 'components/**/*_component.rb')).forEach(paf => {
-    css_paf = paf.replace('_component.rb', '/index.css')
-    html_paf = paf.replace('_component.rb', '/_index.html.erb')
-    jsx_paf = paf.replace('_component.rb', '/index.entry.jsx')
+  glob.sync(path.join(appPath, "components/**/*_component.rb")).forEach(paf => {
+    css_paf = paf.replace("_component.rb", "/index.css");
+    html_paf = paf.replace("_component.rb", "/_index.html.erb");
+    jsx_paf = paf.replace("_component.rb", "/index.entry.jsx");
 
     // Ignore if we have a JSX or HTML file, or no CSS file.
-    if (fs.existsSync(jsx_paf) || fs.existsSync(html_paf) || !fs.existsSync(css_paf)) return
+    if (
+      fs.existsSync(jsx_paf) ||
+      fs.existsSync(html_paf) ||
+      !fs.existsSync(css_paf)
+    )
+      return;
 
-    const namespace = path.relative(path.join(appPath), path.dirname(css_paf))
-    const name = path.join(namespace, path.basename(css_paf, path.extname(css_paf)))
+    const namespace = path.relative(path.join(appPath), path.dirname(css_paf));
+    const name = path.join(
+      namespace,
+      path.basename(css_paf, path.extname(css_paf))
+    );
 
-    result[name] = css_paf
-  })
+    result[name] = css_paf;
+  });
 
-  return result
-}
+  return result;
+};
 
 module.exports = {
   entry: { ...buildComponents() }
-}
+};

data/package/config.js

@@ -0,0 +1,38 @@
+const spawnSync = require("child_process").spawnSync;
+const path = require("path");
+
+const isTest = process.env.NODE_ENV === "test";
+const configFromRails = railsRun("print Frails.config_as_json");
+const rootPath = isTest
+  ? path.join(process.cwd(), "test/dummy")
+  : process.cwd();
+
+module.exports = {
+  ...configFromRails,
+
+  rootPath,
+  appPath: path.join(rootPath, "app"),
+  absolutePublicPath: path.join(
+    rootPath,
+    "public",
+    configFromRails.publicOutputPath
+  ),
+};
+
+function railsRun(argument) {
+  if (isTest) {
+    return {
+      publicOutputPath: "frails",
+    };
+  }
+
+  const result = spawnSync("./bin/rails", ["runner", argument]);
+
+  if (result.status === 0) {
+    return JSON.parse(result.stdout.toString());
+  } else if (result.signal !== null) {
+    throw `Rails runner was terminated with signal: ${result.signal}`;
+  } else {
+    throw `Rails runner failed with '${result.error.toString()}'.`;
+  }
+}