isomorfeus-installer 1.0.0.delta1 → 1.0.0.delta2

data/lib/isomorfeus/installer/templates/application_web_worker.js.erb

@@ -0,0 +1,5 @@
+import init_app from 'isomorfeus_web_worker_loader.rb';
+init_app();
+Opal.load('isomorfeus_web_worker_loader');
+
+if (module.hot) { module.hot.accept(); }

data/lib/isomorfeus/installer/templates/config_ru.erb

@@ -0,0 +1,3 @@
+require './<%= app_require %>'
+
+run <%= app_class %>.app

data/lib/isomorfeus/installer/templates/isomorfeus_loader.rb.erb

@@ -2,7 +2,16 @@ require 'opal'
 require 'opal-autoloader'
 require 'isomorfeus-redux'
 require 'isomorfeus-react'
+<% if use_transport %>
+require 'isomorfeus-transport'
+<%= transport_requires %>
+<% end %>
+<% if use_database %>require 'isomorfeus-record'<% end %>
+<% if use_policy %>require 'isomorfeus-policy'<% end %>
+<% if use_operation %>require 'isomorfeus-operation'<% end %>
+<% if use_i18n %>require 'isomorfeus-i18n'<% end %>
 
+<% if use_policy %>require_tree 'policies'<% end %>
+<% if use_database %>require_tree 'models'<% end %>
+<% if use_operation %>require_tree 'operations'<% end %>
 require_tree 'components'
-
-Isomorfeus::TopLevel.on_ready_mount(<%= app_name %>)

data/lib/isomorfeus/installer/templates/isomorfeus_web_worker_loader.rb.erb

@@ -0,0 +1,2 @@
+require 'opal'
+require 'opal-autoloader'

data/lib/isomorfeus/installer/templates/my_app.rb.erb

@@ -1,4 +1,4 @@
-class <%= app_name %> < LucidApp::Base
+class <%= app_class %> < LucidApp::Base
   render do
     # here may be a router for example:
     # DIV do

data/lib/isomorfeus/installer/templates/package.json.erb

@@ -2,20 +2,34 @@
   "name": "<%= application_name %>",
   "private": true,
   "dependencies": {
-    <%= npm_packages %>
+    "opal-webpack-loader": "^0.8.3",
     "react": "16.6",
     "react-dom": "16.6",
-    "react-hot-loader": "^4.3.11",
     "react-router": "^4.3.1",
     "react-router-dom": "^4.3.1",
     "redux": "^4.0.1"
   },
-<%= scripts %>
+  "scripts": {
+    "debug": "webpack-dev-server --config=webpack/debug.js",
+    "development": "webpack-dev-server --config=webpack/development.js",
+    "production_build": "webpack --config=webpack/production.js"
+  },
   "devDependencies": {
+    "cache-loader": "^3.0.0",
+    "chokidar": "^2.1.5",
     "compression-webpack-plugin": "^2.0.0",
-    "webpack": "^4.27.0",
-    "webpack-cli": "^3.1.1",
-    "webpack-dev-server": "^3.1.10",
+    "css-loader": "^2.1.1",
+    "extra-watch-webpack-plugin": "^1.0.3",
+    "file-loader": "^1.1.11",
+    "jsdom": "14.0.0",
+    "node-sass": "^4.12.0",
+    "puppeteer": "1.14.0",
+    "sass-loader": "^7.1.0",
+    "style-loader": "^0.23.1",
+    "terser-webpack-plugin": "^1.2.3",
+    "webpack": "^4.30.0",
+    "webpack-cli": "^3.3.0",
+    "webpack-dev-server": "^3.3.1",
     "webpack-manifest-plugin": "^2.0.4"
   }
 }

data/lib/isomorfeus/installer/templates/spec_helper.rb.erb

