jets.benforeva 3.0.17.pre.mount.pre.fix

data/lib/jets/commands/import/templates/submodules-cheatsheet.md

@@ -0,0 +1,89 @@
+# Git Submodule Cheatsheet
+
+Git submodules take a little bit of getting used to. This is a cheatsheet for Git Submodules to help learn how to use them.  This file was generated as part of the `jets <%= @import_command %>` command.
+
+## Cheatsheet Summary
+
+The important submodule commands are:
+
+### On fresh clone project
+
+    git clone <%= @jets_project_repo_url %>
+    git submodule init # required on a fresh clone, or update won't do anything
+    git submodule update # syncs submodule rack folder with what parent project has as commits
+
+### Updating
+
+After doing a git pull on the Jets main project, you might notice changes to the submodule rack folder, you can update the rack folder with:
+
+    git submodule update # syncs submodule rack folder with what parent project has as commits
+
+## More Details
+
+The rest of the guide will explain in a little more detail submodules.
+
+## What are Git Submodules?
+
+Git submodules are a way to have a subfolder in your project be managed as a separate git repo.  The submodule folder is its own separate git repo and has its own history. The parent git project references a commit from the submodule project to sync up the subfolder accordingly.  Using submodules allows you to include a rack subfolder project into your Jets project code base and managed the rack project as a separate git repo.
+
+By using the `--submodule` option when you run the `jets import` command, Jets imports the rack project to the rack folder as a submodule.  This allows you to keep development of the rack project independent from the development of the Jets project. This is a useful setup if you are testing [Jets Mega Mode](http://rubyonjets.com/docs/megamode/) for more extended periods of time.
+
+We'll show you how to managed and sync the `rack` submodule folder with the parent Jets project folder.
+
+### rack submodule
+
+A rack folder was added to your Jets project as a git submodule.  Essentially this command was run.
+
+    git submodule add --force <%= @rack_repo_url %> rack
+
+The rack submodule folder gets immediately synced as a part of that `git submodule add` command.  This has already happened as part of the `jets <%= @import_command %>, we're just explaining the underlying command in case you're interested.
+
+### Fresh Clone
+
+**IMPORTANT**: On a fresh clone of your project, submodule folders do not automatically update and appear "empty".  This can be confusing for people who don't use submodules often. So here are the commands to update and sync the submodule folder:
+
+    git clone <%= @jets_project_repo_url %>
+    git submodule init # important to run init or next update will do nothing
+    git submodule update # after this the rack folder will no longer be empty
+                         # and will have code from <%= @rack_repo_url %>
+
+### Remove submodule
+
+If you ever decide to remove the submodule from your project, here are the commands.
+
+    git submodule deinit rack
+    git rm rack
+    # then add and commit your changes
+
+## Updating Projects
+
+The typical workflow is to go into the rack folder and run `git pull` to update the submodule folder to the latest changes. Then you cd back up to the main Jets project folder and run `git add`.  This updates the project submodule commit reference, which then allows others to pull down the changes and resync the submodules to the same commit. We'll go through some examples to help explain:
+
+### Updating rack folder submodule
+
+Here's an example where we will update the rack submodule folder to the latest `master` branch. Remember the master branch refers to the `rack` submodule folder of the <%= @rack_repo_url %> in this case.
+
+    cd my-jets-project # root of the Jets project
+    cd rack # in the submodule now, which contains a different repo history
+    git checkout master # on a fresh clone, the submodule folder will point to a specific git sha instead of a branch
+    git pull # get latest changes in master
+    cd .. # back to parent Jets project
+    git status # notice, it'll say: modified:  rack (new commits)
+    git add rack # updates the main projects' reference to the submodule git commit
+    git commit -m "update rack submodule"
+    git push # send your changes to everyone else
+
+Eventually, later another developer will pull down your changes on the Jets project and notice that the submodules have been updated.  When he runs a `git pull` and then does a `git status` he'll notice this:
+
+    $ git pull # another developer pulled down the changes
+    $ git st # notice the changes
+        modified:   rack (new commits)
+    $ git diff # another way a summary of the changes in the rack project
+    Submodule rack 6b0fb3a..4f6ea3f (rewind):
+      < test commit in rack submodule project
+
+This is when the developer will need to resync the rack submodule folder. He does it with this:
+
+    git submodule update # updates the rack folder to the commit that the parent is referencing
+
+That's it!

data/lib/jets/commands/import.rb

@@ -0,0 +1,12 @@
+module Jets::Commands
+  class Import < Jets::Commands::Base
+    Jets::Commands::Import::Base.cli_options.each do |args|
+      class_option(*args)
+    end
+    long_desc Help.text('import:rails')
+    register(Jets::Commands::Import::Rails, "rails", "rails", "Imports rails project in the rack subfolder")
+
+    long_desc Help.text('import:rack')
+    register(Jets::Commands::Import::Rack, "rack", "rack", "Imports rack project in the rack subfolder")
+  end
+end

data/lib/jets/commands/main.rb

@@ -0,0 +1,166 @@
+require "thor"
+
+module Jets::Commands
+  class Main < Base
+
+    class_option :noop, type: :boolean
+
+    desc "build", "Builds and packages project for AWS Lambda"
+    long_desc Help.text(:build)
+    option :templates, type: :boolean, default: false, desc: "Only build the CloudFormation templates. Skip code building"
+    def build
+      Build.new(options).run
+    end
+
+    desc "configure [TOKEN]", "configure token and updates ~/.jets/config.yml"
+    long_desc Help.text(:configure)
+    def configure(token=nil)
+      Configure.new(options.merge(token: token)).run
+    end
+
+    desc "deploy [environment]", "Builds and deploys project to AWS Lambda"
+    long_desc Help.text(:deploy)
+    # Note the environment is here to trick the Thor parser to allowing an
+    # environment parameter. It is not actually set here.  It is set earlier
+    # in cli.rb: set_jets_env_from_cli_arg!
+    def deploy(environment=nil)
+      Deploy.new(options).run
+    end
+
+    desc "delete", "Delete the Jets project and all its resources"
+    long_desc Help.text(:delete)
+    option :yes, aliases: %w[y], type: :boolean, desc: "Skip are you sure prompt."
+    option :wait, type: :boolean, default: true, desc: "Wait for stack deletion to complete."
+    # Note the environment is here to trick the Thor parser to allowing an
+    # environment parameter. It is not actually set here.  It is set earlier
+    # in cli.rb: set_jets_env_from_cli_arg!
+    def delete(environment=nil)
+      Delete.new(options).run
+    end
+
+    desc "server", "Runs a local server that mimics API Gateway for development"
+    long_desc Help.text(:server)
+    option :port, default: "8888", desc: "use PORT"
+    option :host, default: "127.0.0.1", desc: "listen on HOST"
+    def server
+      o = options
+      command = "bundle exec rackup --port #{o[:port]} --host #{o[:host]}"
+      puts "=> #{command}".color(:green)
+      puts Jets::Booter.message
+      Jets::Booter.check_config_ru!
+      Jets::RackServer.start(options) unless ENV['JETS_RACK'] == '0' # rack server runs in background by default
+      Bundler.with_unbundled_env do
+        system(command)
+      end
+    end
+
+    desc "routes", "Print out your application routes"
+    long_desc Help.text(:routes)
+    def routes
+      puts Jets::Router.help(Jets::Router.routes)
+      Jets::Router.validate_routes!
+    end
+
+    desc "console", "REPL console with Jets environment loaded"
+    long_desc Help.text(:console)
+    def console
+      Console.run
+    end
+
+    desc "runner", "Run Ruby code in the context of Jets app non-interactively"
+    long_desc Help.text(:runner)
+    def runner(code)
+      Runner.run(code)
+    end
+
+    desc "dbconsole", "Starts DB REPL console"
+    long_desc Help.text(:dbconsole)
+    def dbconsole
+      Dbconsole.start(*args)
+    end
+
+    # Command is called 'call' because invoke is a Thor keyword.
+    desc "call [function] [event]", "Call a lambda function on AWS or locally"
+    long_desc Help.text(:call)
+    option :invocation_type, default: "RequestResponse", desc: "RequestResponse, Event, or DryRun"
+    option :log_type, default: "Tail", desc: "Works if invocation_type set to RequestResponse"
+    option :qualifier, desc: "Lambda function version or alias name"
+    option :show_log, type: :boolean, desc: "Shows last 4KB of log in the x-amz-log-result header"
+    option :lambda_proxy, type: :boolean, default: true, desc: "Enables automatic Lambda proxy transformation of the event payload"
+    option :guess, type: :boolean, default: true, desc: "Enables guess mode. Uses inference to allows use of all dashes to specify functions. Guess mode verifies that the function exists in the code base."
+    option :local, type: :boolean, desc: "Enables local mode. Instead of invoke the AWS Lambda function, the method gets called locally with current app code. With local mode guess mode is always used."
+    option :retry_limit, type: :numeric, default: nil, desc: "Retry count of invoking function. It work with remote call"
+    option :read_timeout, type: :numeric, default: nil, desc: " The number of seconds to wait for response data. It work with remote call"
+    def call(function_name, payload='')
+      # Printing to stdout can mangle up the response when piping
+      # the value to jq. For example:
+      #
+      #   `jets call --local .. | jq`
+      #
+      # By redirecting stderr we can use jq safely.
+      #
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = $stderr # jets call operation
+      Call.new(function_name, payload, options).run
+    end
+
+    desc "generate [type] [args]", "Generates things like scaffolds"
+    long_desc Help.text(:generate) # do use Jets::Generator.help as it'll load Rails const
+    def generate(generator, *args)
+      Jets::Generator.invoke(generator, *args)
+    end
+
+    desc "degenerate [type] [args]", "Destroys things like scaffolds"
+    long_desc Help.text(:degenerate) # do use Jets::Generator.help as it'll load Rails const
+    def degenerate(generator, *args)
+      Jets::Generator.revoke(generator, *args)
+    end
+
+    desc "status", "Shows the current status of the Jets app"
+    long_desc Help.text(:status)
+    def status
+      Jets::Cfn::Status.new(options).run
+    end
+
+    desc "url", "App url if routes are defined"
+    long_desc Help.text(:url)
+    def url
+      Jets::Commands::Url.new(options).display
+    end
+
+    desc "secret", "Generates secret"
+    long_desc Help.text(:secret)
+    def secret
+      puts SecureRandom.hex(64)
+    end
+
+    desc "middleware", "Prints list of middleware"
+    long_desc Help.text(:middleware)
+    def middleware
+      stack = Jets.application.middlewares
+      stack.middlewares.each do |middleware|
+        puts "use #{middleware.name}"
+      end
+      puts "run #{Jets.application.endpoint}"
+    end
+
+    desc "upgrade", "Upgrade Jets"
+    long_desc Help.text(:upgrade)
+    def upgrade
+      Jets::Commands::Upgrade.new(options).run
+    end
+
+    desc "version", "Prints Jets version"
+    long_desc Help.text(:version)
+    def version
+      puts Jets.version
+    end
+
+    long_desc Help.text(:new)
+    Jets::Commands::New.cli_options.each do |args|
+      option(*args)
+    end
+    register(Jets::Commands::New, "new", "new", "Creates a starter skeleton jets project")
+  end
+end

data/lib/jets/commands/markdown/creator.rb

@@ -0,0 +1,58 @@
+module Jets::Commands::Markdown
+  class Creator
+    cattr_accessor :mute
+
+    def self.create_all
+      clean
+      new.create_all
+    end
+
+    def self.clean
+      FileUtils.rm_rf("docs/_reference")
+      FileUtils.rm_f("docs/reference.md")
+    end
+
+    def cli_classes
+      Jets::Commands::Base.namespaced_commands.map do |full_command|
+        # IE of full_command: dynamodb:generate
+        Jets::CLI.new([full_command]).lookup(full_command)
+      end.uniq
+    end
+
+    def create_all
+      create_index
+
+      cli_classes.each do |cli_class|
+        # cli_class examples:
+        #   Jets::Commands::Main
+        #   Jets::Commands::Db
+        #   Jets::Commands::Dynamodb::Migrate
+        cli_class.commands.each do |command|
+          command_name = command.first
+
+          page = Page.new(cli_class: cli_class, command_name: command_name)
+          create_page(page)
+        end
+      end
+    end
+
+    def create_page(page)
+      puts "Creating page: #{page.path}..."
+      FileUtils.mkdir_p(File.dirname(page.path))
+      IO.write(page.path, page.doc)
+    end
+
+    def create_index
+      create_include_reference
+      page = Index.new
+      FileUtils.mkdir_p(File.dirname(page.path))
+      puts "Creating index: #{page.path}"
+      IO.write(page.path, page.doc)
+    end
+
+    def create_include_reference
+      path = "docs/_includes/reference.md"
+      IO.write(path, "Generic tool description. Please edit #{path} with a description.") unless File.exist?(path)
+    end
+  end
+end

data/lib/jets/commands/markdown/index.rb

@@ -0,0 +1,27 @@
+module Jets::Commands::Markdown
+  class Index
+    def path
+      "docs/reference.md"
+    end
+
+    def command_list
+      commands = Jets::Commands::Base.namespaced_commands.sort.reject {|c| c.include?('help') }
+      commands.map do |full_command|
+        # Example: [jets deploy]({% link _reference/jets-deploy.md %})
+        link = full_command.gsub(':','-')
+        "* [jets #{full_command}]({% link _reference/jets-#{link}.md %})"
+      end.join("\n")
+    end
+
+    def doc
+      <<-EOL
+---
+title: CLI Reference
+---
+{% include reference.md %}
+
+#{command_list}
+EOL
+    end
+  end
+end

data/lib/jets/commands/markdown/page.rb

@@ -0,0 +1,125 @@
+module Jets::Commands::Markdown
+  class Page
+    attr_reader :cli_name
+    def initialize(cli_class:, command_name:)
+      @cli_class = cli_class # IE: Jets::Commands::Main
+      @command_name = command_name # IE: generate
+
+      @cli_name = "jets"
+      @command = @cli_class.commands[@command_name]
+    end
+
+    def usage
+      banner = @cli_class.send(:banner, @command) # banner is protected method
+      invoking_command = File.basename($0) # could be rspec, etc
+      banner.sub(invoking_command, cli_name)
+    end
+
+    def full_command
+      [namespace, @command_name].compact.join(':')
+    end
+
+    def namespace
+      ns = @cli_class.to_s.sub('Jets::Commands::','').underscore.gsub('/','-')
+      ns == 'main' ? nil : ns
+    end
+
+    def description
+      @command.description
+    end
+
+    def options
+      shell = Shell.new
+      @cli_class.send(:class_options_help, shell, nil => @command.options.values)
+      text = shell.stdout.string
+      return "" if text.empty? # there are no options
+
+      lines = text.split("\n")[1..-1] # remove first line wihth "Options: "
+      lines.map! do |line|
+        # remove 2 leading spaces
+        line.sub(/^  /, '')
+      end
+      lines.join("\n")
+    end
+
+    # Use command's long description as main description
+    def long_description
+      text = @command.long_description
+      return "" if text.nil? # empty description
+
+      lines = text.split("\n")
+      lines.map do |line|
+        # In the CLI help, we use 2 spaces to designate commands
+        # In Markdown we need 4 spaces.
+        line.sub(/^  \b/, '    ')
+      end.join("\n")
+    end
+
+    def path
+      full_name = [cli_name, namespace, @command_name].compact.join('-')
+      "docs/_reference/#{full_name}.md"
+    end
+
+    def doc
+      <<-EOL
+#{front_matter}
+#{usage_markdown}
+#{long_desc_markdown}
+#{options_markdown}
+EOL
+    end
+
+    def front_matter
+      command = [cli_name, full_command].compact.join(' ')
+      <<-EOL
+---
+title: #{command}
+reference: true
+---
+EOL
+    end
+
+    def usage_markdown
+      <<-EOL
+## Usage
+
+    #{usage}
+EOL
+    end
+
+    def desc_markdown
+      <<-EOL
+## Description
+
+#{description}
+EOL
+    end
+
+    # If the Thor long_description is empty then use the description.
+    def long_desc_markdown
+      return desc_markdown if long_description.empty?
+
+      <<-EOL
+## Description
+
+#{description}.
+
+#{long_description}
+EOL
+    end
+
+    # handles blank options
+    def options_markdown
+      return '' if options.empty?
+
+      <<-EOL
+## Options
+
+```
+#{options}
+```
+EOL
+    end
+
+  end
+end

data/lib/jets/commands/markdown/shell.rb

@@ -0,0 +1,11 @@
+require 'thor'
+
+module Jets::Commands::Markdown
+  # Override stdout as an @io object so we can grab the text written normally
+  # outputted to the shell.
+  class Shell < Thor::Shell::Basic
+    def stdout
+      @io ||= StringIO.new
+    end
+  end
+end

data/lib/jets/commands/new.rb

@@ -0,0 +1,173 @@
+module Jets::Commands
+  class New < Sequence
+    VALID_MODES = %w[html api job]
+    argument :project_folder
+
+    # Ugly, but when the class_option is only defined in the Thor::Group class
+    # it doesnt show up with jets new help :(
+    # If anyone knows how to fix this let me know.
+    def self.cli_options
+      [
+        [:bootstrap, type: :boolean, default: true, desc: "Install bootstrap css"], # same option in WebpackerTemplate
+        [:database, type: :string, default: 'mysql', desc: "Preconfigure database (options: mysql/postgresql)"],
+        [:force, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files."],
+        [:git, type: :boolean, default: true, desc: "Git initialize the project"],
+        [:mode, default: 'html', desc: "mode: #{VALID_MODES.join(',')}"],
+        [:repo, desc: "GitHub repo to use. Format: user/repo"],
+        [:webpacker, type: :boolean, default: true, desc: "Install webpacker"],
+      ]
+    end
+
+    cli_options.each do |args|
+      class_option(*args)
+    end
+
+    def set_initial_variables
+      @project_name = project_folder == '.' ? File.basename(Dir.pwd) : project_folder
+      @database_name = @project_name.gsub('-','_')
+
+      # options is a frozen hash by Thor so cannot modify it.
+      # Also had trouble unfreezing it with .dup. So using instance variables instead
+      case options[:mode]
+      when 'html'
+        @bootstrap = options[:bootstrap]
+        @database = options[:database]
+        @webpacker = options[:webpacker]
+      when 'api'
+        @bootstrap = false
+        @database = options[:database]
+        @webpacker = false
+      when 'job'
+        @bootstrap = false
+        @database = false
+        @webpacker = false
+      else
+        puts "Invalid mode provided: #{@options[:mode].color(:red)}. Please pass in an valid mode: #{VALID_MODES.join(',').color(:green)}."
+        exit 1
+      end
+    end
+
+    def create_project
+      options[:repo] ? clone_project : copy_project
+
+      destination_root = "#{Dir.pwd}/#{project_folder}"
+      self.destination_root = destination_root
+      FileUtils.cd("#{Dir.pwd}/#{project_folder}")
+    end
+
+    def make_bin_executable
+      return unless File.exist?("bin")
+      chmod "bin", 0755 & ~File.umask, verbose: false
+    end
+
+    def bundle_install
+      Bundler.with_unbundled_env do
+        system("BUNDLE_IGNORE_CONFIG=1 bundle install")
+      end
+    end
+
+    def webpacker_install
+      return unless @webpacker
+      unless yarn_installed?
+        puts "Yarn is not installed or has not been detected. Please double check that yarn has been installed.".color(:red)
+        puts <<~EOL
+          To check:
+
+              which yarn
+
+          If it is not installed, you can usually install it with:
+
+              npm install -g yarn
+
+          Refer to the install docs for more info: http://rubyonjets.com/docs/install/
+        EOL
+        exit 1
+      end
+
+      command = "bundle exec jets webpacker:install"
+      command += " FORCE=1" if options[:force]
+      run(command)
+    end
+
+    def update_package_json
+      path = "package.json"
+      return unless File.exist?(path)
+      data = JSON.load(IO.read(path))
+      data["private"] = true
+      IO.write(path, JSON.pretty_generate(data))
+    end
+
+    # bootstrap is dependent on webpacker, options[:bootstrap] is used
+    # in webpacker_install.
+    def bootstrap_install
+      return unless @bootstrap
+
+      # Add jquery and popper plugin to handle Delete of CRUD
+      jquery =<<-JS
+const webpack = require('webpack')
+environment.plugins.prepend('Provide', new webpack.ProvidePlugin({
+  $: 'jquery',
+  jQuery: 'jquery',
+  Popper: ['popper.js', 'default']
+}))
+JS
+      after = "const { environment } = require('@rails/webpacker')\n"
+      insert_into_file("config/webpack/environment.js", jquery, after: after)
+
+      jets_ujs =<<-JS
+import Jets from "@rubyonjets/ujs-compat"
+Jets.start()
+JS
+      after = "Rails.start()\n"
+      insert_into_file("app/javascript/packs/application.js", jets_ujs, after: after)
+
+      run("yarn add bootstrap jquery popper.js postcss-cssnext @rails/ujs @rubyonjets/ujs-compat")
+    end
+
+    def git_init
+      return if !options[:git]
+      return unless git_installed?
+      return if File.exist?(".git") # this is a clone repo
+      return unless git_credentials_set?
+
+      run("git init")
+      run("git add .")
+      run("git commit -m 'first commit'")
+    end
+
+    def user_message
+      more_info = if options[:mode] == 'job'
+        <<~EOL
+          Learn more about jobs here: http://rubyonjets.com/docs/jobs/
+
+          To deploy to AWS Lambda:
+            jets deploy
+        EOL
+      else
+        <<~EOL
+          To start a server and test locally:
+            jets server # localhost:8888 should have the Jets welcome page
+
+          Scaffold example:
+            jets generate scaffold post title:string body:text published:boolean
+            jets db:create db:migrate
+
+          To deploy to AWS Lambda, edit your .env.development.remote and add a DATABASE_URL endpoint.
+          Then run:
+
+            jets deploy
+        EOL
+      end
+
+      puts <<~EOL
+        #{"="*64}
+        Congrats 🎉 You have successfully created a Jets project.
+
+        Cd into the project directory:
+          cd #{project_folder}
+
+        #{more_info}
+      EOL
+    end
+  end
+end