react_on_rails 13.3.5 → 14.0.0

data/rakelib/example_type.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "rake"
-require "pathname"
-
-require_relative "task_helpers"
-
-# Defines the ExampleType class, where each object represents a unique type of example
-# app that we can generate.
-module ReactOnRails
-  module TaskHelpers
-    class ExampleType
-      def self.all
-        @all ||= []
-      end
-
-      def self.namespace_name
-        "examples"
-      end
-
-      attr_reader :name, :generator_options
-
-      def initialize(name: nil, generator_options: nil)
-        @name = name
-        @generator_options = generator_options
-        self.class.all << self
-      end
-
-      def name_pretty
-        "#{@name} example app"
-      end
-
-      def dir
-        File.join(examples_dir, name)
-      end
-
-      def dir_exist?
-        Dir.exist?(dir)
-      end
-
-      def gemfile
-        File.join(dir, "Gemfile")
-      end
-
-      # Gems we need to add to the Gemfile before bundle installing
-      def required_gems
-        relative_gem_root = Pathname(gem_root).relative_path_from(Pathname(dir))
-        [
-          "gem 'react_on_rails', path: '#{relative_gem_root}'",
-          "gem 'shakapacker'"
-        ]
-      end
-
-      # Options we pass when running `rails new` from the command-line.
-      attr_writer :rails_options
-
-      def rails_options
-        @rails_options ||= if ReactOnRails::Utils.rails_version_less_than("7.0")
-                             "--skip-bundle --skip-spring --skip-git --skip-test-unit --skip-active-record -J"
-                           else
-                             "--skip-bundle --skip-spring --skip-git --skip-test-unit --skip-active-record -j webpack"
-                           end
-      end
-
-      %w[gen clobber npm_install build_webpack_bundles].each do |task_type|
-        method_name_normal = "#{task_type}_task_name"          # ex: `clean_task_name`
-        method_name_short = "#{method_name_normal}_short"      # ex: `clean_task_name_short`
-
-        define_method(method_name_normal) { "#{self.class.namespace_name}:#{task_type}_#{name}" }
-        define_method(method_name_short) { "#{task_type}_#{name}" }
-      end
-
-      def rspec_task_name_short
-        "example_#{name}"
-      end
-
-      def rspec_task_name
-        "run_rspec:#{rspec_task_name_short}"
-      end
-
-      # Assumes we are inside a rails app's folder and necessary gems have been installed
-      def generator_shell_commands
-        shell_commands = []
-        shell_commands << "rails generate react_on_rails:install #{generator_options} --ignore-warnings --force"
-        shell_commands << "rails generate react_on_rails:dev_tests #{generator_options}"
-      end
-
-      private
-
-      # Defines globs that scoop up all files (including dotfiles) in given directory
-      def all_files_in_dir(p_dir)
-        [File.join(p_dir, "**", "*"), File.join(p_dir, "**", ".*")]
-      end
-    end
-  end
-end

