react_on_rails 1.2.2 → 2.0.0.beta.1

data/lib/react_on_rails/version.rb

@@ -1,3 +0,0 @@
-module ReactOnRails
-  VERSION = "1.2.2"
-end

data/rakelib/docker.rake

@@ -1,33 +0,0 @@
-namespace :docker do
-  desc "Run Rubocop linter from docker"
-  task :rubocop do
-    sh "docker-compose run lint rake lint:rubocop"
-  end
-
-  desc "Run ruby-lint linter from docker"
-  task :ruby do
-    sh "docker-compose run lint rake lint:ruby"
-  end
-
-  desc "Run scss-lint linter from docker"
-  task :scss do
-    sh "docker-compose run lint rake lint:scss"
-  end
-
-  desc "Run eslint linter from docker"
-  task :eslint do
-    sh "docker-compose run lint rake lint:eslint"
-  end
-
-  desc "Run jscs linter from docker"
-  task :jscs do
-    sh "docker-compose run lint rake lint:jscs"
-  end
-  desc "Run all linting from docker"
-  task :lint do
-    sh "docker-compose run lint rake lint"
-  end
-end
-
-desc "Runs all linters from docker. Run `rake -D docker` to see all available lint options"
-task docker: ["docker:lint"]

data/rakelib/dummy_apps.rake

@@ -1,29 +0,0 @@
-require_relative "task_helpers"
-include ReactOnRails::TaskHelpers
-
-namespace :dummy_apps do
-  task :dummy_app do
-    dummy_app_dir = File.join(gem_root, "spec/dummy")
-    bundle_install_in(dummy_app_dir)
-    dummy_app_client_dir = File.join(dummy_app_dir, "client")
-    sh_in_dir(dummy_app_client_dir, ["npm install",
-                                     "$(npm bin)/webpack --config webpack.server.js",
-                                     "$(npm bin)/webpack --config webpack.client.js"])
-  end
-
-  task :dummy_react_013_app do
-    dummy_app_dir = File.join(gem_root, "spec/dummy-react-013")
-    bundle_install_in(dummy_app_dir)
-    dummy_app_client_dir = File.join(dummy_app_dir, "client")
-    sh_in_dir(dummy_app_client_dir, ["npm install",
-                                     "$(npm bin)/webpack --config webpack.server.js",
-                                     "$(npm bin)/webpack --config webpack.client.js"])
-  end
-
-  task dummy_apps: [:dummy_app, :dummy_react_013_app] do
-    puts "Prepared all Dummy Apps"
-  end
-end
-
-desc "Prepares all dummy apps by installing dependencies"
-task dummy_apps: ["dummy_apps:dummy_apps"]

data/rakelib/example_type.rb

