webpacker-electron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6a19dff91639322ec84b6bda44ad1bd6eb3c63b46de1d772364fd11c958a9030
+  data.tar.gz: 06f7eec37a5c5681da7b83ffae1558da61cbaa6f18af70a3933913a2cf36016b
+SHA512:
+  metadata.gz: f6b23f497b1eb37f2415e4bae735aadb9538eee018bb2ea9ec45f517371d0c922fb5b56cbe9e818d1ba42161cc446467bece1293d6ada80296d607f783857000
+  data.tar.gz: 686884c0190c08bf9c780eb0a00f8e84b43de45a03102e11014fb0813c852246ceca1c0efcfa8aeb37a04ab06716e6315d12fa5ed861b5acc17d2dfae41d7962

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 hpneo
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Webpacker::Electron
+Webpacker::Electron makes it easy to reuse your webpack-based JavaScript application files within an Electron app.
+
+## Installation
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'webpacker-electron'
+```
+
+And then execute:
+```bash
+bundle
+```
+
+Or install it yourself as:
+
+```ruby
+bundle add webpacker-electron
+```
+
+Finally, run the following to install Webpacker::Electron:
+
+```bash
+bundle exec rails webpacker:install:electron
+```
+
+This command will create the following files:
+
+* `config/electron-builder.yml`: Configuration file for [`electron-builder`](https://www.electron.build/).
+* `config/webpack/electron/main/development.js`: Configuration file for Electron's main process (in development mode).
+* `config/webpack/electron/main/production.js`: Configuration file for Electron's main process (in production mode).
+* `config/webpack/electron/renderer/development.js`: Configuration file for Electron's renderer process (in development mode).
+* `config/webpack/electron/renderer/production.js`: Configuration file for Electron's renderer process (in production mode).
+* `lib/javascript/babel.js`: Babel configuration specific for Electron's main process.
+* `public/electron.html`: Template for the renderer process, for both webpack dev server and production build.
+* `src/packs/electron/main.js`: JavaScript pack for Electron's main process.
+* `src/packs/electron/renderer.js`: JavaScript pack for Electron's renderer process.
+
+It also updates the following files:
+
+* `.gitignore`: Ignores `public/dist` and `public/packs-electron`.
+* `config/webpack/environment.js`: Ignore Electron's related packs.
+
+It also installs the following packages:
+
+* `@babel/register`
+* `dotenv`
+* `dotenv-webpack`
+* `electron`
+* `electron-builder`
+* `electron-devtools-installer`
+* `electron-notarize`
+* `electron-debug`
+* `electron-log`
+* `electron-updater`
+* `concurrently`
+* `cross-env`
+
+## Usage
+Once installed, you can start your JavaScript app in Rails as an Electron app with the following command:
+
+```bash
+bundle exec rails webpacker:start:electron
+```
+
+This task will run a webpack dev server for the renderer pack. Also, it will run `rails webpacker:start:electron:main` to start the actual Electron app.
+
+### Package the Electron app
+
+To package the JavaScript application into an Electron app, run the following:
+
+```bash
+rails webpacker:package:electron
+```
+
+First, it will compile the main and renderer packs for Electron, and then it will put the resulting output in an Electron app using `electron-builder`.
+
+The app will be generated in `public/dist`.
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/install/config/electron-builder.yml

@@ -0,0 +1,52 @@
+appId: com.worktimelabs.meet
+productName: Worktime Meetings
+extends: null
+directories:
+  app: "."
+  buildResources: public/assets
+  output: public/dist/
+files:
+  - "package.json"
+  - "!node_modules"
+  - from: public/packs-electron/
+    to: "."
+    filter: "**/main.production.js"
+  - from: public/packs-electron/
+    to: "."
+    filter: "**/index.html"
+  - from: public/packs-electron/
+    to: packs-electron/
+    filter: "**/*"
+afterSign: lib/javascript/notarize.js
+asar: true
+extraMetadata:
+  main: "./main.production.js"
+mac:
+  target:
+    - dmg
+  type: distribution
+  hardenedRuntime: true
+  entitlements: assets/entitlements.mac.plist
+  entitlementsInherit: assets/entitlements.mac.plist
+  gatekeeperAssess: false
+dmg:
+  contents:
+    - x: 130
+      y: 220
+    - x: 410
+      y: 220
+      type: link
+      path: /Applications
+win:
+  target:
+    - nsis
+linux:
+  target:
+    - AppImage
+  category: Development
+# extraResources:
+#   - ./assets/**
+publish:
+  provider: github
+  owner: ableco
+  repo: worktime-meetings

data/lib/install/config/webpack/electron/main/development.js

@@ -0,0 +1,5 @@
+process.env.NODE_ENV = process.env.NODE_ENV || "development";
+
+const environment = require("../../environment");
+
+module.exports = environment.toWebpackConfig();

data/lib/install/config/webpack/electron/main/production.js

@@ -0,0 +1,30 @@
+process.env.NODE_ENV = process.env.NODE_ENV || "production";
+
+const path = require("path");
+const { config } = require("@rails/webpacker");
+const environment = require("../../environment");
+
+environment.entry.delete("application");
+
+const electronConfig = {
+  target: "electron-main",
+  entry: {
+    electron: path.resolve(
+      config.source_path,
+      config.source_entry_path,
+      "electron/main.js",
+    ),
+  },
+  output: {
+    path: path.resolve(config.outputPath, "../", "packs-electron"),
+    filename: "main.production.js",
+  },
+  node: {
+    __dirname: false,
+    __filename: false,
+  },
+};
+
+environment.config.merge(electronConfig);
+
+module.exports = environment.toWebpackConfig();

data/lib/install/config/webpack/electron/renderer/development.js

@@ -0,0 +1,70 @@
+/* eslint-disable unicorn/no-process-exit */
+process.env.NODE_ENV = process.env.NODE_ENV || "development";
+
+const port = process.env.ELECTRON_PORT || 1212;
+const publicPath = `http://localhost:${port}/`;
+
+const path = require("path");
+const { spawn } = require("child_process");
+const webpack = require("webpack");
+const DotEnvPlugin = require("dotenv-webpack");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const { config } = require("@rails/webpacker");
+const environment = require("../../environment");
+
+environment.entry.delete("application");
+
+const electronConfig = {
+  target: "electron-renderer",
+  entry: {
+    electron: path.resolve(
+      "./",
+      config.source_path,
+      config.source_entry_path,
+      "electron/renderer.js",
+    ),
+  },
+  output: {
+    publicPath,
+    path: path.resolve(config.outputPath, "../", "packs-electron"),
+    filename: "renderer.development.js",
+  },
+  node: {
+    __dirname: false,
+    __filename: false,
+  },
+  plugins: [
+    new DotEnvPlugin(),
+    new webpack.LoaderOptionsPlugin({
+      debug: true,
+    }),
+    new HtmlWebpackPlugin({
+      title: "Worktime Meetings",
+      template: path.resolve(config.outputPath, "../", "electron.html"),
+    }),
+  ],
+  devServer: {
+    port,
+    publicPath,
+    contentBase: path.resolve(config.outputPath, "../", "packs-electron"),
+    historyApiFallback: {
+      verbose: true,
+      disableDotRule: false,
+    },
+    before() {
+      console.log("Starting Main Process...");
+
+      spawn("bin/rails", ["webpacker:start:electron:main"], {
+        shell: true,
+        env: process.env,
+        stdio: "inherit",
+      })
+        .on("close", (code) => process.exit(code))
+        .on("error", (spawnError) => console.error(spawnError));
+    },
+  },
+};
+
+environment.config.merge(electronConfig);
+
+module.exports = environment.toWebpackConfig();

