react_on_rails 2.0.0.beta.1 → 2.0.0.beta.2

data/lib/generators/react_on_rails/templates/ruby_linters/lib/tasks/brakeman.rake

@@ -0,0 +1,17 @@
+namespace :brakeman do
+
+  desc "Run Brakeman"
+  task :run, :output_files do |t, args|
+    require 'brakeman'
+
+    files = args[:output_files].split(' ') if args[:output_files]
+    Brakeman.run :app_path => ".", :output_files => files, :print_report => true
+  end
+
+  desc "Check your code with Brakeman"
+  task :check do
+    require 'brakeman'
+    result = Brakeman.run app_path: '.', print_report: true
+    exit Brakeman::Warnings_Found_Exit_Code unless result.filtered_warnings.empty?
+  end
+end

data/lib/generators/react_on_rails/templates/ruby_linters/lib/tasks/ci.rake

@@ -0,0 +1,33 @@
+if Rails.env.development?
+  # See tasks/linters.rake
+
+  task :bundle_audit do
+    puts Rainbow("Running security audit on gems (bundle_audit)").green
+    Rake::Task["bundle_audit"].invoke
+  end
+
+  task :security_audit do
+    puts Rainbow("Running security audit on code (brakeman)").green
+
+    sh "brakeman --exit-on-warn --quiet -A -z"
+  end
+
+  namespace :ci do
+    desc "Run all audits and tests"
+    task all: [:environment, :lint, :spec, :bundle_audit, :security_audit] do
+      begin
+        puts Rainbow("PASSED").green
+        puts ""
+      rescue Exception => e
+        puts "#{e}"
+        puts Rainbow("FAILED").red
+        puts ""
+        raise(e)
+      end
+    end
+  end
+
+  task ci: "ci:all"
+
+  task(:default).clear.enhance([:ci])
+end

data/lib/generators/react_on_rails/templates/ruby_linters/ruby-lint.yml

@@ -0,0 +1,20 @@
+presenter: syntastic
+
+directories:
+  - app
+  - config
+  - spec
+
+ignore_paths:
+  - client
+  - node_modules
+
+analysis_classes:
+  #  - argument_amount
+  - pedantics
+  - shadowing_variables
+  # Too many false positives for these
+  #  - undefined_methods
+  #  - undefined_variables
+  #  - unused_variables
+  - useless_equality_checks

data/lib/react_on_rails.rb

@@ -0,0 +1,6 @@
+require "rails"
+
+require "react_on_rails/version"
+require "react_on_rails/configuration"
+require "react_on_rails/server_rendering_pool"
+require "react_on_rails/engine"

data/lib/react_on_rails/configuration.rb

@@ -0,0 +1,60 @@
+module ReactOnRails
+  def self.configure
+    yield(configuration)
+  end
+
+  # TODO ROB
+  # parse the client/package.json and ensure that either:
+  # 1. version number matches
+  # 2. version number is a relative path (for testing)
+  # Throw error if not.
+  # Allow skipping this check in the configuration in case somebody has a wacky configuration, such
+  # as you don't know where their package.json
+
+  def self.configuration
+    @configuration ||= Configuration.new(
+      server_bundle_js_file: "app/assets/javascripts/generated/server.js",
+      prerender: false,
+      replay_console: true,
+      logging_on_server: true,
+      raise_on_prerender_error: false,
+      trace: Rails.env.development?,
+      development_mode: Rails.env.development?,
+      server_renderer_pool_size: 1,
+      server_renderer_timeout: 20)
+    # TODO ROB: do the version check
+  end
+
+  class Configuration
+    attr_accessor :server_bundle_js_file, :prerender, :replay_console,
+                  :trace, :development_mode,
+                  :logging_on_server, :server_renderer_pool_size,
+                  :server_renderer_timeout, :raise_on_prerender_error
+
+    def initialize(server_bundle_js_file: nil, prerender: nil, replay_console: nil,
+                   trace: nil, development_mode: nil,
+                   logging_on_server: nil, server_renderer_pool_size: nil,
+                   server_renderer_timeout: nil, raise_on_prerender_error: nil)
+      if File.exist?(server_bundle_js_file)
+        self.server_bundle_js_file = server_bundle_js_file
+      else
+        self.server_bundle_js_file = nil
+      end
+
+      self.prerender = prerender
+      self.replay_console = replay_console
+      self.logging_on_server = logging_on_server
+      if development_mode.nil?
+        self.development_mode = Rails.env.development?
+      else
+        self.development_mode = development_mode
+      end
+      self.trace = trace.nil? ? Rails.env.development? : trace
+      self.raise_on_prerender_error = raise_on_prerender_error
+
+      # Server rendering:
+      self.server_renderer_pool_size = self.development_mode ? 1 : server_renderer_pool_size
+      self.server_renderer_timeout = server_renderer_timeout # seconds
+    end
+  end
+end