@@ -1,160 +0,0 @@
-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
-        @example_types ||= []
-      end
-
-      def self.namespace_name
-        "examples"
-      end
-
-      attr_reader :name, :generator_options
-
-      def initialize(name:, generator_options:)
-        @name = name
-        @generator_options = generator_options
-        self.class.all << self
-      end
-
-      def name_pretty
-        "#{@name} example app"
-      end
-
-      def server_rendering?
-        generator_options.include?("--server-rendering")
-      end
-
-      def dir
-        File.join(examples_dir, name)
-      end
-
-      def dir_exist?
-        Dir.exist?(dir)
-      end
-
-      def client_dir
-        File.join(dir, "client")
-      end
-
-      def source_package_json
-        File.join(gem_root, "lib/generators/react_on_rails/templates/base/base/client/package.json.tt")
-      end
-
-      def node_modules_dir
-        File.join(client_dir, "node_modules")
-      end
-
-      def webpack_bundles_dir
-        File.join(dir, "app", "assets", "javascripts", "generated")
-      end
-
-      def webpack_bundles
-        bundles = []
-        bundles << File.join(webpack_bundles_dir, "app-bundle.js")
-        bundles << File.join(webpack_bundles_dir, "server-bundle.js") if server_rendering?
-        bundles << File.join(webpack_bundles_dir, "vendor-bundle.js")
-      end
-
-      def gemfile
-        File.join(dir, "Gemfile")
-      end
-
-      def gemfile_lock
-        "#{gemfile}.lock"
-      end
-
-      def package_json
-        File.join(client_dir, "package.json")
-      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}'"]
-      end
-
-      # Options we pass when running `rails new` from the command-line
-      def rails_options
-        "--skip-bundle --skip-spring --skip-git --skip-test-unit --skip-active-record"
-      end
-
-      # Methods for retrieving the name of a task specific to the example type
-      %w(gen prepare clean clobber npm_install build_webpack_bundles).each do |task_type|
-        method = "#{task_type}_task_name"      # ex: `clean_task_name`
-        task_name = "#{task_type}_#{name}"     # ex: `clean_basic`
-
-        define_method(method) { "#{self.class.namespace_name}:#{task_name}" }
-        define_method("#{method}_short") { task_name }
-      end
-
-      def rspec_task_name_short
-        "example_#{name}"
-      end
-
-      def rspec_task_name
-        "run_rspec:#{rspec_task_name_short}"
-      end
-
-      def source_files
-        FileList.new(all_files_in_dir(generators_source_dir))
-      end
-
-      # Note: we need to explicitly declare a file we know is supposed to be there
-      # to indicate that the example is in need of being rebuilt in the case of its absence.
-      def generated_files
-        FileList.new(all_files_in_dir(dir)) do |fl|
-          fl.include(gemfile)                          # explicitly declared file (dependency of Gemfile.lock)
-          fl.include(package_json)                     # explicitly declared file (dependency of NPM Install)
-          fl.exclude(%r{client(/node_modules(.+)?)?$}) # leave node_modules folder
-        end
-      end
-
-      def generated_client_files
-        generated_files.exclude { |f| !f.start_with?(client_dir) }
-      end
-
-      # generated files plus explicitly included files resulting from running
-      # bundle install, npm install, and generating the webpack bundles
-      def prepared_files
-        generated_files
-          .include(webpack_bundles)
-          .include(node_modules_dir)
-          .include(gemfile_lock)
-      end
-
-      def clean_files
-        generated_files
-      end
-
-      # Assumes we are inside client folder
-      def build_webpack_bundles_shell_commands
-        webpack_command = File.join("$(npm bin)", "webpack")
-        shell_commands = []
-        shell_commands << "#{webpack_command} --config webpack.server.rails.config.js" if server_rendering?
-        shell_commands << "#{webpack_command} --config webpack.client.rails.config.js"
-      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}"
-        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,103 +0,0 @@
-# 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_relative "example_type"
-require_relative "task_helpers"
-include ReactOnRails::TaskHelpers
-
-namespace :examples do
-  # Loads data from examples_config.yml and instantiates corresponding ExampleType objects
-  examples_config_file = File.expand_path("../examples_config.yml", __FILE__)
-  examples_config = symbolize_keys(YAML.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|
-    # GENERATED FILES
-    example_type.generated_files.each do |f|
-      file f => example_type.source_files do
-        Rake::Task[example_type.gen_task_name].invoke
-      end
-    end
-
-    # GEMFILE.LOCK
-    file example_type.gemfile_lock => example_type.gemfile do
-      bundle_install_in(example_type.dir)
-    end
-
-    # WEBPACK BUNDLES
-    example_type.webpack_bundles.each do |f|
-      file f => example_type.generated_client_files do
-        Rake::Task[example_type.build_webpack_bundles_task_name].invoke
-      end
-    end
-
-    # BUILD WEBPACK BUNDLES
-    task example_type.build_webpack_bundles_task_name_short => example_type.npm_install_task_name do
-      sh_in_dir(example_type.client_dir, example_type.build_webpack_bundles_shell_commands)
-    end
-
-    # NPM INSTALL
-    task example_type.npm_install_task_name_short => example_type.package_json do
-      unless uptodate?(example_type.node_modules_dir, [example_type.source_package_json])
-        sh_in_dir(example_type.client_dir, "npm install")
-      end
-    end
-
-    # CLEAN
-    desc "Cleans #{example_type.name_pretty}"
-    task example_type.clean_task_name_short do
-      example_type.clean_files.each { |f| rm_rf(f) }
-    end
-
-    # 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.clean_task_name do
-      mkdir_p(example_type.dir)
-      sh_in_dir(examples_dir, "rails new #{example_type.name} #{example_type.rails_options}")
-      append_to_gemfile(example_type.gemfile, example_type.required_gems)
-      bundle_install_in(example_type.dir)
-      sh_in_dir(example_type.dir, example_type.generator_shell_commands)
-    end
-
-    # PREPARE
-    desc "Prepares #{example_type.name_pretty} (generates example, `npm install`s, and generates webpack bundles)"
-    multitask example_type.prepare_task_name_short => example_type.prepared_files
-  end
-
-  desc "Cleans all example apps"
-  multitask clean: ExampleType.all.map(&:clean_task_name)
-
-  desc "Clobbers (deletes) all example apps"
-  task :clobber do
-    rm_rf(examples_dir)
-  end
-
-  desc "Generates all example apps"
-  multitask gen_all: ExampleType.all.map(&:gen_task_name)
-
-  desc "Prepares all example apps"
-  multitask prepare_all: ExampleType.all.map(&:prepare_task_name)
-end
-
-desc "Prepares all example apps. Run `rake -D examples` to see all available options"
-multitask examples: ["examples:prepare_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,19 +0,0 @@
-example_type_data:
-  -
-    name: basic
-    generator_options: ""
-  -
-    name: basic-server-rendering
-    generator_options: --server-rendering
-  -
-    name: redux
-    generator_options: --redux --server-rendering
-  -
-    name: redux-server-rendering
-    generator_options: --redux --server-rendering
-  -
-    name: heroku-deployment
-    generator_options: --heroku-deployment
-  -
-    name: skip-bootstrap
-    generator_options: --skip-bootstrap

data/rakelib/lint.rake

@@ -1,37 +0,0 @@
-require_relative "task_helpers"
-include ReactOnRails::TaskHelpers
-
-namespace :lint do
-  desc "Run Rubocop as shell"
-  task :rubocop do
-    sh_in_dir(gem_root, "rubocop .")
-  end
-
-  desc "Run ruby-lint as shell"
-  task :ruby do
-    sh_in_dir(gem_root, "ruby-lint app spec lib")
-  end
-
-  desc "Run scss-lint as shell"
-  task :scss do
-    sh_in_dir(gem_root, "scss-lint spec/dummy/app/assets/stylesheets/")
-  end
-
-  desc "Run eslint as shell"
-  task :eslint do
-    sh_in_dir(gem_root, "eslint . --ext .jsx and .js")
-  end
-
-  desc "Run jscs from shell"
-  task :jscs do
-    sh_in_dir(gem_root, "jscs -e -v .")
-  end
-
-  desc "Run all eslint, jscs, rubocop linters. Skip ruby-lint and scss"
-  task lint: [:eslint, :jscs, :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/run_rspec.rake

@@ -1,65 +0,0 @@
-require "coveralls/rake/task"
-require "pathname"
-
-require_relative "task_helpers"
-require_relative "example_type"
-
-include ReactOnRails::TaskHelpers
-
-namespace :run_rspec do
-  desc "Run RSpec for top level only"
-  task :gem do
-    run_tests_in("", rspec_args: "spec/react_on_rails")
-  end
-
-  desc "Run RSpec for spec/dummy only"
-  task dummy: ["dummy_apps:dummy_app"] do
-    run_tests_in("spec/dummy", env_vars: "DRIVER=selenium_firefox")
-  end
-
-  desc "Run RSpec for spec/dummy_react_013 only"
-  task dummy_react_013: ["dummy_apps:dummy_react_013_app"] do
-    run_tests_in("spec/dummy-react-013", env_vars: "DRIVER=selenium_firefox")
-  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.prepare_task_name do
-      run_tests_in("#{File.basename(examples_dir)}/#{example_type.name}") # have to use relative path
-    end
-  end
-
-  desc "Runs Rspec for example apps only"
-  task examples: "examples:prepare_all" do
-    ExampleType.all.each { |example_type| Rake::Task[example_type.rspec_task_name].invoke }
-  end
-
-  desc "(HACK) Run RSpec on spec/empty_spec in order to have SimpleCov generate a coverage report from cache"
-  task :empty do
-    sh %(COVERAGE=true rspec spec/empty_spec.rb)
-  end
-
-  Coveralls::RakeTask.new
-
-  task run_rspec: [:gem, :dummy, :dummy_react_013, :examples, :empty, "coveralls:push"] do
-    puts "Completed all RSpec tests"
-  end
-end
-
-desc "Runs all tests. Run `rake -D run_rspec` to see all available test options"
-task run_rspec: ["run_rspec:run_rspec"]
-
-private
-
-# Runs rspec in the given directory (if string is passed, assumed to be 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 = {})
-  dir = Pathname.new(File.join(gem_root, dir)) if dir.is_a?(String)
-  command_name = options.fetch(:command_name, dir.basename)
-  rspec_args = options.fetch(:rspec_args, "")
-  env_vars = %(#{options.fetch(env_vars, '')} COVERAGE=true TEST_ENV_COMMAND_NAME="#{command_name}")
-  sh_in_dir(dir, "#{env_vars} bundle exec rspec #{rspec_args}")
-end