react_on_rails 11.2.2 → 12.0.0.pre.beta.3

data/docs/api/ruby-api-hot-reload-view-helpers.md

@@ -1,44 +0,0 @@
-## NOTE: These helpers are NOT needed if using webpacker
-
-## Hot Reloading View Helpers
-The `env_javascript_include_tag` and `env_stylesheet_link_tag` support the usage of a webpack dev server for providing the JS and CSS assets during development mode. See the [shakacode/react-webpack-rails-tutorial](https://github.com/shakacode/react-webpack-rails-tutorial/) for a working example.
-
-The key options are `static` and `hot` which specify what you want for static vs. hot. Both of these params are optional, and support either a single value, or an array.
-
-static vs. hot is picked based on whether `ENV["REACT_ON_RAILS_ENV"] == "HOT"`
-
-```erb
- <%= env_stylesheet_link_tag(static: 'application_static',
-                             hot: 'application_non_webpack',
-                             media: 'all',
-                             'data-turbolinks-track' => true)  %>
-
- <!-- These do not use turbolinks, so no data-turbolinks-track -->
- <!-- This is to load the hot assets. -->
- 
- <!-- Note, you can have multiple files here. It's an array. -->
- <%= env_javascript_include_tag(hot: ['http://localhost:3500/hello-world-bundle.js]') %>
-
- <!-- These do use turbolinks -->
- <%= env_javascript_include_tag(static: 'application_static',
-                                hot: 'application_non_webpack',
-                                'data-turbolinks-track' => true) %>
-```
-
-See application.html.erb for usage example and [application.html.erb](https://github.com/shakacode/react-webpack-rails-tutorial/blob/master/app%2Fviews%2Flayouts%2Fapplication.html.erb)
-
-Helper to set CSS and JS assets depending on if we want static or "hot", which means from the Webpack dev server.
-
-In this example, `application_non_webpack` is simply a CSS asset pipeline file which includes styles not placed in the webpack build. The same can be said for `application_non_webpack` for JS files. Note, the suffix is not used in the helper calls.
-
-We don't need styles from the webpack build, as those will come via the JavaScript include tags.
-
-The key options are `static` and `hot` which specify what you want for static vs. hot. Both of
-these params are optional, and support either a single value, or an array.
-
-```erb
- <%= env_stylesheet_link_tag(static: 'application_static',
-                             hot: 'application_non_webpack',
-                             media: 'all',
-                             'data-turbolinks-track' => true)  %>
-```

data/lib/generators/react_on_rails/templates/base/base/Procfile.dev-server

@@ -1,12 +0,0 @@
-# You can run these commands in separate shells instead of using foreman
-web: rails s -p 3000
-
-# Next line runs the webpack-dev-server
-# You can edit config/webpacker.yml to set HMR to true to see hot reloading.
-# Note, hot and live reloading don't work with the default generator setup on top of
-# the rails/webpacker Webpack config with server rendering.
-# If you have server rendering enabled, modify the call to bin/webpack-dev-server line
-# so you add `--inline=false` and then CSS is not inlined.
-# Otherwise, you will have an error. If you want HMR and Server Rendering, see
-# the example in the https://github.com/shakacode/react-webpack-rails-tutorial
-client: sh -c 'rm -rf public/packs/* || true && bundle exec rake react_on_rails:locale && bin/webpack-dev-server'

data/lib/react_on_rails/assets_precompile.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-module ReactOnRails
-  class AssetsPrecompile
-    class SymlinkTargetDoesNotExistException < StandardError
-    end
-
-    # Used by the rake task
-    def default_asset_path
-      dir = File.join(Rails.configuration.paths["public"].first,
-                      Rails.configuration.assets.prefix)
-      Pathname.new(dir)
-    end
-
-    # assets_path should be a Pathname object
-    def initialize(assets_path: nil,
-                   symlink_non_digested_assets_regex: nil,
-                   generated_assets_dir: nil)
-      @assets_path = ReactOnRails::Utils.truthy_presence(assets_path) || default_asset_path
-      @symlink_non_digested_assets_regex =
-        ReactOnRails::Utils.truthy_presence(symlink_non_digested_assets_regex) ||
-        ReactOnRails.configuration.symlink_non_digested_assets_regex
-      @generated_assets_dir = ReactOnRails::Utils.truthy_presence(generated_assets_dir) ||
-                              ReactOnRails.configuration.generated_assets_dir
-    end
-
-    # target and symlink are relative to the assets directory
-    def symlink_file(target, symlink)
-      target_path = @assets_path.join(target)
-      symlink_path = @assets_path.join(symlink)
-
-      target_exists = File.exist?(target_path)
-      raise SymlinkTargetDoesNotExistException, "Target Path was: #{target_path}" unless target_exists
-
-      if symlink_and_points_to_existing_file?(symlink_path)
-        puts "React On Rails: Digested version of #{symlink} already exists indicating #{target} did not change."
-        return
-      end
-
-      if file_or_symlink_exists_at_path?(symlink_path)
-        puts "React On Rails: Removing existing invalid symlink or file #{symlink_path}"
-        FileUtils.remove_file(symlink_path, true)
-      end
-
-      # Might be like:
-      # "images/5cf5db49df178f9357603f945752a1ef.png":
-      # "images/5cf5db49df178f9357603f945752a1ef-033650e1d6193b70d59bb60e773f47b6d9aefdd56abc7cc.png"
-      # need to cd to directory and then symlink
-      target_sub_path, _divider, target_filename = target.rpartition("/")
-      _symlink_sub_path, _divider, symlink_filename = symlink.rpartition("/")
-      dest_path = File.join(@assets_path, target_sub_path)
-
-      puts "React On Rails: Symlinking \"#{target}\" to \"#{symlink}\""
-      FileUtils.chdir(dest_path) do
-        File.symlink(target_filename, symlink_filename)
-      end
-    end
-
-    def symlink_non_digested_assets
-      # digest ==> means that the file has a unique sha so the browser will load a new copy.
-      # Webpack's CSS extract-text-plugin copies digested asset files over to directory where we put
-      # we deploy the webpack compiled JS file. Since Rails will deploy the image files in this
-      # directory with a digest, then the files are essentially "double-digested" and the CSS
-      # references from webpack's CSS would be invalid. The fix is to symlink the double-digested
-      # file back to the original digested name, and make a similar symlink for the gz version.
-      return unless @symlink_non_digested_assets_regex
-
-      manifest_glob = Dir.glob(@assets_path.join(".sprockets-manifest-*.json")) +
-                      Dir.glob(@assets_path.join("manifest-*.json")) +
-                      Dir.glob(@assets_path.join("manifest.yml"))
-      if manifest_glob.empty?
-        puts "Warning: React On Rails: expected to find .sprockets-manifest-*.json, manifest-*.json "\
-                 "or manifest.yml at #{@assets_path}, but found none. Canceling symlinking tasks."
-        return -1
-      end
-      manifest_path = take_most_recent_manifest_path(manifest_glob)
-      manifest_file = File.new(manifest_path)
-      manifest_data = if File.extname(manifest_file) == ".json"
-                        manifest_file_data = File.read(manifest_path)
-                        JSON.parse(manifest_file_data)["assets"]
-                      else
-                        YAML.safe_load(manifest_file)
-                      end
-
-      # We realize that we're copying other Rails assets that match the regexp, but this just
-      # means that we'd be exposing the original, undigested names.
-      manifest_data.each do |original_filename, rails_digested_filename|
-        # TODO: we should remove any original_filename that is NOT in the webpack deploy folder.
-        next unless original_filename =~ @symlink_non_digested_assets_regex
-
-        # We're symlinking from the digested filename back to the original filename which has
-        # already been symlinked by Webpack
-        symlink_file(rails_digested_filename, original_filename)
-
-        # We want the gz ones as well if they exist
-        if File.exist?(@assets_path.join("#{rails_digested_filename}.gz"))
-          symlink_file("#{rails_digested_filename}.gz", "#{original_filename}.gz")
-        end
-      end
-    end
-
-    def delete_broken_symlinks
-      Dir.glob(@assets_path.join("*")).each do |filename|
-        next unless File.lstat(filename).symlink?
-
-        begin
-          target = File.readlink(filename)
-        rescue StandardError
-          puts "React on Rails: Warning: your platform doesn't support File::readlink method." \
-               "Skipping broken link check."
-          break
-        end
-        path = Pathname.new(File.dirname(filename))
-        target_path = path.join(target)
-        unless File.exist?(target_path)
-          puts "React on Rails: Deleting broken link: #{filename}"
-          File.delete(filename)
-        end
-      end
-    end
-
-    def clobber
-      dir = Rails.root.join(@generated_assets_dir)
-      if dir.present? && File.directory?(dir)
-        puts "Deleting files in directory #{dir}"
-        FileUtils.rm_r(Dir.glob(Rails.root.join("#{@generated_assets_dir}/*")))
-      else
-        puts "Could not find generated_assets_dir #{dir} defined in react_on_rails initializer: "
-      end
-    end
-
-    private
-
-    def take_most_recent_manifest_path(manifest_glob)
-      manifest_glob.max_by { |name| File.mtime(name) }
-    end
-
-    def symlink_and_points_to_existing_file?(symlink_path)
-      # File.exist?(symlink_path) will check the file the sym is pointing to is existing
-      # File.lstat(symlink_path).symlink? confirms that this is a symlink
-      File.exist?(symlink_path) && File.lstat(symlink_path).symlink?
-    end
-
-    def file_or_symlink_exists_at_path?(path)
-      # We use lstat and not stat, we we don't want to visit the file that the symlink maybe
-      # pointing to. We can't use File.exist?, as that would check the file pointed at by the symlink.
-      File.lstat(path)
-      true
-    rescue StandardError
-      false
-    end
-  end
-end

data/lib/react_on_rails/locales_to_js.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require "erb"
-
-module ReactOnRails
-  class LocalesToJs
-    def initialize
-      return if i18n_dir.nil?
-      return unless obsolete?
-
-      @translations, @defaults = generate_translations
-      convert
-    end
-
-    private
-
-    def obsolete?
-      return true if exist_js_files.empty?
-
-      js_files_are_outdated
-    end
-
-    def exist_js_files
-      @exist_js_files ||= js_files.select(&File.method(:exist?))
-    end
-
-    def js_files_are_outdated
-      latest_yml = locale_files.map(&File.method(:mtime)).max
-      earliest_js = exist_js_files.map(&File.method(:mtime)).min
-      latest_yml > earliest_js
-    end
-
-    def js_file_names
-      %w[translations default]
-    end
-
-    def js_files
-      @js_files ||= js_file_names.map { |n| js_file(n) }
-    end
-
-    def js_file(name)
-      "#{i18n_dir}/#{name}.js"
-    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
-      js_file_names.each do |name|
-        template = send("template_#{name}")
-        path = js_file(name)
-        generate_js_file(template, path)
-      end
-    end
-
-    def generate_js_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