data/lib/react_on_rails/engine.rb

@@ -0,0 +1,7 @@
+module ReactOnRails
+  class Engine < ::Rails::Engine
+    config.to_prepare do
+      ReactOnRails::ServerRenderingPool.reset_pool
+    end
+  end
+end

data/lib/react_on_rails/prerender_error.rb

@@ -0,0 +1,31 @@
+module ReactOnRails
+  class PrerenderError < RuntimeError
+    # err might be nil if JS caught the error
+    def initialize(component_name: nil, err: nil, props: nil,
+                   js_code: nil, console_messages: nil)
+      message = "ERROR in SERVER PRERENDERING\n"
+      if err
+        message << <<-MSG
+Encountered error: \"#{err}\"
+        MSG
+        backtrace = err.backtrace.join("\n")
+      else
+        backtrace = nil
+      end
+      message << <<-MSG
+when prerendering #{component_name} with props: #{props}
+js_code was:
+#{js_code}
+      MSG
+
+      if console_messages
+        message << <<-MSG
+console messages:
+#{console_messages}
+        MSG
+      end
+
+      super([message, backtrace].compact.join("\n"))
+    end
+  end
+end

data/lib/react_on_rails/server_rendering_pool.rb

@@ -0,0 +1,110 @@
+require "connection_pool"
+
+# Based on the react-rails gem.
+# None of these methods should be called directly.
+# See app/helpers/react_on_rails_helper.rb
+module ReactOnRails
+  class ServerRenderingPool
+    def self.reset_pool
+      options = { size: ReactOnRails.configuration.server_renderer_pool_size,
+                  timeout: ReactOnRails.configuration.server_renderer_pool_size }
+      @js_context_pool = ConnectionPool.new(options) { create_js_context }
+    end
+
+    def self.reset_pool_if_server_bundle_was_modified
+      return unless ReactOnRails.configuration.development_mode
+      file_mtime = File.mtime(ReactOnRails.configuration.server_bundle_js_file)
+      @server_bundle_timestamp ||= file_mtime
+      return if @server_bundle_timestamp == file_mtime
+      ReactOnRails::ServerRenderingPool.reset_pool
+      @server_bundle_timestamp = file_mtime
+    end
+
+    # js_code: JavaScript expression that returns a string.
+    # Returns a Hash:
+    #   html: string of HTML for direct insertion on the page by evaluating js_code
+    #   consoleReplayScript: script for replaying console
+    #   hasErrors: true if server rendering errors
+    # Note, js_code does not have to be based on React.
+    # js_code MUST RETURN json stringify Object
+    # Calling code will probably call 'html_safe' on return value before rendering to the view.
+    def self.server_render_js_with_console_logging(js_code)
+      trace_messsage(js_code)
+      json_string = eval_js(js_code)
+      result = JSON.parse(json_string)
+
+      if ReactOnRails.configuration.logging_on_server
+        console_script = result["consoleReplayScript"]
+        console_script_lines = console_script.split("\n")
+        console_script_lines = console_script_lines[2..-2]
+        re = /console\.log\.apply\(console, \["\[SERVER\] (?<msg>.*)"\]\);/
+        if console_script_lines
+          console_script_lines.each do |line|
+            match = re.match(line)
+            Rails.logger.info { "[react_on_rails] #{match[:msg]}" } if match
+          end
+        end
+      end
+      result
+    end
+
+    class << self
+      private
+
+      def trace_messsage(js_code)
+        return unless ENV["TRACE_REACT_ON_RAILS"].present?
+        # Set to anything to print generated code.
+        puts "Z" * 80
+        puts "react_renderer.rb: 92"
+        puts "wrote file tmp/server-generated.js"
+        File.write("tmp/server-generated.js", js_code)
+        puts "Z" * 80
+      end
+
+      def eval_js(js_code)
+        @js_context_pool.with do |js_context|
+          result = js_context.eval(js_code)
+          js_context.eval("console.history = []")
+          result
+        end
+      end
+
+      def create_js_context
+        server_js_file = ReactOnRails.configuration.server_bundle_js_file
+        if server_js_file.present? && File.exist?(server_js_file)
+          bundle_js_code = File.read(server_js_file)
+          base_js_code = <<-JS
+#{console_polyfill}
+          #{bundle_js_code};
+          JS
+          ExecJS.compile(base_js_code)
+        else
+          if server_js_file.present?
+            msg = "You specified server rendering JS file: #{server_js_file}, but it cannot be "\
+              "read. You may set the server_bundle_js_file in your configuration to be \"\" to "\
+              "avoid this warning"
+            Rails.logger.warn msg
+            puts msg
+          end
+          ExecJS.compile("")
+        end
+      end
+
+      # Reimplement console methods for replaying on the client
+      def console_polyfill
+        <<-JS
+var console = { history: [] };
+['error', 'log', 'info', 'warn'].forEach(function (level) {
+  console[level] = function () {
+    var argArray = Array.prototype.slice.call(arguments);
+    if (argArray.length > 0) {
+      argArray[0] = '[SERVER] ' + argArray[0];
+    }
+    console.history.push({level: level, arguments: argArray});
+  };
+});
+        JS
+      end
+    end
+  end
+end