@@ -0,0 +1,19 @@
+ENV['NODE_PATH'] = File.join(File.expand_path('..', __dir__), 'node_modules')
+ENV['<%= project_env %>'] = 'production'
+require 'bundler/setup'
+require 'rspec'
+require 'rspec/expectations'
+require 'isomorfeus-puppetmaster'
+require_relative '../<%= app_require %>'
+
+ASSETS_COMPILED ||= `yarn run production_build`
+
+Isomorfeus::Puppetmaster.download_path = File.join(Dir.pwd, 'download_path_tmp')
+Isomorfeus::Puppetmaster.driver = :chromium
+Isomorfeus::Puppetmaster.app = <%= app_class %>
+Isomorfeus::Puppetmaster.boot_app
+
+RSpec.configure do |config|
+  config.include Isomorfeus::Puppetmaster::DSL
+end
+

data/lib/isomorfeus/installer/templates/test_spec.rb.erb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+RSpec.describe 'opal-webpack-loader compiled successfully' do
+  it 'and opal code can be executed in the browser' do
+    doc = visit('/')
+    expect(doc.evaluate_script('1 + 4')).to eq(5)
+    expect(doc.evaluate_script('typeof Opal')).to include('object')
+    result = doc.evaluate_ruby do
+      1 + 5
+    end
+    expect(result).to eq(6)
+  end
+end

data/lib/isomorfeus/installer/transport_stores/redis.rb

@@ -0,0 +1,14 @@
+module Isomorfeus
+  module Installer
+    module TransportStores
+      module Redis
+
+      end
+    end
+  end
+end
+
+Isomorfeus::Installer.add_transport_store_module('redis', {
+  gems: [ { name: 'isomorfeus-transport-store-redis', version: "~> #{Isomorfeus::Installer::VERSION}" } ],
+  installer: Isomorfeus::Installer::TransportStores::Redis
+})

data/lib/isomorfeus/installer/transports/actioncable.rb

@@ -2,10 +2,42 @@ module Isomorfeus
   module Installer
     module Transports
       module ActionCable
+        def self.install(root)
+          # data_hash = { requires: Isomorfeus::Installer.create_requires }
+          # Isomorfeus::Installer.create_file_from_template(File.join('actioncable', 'actioncable_ru.erb'), 'actioncable.ru', data_hash)
+        end
 
+        def self.config
+          'ActionCable::Server::Base.config.logger = ActiveSupport::Logger.new(STDOUT)'
+        end
+
+        def self.js_import
+          "import ActionCable from 'actioncable';"
+        end
+
+        def self.js_global
+          "global.ActionCable = ActionCable;"
+        end
+
+        def self.rack_app
+          'ActionCable.server'
+        end
+
+        def self.rack_app_mount_path
+          'websocket'
+        end
+
+        def self.requires
+          "require 'isomorfeus-transport-actioncable'"
+        end
       end
     end
   end
 end
 
-Isomorfeus::Installer.add_transport('actioncable', {})
+Isomorfeus::Installer.add_transport_module('actioncable', {
+  gems: [ { name: 'isomorfeus-transport', version: "~> #{Isomorfeus::Installer::VERSION}" },
+          { name: 'isomorfeus-transport-actioncable', version: "~> #{Isomorfeus::Installer::VERSION}" } ],
+  npms: [ { name: 'actioncable', version: '^5.2.2' } ],
+  installer: Isomorfeus::Installer::Transports::ActionCable
+})

data/lib/isomorfeus/installer.rb

@@ -1,80 +1,134 @@
 module Isomorfeus
   module Installer
-
+    VERSION = File.read(File.expand_path("../../../../ISOMORFEUS_VERSION", __dir__)).strip
     # driver support
 
-    def self.add_asset_bundler(name, props)
-      asset_bundlers[name] = props
-    end
-
     def self.add_database(name, props)
       databases[name] = props
     end
 
-    def self.add_framework(name, props)
-      frameworks[name] = props
+    def self.add_i18n_module(name, props)
+      i18ns[name] = props
+    end
+
+    def self.add_operation_module(name, props)
+      operations[name] = props
+    end
+
+    def self.add_policy_module(name, props)
+      policies[name] = props
+    end
+
+    def self.add_rack_server(name, props)
+      rack_servers[name] = props
     end
 
-    def self.add_transport(name, props)
+    def self.add_transport_module(name, props)
       transports[name] = props
     end
 
