jets_bb_fork 0.0.4

data/lib/jets/commands/main.rb

@@ -0,0 +1,157 @@
+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 "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 :sure, 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_clean_env do
+        system(command)
+      end
+    end
+
+    desc "routes", "Print out your application routes"
+    long_desc Help.text(:routes)
+    def routes
+      puts Jets::Router.routes_help
+    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."
+    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)
+    def generate(generator, *args)
+      Jets::Generator.invoke(generator, *args)
+    end
+
+    desc "degenerate [type] [args]", "Destroys things like scaffolds"
+    long_desc Help.text(:degenerate)
+    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,157 @@
+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
+
+      # 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_clean_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
+
+    # 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)
+
+      run("yarn add bootstrap@4.0.0-beta jquery popper.js postcss-cssnext")
+    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