data/lib/react_on_rails/version.rb

@@ -0,0 +1,3 @@
+module ReactOnRails
+  VERSION = "2.0.0.beta.2"
+end

data/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "react-on-rails",
+  "version": "2.0.0-beta.1",
+  "description": "react-on-rails JavaScript for react_on_rails Ruby gem",
+  "main": "node_package/lib/ReactOnRails.js",
+  "directories": {
+    "doc": "docs"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "babel": "^6.3.13",
+    "babel-cli": "^6.3.17",
+    "babel-core": "^6.3.17",
+    "babel-eslint": "^5.0.0-beta4",
+    "babel-loader": "^6.2.0",
+    "babel-plugin-transform-runtime": "^6.3.13",
+    "babel-preset-es2015": "^6.3.13",
+    "babel-preset-react": "^6.3.13",
+    "babel-preset-stage-0": "^6.3.13",
+    "babel-runtime": "^6.3.13",
+    "babel-tape-runner": "^2.0.0",
+    "babelify": "^7.2.0",
+    "blue-tape": "^0.1.11",
+    "eslint": "^1.10.3",
+    "eslint-config-airbnb": "^2.0.0",
+    "eslint-plugin-babel": "^3.0.0",
+    "eslint-plugin-react": "^3.11.3",
+    "jscs": "^2.6.0",
+    "react": "^0.14.3",
+    "react-dom": "^0.14.3",
+    "tap-spec": "^4.1.1",
+    "tape": "^4.4.0",
+    "webpack": "^1.12.9"
+  },
+  "peerDependencies": {
+    "react": ">= 0.14",
+    "react-dom": ">= 0.14"
+  },
+  "files": [
+    "node_package/lib"
+  ],
+  "scripts": {
+    "test": "node_package/scripts/test",
+    "clean": "node_package/scripts/clean",
+    "prepublish": "npm run build",
+    "build": "node_package/scripts/build",
+    "lint": "node_package/scripts/lint && cd spec/dummy/client && npm run lint",
+    "lint:fix": "node_package/scripts/lint-fix",
+    "check": "npm run lint && npm run test",
+    "prerelease": "npm run check && npm run clean && npm run build",
+    "release:patch": "node_package/scripts/release patch",
+    "release:minor": "node_package/scripts/release minor",
+    "release:major": "node_package/scripts/release major",
+    "dummy:install": "rake dummy_apps",
+    "dummy:spec": "rake run_rspec:dummy",
+    "local": "echo 'Be sure to run npm run dummy:install' && npm run build && cd spec/dummy && foreman start"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/shakacode/react_on_rails.git"
+  },
+  "keywords": [
+    "react",
+    "webpack",
+    "JavaScript",
+    "Ruby",
+    "on",
+    "Rails"
+  ],
+  "author": "justin.gordon@gmail.com",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/shakacode/react_on_rails/issues"
+  },
+  "homepage": "https://github.com/shakacode/react_on_rails#readme"
+}

data/rakelib/docker.rake

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,20 @@
+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_apps: [:dummy_app, :node_package] 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

@@ -0,0 +1,160 @@
+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