-    def self.asset_bundler
-      @asset_bundler
+    def self.add_transport_store_module(name, props)
+      transport_stores[name] = props
     end
 
-    def self.asset_bundler=(asset_b)
-      @asset_bundler = asset_b
+    class << self
+      # application options
+      attr_reader   :app_class
+      attr_reader   :app_require
+      attr_reader   :component_name
+      attr_accessor :database
+      attr_accessor :framework
+      attr_accessor :i18n
+      attr_accessor :operation
+      attr_accessor :policy
+      attr_reader   :project_env
+      attr_reader   :project_name
+      attr_accessor :rack_server
+      attr_accessor :transport
+      attr_accessor :transport_store
+
+      # installer options
+      attr_reader :options
     end
 
-    def self.asset_bundlers
-      @asset_bundlers ||= {}
+    def self.set_project_names(pro_name)
+      @project_name   = pro_name.underscore
+      @app_class      = pro_name.camelize + 'App'
+      @app_require    = pro_name.underscore + '_app'
+      @component_name = pro_name.camelize + 'Component'
+      @project_env    = pro_name.underscore.upcase + '_ENV'
     end
 
-    def self.databases
-      @databases ||= {}
+    def self.options=(options)
+      Isomorfeus::Installer::OptionsMangler.mangle_options(options)
+      puts "options: #{options}"
+      @options = options
     end
 
-    def self.frameworks
-      @frameworks ||= {}
+    def self.sorted_databases
+      databases.keys.sort
     end
 
-    def self.framework
-      @framework
+    def self.sorted_i18ns
+      i18ns.keys.sort
     end
 
-    def self.framework=(frame_w)
-      @framework = frame_w
+    def self.sorted_operations
+      operations.keys.sort
     end
 
-    def self.transports
-      @transports ||= {}
+    def self.sorted_policies
+      policies.keys.sort
     end
 
-    def self.structure=(struct)
-      @structure = struct
+    def self.sorted_rack_servers
+      rack_servers.keys.sort
     end
 
-    def self.structure
-      @structure
+    def self.sorted_transports
+      transports.keys
     end
 
-    # installer options and config
+    def self.sorted_transport_stores
+      transport_stores.keys
+    end
 
-    def self.options
-      @options
+    def self.databases
+      @databases ||= {}
     end
 
-    def self.options=(opts)
-      @options = opts
+    def self.i18ns
+      @i18ns ||= {}
     end
 
+    def self.operations
+      @operations ||= {}
+    end
+
+    def self.policies
+      @policies ||= {}
+    end
+
+    def self.rack_servers
+      @rack_servers ||= {}
+    end
+
+    def self.transports
+      @transports ||= {}
+    end
+
+    def self.transport_stores
+      @transport_stores ||= {}
+    end
+
+    # installer options and config
+
     def self.module_directories
-      %w[asset_bundlers databases frameworks transports]
+      %w[databases transports transport_stores]
     end
 
     # installer paths
-    #
+
     def self.base_path
       @base_path ||= File.realpath(File.join(File.dirname(File.realpath(__FILE__)), 'installer'))
     end
@@ -89,57 +143,45 @@ module Isomorfeus
       File.join('public', 'assets')
     end
 
-    def self.entrypoint
-      'application.js'
+    def self.entrypoint_path(entrypoint)
+      File.join(isomorfeus_path, 'imports', entrypoint)
     end
 
-    def self.entrypoint_path
-      if structure == :app_iso
-        File.join('app', 'assets', 'javascripts', entrypoint)
-      else
-        File.join('assets', 'javascripts', entrypoint)
-      end
+    def self.isomorfeus_path
+      'isomorfeus'
     end
 
-    def self.isomorfeus_path
-      if structure == :app_iso
-        File.join('app', 'isomorfeus')
-      else
-        'isomorfeus'
-      end
+    def self.stylesheet_path(stylesheet)
+      File.join(isomorfeus_path, 'styles', stylesheet)
     end
 
-    def self.stylesheets_path
-      if structure == :app_iso
-        File.join('app', 'assets', 'stylesheets')
-      else
-        File.join('assets', 'stylesheets')
-      end
+    def self.middlewares_includes
+      'extend Isomorfeus::Transport::Middlewares'
     end
 
     # install helpers
 