data/lib/install/config/webpack/electron/renderer/production.js

@@ -0,0 +1,37 @@
+process.env.NODE_ENV = process.env.NODE_ENV || "production";
+
+const path = require("path");
+const DotEnvPlugin = require("dotenv-webpack");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const { config } = require("@rails/webpacker");
+const environment = require("../../environment");
+
+environment.entry.delete("application");
+
+const electronConfig = {
+  target: "electron-renderer",
+  entry: {
+    electron: path.resolve(
+      "./",
+      config.source_path,
+      config.source_entry_path,
+      "electron/renderer.js",
+    ),
+  },
+  output: {
+    path: path.resolve(config.outputPath, "../", "packs-electron"),
+    publicPath: "/packs-electron/",
+    filename: "renderer.production.js",
+  },
+  plugins: [
+    new DotEnvPlugin(),
+    new HtmlWebpackPlugin({
+      title: "Worktime Meetings",
+      template: path.resolve(config.outputPath, "../", "electron.html"),
+    }),
+  ],
+};
+
+environment.config.merge(electronConfig);
+
+module.exports = environment.toWebpackConfig();

data/lib/install/lib/javascript/babel.js

@@ -0,0 +1,23 @@
+const path = require("path");
+
+require("@babel/register")({
+  extensions: [".es6", ".es", ".jsx", ".js", ".mjs", ".ts", ".tsx"],
+  cwd: path.join(__dirname, "../.."),
+  overrides: [
+    {
+      test: "./src/packs/electron",
+      presets: [
+        [
+          "@babel/preset-env",
+          {
+            forceAllTransforms: true,
+            useBuiltIns: "entry",
+            corejs: 3,
+            modules: "auto",
+            exclude: ["transform-typeof-symbol"],
+          },
+        ],
+      ],
+    },
+  ],
+});

