neutron-ruby-electron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7b94b9dba9d64ca5279b5b46edaaa489678eb8fd
+  data.tar.gz: 15f706d8e6bd8744117795b0af8bacf34fadc4c2
+SHA512:
+  metadata.gz: 4710ac1b334f0bc28a47bf4c62a266b34016bf1a21b90e127e0a5542e1dbee4dcee2c3d14f3b48337faefc854f06ed07766fdb9c334a20fd8d094fb12ed52dc8
+  data.tar.gz: ffc603482d038a546562ad1983353b899303074947277778aec85969e8534b5517d64863d97767807eb53f0df2bdd80fcb5166984e3b38e68fa4b7e10d24abab

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/local_test/
+/tmp/
+
+/ciccio/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in neutron.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 pioz
+
+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,125 @@
+# Neutron
+
+Neutron is a mini framework to build desktop app with [Electron](https://electron.atom.io/) and [Ruby](https://www.ruby-lang.org/).
+Neutron follow the pattern `MVC` where the `V` is handled by Electron and (if you want) [ReactJS](https://facebook.github.io/react/).
+The `MC` can be handled with pure Ruby code.
+
+
+## Installation
+
+Install it yourself as:
+
+    $ gem install neutron-ruby-electron
+
+
+## Usage
+
+First of all generate a new Neutron project:
+
+    $ neutron project_name
+
+It will generate a new folder with the follow tree
+```
+.
+├── LICENSE.txt
+├── README.md
+└── src
+    ├── Gemfile
+    ├── Gemfile.lock
+    ├── assets
+    │   ├── index.html
+    │   ├── javascripts
+    │   │   ├── components
+    │   │   │   └── neutron_entry_point_component.js
+    │   │   └── neutron.js
+    │   └── stylesheets
+    ├── backend.rb
+    ├── main.rb
+    ├── main_window.js
+    ├── node_modules/
+    └── package.json
+```
+You can run the just generated app with the command:
+
+    $ cd project_name/src
+    $ ruby main.rb
+
+- The `main.rb` is the main of your app.
+- The `main_window.js` is the Electron entry point file where the [Electron app](https://electron.atom.io/docs/api/app/) and the [main browser window](https://electron.atom.io/docs/api/browser-window/) are created.
+- The `backend.rb` is a Ruby class where you can add your instance methods that can be called from the view, from your React components of your Javascript code. This class extends `Neutron::Controller` and looks like this:
+```
+class MyController < Neutron::Controller
+  def ping
+    return 'pong'
+  end
+
+  def add(a, b)
+    return(a + b)
+  end
+end
+```
+- The `neutron_entry_point_component.js` is the main component that render all your application.
+
+
+### Communication between Electron and Ruby
+
+Inside a React component you can import the Neutron module with
+
+    import neutron from 'neutron'
+
+and use neutron to call a controller method like this:
+
+    neutron.send('method_name', [params], options).then((result) => {...}).catch((error) => {...})
+
+You can call a Ruby Controller method with `neutron.send` method that return a JS promise with the return value of the method or an error.
+
+For example you can have a component like this:
+```
+import React from 'react'
+import neutron from 'neutron'
+
+export default class Sum extends React.Component {
+
+  constructor(props) {
+    super(props)
+    this.state = {}
+  }
+
+  sum() {
+    const a = parseInt(this.a.value)
+    const b = parseInt(this.b.value)
+    neutron.send('add', [a, b]).then((result) => {
+      this.setState({result: result})
+    }).catch((error) => {
+      console.log(error)
+    })
+  }
+
+  render() {
+    return(
+      <div>
+        <p>
+          <input ref={(input) => this.a = input}/>
+          +
+          <input ref={(input) => this.b = input}/>
+          = {this.state.result}
+        </p>
+        <p>
+          <button onClick={this.sum.bind(this)}>Calculate</button>
+        </p>
+      </div>
+    )
+  }
+}
+```
+In this componenet the sum is calculated by the method `add` in the Ruby controller.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pioz/neutron.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "neutron"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/neutron

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neutron/version'
+require 'neutron/generator'
+require 'optparse'
+
+def parse_args(args)
+  options = {react: true, jquery: false, bootstrap: true, development: false, debug: false}
+  opt_parser = OptionParser.new do |opts|
+    opts.banner = "Usage: neutron [options] PROJECT_NAME"
+    opts.separator ''
+    opts.separator 'Options:'
+    opts.on('-r', '--[no-]react', 'Create a project with ReactJS support') do |opt|
+      options[:react] = opt
+    end
+    opts.on('-j', '--[no-]jquery', 'Create a project with jQuery support') do |opt|
+      options[:jquery] = opt
+    end
+    opts.on('-b', '--[no-]bootstrap', 'Create a project with Twitter Bootstrap support') do |opt|
+      options[:bootstrap] = opt
+    end
+    opts.on_tail('--dev-mode', 'Development mode') do |opt|
+      options[:development] = opt
+    end
+    opts.on_tail('-d', '--[no-]debug', 'Debug mode') do |opt|
+      options[:debug] = opt
+    end
+    opts.on_tail('-v', '--version', 'Print Neutron version') do
+      puts Neutron::VERSION
+      exit
+    end
+    opts.on_tail('-h', '--help', 'Help') do
+      puts opts
+      exit
+    end
+  end
+  opt_parser.parse!(args)
+  if args.size != 1
+    puts opt_parser.help
+    exit
+  end
+  options[:path] = args.first
+  options[:name] = File.basename(options[:path])
+  return options
+end
+
+Neutron::Generator.new(parse_args(ARGV)).generate!

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/neutron/app.rb

@@ -0,0 +1,27 @@
+require 'sys/proctable'
+
+module Neutron
+
+  class App
+
+    def initialize(controller:)
+      raise 'Controller must be inherit from Neutron::Controller' unless controller.is_a?(::Neutron::Controller)
+      @controller = controller
+    end
+
+    def run
+      path = File.expand_path('..', caller[0].split(':').first)
+      begin
+        Thread.new { @controller.run }
+        `cd '#{path}' && npm run boot`
+      ensure
+        process_path = File.join(path, 'node_modules/electron-prebuilt-compile/lib/es6-init.js')
+        p = Sys::ProcTable.ps.select { |p| p.cmdline.include?(process_path) }.first
+        Process.kill('HUP', p.pid) if p
+        @controller.stop
+      end
+    end
+
+  end
+
+end

data/lib/neutron/controller.rb

@@ -0,0 +1,145 @@
+require 'socket'
+require 'json'
+
+module Neutron
+
+  Thread.abort_on_exception = true
+
+  class Controller < UNIXServer
+
+    def initialize(path = '/tmp/neutron.sock')
+      File.delete(path) if File.exists?(path)
+
+      super(path)
+      @path = path
+      @run = true
+
+      trap('INT') do
+        STDOUT.puts 'Closing socket...'
+        self.stop
+      end
+    end
+
+    def stop
+      @run = false
+      self.close
+      File.delete(@path) if File.exists?(@path)
+    end
+
+    def run
+      while @run do
+        begin
+          Thread.fork(self.accept) do |sock| # begin
+            Thread.current[:threads] = {}
+            while (data = sock.gets)
+              break if data.empty?
+              data.chop!
+              # STDOUT.puts data
+              Thread.fork(sock, data, Thread.current[:threads]) do |sock, data, threads|
+                Thread.current[:sock] = sock
+                Thread.current[:threads] = threads
+                response = dispatch(data)
+                if response
+                  send_string(sock, response.to_json + "\n")
+                end
+              end
+            end
+          end
+        rescue Errno::EBADF
+          # socket has been closed and server is waiting on socket.accept
+        end
+      end
+    end
+
+    def notify(event, result = nil)
+      if result.is_a?(Hash) && result[:error].is_a?(Hash)
+        result[:error][:code] ||= SERVER_ERROR
+        result[:error][:message] ||= 'Server error'
+        response = {jsonrpc: '2.0', error: result[:error], event: event, id: -1}
+      else
+        response = {jsonrpc: '2.0', result: result, event: event, id: -1}
+      end
+      sock = Thread.current[:sock]
+      if sock
+        send_string(sock, response.to_json + "\n")
+      end
+    end
+
+    PARSE_ERROR = -32700
+    INVALID_REQUEST = -32600
+    METHOD_NOT_FOUND = -32601
+    INTERNAL_ERROR = -32603
+    SERVER_ERROR = -32000
+
+    protected
+
+    def run_thread(&block)
+      #c = caller[0][/`.*'/][1..-2].to_sym
+      callers = caller.map{|c| c[/`.*'/][1..-2].to_sym}
+      c = callers.select{|c| Thread.current[:threads].keys.include?(c)}.first
+      sock = Thread.current[:sock]
+      Thread.current[:threads][c] << Thread.fork do
+        Thread.current[:sock] = sock
+        block.call
+      end
+    end
+
+    private
+
+    def send_string(sock, s)
+      while(s.length > 0)
+        sent = sock.send(s, 0)
+        s = s[sent..-1]
+      end
+      sock.flush
+    end
+
+    def dispatch(data)
+      begin
+        jsonrpc = JSON.parse(data)
+      rescue JSON::ParserError
+        return {jsonrpc: '2.0', error: {code: PARSE_ERROR, message: 'Parse error'}, id: nil}
+      end
+      if jsonrpc['jsonrpc'] != '2.0' || !jsonrpc['id'].is_a?(Integer) || jsonrpc['id'] < 0
+        return {jsonrpc: '2.0', error: {code: INVALID_REQUEST, message: 'Invalid request'}, id: jsonrpc['id']}
+      end
+      if !self.respond_to?(jsonrpc['method'])
+        return {jsonrpc: '2.0', error: {code: METHOD_NOT_FOUND, message: 'Method not found'}, id: jsonrpc['id']}
+      end
+
+      # begin
+      #  result = run_method(jsonrpc['method'], jsonrpc['params'], once: jsonrpc['once'])
+      # rescue Exception => e
+      #   return {jsonrpc: '2.0', error: {code: INTERNAL_ERROR, message: e.message}, id: jsonrpc['id']}
+      # end
+      result = run_method(jsonrpc['method'], jsonrpc['params'], once: jsonrpc['once'])
+
+      if result.is_a?(Hash) && result[:error].is_a?(Hash)
+        result[:error][:code] ||= SERVER_ERROR
+        result[:error][:message] ||= 'Server error'
+        return {jsonrpc: '2.0', error: result[:error], event: jsonrpc['method'], id: jsonrpc['id']}
+      else
+        r = result.is_a?(Hash) && !result[:result].nil? ? result[:result] : result
+        # Reply with a non error result
+        return {jsonrpc: '2.0', result: r, event: jsonrpc['method'], id: jsonrpc['id']}
+      end
+    end
+
+    def run_method(method, params, once: true)
+      if once
+        Thread.current[:threads][method.to_sym] ||= []
+        Thread.current[:threads][method.to_sym].each do |t|
+          t.kill if t.alive?
+          Thread.current[:threads][method.to_sym].delete(t)
+        end
+        Thread.current[:threads][method.to_sym] << Thread.current
+      end
+      if params
+        return self.__send__(method, *params)
+      else
+        return self.__send__(method)
+      end
+    end
+
+  end
+end

data/lib/neutron/generator.rb

@@ -0,0 +1,77 @@
+require 'thor'
+require 'json'
+require 'etc'
+
+
+module Neutron
+
+  TEMPLATE_PATH = File.expand_path('../template', __FILE__)
+  NEUTRON_NPM_PACKAGE_PATH = File.expand_path('../neutron_npm_package', __FILE__)
+
+  class Generator < Thor::Group
+    include Thor::Actions
+
+    def initialize(options)
+      super()
+      @options = options
+    end
+
+    def self.source_root
+      File.dirname(__FILE__)
+    end
+
+    def generate!
+      self.copy_template
+      self.generate_package_json
+    end
+
+    def copy_template
+      directory(TEMPLATE_PATH, options[:path], exclude_pattern: /components/)
+      if options[:react]
+        directory(File.join(TEMPLATE_PATH, 'src/assets/javascripts/components'), File.join(options[:path], 'src/assets/javascripts/components'))
+      end
+      inside(File.join(options[:path], 'src')) do
+        system 'bundle install'
+      end
+    end
+
+    def generate_package_json
+      say_status :generate, File.join(options[:path], 'src', 'package.json')
+      inside(File.join(options[:path], 'src')) do
+        # Init NPM
+        `npm init -y`
+        # Install local neutron npm package
+        system "npm install --save-dev #{NEUTRON_NPM_PACKAGE_PATH}"
+        # Install NPM packages
+        %w(electron electron-prebuilt-compile).each do |package|
+          system "npm install --save-dev #{package}"
+        end
+        if options[:jquery] || options[:bootstrap]
+          system "npm install --save jquery"
+        end
+        if options[:bootstrap]
+          system "npm install --save bootstrap"
+        end
+        if options[:react]
+          system "npm install --save react"
+          system "npm install --save react-dom"
+        end
+        # Edit package.json
+        username = Etc.getlogin.downcase
+        json = JSON.parse(File.read('package.json'))
+        json['name'] = options[:name]
+        json['description'] = 'Another Neutron app'
+        json['repository'] = "https://github.com/#{username}/#{options[:name]}"
+        json['author'] = username
+        json['license'] = 'MIT'
+        json['main'] = 'main_window.js'
+        json['scripts']['boot'] = './node_modules/.bin/electron .'
+        json['scripts']['buildjs'] = 'NODE_ENV=production ./node_modules/.bin/electron-compile .'
+        #json['babel'] = {'presets' => ['es2015']}
+        File.open('package.json', 'w') {|f| f << json.to_json}
+      end
+    end
+
+  end
+
+end

data/lib/neutron/neutron_npm_package/index.js

@@ -0,0 +1,128 @@
+// import Events from 'events'
+// import net from 'net'
+const Events = require('events')
+const net = require('net')
+
+
+let global_jsonrpc_id = 1
+
+
+class Neutron extends Events.EventEmitter {
+
+  constructor(path = '/tmp/neutron.sock') {
+    super()
+    this.setMaxListeners(0)
+    this.promises = {}
+    this.path = path
+    this.socket = new net.Socket()
+    this.msg = ''
+
+    this.socket.on('data', (data) => {
+      const s = data.toString()
+      this.msg += s
+      if (s[s.length-1] === "\n") {
+        const msg = this.msg.slice(0, -1)
+        this.msg = ''
+        const messages = msg.split("\n")
+        for (let i = 0; i < messages.length; i++) {
+          try {
+            const jsonrpc = JSON.parse(messages[i])
+            if (typeof(jsonrpc['id']) !== 'number') {
+              this.emit('err', {message: 'Missing id on jsonrpc reply'})
+              this.emit('all')
+            } else {
+              if (jsonrpc['error']) {
+                const error = jsonrpc['error']
+                error.toString = () => {
+                  this.message
+                }
+                if (jsonrpc['event'])
+                  this.emit(`err-${jsonrpc['event']}`, error)
+                this.emit(`err-${jsonrpc['id']}`, error)
+                this.emit('all')
+              } else {
+                if (jsonrpc['event'])
+                  this.emit(jsonrpc['event'], jsonrpc['result'])
+                this.emit(`json-${jsonrpc['id']}`, jsonrpc['result'])
+                this.emit('all')
+              }
+            }
+          } catch(error) {
+            this.emit('err', {message: 'Error to parse the response'})
+            this.emit('all')
+          }
+        }
+      }
+    })
+
+    this.socket.on('connect', () => {
+      this.emit('connect')
+      this.emit('all')
+    })
+
+    this.socket.on('end', () => {
+      this.emit('end')
+      this.emit('all')
+      this.reconnect(2000)
+    })
+
+    this.socket.on('error', (error) => {
+      this.emit('err-connection', error)
+      this.emit('err', error)
+      this.emit('all')
+      this.reconnect(2000)
+    })
+  }
+
+  connect() {
+    // remote.process.on('uncaughtException', (error) => {
+    //   this.emit('connection-error', error)
+    //   this.emit('all')
+    //   this.emit('all-errors')
+    //   this.reconnect(2000)
+    // })
+    this.socket.connect({path: this.path})
+  }
+
+  reconnect(timeout = 0) {
+    setTimeout(() => {
+      console.log('Try to reconnect to the socket ' + this.path + '...')
+      this.socket.end()
+      this.socket.connect({path: this.path})
+    }, timeout)
+  }
+
+  close() {
+    this.socket.end()
+  }
+
+  real_send(method, params, {once = true} = {}) {
+    const id = global_jsonrpc_id++
+    this.socket.write(JSON.stringify({
+      jsonrpc: '2.0',
+      method: method,
+      params: params,
+      once: once,
+      id: id
+    }) + "\n")
+    return id
+  }
+
+  send(method, params, {once = true} = {}) {
+    const id = this.real_send(method, params, {once: once})
+    return new Promise((resolve, reject) => {
+      this.on(`json-${id}`, resolve)
+      this.on(`err-${id}`, reject)
+      this.on('err', reject)
+    })
+  }
+
+}
+
+const neutron = new Neutron()
+neutron.on('connect', () => {
+  console.log('Electron connected to Ruby!')
+})
+neutron.connect()
+// export default neutron
+module.exports = neutron

data/lib/neutron/neutron_npm_package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "neutron",
+  "version": "0.1.0",
+  "description": "Mini framework to build desktop app with Electron and Ruby",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pioz/neutron.git"
+  },
+  "keywords": [
+    "ruby",
+    "electron"
+  ],
+  "author": "pioz",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pioz/neutron/issues"
+  },
+  "homepage": "https://github.com/pioz/neutron#readme"
+}

data/lib/neutron/template/LICENSE.txt.tt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <%= Time.now.year %> <%= Etc.getlogin.downcase %>
+
+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/lib/neutron/template/README.md.tt

@@ -0,0 +1,3 @@
+# <%= options[:name] %>
+
+Project README here...

data/lib/neutron/template/Rakefile.tt

@@ -0,0 +1,94 @@
+require 'bundler'
+
+PACKAGE_NAME = '<%= options[:name] %>'
+VERSION = '0.1.0'
+RUBY_V = '2.2'
+TRAVELING_RUBY_VERSION = "20150715-#{RUBY_V}.2"
+
+desc 'Package your app'
+task package: ['package:linux:x86', 'package:linux:x86_64', 'package:osx']
+
+namespace :package do
+  namespace :linux do
+    desc 'Package your app for Linux x86'
+    task :x86 => "packaging/traveling-ruby-#{TRAVELING_RUBY_VERSION}-linux-x86.tar.gz" do
+      create_package('linux-x86')
+    end
+
+    desc 'Package your app for Linux x86_64'
+    task :x86_64 => "packaging/traveling-ruby-#{TRAVELING_RUBY_VERSION}-linux-x86_64.tar.gz" do
+      create_package('linux-x86_64')
+    end
+  end
+
+  desc 'Package your app for OS X'
+  task :osx do
+    create_package('osx')
+  end
+
+end
+
+def create_package(target)
+  if RUBY_VERSION !~ /^#{RUBY_V}\./
+    abort "You can only use Ruby #{RUBY_V}, because that's what Traveling Ruby uses."
+  end
+  package_dir = "#{PACKAGE_NAME}-#{VERSION}-#{target}"
+  sh "rm -rf #{package_dir}"
+  sh "rm -rf tmp/"
+  sh "mkdir tmp"
+  sh "mkdir -p #{package_dir}/lib/ruby"
+  sh "rsync -a src #{package_dir}/lib"
+  download_runtime('osx')
+  sh "tar -xzf tmp/traveling-ruby-#{TRAVELING_RUBY_VERSION}-#{target}.tar.gz -C #{package_dir}/lib/ruby"
+  create_wrapper("#{package_dir}/#{PACKAGE_NAME}")
+  sh "chmod 755 #{package_dir}/#{PACKAGE_NAME}"
+  bundle_install
+  sh "cp -pR tmp/vendor #{package_dir}/lib/"
+  sh "cp src/Gemfile src/Gemfile.lock #{package_dir}/lib/vendor/"
+  sh "mkdir #{package_dir}/lib/vendor/.bundle"
+  sh "cp tmp/bundler-config #{package_dir}/lib/vendor/.bundle/config"
+  if !ENV['DIR_ONLY']
+    sh "tar -czf #{package_dir}.tar.gz #{package_dir}"
+    sh "rm -rf #{package_dir}"
+  end
+  sh "rm -rf tmp/"
+end
+
+def download_runtime(target)
+  sh "cd tmp && curl -L -O --fail https://d6r77u77i8pq3.cloudfront.net/releases/traveling-ruby-#{TRAVELING_RUBY_VERSION}-#{target}.tar.gz"
+end
+
+def bundle_install
+  sh "cp src/Gemfile src/Gemfile.lock tmp/"
+  Bundler.with_clean_env do
+    sh "cd tmp && env BUNDLE_IGNORE_CONFIG=1 bundle install --path vendor --without development"
+<% if options[:development] -%>
+    sh "cd tmp && env BUNDLE_IGNORE_CONFIG=1 bundle package --all"
+    sh "mv tmp/vendor/cache/neutron tmp/vendor/ruby/#{RUBY_V}.0/gems"
+<% end -%>
+  end
+  sh "rm -rf tmp/vendor/cache"
+  sh "rm -rf tmp/vendor/ruby/#{RUBY_V}.0/cache"
+  bundle_config = <<-CONFIG
+    BUNDLE_PATH: .
+    BUNDLE_WITHOUT: development
+    BUNDLE_DISABLE_SHARED_GEMS: '1'
+  CONFIG
+  File.open('tmp/bundler-config', 'w') {|f| f << bundle_config.gsub(/^\s{4}/, '') }
+end
+
+def create_wrapper(out)
+  wrapper = <<-WRAPPER
+    #!/bin/bash
+    set -e
+
+    SELFDIR="`dirname \"$0\"`"
+    SELFDIR="`cd \"$SELFDIR\" && pwd`"
+
+    export BUNDLE_GEMFILE="$SELFDIR/lib/vendor/Gemfile"
+    unset BUNDLE_IGNORE_CONFIG
+
+    exec "NODE_ENV=production $SELFDIR/lib/ruby/bin/ruby" -rbundler/setup "$SELFDIR/lib/src/main.rb"
+  WRAPPER
+  File.open(out, 'w') {|f| f << wrapper.gsub(/^\s{4}/, '') }
+end

data/lib/neutron/template/src/Gemfile.tt

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+<% if options[:development] -%>
+gem 'neutron', path: '<%= File.expand_path('..', __FILE__) %>'
+<% else -%>
+gem 'neutron'
+<% end -%>

data/lib/neutron/template/src/assets/index.html.tt

@@ -0,0 +1,27 @@
+<html>
+  <head>
+    <script src='./javascripts/neutron.js'></script>
+    <link href='./stylesheets/neutron.less' type='text/less' rel='stylesheet'>
+  </head>
+  <body>
+<% if options[:react] -%>
+    <div id='react-entry-point'></div>
+    <script>
+      ReactDOM.render(React.createElement(NeutronEntryPointComponent, null), document.getElementById('react-entry-point'))
+    </script>
+<% else -%>
+    <div>
+      <h2>Welcome to NEUTRON</h2>
+      <p>
+        <button id='b'>Try Neutron</button>
+        <script>
+          document.getElementById('b').addEventListener('click', () => {
+            for(let i = 0; i < 10; i++)
+              neutron.send('add', [0, i], {once: false}).then(result => console.log(result)).catch(e => console.log(e))
+          })
+        </script>
+      </p>
+    </div>
+<% end -%>
+  </body>
+</html>

data/lib/neutron/template/src/assets/javascripts/components/neutron_entry_point_component.js.tt

@@ -0,0 +1,22 @@
+import React from 'react'
+import neutron from 'neutron'
+
+export default class NeutronEntryPointComponent extends React.Component {
+
+  button_click() {
+    for(let i = 0; i < 10; i++)
+      neutron.send('add', [0, i], {once: false}).then(result => console.log(result)).catch(e => console.log(e))
+  }
+
+  render() {
+    return(
+      <div>
+        <h2>Welcome to NEUTRON</h2>
+        <p>
+          <button className='btn btn-default' onClick={this.button_click}>Try Neutron</button>
+        </p>
+      </div>
+    )
+  }
+
+}

data/lib/neutron/template/src/assets/javascripts/components/sum.js

@@ -0,0 +1,36 @@
+import React from 'react'
+import neutron from 'neutron'
+
+export default class Sum extends React.Component {
+
+  constructor(props) {
+    super(props)
+    this.state = {}
+  }
+
+  sum() {
+    const a = parseInt(this.a.value)
+    const b = parseInt(this.b.value)
+    neutron.send('add', [a, b]).then((result) => {
+      this.setState({result: result})
+    }).catch((error) => {
+      console.log(error)
+    })
+  }
+
+  render() {
+    return(
+      <div>
+        <p>
+          <input ref={(input) => this.a = input}/>
+          +
+          <input ref={(input) => this.b = input}/>
+          = {this.state.result}
+        </p>
+        <p>
+          <button onClick={this.sum.bind(this)}>Calculate</button>
+        </p>
+      </div>
+    )
+  }
+}

data/lib/neutron/template/src/assets/javascripts/neutron.js.tt

@@ -0,0 +1,23 @@
+<% if options[:jquery] || options[:bootstrap] -%>
+import jQuery from 'jquery'
+<% end -%>
+<% if options[:react] -%>
+import ReactDOM from 'react-dom'
+import React from 'react'
+import NeutronEntryPointComponent from './javascripts/components/neutron_entry_point_component'
+<% else -%>
+import neutron from 'neutron'
+<% end -%>
+<% if options[:jquery] || options[:bootstrap] -%>
+window.jQuery = window.$ = jQuery
+<% end -%>
+<% if options[:react] -%>
+window.ReactDOM = ReactDOM
+window.React = React
+window.NeutronEntryPointComponent = NeutronEntryPointComponent
+<% else -%>
+window.neutron = neutron
+<% end -%>
+<% if options[:bootstrap] -%>
+require('bootstrap')
+<% end -%>

data/lib/neutron/template/src/assets/stylesheets/neutron.less.tt

@@ -0,0 +1,4 @@
+<% if options[:bootstrap] -%>
+@import '../../node_modules/bootstrap/less/bootstrap.less';
+@icon-font-path: '../../node_modules/bootstrap/fonts/';
+<% end -%>

data/lib/neutron/template/src/backend.rb.tt

@@ -0,0 +1,9 @@
+require 'neutron/controller'
+
+class Backend < Neutron::Controller
+
+  def add(a, b)
+    return a + b
+  end
+
+end

data/lib/neutron/template/src/main.rb.tt

@@ -0,0 +1,11 @@
+<% if options[:development] -%>
+require 'bundler'
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', __FILE__)
+Bundler.require
+
+<% end -%>
+require 'neutron/app'
+require File.expand_path('../backend.rb', __FILE__)
+
+app = Neutron::App.new(controller: Backend.new)
+app.run

data/lib/neutron/template/src/main_window.js.tt

@@ -0,0 +1,40 @@
+import { app, BrowserWindow } from 'electron'
+import { enableLiveReload } from 'electron-compile'
+import path from 'path'
+import url from 'url'
+
+if (process.env.NODE_ENV !== 'production')
+  enableLiveReload()
+
+let win = null
+
+function createWindow() {
+  win = new BrowserWindow({title: 'Another Neutron app', width: 800, height: 600})
+  win.loadURL(url.format({
+    pathname: path.join(__dirname, 'assets/index.html'),
+    protocol: 'file:',
+    slashes: true
+  }))
+  if (process.env.NODE_ENV !== 'production')
+    win.webContents.openDevTools()
+  win.on('close', (event) => {
+    if (app.quitting)
+      win = null
+    else {
+      event.preventDefault()
+      win.hide()
+    }
+  })
+}
+
+app.on('ready', createWindow)
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('activate', () => { win.show() })
+
+app.on('before-quit', () => app.quitting = true)

data/lib/neutron/version.rb

@@ -0,0 +1,3 @@
+module Neutron
+  VERSION = "0.1.0"
+end

data/neutron.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neutron/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "neutron-ruby-electron"
+  spec.version       = Neutron::VERSION
+  spec.authors       = ["pioz"]
+  spec.email         = ["epilotto@gmx.com"]
+
+  spec.summary       = %q{Mini framework to build desktop app with Electron and Ruby}
+  spec.description   = %q{Mini framework to build desktop app with Electron and Ruby}
+  spec.homepage      = "https://github.com/pioz/neutron"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = ["neutron"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "thor", "~> 0.19"
+  spec.add_runtime_dependency "sys-proctable", "~> 1.1"
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: neutron-ruby-electron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- pioz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: sys-proctable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Mini framework to build desktop app with Electron and Ruby
+email:
+- epilotto@gmx.com
+executables:
+- neutron
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/neutron
+- bin/setup
+- lib/neutron/app.rb
+- lib/neutron/controller.rb
+- lib/neutron/generator.rb
+- lib/neutron/neutron_npm_package/index.js
+- lib/neutron/neutron_npm_package/package.json
+- lib/neutron/template/LICENSE.txt.tt
+- lib/neutron/template/README.md.tt
+- lib/neutron/template/Rakefile.tt
+- lib/neutron/template/src/Gemfile.tt
+- lib/neutron/template/src/assets/index.html.tt
+- lib/neutron/template/src/assets/javascripts/components/neutron_entry_point_component.js.tt
+- lib/neutron/template/src/assets/javascripts/components/sum.js
+- lib/neutron/template/src/assets/javascripts/neutron.js.tt
+- lib/neutron/template/src/assets/stylesheets/neutron.less.tt
+- lib/neutron/template/src/backend.rb.tt
+- lib/neutron/template/src/main.rb.tt
+- lib/neutron/template/src/main_window.js.tt
+- lib/neutron/version.rb
+- neutron.gemspec
+homepage: https://github.com/pioz/neutron
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Mini framework to build desktop app with Electron and Ruby
+test_files: []