+    def self.generate_gem_line(gem_hash)
+      line = "gem '#{gem_hash[:name]}', '#{gem_hash[:version]}'"
+      line << ", require: false" if gem_hash.has_key?(:require) && !gem_hash[:require]
+      line << "\n"
+    end
+
     def self.create_directories
-      if structure == :app_iso
-        Dir.mkdir('config') unless Dir.exist?('config')
-        Dir.mkdir('app') unless Dir.exist?('app')
-        Dir.chdir('app')
+      create_directory(File.join(isomorfeus_path, 'imports'))
+      create_directory(File.join(isomorfeus_path, 'components'))
+      create_directory(File.join(isomorfeus_path, 'models'))
+      create_directory(File.join(isomorfeus_path, 'operations'))
+      create_directory(File.join(isomorfeus_path, 'policies'))
+      create_directory(File.join(isomorfeus_path, 'styles'))
+      create_directory('spec')
+    end
+
+    def self.create_directory(directory)
+      unless Dir.exist?(directory)
+        puts "Creating directory #{directory}."
+        FileUtils.mkdir_p(directory)
       end
-      Dir.mkdir('isomorfeus') unless Dir.exist?('isomorfeus')
-      Dir.chdir('isomorfeus')
-      Dir.mkdir('components') unless Dir.exist?('components')
-      if use_database?
-        Dir.mkdir('models') unless Dir.exist?('models')
-      end
-
-      Dir.chdir('..') if structure == :app_iso
-      Dir.chdir('..')
-
-      Dir.mkdir('public') unless Dir.exist?('public')
-      Dir.mkdir('public/assets') unless Dir.exist?('public/assets')
-      Dir.mkdir('assets') unless Dir.exist?('assets')
-      Dir.mkdir('assets/javascripts') unless Dir.exist?('assets/javascripts')
-      Dir.mkdir('assets/stylesheets') unless Dir.exist?('assets/stylesheets')
     end
 
     def self.create_file_from_template(template_path, target_file_path, data_hash)
@@ -149,86 +191,164 @@ module Isomorfeus
       File.write(target_file_path + ext, result, mode: 'w')
     end
 