data/lib/install/lib/javascript/notarize.js

@@ -0,0 +1,40 @@
+const { notarize } = require("electron-notarize");
+const YAML = require("yaml");
+const fs = require("fs");
+const { promisify } = require("util");
+
+const readFile = promisify(fs.readFile);
+
+exports.default = async function notarizeMacOS(context) {
+  const { electronPlatformName, appOutDir } = context;
+  if (electronPlatformName !== "darwin") {
+    return;
+  }
+
+  if (!process.env.CI) {
+    console.warn("Skipping notarizing step. Packaging is not running in CI");
+    return;
+  }
+
+  if (!("APPLE_ID" in process.env && "APPLE_ID_PASS" in process.env)) {
+    console.warn(
+      "Skipping notarizing step. APPLE_ID and APPLE_ID_PASS env variables must be set",
+    );
+    return;
+  }
+
+  const electronBuilderConfig = await readFile(
+    "../../config/electron-builder.yml",
+    "utf8",
+  );
+  const buildInfo = YAML.parse(electronBuilderConfig);
+
+  const appName = context.packager.appInfo.productFilename;
+
+  await notarize({
+    appBundleId: buildInfo.appId,
+    appPath: `${appOutDir}/${appName}.app`,
+    appleId: process.env.APPLE_ID,
+    appleIdPassword: process.env.APPLE_ID_PASS,
+  });
+};

data/lib/install/public/electron.html

@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Electron App</title>
+  </head>
+  <body>
+  </body>
+</html>

data/lib/install/src/packs/electron/main.js