data/rakelib/examples.rake

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Defines tasks related to generating example apps using the gem's generator.
-# Allows us to create and test apps generated using a wide range of options.
-#
-# Also see example_type.rb
-
-require "yaml"
-require "rails/version"
-
-require_relative "example_type"
-require_relative "task_helpers"
-
-namespace :examples do # rubocop:disable Metrics/BlockLength
-  include ReactOnRails::TaskHelpers
-  # Loads data from examples_config.yml and instantiates corresponding ExampleType objects
-  examples_config_file = File.expand_path("examples_config.yml", __dir__)
-  examples_config = symbolize_keys(YAML.safe_load(File.read(examples_config_file)))
-  examples_config[:example_type_data].each { |example_type_data| ExampleType.new(**symbolize_keys(example_type_data)) }
-
-  # Define tasks for each example type
-  ExampleType.all.each do |example_type|
-    # CLOBBER
-    desc "Clobbers (deletes) #{example_type.name_pretty}"
-    task example_type.clobber_task_name_short do
-      rm_rf(example_type.dir)
-    end
-
-    # GENERATE
-    desc "Generates #{example_type.name_pretty}"
-    task example_type.gen_task_name_short => example_type.clobber_task_name do
-      mkdir_p(example_type.dir)
-      example_type.rails_options += "--skip-javascript"
-      sh_in_dir(examples_dir, "rails new #{example_type.name} #{example_type.rails_options}")
-      sh_in_dir(example_type.dir, "touch .gitignore")
-      append_to_gemfile(example_type.gemfile, example_type.required_gems)
-      bundle_install_in(example_type.dir)
-      sh_in_dir(example_type.dir, "rake webpacker:install")
-      sh_in_dir(example_type.dir, example_type.generator_shell_commands)
-      sh_in_dir(example_type.dir, "yarn")
-    end
-  end
-
-  desc "Clobbers (deletes) all example apps"
-  task :clobber do
-    rm_rf(examples_dir)
-  end
-
-  desc "Generates all example apps"
-  task gen_all: ExampleType.all.map(&:gen_task_name)
-end
-
-desc "Generates all example apps. Run `rake -D examples` to see all available options"
-task examples: ["examples:gen_all"]
-
-private
-
-# Appends each string in an array as a new line of text in the given Gemfile.
-# Automatically adds line returns.
-def append_to_gemfile(gemfile, lines)
-  old_text = File.read(gemfile)
-  new_text = lines.reduce(old_text) { |a, e| a << "#{e}\n" }
-  File.open(gemfile, "w") { |f| f.puts(new_text) }
-end

data/rakelib/examples_config.yml

@@ -1,14 +0,0 @@
-example_type_data:
-  -
-    name: basic
-    generator_options: ""
-  -
-    name: basic-server-rendering
-    generator_options: --example-server-rendering
-  -
-    name: redux
-    generator_options: --redux
-  -
-    name: redux-server-rendering
-    generator_options: --redux --example-server-rendering
-

data/rakelib/lint.rake

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "task_helpers"
-
-namespace :lint do
-  include ReactOnRails::TaskHelpers
-
-  desc "Run Rubocop as shell"
-  task :rubocop do
-    sh_in_dir(gem_root, "bundle exec rubocop --version", "bundle exec rubocop .")
-  end
-
-  desc "Run scss-lint as shell"
-  task :scss do
-    sh_in_dir(gem_root, "bundle exec scss-lint spec/dummy/app/assets/stylesheets/")
-  end
-
-  desc "Run eslint as shell"
-  task :eslint do
-    sh_in_dir(gem_root, "yarn run eslint --version", "yarn run eslint .")
-  end
-
-  desc "Run all eslint & rubocop linters. Skip scss"
-  task lint: %i[eslint rubocop] do
-    puts "Completed all linting"
-  end
-end
-
-desc "Runs all linters. Run `rake -D lint` to see all available lint options"
-task lint: ["lint:lint"]

data/rakelib/node_package.rake

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "task_helpers"
-
-namespace :node_package do
-  include ReactOnRails::TaskHelpers
-
-  task :build do
-    puts "Building Node Package and running 'yalc publish'"
-    sh "yarn run build && yalc publish"
-  end
-end
-
-desc "Prepares node_package by building and symlinking any example/dummy apps present"
-task node_package: "node_package:build"

