react_on_rails 11.0.0 → 12.0.0

data/lib/react_on_rails/locales/base.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ReactOnRails
+  module Locales
+    def self.compile
+      if ReactOnRails.configuration.i18n_output_format&.downcase == "js"
+        ReactOnRails::Locales::ToJs.new
+      else
+        ReactOnRails::Locales::ToJson.new
+      end
+    end
+
+    class Base
+      def initialize
+        return if i18n_dir.nil?
+        return unless obsolete?
+
+        @translations, @defaults = generate_translations
+        convert
+      end
+
+      private
+
+      def file_format; end
+
+      def obsolete?
+        return true if exist_files.empty?
+
+        files_are_outdated
+      end
+
+      def exist_files
+        @exist_files ||= files.select(&File.method(:exist?))
+      end
+
+      def files_are_outdated
+        latest_yml = locale_files.map(&File.method(:mtime)).max
+        earliest = exist_files.map(&File.method(:mtime)).min
+        latest_yml > earliest
+      end
+
+      def file_names
+        %w[translations default]
+      end
+
+      def files
+        @files ||= file_names.map { |n| file(n) }
+      end
+
+      def file(name)
+        "#{i18n_dir}/#{name}.#{file_format}"
+      end
+
+      def locale_files
+        @locale_files ||= begin
+          if i18n_yml_dir.present?
+            Dir["#{i18n_yml_dir}/**/*.yml"]
+          else
+            ReactOnRails::Utils.truthy_presence(
+              Rails.application && Rails.application.config.i18n.load_path
+            ).presence
+          end
+        end
+      end
+
+      def i18n_dir
+        @i18n_dir ||= ReactOnRails.configuration.i18n_dir
+      end
+
+      def i18n_yml_dir
+        @i18n_yml_dir ||= ReactOnRails.configuration.i18n_yml_dir
+      end
+
+      def default_locale
+        @default_locale ||= I18n.default_locale.to_s || "en"
+      end
+
+      def convert
+        file_names.each do |name|
+          template = send("template_#{name}")
+          path = file(name)
+          generate_file(template, path)
+        end
+      end
+
+      def generate_file(template, path)
+        result = ERB.new(template).result()
+        File.open(path, "w") do |f|
+          f.write(result)
+        end
+      end
+
+      def generate_translations
+        translations = {}
+        defaults = {}
+        locale_files.each do |f|
+          translation = YAML.safe_load(File.open(f))
+          key = translation.keys[0]
+          val = flatten(translation[key])
+          translations = translations.deep_merge(key => val)
+          defaults = defaults.deep_merge(flatten_defaults(val)) if key == default_locale
+        end
+        [translations.to_json, defaults.to_json]
+      end
+
+      def format(input)
+        input.to_s.tr(".", "_").camelize(:lower).to_sym
+      end
+
+      def flatten_defaults(val)
+        flatten(val).each_with_object({}) do |(k, v), h|
+          key = format(k)
+          h[key] = { id: k, defaultMessage: v }
+        end
+      end
+
+      def flatten(translations)
+        translations.each_with_object({}) do |(k, v), h|
+          if v.is_a? Hash
+            flatten(v).map { |hk, hv| h["#{k}.#{hk}".to_sym] = hv }
+          elsif v.is_a?(String)
+            h[k] = v.gsub("%{", "{")
+          elsif !v.is_a?(Array)
+            h[k] = v
+          end
+        end
+      end
+
+      def template_translations
+        <<-JS.strip_heredoc
+          export const translations = #{@translations};
+        JS
+      end
+
+      def template_default
+        <<-JS.strip_heredoc
+          import { defineMessages } from 'react-intl';
+
+          const defaultLocale = \'#{default_locale}\';
+
+          const defaultMessages = defineMessages(#{@defaults});
+
+          export { defaultMessages, defaultLocale };
+        JS
+      end
+    end
+  end
+end

data/lib/react_on_rails/locales/to_js.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ReactOnRails
+  module Locales
+    class ToJs < Base
+      def initialize
+        super
+      end
+
+      private
+
+      def file_format
+        "js"
+      end
+
+      def template_translations
+        <<-JS.strip_heredoc
+          export const translations = #{@translations};
+        JS
+      end
+
+      def template_default
+        <<-JS.strip_heredoc
+          import { defineMessages } from 'react-intl';
+
+          const defaultLocale = \'#{default_locale}\';
+
+          const defaultMessages = defineMessages(#{@defaults});
+
+          export { defaultMessages, defaultLocale };
+        JS
+      end
+    end
+  end
+end

data/lib/react_on_rails/locales/to_json.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module ReactOnRails
+  module Locales
+    class ToJson < Base
+      def initialize
+        super
+      end
+
+      private
+
+      def file_format
+        "json"
+      end
+
+      def template_translations
+        @translations
+      end
+
+      def template_default
+        @defaults
+      end
+    end
+  end
+end

data/lib/react_on_rails/prerender_error.rb

@@ -2,39 +2,77 @@
 
 # rubocop:disable: Layout/IndentHeredoc
 module ReactOnRails
-  class PrerenderError < StandardError
+  class PrerenderError < ::ReactOnRails::Error
+    MAX_ERROR_SNIPPET_TO_LOG = 1000
+    # TODO: Consider remove providing original `err` as already have access to `self.cause`
+    # http://blog.honeybadger.io/nested-errors-in-ruby-with-exception-cause/
+    attr_reader :component_name, :err, :props, :js_code, :console_messages
+
     # err might be nil if JS caught the error
     def initialize(component_name: nil, err: nil, props: nil,
                    js_code: nil, console_messages: nil)
+      @component_name = component_name
+      @err = err
+      @props = props
+      @js_code = js_code
+      @console_messages = console_messages
+
+      backtrace, message = calc_message(component_name, console_messages, err, js_code, props)
+
+      super([message, backtrace].compact.join("\n"))
+    end
+
+    def to_honeybadger_context
+      to_error_context
+    end
+
+    def raven_context
+      to_error_context
+    end
+
+    def to_error_context
+      result = {
+        component_name: component_name,
+        err: err,
+        props: props,
+        js_code: js_code,
+        console_messages: console_messages
+      }
+
+      result.merge!(err.to_error_context) if err.respond_to?(:to_error_context)
+      result
+    end
+
+    private
+
+    def calc_message(component_name, console_messages, err, js_code, props)
       message = "ERROR in SERVER PRERENDERING\n".dup
       if err
-        # rubocop:disable Layout/IndentHeredoc
-        message << <<-MSG
-Encountered error: \"#{err}\"
+        message << <<~MSG
+          Encountered error: \"#{err}\"
         MSG
-        # rubocop:enable Layout/IndentHeredoc
+
         backtrace = err.backtrace.join("\n")
       else
         backtrace = nil
       end
-      # rubocop:disable Layout/IndentHeredoc
-      message << <<-MSG
-when prerendering #{component_name} with props: #{props}
-js_code was:
-#{js_code}
+      message << <<~MSG
+        when prerendering #{component_name} with props: #{Utils.smart_trim(props, MAX_ERROR_SNIPPET_TO_LOG)}
+
+        code:
+
+        #{Utils.smart_trim(js_code, MAX_ERROR_SNIPPET_TO_LOG)}
+
       MSG
-      # rubocop:enable Layout/IndentHeredoc
 
       if console_messages
-        # rubocop:disable Layout/IndentHeredoc
-        message << <<-MSG
-console messages:
-#{console_messages}
+        message << <<~MSG
+          console messages:
+          #{console_messages}
         MSG
-        # rubocop:enable Layout/IndentHeredoc
-      end
 
-      super([message, backtrace].compact.join("\n"))
+      end
+      [backtrace, message]
     end
   end
 end

data/lib/react_on_rails/react_component/render_options.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "react_on_rails/utils"
+
+module ReactOnRails
+  module ReactComponent
+    class RenderOptions
+      include Utils::Required
+
+      attr_accessor :request_digest
+
+      NO_PROPS = {}.freeze
+
+      def initialize(react_component_name: required("react_component_name"), options: required("options"))
+        @react_component_name = react_component_name.camelize
+        @options = options
+      end
+
+      attr_reader :react_component_name
+
+      def props
+        options.fetch(:props) { NO_PROPS }
+      end
+
+      def random_dom_id
+        retrieve_key(:random_dom_id)
+      end
+
+      def dom_id
+        @dom_id ||= options.fetch(:id) do
+          if random_dom_id
+            generate_unique_dom_id
+          else
+            base_dom_id
+          end
+        end
+      end
+
+      def random_dom_id?
+        return false if options[:id]
+
+        return false unless random_dom_id
+
+        true
+      end
+
+      def html_options
+        options[:html_options].to_h
+      end
+
+      def prerender
+        retrieve_key(:prerender)
+      end
+
+      def trace
+        retrieve_key(:trace)
+      end
+
+      def replay_console
+        retrieve_key(:replay_console)
+      end
+
+      def raise_on_prerender_error
+        retrieve_key(:raise_on_prerender_error)
+      end
+
+      def logging_on_server
+        retrieve_key(:logging_on_server)
+      end
+
+      def to_s
+        "{ react_component_name = #{react_component_name}, options = #{options}, request_digest = #{request_digest}"
+      end
+
+      def internal_option(key)
+        options[key]
+      end
+
+      private
+
+      attr_reader :options
+
+      def base_dom_id
+        "#{react_component_name}-react-component"
+      end
+
+      def generate_unique_dom_id
+        "#{base_dom_id}-#{SecureRandom.uuid}"
+      end
+
+      def retrieve_key(key)
+        options.fetch(key) do
+          ReactOnRails.configuration.public_send(key)
+        end
+      end
+    end
+  end
+end

data/lib/react_on_rails/server_rendering_js_code.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ReactOnRails
+  module ServerRenderingJsCode
+    class << self
+      def js_code_renderer
+        @js_code_renderer ||= if ReactOnRails::Utils.react_on_rails_pro?
+                                ReactOnRailsPro::ServerRenderingJsCode
+                              else
+                                self
+                              end
+      end
+
+      def server_rendering_component_js_code(
+        props_string: nil,
+        rails_context: nil,
+        redux_stores: nil,
+        react_component_name: nil,
+        render_options: nil
+      )
+        js_code_renderer.render(props_string, rails_context, redux_stores, react_component_name, render_options)
+      end
+
+      def render(props_string, rails_context, redux_stores, react_component_name, render_options)
+        <<-JS
+        (function() {
+          var railsContext = #{rails_context};
+        #{redux_stores}
+          var props = #{props_string};
+          return ReactOnRails.serverRenderReactComponent({
+            name: '#{react_component_name}',
+            domNodeId: '#{render_options.dom_id}',
+            props: props,
+            trace: #{render_options.trace},
+            railsContext: railsContext
+          });
+        })()
+        JS
+      end
+    end
+  end
+end