-    def self.create_entrypoint
-      data_hash = {}
-      create_file_from_template(entrypoint + '.erb', entrypoint_path, data_hash)
-    end
-
-    def self.create_gemfile(framework_gems, asset_bundler_gems)
-      asset_bundler_gems_result = ''
-      asset_bundler_gems.each { |gem| asset_bundler_gems_result << "gem '#{gem[:name]}', '#{gem[:version]}'\n" } if asset_bundler_gems
-      if framework_gems == :has_gemfile
-        framework_gems_result = File.read('Gemfile')
-        File.delete('Gemfile')
-        data_hash = { asset_bundler_gems: asset_bundler_gems_result,
-                      framework_gems: framework_gems_result,
-                      skip_header: true }
-      else
-        framework_gems_result = ''
-        framework_gems.each { |gem| framework_gems_result << "gem '#{gem[:name]}', '#{gem[:version]}'\n" }
-        data_hash = { asset_bundler_gems: asset_bundler_gems_result,
-                      framework_gems: framework_gems_result }
+    def self.install_framework
+      data_hash = { app_class:                      app_class,
+                    isomorfeus_config:              create_isomorfeus_config,
+                    middlewares:                    create_middlewares,
+                    middlewares_includes:           middlewares_includes,
+                    transport_rack_app_mount_path:  transport&.rack_app_mount_path,
+                    transport_rack_app:             transport&.rack_app,
+                    transport_config:               transport&.config,
+                    use_transport:                  use_transport?,
+                    use_transport_rack_app:         use_transport_rack_app? }
+      create_file_from_template('app.rb.erb', "#{@project_name}_app.rb", data_hash)
+      data_hash = { app_require: app_require, app_class: app_class }
+      create_file_from_template('config_ru.erb', 'config.ru', data_hash)
+      data_hash = { project_env: @project_env }
+      create_file_from_template(File.join('app_loader.rb.erb'), 'app_loader.rb', data_hash)
+    end
+
+    def self.install_isomorfeus_entries
+      data_hash = { app_class:          app_class,
+                    use_database:       use_database?,
+                    use_i18n:           use_i18n?,
+                    use_operation:      use_operation?,
+                    use_policy:         use_policy?,
+                    use_transport:      use_transport?,
+                    transport_requires: use_transport? ? transport.requires : nil }
+
+      create_file_from_template('isomorfeus_loader.rb.erb', File.join(isomorfeus_path, 'isomorfeus_loader.rb'), data_hash)
+      create_file_from_template('isomorfeus_web_worker_loader.rb.erb', File.join(isomorfeus_path, 'isomorfeus_web_worker_loader.rb'), data_hash)
+    end
+
+    def self.install_js_entries
+
+      data_hash = { use_transport:    use_transport_import?,
+                    transport_import: (use_transport_import? ? transport.js_import : nil),
+                    transport_global: (use_transport_import? ? transport.js_global : nil) }
+      create_file_from_template('application.js.erb', entrypoint_path('application.js'), data_hash)
+      create_file_from_template('application_common.js.erb', entrypoint_path('application_common.js'), data_hash)
+      create_file_from_template('application_debug.js.erb', entrypoint_path('application_debug.js'), data_hash)
+      create_file_from_template('application_ssr.js.erb', entrypoint_path('application_ssr.js'), data_hash)
+      create_file_from_template('application_web_worker.js.erb', entrypoint_path('application_web_worker.js'), data_hash)
+    end
+
+    def self.install_styles
+      create_file_from_template('application.css.erb', stylesheet_path('application.css'), {})
+    end
+
+    def self.create_gemfile
+      rack_server_gems = ''
+      Isomorfeus::Installer.rack_servers[options[:rack_server]]&.fetch(:gems)&.each do |gem|
+        rack_server_gems << generate_gem_line(gem)
+      end
+      transport_gems = ''
+      Isomorfeus::Installer.transports[options[:transport]]&.fetch(:gems)&.each do |gem|
+        transport_gems << generate_gem_line(gem)
       end
+      Isomorfeus::Installer.transport_stores[options[:transport_store]]&.fetch(:gems)&.each do |gem|
+        transport_gems << generate_gem_line(gem)
+      end
+      database_gems = ''
+      Isomorfeus::Installer.databases[options[:database]]&.fetch(:gems)&.each do |gem|
+        database_gems << generate_gem_line(gem)
+      end
+      i18n_gems = ''
+      Isomorfeus::Installer.i18ns['i18n']&.fetch(:gems)&.each do |gem|
+        i18n_gems << generate_gem_line(gem)
+      end
+      operation_gems = ''
+      Isomorfeus::Installer.operations['operation']&.fetch(:gems)&.each do |gem|
+        operation_gems << generate_gem_line(gem)
+      end
+      policy_gems = ''
+      Isomorfeus::Installer.policies['policy']&.fetch(:gems)&.each do |gem|
+        policy_gems << generate_gem_line(gem)
+      end
+
+      data_hash = { database_gems:      database_gems.chop,
+                    i18n_gems:          i18n_gems.chop,
+                    operation_gems:     operation_gems.chop,
+                    policy_gems:        policy_gems.chop,
+                    rack_server_gems:   rack_server_gems.chop,
+                    transport_gems:     transport_gems.chop }
       create_file_from_template('Gemfile.erb', 'Gemfile', data_hash)
     end
 
-    def self.create_loader(app_name)
-      data_hash = { app_name: app_name }
-      iso_entry = File.join(isomorfeus_path, 'isomorfeus_loader.rb')
-      create_file_from_template('isomorfeus_loader.rb.erb', iso_entry, data_hash)
+    def self.create_component
+      data_hash = { component_name: component_name }
+      create_file_from_template('my_component.rb.erb',
+                                File.join(isomorfeus_path, 'components', component_name.underscore + '.rb'), data_hash)
+    end
+
+    def self.create_middlewares
+      "use_isomorfeus_middlewares" if options.has_key?(:transport)
+    end
+
+    def self.create_isomorfeus_config
+      '' # "Isomorfeus.env = ENV['#{project_env}']"
     end
 
     def self.create_package_json
       npms = ''