data/rakelib/release.rake

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler"
-require_relative "task_helpers"
-require_relative File.join(gem_root, "lib", "react_on_rails", "version_syntax_converter")
-require_relative File.join(gem_root, "lib", "react_on_rails", "git_utils")
-require_relative File.join(gem_root, "lib", "react_on_rails", "utils")
-
-class RaisingMessageHandler
-  def add_error(error)
-    raise error
-  end
-end
-
-# rubocop:disable Metrics/BlockLength
-
-desc("Releases both the gem and node package using the given version.
-
-IMPORTANT: the gem version must be in valid rubygem format (no dashes).
-It will be automatically converted to a valid yarn semver by the rake task
-for the node package version. This only makes a difference for pre-release
-versions such as `3.0.0.beta.1` (yarn version would be `3.0.0-beta.1`).
-
-This task depends on the gem-release (ruby gem) and release-it (node package)
-which are installed via `bundle install` and `yarn global add release-it`
-
-1st argument: The new version in rubygem format (no dashes). Pass no argument to
-              automatically perform a patch version bump.
-2nd argument: Perform a dry run by passing 'true' as a second argument.
-
-Note, accept defaults for npmjs options. Script will pause to get 2FA tokens.
-
-Example: `rake release[2.1.0,false]`")
-task :release, %i[gem_version dry_run tools_install] do |_t, args|
-  include ReactOnRails::TaskHelpers
-
-  # Check if there are uncommited changes
-  ReactOnRails::GitUtils.uncommitted_changes?(RaisingMessageHandler.new)
-  args_hash = args.to_hash
-
-  is_dry_run = ReactOnRails::Utils.object_to_boolean(args_hash[:dry_run])
-
-  gem_version = args_hash.fetch(:gem_version, "")
-
-  npm_version = if gem_version.strip.empty?
-                  ""
-                else
-                  ReactOnRails::VersionSyntaxConverter.new.rubygem_to_npm(gem_version)
-                end
-
-  # Having the examples prevents publishing
-  Rake::Task["examples:clobber"].invoke
-  # Delete any react_on_rails.gemspec except the root one
-  sh_in_dir(gem_root, "find . -mindepth 2 -name 'react_on_rails.gemspec' -delete")
-
-  # See https://github.com/svenfuchs/gem-release
-  sh_in_dir(gem_root, "git pull --rebase")
-  sh_in_dir(gem_root, "gem bump --no-commit #{gem_version.strip.empty? ? '' : %(--version #{gem_version})}")
-
-  # Update dummy app's Gemfile.lock
-  bundle_install_in(dummy_app_dir)
-
-  puts "Carefully add your OTP for NPM. If you get an error, 'git reset --hard' and start over."
-  # Will bump the yarn version, commit, tag the commit, push to repo, and release on yarn
-  release_it_command = +"release-it"
-  release_it_command << " #{npm_version}" unless npm_version.strip.empty?
-  release_it_command << " --npm.publish --no-git.requireCleanWorkingDir"
-  release_it_command << " --dry-run --verbose" if is_dry_run
-  sh_in_dir(gem_root, release_it_command)
-
-  # Release the new gem version
-
-  puts "Carefully add your OTP for Rubygems. If you get an error, run 'gem release' again."
-  sh_in_dir(gem_root, "gem release") unless is_dry_run
-
-  msg = <<~MSG
-    Once you have successfully published, run these commands to update the spec apps:
-
-    cd #{dummy_app_dir}; bundle update react_on_rails
-    cd #{gem_root}#{' '}
-    git commit -a -m 'Update Gemfile.lock for spec app'
-    git push
-  MSG
-  puts msg
-end
-# rubocop:enable Metrics/BlockLength
-
-task :test do
-  unbundled_sh_in_dir(gem_root, "cd #{dummy_app_dir}; bundle update react_on_rails")
-  sh_in_dir(gem_root, "git commit -a -m 'Update Gemfile.lock for spec app'")
-  sh_in_dir(gem_root, "git push")
-end

data/rakelib/run_rspec.rake

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require "coveralls/rake/task" if ENV["USE_COVERALLS"] == "TRUE"
-
-require "pathname"
-
-require_relative "task_helpers"
-require_relative "example_type"
-
-# rubocop:disable Metrics/BlockLength
-namespace :run_rspec do
-  include ReactOnRails::TaskHelpers
-
-  spec_dummy_dir = File.join("spec", "dummy")
-
-  desc "Run RSpec for top level only"
-  task :gem do
-    run_tests_in("", rspec_args: File.join("spec", "react_on_rails"))
-  end
-
-  desc "Runs dummy rspec with turbolinks"
-  task dummy: ["dummy_apps:dummy_app"] do
-    run_tests_in(spec_dummy_dir)
-  end
-
-  desc "Runs dummy rspec without turbolinks"
-  task dummy_no_turbolinks: ["dummy_apps:dummy_app"] do
-    run_tests_in(spec_dummy_dir,
-                 env_vars: "DISABLE_TURBOLINKS=TRUE",
-                 command_name: "dummy_no_turbolinks")
-  end
-
-  # Dynamically define Rake tasks for each example app found in the examples directory
-  ExampleType.all.each do |example_type|
-    desc "Runs RSpec for #{example_type.name_pretty} only"
-    task example_type.rspec_task_name_short => example_type.gen_task_name do
-      run_tests_in(File.join(examples_dir, example_type.name)) # have to use relative path
-    end
-  end
-
-  desc "Runs Rspec for example apps only"
-  task examples: "examples:gen_all" do
-    ExampleType.all.each { |example_type| Rake::Task[example_type.rspec_task_name].invoke }
-  end
-
-  Coveralls::RakeTask.new if ENV["USE_COVERALLS"] == "TRUE"
-
-  desc "run all tests no examples"
-  task all_but_examples: %i[gem dummy_no_turbolinks dummy js_tests] do
-    puts "Completed all RSpec tests"
-  end
-
-  desc "run all dummy tests"
-  task all_dummy: %i[dummy_no_turbolinks dummy] do
-    puts "Completed all RSpec tests"
-  end
-
-  desc "run all tests"
-  task run_rspec: %i[all_but_examples examples] do
-    puts "Completed all RSpec tests"
-  end
-end
-# rubocop:enable Metrics/BlockLength
-
-desc "js tests (same as 'yarn run test')"
-task :js_tests do
-  sh "yarn run test"
-end
-
-msg = <<-DESC.strip_heredoc
-  Runs all tests, run `rake -D run_rspec` to see all available test options.
-  "rake run_rspec:example_basic" is a good way to run only one generator test.
-DESC
-desc msg
-task run_rspec: ["run_rspec:run_rspec"]
-
-private
-
-def calc_path(dir)
-  if dir.is_a?(String)
-    if dir.start_with?(File::SEPARATOR)
-      Pathname.new(dir)
-    else
-      Pathname.new(File.join(gem_root, dir))
-    end
-  else
-    dir
-  end
-end
-
-# Runs rspec in the given directory.
-# If string is passed and it's not absolute, it's converted relative to root of the gem.
-# TEST_ENV_COMMAND_NAME is used to make SimpleCov.command_name unique in order to
-# prevent a name collision. Defaults to the given directory's name.
-def run_tests_in(dir, options = {})
-  path = calc_path(dir)
-
-  command_name = options.fetch(:command_name, path.basename)
-  rspec_args = options.fetch(:rspec_args, "")
-  env_vars = +"#{options.fetch(:env_vars, '')} TEST_ENV_COMMAND_NAME=\"#{command_name}\""
-  env_vars << "COVERAGE=true" if ENV["USE_COVERALLS"]
-  sh_in_dir(path.realpath, "#{env_vars} bundle exec rspec #{rspec_args}")
-end

data/rakelib/task_helpers.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module ReactOnRails
-  module TaskHelpers
-    # Returns the root folder of the react_on_rails gem
-    def gem_root
-      File.expand_path("..", __dir__)
-    end
-
-    # Returns the folder where examples are located
-    def examples_dir
-      File.join(gem_root, "gen-examples", "examples")
-    end
-
-    def dummy_app_dir
-      File.join(gem_root, "spec/dummy")
-    end
-
-    # Executes a string or an array of strings in a shell in the given directory in an unbundled environment
-    def sh_in_dir(dir, *shell_commands)
-      shell_commands.flatten.each { |shell_command| sh %(cd #{dir} && #{shell_command.strip}) }
-    end
-
-    # Executes a string or an array of strings in a shell in the given directory
-    def unbundled_sh_in_dir(dir, *shell_commands)
-      Dir.chdir(dir) do
-        # Without `with_unbundled_env`, running bundle in the child directories won't correctly
-        # update the Gemfile.lock
-        Bundler.with_unbundled_env do
-          shell_commands.flatten.each do |shell_command|
-            sh(shell_command.strip)
-          end
-        end
-      end
-    end
-
-    def bundle_install_in(dir)
-      unbundled_sh_in_dir(dir, "bundle install")
-    end
-
-    def bundle_install_in_no_turbolinks(dir)
-      sh_in_dir(dir, "DISABLE_TURBOLINKS=TRUE bundle install")
-    end
-
-    # Runs bundle exec using that directory's Gemfile
-    def bundle_exec(dir: nil, args: nil, env_vars: "")
-      sh_in_dir(dir, "#{env_vars} #{args}")
-    end
-
-    def generators_source_dir
-      File.join(gem_root, "lib/generators/react_on_rails")
-    end
-
-    def symbolize_keys(hash)
-      hash.each_with_object({}) do |(key, value), new_hash|
-        new_key = key.is_a?(String) ? key.to_sym : key
-        new_value = value.is_a?(Hash) ? symbolize_keys(value) : value
-        new_hash[new_key] = new_value
-      end
-    end
-  end
-end

data/script/bootstrap

@@ -1,33 +0,0 @@
-#!/bin/sh
-
-# script/bootstrap: Resolve all dependencies that the application requires to
-#                   run.
-
-set -e
-
-cd "$(dirname "$0")/.."
-
-if [ -f "Brewfile" ] && [ "$(uname -s)" = "Darwin" ]; then
-  brew update
-
-  brew bundle check 2>&1 >/dev/null || {
-    echo "==> Installing Homebrew dependencies…"
-    brew bundle
-  }
-fi
-
-if [ -f ".ruby-version" ] && [ -z "$(rbenv version-name 2>/dev/null)" ]; then
-  echo "==> Installing Ruby…"
-  rbenv install --skip-existing
-  which bundle 2>&1 >/dev/null || {
-    gem install bundler
-    rbenv rehash
-  }
-fi
-
-if [ -f "Gemfile" ]; then
-  echo "==> Installing gem dependencies…"
-  bundle check --path vendor/gems 2>&1 >/dev/null || {
-    bundle install --path vendor/gems --quiet --without production
-  }
-fi

data/script/release

@@ -1,3 +0,0 @@
-#!/bin/bash
-
-echo "See `rake -D release`"

data/script/setup

@@ -1,23 +0,0 @@
-#!/bin/sh
-
-# script/setup: Set up application for the first time after cloning, or set it
-#               back to the initial first unused state.
-
-set -e
-
-cd "$(dirname "$0")/.."
-
-script/bootstrap
-
-echo "===> Setting up DB..."
-# reset database to a fresh state.
-bin/rake db:create db:reset
-
-if [ -z "$RAILS_ENV" ] && [ -z "$RACK_ENV" ]; then
-  # Only things for a development environment will run inside here
-  # Do things that need to be done to the application to set up for the first
-  # time. Or things needed to be run to to reset the application back to first
-  # use experience. These things are scoped to the application's domain.
-fi
-
-echo "==> App is now ready to go!"

data/script/test

@@ -1,38 +0,0 @@
-#!/bin/sh
-
-# script/test: Run test suite for application. Optionally pass in a path to an
-#              individual test file to run a single test.
-
-
-set -e
-
-cd "$(dirname "$0")/.."
-
-[ -z "$DEBUG" ] || set -x
-
-export RACK_ROOT=$(cd "$(dirname $0)"/.. && pwd)
-
-if [ "$RAILS_ENV" = "test" ] || [ "$RACK_ENV" = "test" ]; then
-  # if executed and the environment is already set to `test`, then we want a
-  # clean from scratch application. This almost always means a ci environment,
-  # since we set the environment to `test` directly in `script/cibuild`.
-  script/setup
-else
-  # if the environment isn't set to `test`, set it to `test` and update the
-  # application to ensure all dependencies are met as well as any other things
-  # that need to be up to date, like db migrations. The environement not having
-  # already been set to `test` almost always means this is being called on it's
-  # own from a `development` environment.
-  export RAILS_ENV="test" RACK_ENV="test"
-
-  script/update
-fi
-
-echo "===> Running tests..."
-
-if [ -n "$1" ]; then
-  # pass arguments to test call. This is useful for calling a single test.
-  bin/rake test "$1"
-else
-  bin/rake test
-fi

data/webpackConfigLoader.js

@@ -1,71 +0,0 @@
-/**
- * TODO: THIS SHOULD BE REMOVED
- *
- * Allow defaults for the config/webpacker.yml. Thee values in this file MUST match values
- * in https://github.com/rails/webpacker/blob/master/lib/install/config/webpacker.yml
- *
- * NOTE: for HMR reloading, env.WEBPACKER_HMR value will override any config value. This env value
- * should be set to TRUE to turn this on.
- */
-
-const { join, resolve } = require('path');
-const { env } = require('process');
-const { safeLoad } = require('js-yaml');
-const { readFileSync } = require('fs');
-
-function removeOuterSlashes(string) {
-  return string.replace(/^\/*/, '').replace(/\/*$/, '');
-}
-
-function formatPublicPath(settings) {
-  if (settings.dev_server) {
-    const { host } = settings.dev_server;
-    const { port } = settings.dev_server;
-    const path = settings.public_output_path;
-    const hostWithHttp = `http://${host}:${port}`;
-
-    let formattedHost = removeOuterSlashes(hostWithHttp);
-    if (formattedHost && !/^http/i.test(formattedHost)) {
-      formattedHost = `//${formattedHost}`;
-    }
-    const formattedPath = removeOuterSlashes(path);
-    return `${formattedHost}/${formattedPath}/`;
-  }
-
-  const publicOuterPathWithoutOutsideSlashes = removeOuterSlashes(settings.public_output_path);
-  return `//${publicOuterPathWithoutOutsideSlashes}/`;
-}
-
-/**
- * @param configPath, location where webpacker.yml will be found
- * Return values are consistent with Webpacker's js helpers
- * For example, you might define:
- *   const isHMR = settings.dev_server && settings.dev_server.hmr
- * @returns {{
-     settings,
-     resolvedModules,
-     output: { path, publicPath, publicPathWithHost }
-   }}
- */
-const configLoader = (configPath) => {
-  // Some test environments might not have the NODE_ENV set, so we'll have fallbacks.
-  const configEnv = env.NODE_ENV || env.RAILS_ENV || 'development';
-  const ymlConfigPath = join(configPath, 'webpacker.yml');
-  const settings = safeLoad(readFileSync(ymlConfigPath, 'utf8'))[configEnv];
-
-  // NOTE: Rails path is hard coded to `/public`
-  const output = {
-    // Next line differs from the webpacker definition as we use the configPath to create
-    // the relative path.
-    path: resolve(configPath, '..', 'public', settings.public_output_path),
-    publicPath: `/${settings.public_output_path}/`.replace(/([^:]\/)\/+/g, '$1'),
-    publicPathWithHost: formatPublicPath(settings),
-  };
-
-  return {
-    settings,
-    output,
-  };
-};
-
-module.exports = configLoader;