@@ -0,0 +1,217 @@
+/* eslint-disable no-console */
+/**
+ * This module executes inside of electron's main process. You can start
+ * electron renderer process from here and communicate with the other processes
+ * through IPC.
+ */
+import "core-js/stable";
+import "regenerator-runtime/runtime";
+import path from "path";
+import { app, session, protocol, BrowserWindow, shell } from "electron";
+import { autoUpdater } from "electron-updater";
+import log from "electron-log";
+import fs from "fs";
+import { promisify } from "util";
+
+const stat = promisify(fs.stat);
+
+const FILE_NOT_FOUND = -6;
+
+const getPath = async (path_) => {
+  try {
+    const result = await stat(path_);
+
+    if (result.isFile()) {
+      return path_;
+    }
+
+    if (result.isDirectory()) {
+      return getPath(path.join(path_, "index.html"));
+    }
+  } catch (_) {}
+};
+
+function serve(baseOptions) {
+  const options = Object.assign(
+    {
+      isCorsEnabled: true,
+      scheme: "app",
+    },
+    baseOptions,
+  );
+
+  if (!options.directory) {
+    throw new Error("The `directory` option is required");
+  }
+
+  options.directory = path.resolve(app.getAppPath(), options.directory);
+
+  const handler = async (request, callback) => {
+    const indexPath = path.join(options.directory, "index.html");
+    const filePath = path.join(
+      options.directory,
+      decodeURIComponent(new URL(request.url).pathname),
+    );
+    const resolvedPath = await getPath(filePath);
+    const fileExtension = path.extname(filePath);
+
+    if (
+      resolvedPath ||
+      !fileExtension ||
+      fileExtension === ".html" ||
+      fileExtension === ".asar"
+    ) {
+      callback({
+        path: resolvedPath || indexPath,
+      });
+    } else {
+      callback({ error: FILE_NOT_FOUND });
+    }
+  };
+
+  protocol.registerSchemesAsPrivileged([
+    {
+      scheme: options.scheme,
+      privileges: {
+        standard: true,
+        secure: true,
+        allowServiceWorkers: true,
+        supportFetchAPI: true,
+        corsEnabled: options.isCorsEnabled,
+      },
+    },
+  ]);
+
+  app.on("ready", () => {
+    const protocolSession = options.partition
+      ? session.fromPartition(options.partition)
+      : session.defaultSession;
+
+    protocolSession.protocol.registerFileProtocol(options.scheme, handler);
+  });
+
+  return async (window_) => {
+    await window_.loadURL(`${options.scheme}://-`);
+  };
+}
+
+const loadURL = serve({
+  directory: ".",
+});
+
+export default class AppUpdater {
+  constructor() {
+    log.transports.file.level = "info";
+    autoUpdater.logger = log;
+    autoUpdater.checkForUpdatesAndNotify();
+  }
+}
+
+let mainWindow = null;
+
+if (process.env.NODE_ENV === "production") {
+  const sourceMapSupport = require("source-map-support");
+  sourceMapSupport.install();
+}
+
+if (
+  process.env.NODE_ENV === "development" ||
+  process.env.DEBUG_PROD === "true"
+) {
+  require("electron-debug")();
+}
+
+const installExtensions = async () => {
+  const installer = require("electron-devtools-installer");
+  const forceDownload = !!process.env.UPGRADE_EXTENSIONS;
+  const extensions = ["REACT_DEVELOPER_TOOLS"];
+
+  return installer
+    .default(
+      extensions.map((name) => installer[name]),
+      forceDownload,
+    )
+    .catch(console.log);
+};
+
+const createWindow = async () => {
+  if (
+    process.env.NODE_ENV === "development" ||
+    process.env.DEBUG_PROD === "true"
+  ) {
+    await installExtensions();
+  }
+
+  const RESOURCES_PATH = app.isPackaged
+    ? path.join(process.resourcesPath, "assets")
+    : path.join(__dirname, "../assets");
+
+  const getAssetPath = (...paths) => {
+    return path.join(RESOURCES_PATH, ...paths);
+  };
+
+  mainWindow = new BrowserWindow({
+    show: false,
+    width: 1024,
+    height: 728,
+    icon: getAssetPath("icon.png"),
+    webPreferences: {
+      nodeIntegration: true,
+      devTools: true,
+    },
+  });
+
+  if (process.env.NODE_ENV === "development") {
+    mainWindow.loadURL("http://localhost:1212");
+  } else {
+    loadURL(mainWindow);
+  }
+  // @TODO: Use 'ready-to-show' event
+  //        https://github.com/electron/electron/blob/master/docs/api/browser-window.md#using-ready-to-show-event
+  mainWindow.webContents.on("did-finish-load", () => {
+    if (!mainWindow) {
+      throw new Error('"mainWindow" is not defined');
+    }
+    if (process.env.START_MINIMIZED) {
+      mainWindow.minimize();
+    } else {
+      mainWindow.show();
+      mainWindow.focus();
+    }
+  });
+
+  mainWindow.webContents.session.clearStorageData();
+
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+
+  // Open urls in the user's browser
+  mainWindow.webContents.on("new-window", (event, url) => {
+    event.preventDefault();
+    shell.openExternal(url);
+  });
+
+  // Remove this if your app does not use auto updates
+  new AppUpdater();
+};
+
+/**
+ * Add event listeners...
+ */
+
+app.on("window-all-closed", () => {
+  // Respect the OSX convention of having the application in memory even
+  // after all windows have been closed
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.whenReady().then(createWindow).catch(console.log);
+
+app.on("activate", () => {
+  // On macOS it's common to re-create a window in the app when the
+  // dock icon is clicked and there are no other windows open.
+  if (mainWindow === null) createWindow();
+});

data/lib/install/src/packs/electron/renderer.js

@@ -0,0 +1 @@
+import "../application.js";

data/lib/install/template.rb

@@ -0,0 +1,67 @@
+require "webpacker/configuration"
+
+say "Checking for package's name and version"
+package = JSON.parse(File.read(Rails.root.join("package.json")))
+
+if package["name"].present? && package["version"].present?
+  say "Adding Electron to #{package['name']}@#{package['version']}", :blue
+else
+  say "Couldn't find a name or version for this application. Add a 'name' or 'version' in your package.json", :red
+  return
+end
+
+say "Copying Webpacker configuration files for Electron"
+
+directory "#{__dir__}/config/webpack/electron", "config/webpack/electron"
+copy_file "#{__dir__}/config/electron-builder.yml", "config/electron-builder.yml"
+copy_file "#{__dir__}/lib/javascript/babel.js", "lib/javascript/babel.js"
+copy_file "#{__dir__}/lib/javascript/notarize.js", "lib/javascript/notarize.js"
+
+say "Updating webpack environment configuration to ignore Electron packs"
+
+unless File.read(Rails.root.join("config/webpack/environment.js")).include?(".filter((key) => key.match(/^electron/))")
+  insert_into_file Rails.root.join("config/webpack/environment.js"), after: "const { environment } = require(\"@rails/webpacker\");\n" do
+    <<~JS
+
+    Object.keys(environment.entry)
+      .filter((key) => key.match(/^electron/))
+      .forEach((entry) => {
+        environment.entry.delete(entry);
+      });
+
+    JS
+  end
+end
+
+if File.exists?(Rails.root.join(".gitignore"))
+  unless File.read(Rails.root.join(".gitignore")).include?("public/packs-electron")
+    append_to_file Rails.root.join(".gitignore") do
+      <<~TEXT
+
+      # Electron
+      public/packs-electron
+      public/dist
+
+      TEXT
+    end
+  end
+end
+
+say "Creating dist directories for Electron builds"
+
+empty_directory "public/packs-electron"
+empty_directory "public/dist"
+empty_directory "public/assets/icons"
+
+say "Copying Electron packs and entry files to #{Webpacker.config.source_entry_path}"
+
+directory "#{__dir__}/src/packs/electron", "#{Webpacker.config.source_entry_path}/electron"
+copy_file "#{__dir__}/public/electron.html", "public/electron.html"
+
+say "Installing all Electron dependencies"
+
+run "yarn add --dev electron electron-builder electron-notarize electron-devtools-installer @babel/register dotenv dotenv-webpack html-webpack-plugin@4.5.1 concurrently cross-env yaml"
+run "yarn add electron-updater electron-log electron-debug"
+run "yarn run electron-builder install-app-deps"
+
+say "Webpacker now supports Electron 🎉", :green

data/lib/tasks/webpacker.rake

@@ -0,0 +1,66 @@
+bin_path = ENV["BUNDLE_BIN"] || Rails.root.join("bin")
+
+namespace :webpacker do
+  desc "Install everything needed for Electron"
+  task "install:electron": ["webpacker:check_yarn"] do |task|
+    prefix = task.name.split(/#|webpacker:install/).first
+    install_template_path = template_path("../install/template.rb")
+
+    if Rails::VERSION::MAJOR >= 5
+      Kernel.exec "#{RbConfig.ruby} #{bin_path}/rails #{prefix}app:template LOCATION=#{install_template_path}"
+    else
+      Kernel.exec "#{RbConfig.ruby} #{bin_path}/rake #{prefix}rails:template LOCATION=#{install_template_path}"
+    end
+  end
+
+  desc "Start Electron app"
+  task "start:electron": ["webpacker:verify_install", :environment] do
+    webpacker_config_path = Webpacker.config.config_path.dirname.join("webpack", "electron")
+
+    Dir.chdir(Rails.root) do
+      Kernel.exec "yarn run cross-env NODE_ENV=development webpack-dev-server --config #{webpacker_config_path.join('renderer', 'development.js')}"
+    end
+  end
+
+  desc "Start Electron main process"
+  task "start:electron:main": ["webpacker:verify_install", :environment] do
+    source_entry_path = Webpacker.config.source_entry_path.join("electron")
+
+    Dir.chdir(Rails.root) do
+      Kernel.exec "yarn run cross-env NODE_ENV=development electron -r ./lib/javascript/babel #{source_entry_path.join('main.js')}"
+    end
+  end
+
+  desc "Compile JavaScript packs using webpack for Electron"
+  task "compile:electron": ["webpacker:verify_install", :environment] do
+    webpacker_config_path = Webpacker.config.config_path.dirname.join("webpack", "electron")
+
+    compile_electron_main = "yarn run cross-env RAILS_ENV=production NODE_ENV=production webpack --config #{webpacker_config_path.join('main', 'production.js')}"
+    compile_electron_renderer = "yarn run cross-env RAILS_ENV=production NODE_ENV=production webpack --config #{webpacker_config_path.join('renderer', 'production.js')}"
+
+    Dir.chdir(Rails.root) do
+      Kernel.exec "yarn run concurrently \"#{compile_electron_main}\" \"#{compile_electron_renderer}\""
+    end
+  end
+
+  desc "Package Electron app"
+  task "package:electron": ["webpacker:verify_install", :environment] do
+    electron_builder_config_path = Rails.root.join("config", "electron-builder.yml")
+
+    if Rails::VERSION::MAJOR >= 5
+      compile_task = "#{RbConfig.ruby} #{bin_path}/rails webpacker:compile:electron"
+    else
+      compile_task = "#{RbConfig.ruby} #{bin_path}/rake webpacker:compile:electron"
+    end
+
+    Dir.chdir(Rails.root) do
+      Kernel.exec "rm -rf public/dist && #{compile_task} && yarn run electron-builder build --config #{electron_builder_config_path} --publish never"
+    end
+  end
+end
+
+private
+
+def template_path(template)
+  File.expand_path(template, __dir__).freeze
+end

data/lib/webpacker/electron.rb

@@ -0,0 +1,8 @@
+require "webpacker/electron/version"
+require "webpacker/electron/railtie"
+
+module Webpacker
+  module Electron
+    # Your code goes here...
+  end
+end

data/lib/webpacker/electron/railtie.rb

@@ -0,0 +1,12 @@
+module Webpacker
+  module Electron
+    class Railtie < ::Rails::Railtie
+      railtie_name :"webpacker-electron"
+
+      rake_tasks do
+        path = File.expand_path(__dir__)
+        Dir.glob("#{path}/../../tasks/**/*.rake").each { |f| load f }
+      end
+    end
+  end
+end

data/lib/webpacker/electron/version.rb

@@ -0,0 +1,5 @@
+module Webpacker
+  module Electron
+    VERSION = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: webpacker-electron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Able
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: webpacker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.76'
+- !ruby/object:Gem::Dependency
+  name: rubocop-able
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+description: Use webpacker configuration to build Electron apps using the same codebase.
+email:
+- engineering@able.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/install/config/electron-builder.yml
+- lib/install/config/webpack/electron/main/development.js
+- lib/install/config/webpack/electron/main/production.js
+- lib/install/config/webpack/electron/renderer/development.js
+- lib/install/config/webpack/electron/renderer/production.js
+- lib/install/lib/javascript/babel.js
+- lib/install/lib/javascript/notarize.js
+- lib/install/public/electron.html
+- lib/install/src/packs/electron/main.js
+- lib/install/src/packs/electron/renderer.js
+- lib/install/template.rb
+- lib/tasks/webpacker.rake
+- lib/webpacker/electron.rb
+- lib/webpacker/electron/railtie.rb
+- lib/webpacker/electron/version.rb
+homepage: https://github.com/ableco/webpacker-electron
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ableco/webpacker-electron
+  source_code_uri: https://github.com/ableco/webpacker-electron
+  changelog_uri: https://github.com/ableco/webpacker-electron/blob/master/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Electron integration for Webpacker.
+test_files: []