-      if options.has_key?(:asset_bundler) && asset_bundlers[options[:asset_bundler]].has_key?(:npms)
-        asset_bundlers[options[:asset_bundler]][:npms].each do |npm|
-          npms << "\"#{npm[:name]}\": \"#{npm[:version]}\",\n"
+      if use_transport? && transports[options[:transport]].has_key?(:npms)
+        transports[options[:transport]][:npms].each do |npm|
+          npms << "    \"#{npm[:name]}\": \"#{npm[:version]}\",\n"
         end
       end
-      data_hash = { application_name: options[:new],
-                    scripts: asset_bundler.respond_to?(:package_scripts) ? asset_bundler.package_scripts : '',
-                    npm_packages: npms }
+      data_hash = { application_name: app_class,
+                    npm_packages:     npms.chop }
       create_file_from_template('package.json.erb', 'package.json', data_hash)
     end
 
     def self.create_procfile
-      data_hash = { framework_start_command: framework.start_command,
-                    asset_bundler_start_command: asset_bundler.start_command }
+      data_hash = { rack_server_start_command: rack_server[:start_command] }
       create_file_from_template('Procfile.erb', 'Procfile', data_hash)
+      create_file_from_template('ProcfileDebug.erb', 'ProcfileDebug', data_hash)
     end
 
-    def self.create_component(component_name)
-      data_hash = { component_name: component_name }
-      create_file_from_template('my_component.rb.erb',File.join(isomorfeus_path, 'components', component_name.underscore + '.rb'), data_hash)
+    def self.create_spec
+      data_hash = { app_class: app_class, app_require: app_require, project_env: project_env }
+      create_file_from_template('spec_helper.rb.erb', File.join('spec', 'spec_helper.rb'), data_hash)
+      create_file_from_template('test_spec.rb.erb', File.join('spec', 'test_spec.rb'), {})
     end
 
-    def self.create_toplevel(app_name, component_name)
-      data_hash = { app_name: app_name, component_name: component_name }
-      create_file_from_template('my_app.rb.erb',File.join(isomorfeus_path, 'components', app_name.underscore + '.rb'), data_hash)
+    def self.create_toplevel
+      data_hash = { app_class: app_class, component_name: component_name }
+      create_file_from_template('my_app.rb.erb',
+                                File.join(isomorfeus_path, 'components', app_class.underscore + '.rb'), data_hash)
     end
 
-    def self.create_requires
-      "require 'bundler/setup'\nBundler.require(:default)\n"
+    def self.use_asset_bundler?
+      options.has_key?('asset_bundler')
     end
 
-    # def self.require_record?
-    #   @require_record
-    # end
-    #
-    # def self.require_operation?
-    #   @require_operation
-    # end
-    #
-    # def self.require_policy?
-    #   @require_policy
-    # end
-    #
-    # def self.require_spectre?
-    #   @require_spectre
-    # end
-
     def self.use_database?
-      options.has_key?(:database) && options[:database] != 'none'
+      options.has_key?('database')
+    end
+
+    def self.use_i18n?
+      options['i18n']
+    end
+
+    def self.use_operation?
+      options['operation']
+    end
+
+    def self.use_policy?
+      options['policy']
+    end
+
+    def self.use_transport?
+      options.has_key?('transport')
+    end
+
+    def self.use_transport_import?
+      use_transport? && transport&.respond_to?(:js_import)
+    end
+
+    def self.use_transport_rack_app?
+      transport&.respond_to?(:rack_app)
     end
   end
 end

data/readme.md

@@ -2,11 +2,8 @@
 
 Create new isomorfeus applications with ease.
 
-#### Supported Frameworks
-- Cuba
-- Rails
-- Roda
-- Sinatra
+### Community and Support
+At the [Isomorfeus Framework Project](http://isomorfeus.com) 
 
 #### Supported Isomorfeus modules
 - isomorfeus-react