frails 0.1.0 → 0.3.0

data/bin/test

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("../test", __dir__)
+
+require "bundler/setup"
+require "rails/plugin/test"

data/frails.gemspec

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-lib = File.expand_path('lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
 require 'frails/version'
 
 Gem::Specification.new do |spec|
@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Joel Moss']
   spec.email         = ['joel@developwithstyle.com']
 
-  spec.summary       = 'A Modern Front End on Rails and Webpack'
+  spec.summary       = 'A Modern [F]ront End on [Rails] and Webpack'
   spec.homepage      = 'https://github.com/joelmoss/frails'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
@@ -34,10 +34,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'nokogiri',   '>= 1.10.4'
   spec.add_dependency 'rack-proxy', '>= 0.6.5'
-  spec.add_dependency 'railties',   '>= 5.2'
-
-  spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_dependency 'rails',      '>= 6.0'
 end

data/index.js

@@ -0,0 +1,35 @@
+const path = require('path')
+
+const rootPath = path.resolve(__dirname, '../../../')
+const publicOutputPath = process.env.FRAILS_PUBLIC_OUTPUT_PATH || 'assets'
+
+// Ensure that the publicPath includes our asset host so dynamic imports
+// (code-splitting chunks and static assets) load from the CDN instead of a relative path.
+const getPublicPathWithAssetHost = () => {
+  const rootUrl = process.env.RAILS_ASSET_HOST || '/'
+  let packPath = `${publicOutputPath}/`
+
+  // Add relative root prefix to pack path.
+  if (process.env.RAILS_RELATIVE_URL_ROOT) {
+    let relativeRoot = process.env.RAILS_RELATIVE_URL_ROOT
+    relativeRoot = relativeRoot.startsWith('/') ? relativeRoot.substr(1) : relativeRoot
+    packPath = `${ensureTrailingSlash(relativeRoot)}${packPath}`
+  }
+
+  return (rootUrl.endsWith('/') ? rootUrl : `${rootUrl}/`) + packPath
+}
+
+module.exports = {
+  // Configuration
+  publicOutputPath,
+  manifestPath: process.env.FRAILS_MANIFEST_PATH || 'manifest.json',
+  devServerPort: process.env.FRAILS_DEV_SERVER_PORT || '8080',
+  devServerHost: process.env.FRAILS_DEV_SERVER_HOST || 'localhost',
+
+  // The local ident name required for loading component styles.
+  cssLocalIdentName: process.env.NODE_ENV == 'development' ? '[path][name]__[local]___[md5:hash:hex:6]' : '[local]-[md5:hash:hex:6]',
+
+  getPublicPathWithAssetHost,
+  sideLoadEntry: require('./package/side_load'),
+  components: require('./package/components')
+}

data/lib/frails.rb

@@ -4,30 +4,34 @@ require 'frails/version'
 require 'active_support/core_ext/module'
 require 'active_support/core_ext/module/attribute_accessors'
 
+# ENV['FRAILS_DEV_SERVER_PORT'] ||= '8080'
+# ENV['FRAILS_DEV_SERVER_HOST'] ||= 'localhost'
+# ENV['FRAILS_PUBLIC_OUTPUT_PATH'] ||= 'assets'
+# ENV['FRAILS_MANIFEST_PATH'] ||= 'manifest.json'
+
 module Frails
   extend self
 
-  def instance=(instance)
-    @instance = instance
+  def dev_server
+    @dev_server ||= Frails::DevServer.new
   end
 
-  def instance
-    @instance ||= Frails::Instance.new
+  def manifest
+    @manifest ||= Frails::ManifestManager.new
   end
 
-  def with_node_env(env)
-    original = ENV['NODE_ENV']
-    ENV['NODE_ENV'] = env
-    yield
-  ensure
-    ENV['NODE_ENV'] = original
+  def public_output_path
+    ENV['FRAILS_PUBLIC_OUTPUT_PATH'] || 'assets'
   end
 
-  delegate :manifest, :dev_server, to: :instance
+  def manifest_path
+    ENV['FRAILS_MANIFEST_PATH'] || 'manifest.json'
+  end
 end
 
-require 'frails/instance'
+require 'frails/log_subscriber'
 require 'frails/dev_server_proxy'
-require 'frails/manifest'
+require 'frails/manifest_manager'
 require 'frails/dev_server'
+require 'frails/component'
 require 'frails/railtie'

data/lib/frails/component.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Frails::Component
+end
+
+require 'frails/component/renderer_concerns'
+require 'frails/component/component_renderer'
+require 'frails/component/react_component_renderer'
+require 'frails/component/abstract_component'
+require 'frails/component/plain_component'
+require 'frails/component/react_component'

data/lib/frails/component/abstract_component.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class Frails::Component::AbstractComponent
+  include ActiveSupport::Callbacks
+
+  define_callbacks :render
+
+  def initialize(view, options)
+    @view, @options = view, options
+
+    expand_instance_vars
+  end
+
+  class << self
+    def before_render(*methods, &block)
+      set_callback :render, :before, *methods, &block
+    end
+
+    def after_render(*methods, &block)
+      set_callback :render, :after, *methods, &block
+    end
+  end
+
+  # rubocop:disable Lint/ShadowedException, Style/MissingRespondToMissing
+  def method_missing(method, *args, &block)
+    super
+  rescue NoMethodError, NameError => e1
+    # the error is not mine, so just releases it as is.
+    raise e1 if e1.name != method
+
+    begin
+      @view.send method, *args, &block
+    rescue NoMethodError => e2
+      raise e2 if e2.name != method
+
+      raise NoMethodError.new("undefined method `#{method}' for either #{self} or #{@view}",
+                              method)
+    rescue NameError => e2
+      raise e2 if e2.name != method
+
+      raise NameError.new("undefined local variable `#{method}' for either #{self} or #{@view}",
+                          method)
+    end
+  end
+  # rubocop:enable Style/MissingRespondToMissing, Lint/ShadowedException
+
+  private
+
+    # Define instance variables for those that are already defined in the @view_context. Excludes
+    # variables starting with an underscore.
+    def expand_instance_vars
+      @view.instance_variables.each do |var|
+        next if var.to_s.start_with?('@_')
+
+        instance_variable_set var, @view.instance_variable_get(var)
+      end
+    end
+end

data/lib/frails/component/component_renderer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class Frails::Component::ComponentRenderer < ActionView::PartialRenderer
+  include Frails::Component::RendererConcerns
+
+  def render(context, options, &block)
+    @view = context
+    @component = options.delete(:component).to_s
+    @presenter = presenter_class.new(@view, options)
+
+    result = @presenter.run_callbacks :render do
+      if @presenter.respond_to?(:render)
+        @presenter.render(&block)
+      else
+        options[:locals] = @presenter.locals
+        super context, options, block
+      end
+    end
+
+    apply_styles((result.respond_to?(:body) ? result.body : result) || nil)
+  end
+
+  private
+
+    def presenter_class
+      super || Frails::Component::PlainComponent
+    end
+
+    def apply_styles(content)
+      return nil if content.nil?
+
+      render_inline_styles
+      replace_css_module_attribute(content).html_safe
+    end
+
+    def stylesheet_entry_file
+      "components/#{@component}/index"
+    end
+
+    def replace_css_module_attribute(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)
+      hash_digest = Digest::MD5.hexdigest("#{stylesheet_path}+#{local_name}")[0, 6]
+
+      return "#{local_name}-#{hash_digest}" unless Frails.dev_server.running?
+
+      name = stylesheet_path.basename.sub(stylesheet_path.extname, '').sub('.', '-')
+      ident = +"#{name}__#{local_name}___#{hash_digest}"
+      ident.prepend("#{stylesheet_path.dirname.to_s.tr('/', '-')}-")
+      ident
+    end
+
+    def stylesheet_path
+      @stylesheet_path ||= begin
+        style_file = "#{@component}/index.css"
+        Rails.root.join('app', 'components', style_file).relative_path_from(Rails.root)
+      end
+    end
+end

data/lib/frails/component/plain_component.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Frails::Component::PlainComponent < Frails::Component::AbstractComponent
+  PRIVATE_METHODS = %i[render method_missing locals].freeze
+
+  def initialize(view, options)
+    super
+
+    @locals = @options.fetch(:locals, @options)
+  end
+
+  def locals
+    hash = {}
+    public_methods(false).each do |method|
+      hash[method] = send(method) unless PRIVATE_METHODS.include?(method)
+    end
+    hash.merge @locals
+  end
+end

data/lib/frails/component/react_component.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Frails::Component::ReactComponent < Frails::Component::AbstractComponent
+  attr_accessor :class_name, :props, :tag, :prerender, :content_loader
+
+  def initialize(view, options)
+    @view, @options = view, options
+
+    @class_name = @options.fetch(:class, nil)
+    @props = @options.fetch(:props, {})
+    @tag = @options.fetch(:tag, :div)
+    @prerender = @options.fetch(:prerender, false)
+    @content_loader = @options.fetch(:content_loader, false)
+
+    expand_instance_vars
+  end
+end

data/lib/frails/component/react_component_renderer.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Frails::Component::ReactComponentRenderer
+  include Frails::Component::RendererConcerns
+
+  def render(context, options, &block)
+    @view = context
+    @component = options.delete(:component).to_s
+    @presenter = presenter_class.new(@view, options)
+
+    @children = @view.capture(&block) if block_given?
+
+    render_with_callbacks || nil
+  end
+
+  private
+
+    # rubocop:disable Rails/OutputSafety
+    def render_with_callbacks
+      @presenter.run_callbacks :render do
+        @prerender = @presenter.prerender
+        @content_loader = @presenter.content_loader
+        @props = camelize_keys(@presenter.props)
+        @props[:children] = @children if @children
+
+        @prerender && render_inline_styles
+
+        rendered_tag = content_tag do
+          @prerender ? React::Renderer.new.render(@component, @props).html_safe : loader
+        end
+
+        @prerender ? move_console_replay_script(rendered_tag) : rendered_tag
+      end
+    end
+    # rubocop:enable Rails/OutputSafety
+
+    def presenter_class
+      super || Frails::Component::ReactComponent
+    end
+
+    def data_for_content_tag
+      {
+        componentPath: @component,
+        componentName: @component.to_s.tr('/', '_').camelize,
+        props: @props,
+        contentLoader: @content_loader,
+        renderMethod: @prerender ? 'hydrate' : 'render'
+      }.to_json
+    end
+
+    def content_tag(&block)
+      classes = "js__reactComponent #{@presenter.class_name}"
+      @view.content_tag @presenter.tag, class: classes, data: data_for_content_tag, &block
+    end
+
+    def camelize_keys(data)
+      data.deep_transform_keys { |key| key.to_s.camelize :lower }
+    end
+
+    def loader
+      return unless @content_loader
+
+      @view.render "shared/content_loaders/#{@content_loader == true ? 'code' : @content_loader}"
+    end
+
+    # Grab the server-rendered console replay script and move it outside the container div.
+    #
+    # rubocop:disable Rails/OutputSafety, Style/RegexpLiteral
+    def move_console_replay_script(rendered_tag)
+      regex = /\n(<script class="js__reactServerConsoleReplay">.*<\/script>)<\/(\w+)>$/m
+      rendered_tag.sub(regex, '</\2>\1').html_safe
+    end
+    # rubocop:enable Rails/OutputSafety, Style/RegexpLiteral
+
+    def stylesheet_entry_file
+      "#{@component.tr('/', '-')}-index-entry-jsx"
+    end
+end

data/lib/frails/component/renderer_concerns.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Frails::Component::RendererConcerns
+  extend ActiveSupport::Concern
+
+  private
+
+    def presenter_class
+      klass_file = Rails.root.join('app', 'components', "#{@component}_component.rb")
+      klass_file.exist? && "#{@component.to_s.camelcase}Component".constantize
+    end
+
+    def render_inline_styles
+      # TODO: We don't yet have support for compiling Webpack for tests.
+      return if Rails.env.test?
+
+      # Don't inline the styles if already inlined.
+      return if inlined_stylesheets.include?(@component)
+
+      Frails.manifest.read!(stylesheet_entry_file, :stylesheet) do |path, src|
+        @view.content_for :component_styles do
+          @view.content_tag(:style, src, { data: { href: path } }, false)
+        end
+      end
+
+      inlined_stylesheets << @component
+    end
+
+    def inlined_stylesheets
+      if @view.instance_variable_defined?(:@inlined_stylesheets)
+        @view.instance_variable_get :@inlined_stylesheets
+      else
+        @view.instance_variable_set :@inlined_stylesheets, []
+      end
+    end
+end

data/lib/frails/dev_server.rb

@@ -15,10 +15,10 @@ class Frails::DevServer
   end
 
   def host
-    Rails.configuration.frails.dev_server_host
+    ENV['FRAILS_DEV_SERVER_HOST'] || 'localhost'
   end
 
   def port
-    Rails.configuration.frails.dev_server_port
+    ENV['FRAILS_DEV_SERVER_PORT'] || 8080
   end
 end

data/lib/frails/dev_server_proxy.rb

@@ -3,13 +3,6 @@
 require 'rack/proxy'
 
 class Frails::DevServerProxy < Rack::Proxy
-  delegate :dev_server, to: :@frails
-
-  def initialize(app = nil, opts = {})
-    @frails = Frails.instance
-    super
-  end
-
   def rewrite_response(response)
     _status, headers, _body = response
     headers.delete 'transfer-encoding'
@@ -17,8 +10,8 @@ class Frails::DevServerProxy < Rack::Proxy
   end
 
   def perform_request(env)
-    if env['PATH_INFO'].start_with?(public_output_path) && dev_server.running?
-      host = dev_server.host_with_port
+    if env['PATH_INFO'].start_with?(public_output_path) && Frails.dev_server.running?
+      host = Frails.dev_server.host_with_port
       env['HTTP_HOST'] = env['HTTP_X_FORWARDED_HOST'] = env['HTTP_X_FORWARDED_SERVER'] = host
       env['HTTP_X_FORWARDED_PROTO'] = env['HTTP_X_FORWARDED_SCHEME'] = 'http'
       env['SCRIPT_NAME'] = ''
@@ -32,6 +25,6 @@ class Frails::DevServerProxy < Rack::Proxy
   private
 
     def public_output_path
-      Rails.configuration.frails.public_output_path
+      "/#{Frails.public_output_path}"
     end
 end