jets-fs 1.6.10

data/lib/jets/cli.rb

@@ -0,0 +1,189 @@
+require "thor"
+
+class Jets::CLI
+  def self.start(given_args=ARGV)
+    new(given_args).start
+  end
+
+  def self.thor_tasks
+    Jets::Commands::Base.namespaced_commands
+  end
+
+  def initialize(given_args=ARGV, **config)
+    @given_args = given_args.dup
+    @config = config
+  end
+
+  def start
+    command_class = lookup(full_command)
+    if command_class
+      boot_jets
+      command_class.perform(full_command, thor_args)
+    elsif version_requested?
+      puts Jets.version
+    else
+      main_help
+    end
+  end
+
+  def version_requested?
+    #   jets --version
+    #   jets -v
+    version_flags = ["--version", "-v"]
+    @given_args.length == 1 && !(@given_args & version_flags).empty?
+  end
+
+  # The commands new and help do not call Jets.boot. Main reason is that
+  # Jets.boot are ran inside a Jets project folder.
+  #
+  # * jets new - need to generate a project outside a project folder.
+  # * jets help - don't need to be in a project folder general help.
+  #   When you are inside a project folder though, more help commands
+  #   are available and displayed.
+  #
+  def boot_jets
+    command = thor_args.first
+    if !%w[new help].include?(command)
+      set_jets_env_from_cli_arg!
+      Jets.boot
+    end
+  end
+
+  # Adjust JETS_ENV before boot_jets is called for the jets deploy
+  # command.  Must do this early in the process before Jets.boot because
+  # Jets.boot calls Jets.env as part of the bootup process in
+  # require_bundle_gems and sets the Jets.env to whatever the JETS_ENV is
+  # at the time.
+  #
+  # Defaults to development when not set.
+  def set_jets_env_from_cli_arg!
+    command, env = thor_args[0..1]
+    return unless %w[deploy delete].include?(command)
+    env = nil if env&.starts_with?('-')
+    return unless env
+    ENV['JETS_ENV'] = env ? env : 'development'
+  end
+
+  # thor_args normalized the args Array to work with our Thor command
+  # subclasses.
+  # 1. The namespace is stripe
+  # 2. Help is shifted in front if a help flag is detected
+  def thor_args
+    args = @given_args.clone
+
+    help_args = args & help_flags
+    unless help_args.empty?
+      # Allow using help flags at the end of the command to trigger help menu
+      args -= help_flags # remove "help" and help flags from args
+      args[0] = meth # first command will always be the meth now since
+        # we removed the help flags
+      args.unshift("help")
+      args.compact!
+      return args
+    end
+
+    # reassigns the command without the namespace if reached here
+    args[0] = meth
+    args.compact
+  end
+
+  ALIASES = {
+    "g"  => "generate",
+    "c"  => "console",
+    "s"  => "server",
+    "db" => "dbconsole",
+  }
+  def full_command
+    # Removes any args that starts with -, those are option args.
+    # Also remove "help" flag.
+    args = @given_args.reject {|o| o =~ /^-/ } - help_flags
+    command = args[0] # first argument should always be the command
+    command = ALIASES[command] || command
+    Jets::Commands::Base.autocomplete(command)
+  end
+
+  # 1. look up Thor tasks
+  # 2. look up Rake tasks
+  # 3. help menu with all commands when both Thor and Rake tasks are not found
+  def lookup(full_command)
+    thor_task_found = Jets::Commands::Base.namespaced_commands.include?(full_command)
+    if thor_task_found
+      return Jets::Commands::Base.klass_from_namespace(namespace)
+    end
+
+    rake_task_found = Jets::Commands::RakeCommand.namespaced_commands.include?(full_command)
+    if rake_task_found
+      return Jets::Commands::RakeCommand
+    end
+  end
+
+  # ["-h", "-?", "--help", "-D", "help"]
+  def help_flags
+    Thor::HELP_MAPPINGS + ["help"]
+  end
+
+  def namespace
+    return nil unless full_command
+
+    if full_command.include?(':')
+      words = full_command.split(':')
+      words.pop
+      words.join(':')
+    end
+  end
+
+  def meth
+    return nil unless full_command
+
+    if full_command.include?(':')
+      full_command.split(':').pop
+    else
+      full_command
+    end
+  end
+
+  def main_help
+    shell = Thor::Shell::Basic.new
+    shell.say "Commands:"
+    shell.print_table(thor_list, :indent => 2, :truncate => true)
+
+    unless rake_list.empty?
+      shell.say "\nCommands via rake:"
+      shell.print_table(rake_list, :indent => 2, :truncate => true)
+    end
+
+    shell.say "\n"
+    shell.say main_help_body
+  end
+
+  def thor_list
+    Jets::Commands::Base.help_list(show_all_tasks)
+  end
+
+  def rake_list
+    list = Jets::Commands::RakeCommand.formatted_rake_tasks(show_all_tasks)
+    list.map do |array|
+      array[0] = "jets #{array[0]}"
+      array
+    end
+  end
+
+  def show_all_tasks
+    @given_args.include?("--all") || @given_args.include?("-A")
+  end
+
+  def main_help_body
+    <<-EOL
+Add -h to any of the commands for more help.  Examples:
+
+  jets call -h
+  jets routes -h
+  jets deploy -h
+  jets status -h
+  jets dynamodb:create -h
+  jets db:create -h
+
+EOL
+  end
+
+end

data/lib/jets/commands.rb

@@ -0,0 +1,27 @@
+module Jets::Commands
+  autoload :Base, "jets/commands/base"
+  autoload :Build, "jets/commands/build"
+  autoload :Call, "jets/commands/call"
+  autoload :Clean, "jets/commands/clean"
+  autoload :Console, "jets/commands/console"
+  autoload :Db, "jets/commands/db"
+  autoload :Dbconsole, "jets/commands/dbconsole"
+  autoload :Delete, "jets/commands/delete"
+  autoload :Deploy, "jets/commands/deploy"
+  autoload :Dynamodb, "jets/commands/dynamodb"
+  autoload :Gems, 'jets/commands/gems'
+  autoload :Help, "jets/commands/help"
+  autoload :Import, "jets/commands/import"
+  autoload :Main, "jets/commands/main"
+  autoload :Markdown, "jets/commands/markdown"
+  autoload :New, "jets/commands/new"
+  autoload :Process, "jets/commands/process"
+  autoload :RakeCommand, "jets/commands/rake_command"
+  autoload :RakeTasks, 'jets/commands/rake_tasks'
+  autoload :Runner, 'jets/commands/runner'
+  autoload :Sequence, "jets/commands/sequence"
+  autoload :StackInfo, "jets/commands/stack_info"
+  autoload :Upgrade, "jets/commands/upgrade"
+  autoload :Url, "jets/commands/url"
+  autoload :WebpackerTemplate, 'jets/commands/webpacker_template'
+end

data/lib/jets/commands/base.rb

@@ -0,0 +1,164 @@
+require "thor"
+
+# Override thor's long_desc identation behavior
+# https://github.com/erikhuda/thor/issues/398
+class Thor
+  module Shell
+    class Basic
+      def print_wrapped(message, options = {})
+        message = "\n#{message}" unless message.starts_with?("\n")
+        stdout.puts message
+      end
+    end
+  end
+end
+
+class Jets::Commands::Base < Thor
+  class << self
+    extend Memoist
+
+    # thor_args is an array of commands. Examples:
+    #   ["help"]
+    #   ["dynamodb:migrate"]
+    #
+    # Same signature as RakeCommand.perform.  Not using full_command.
+    def perform(full_command, thor_args)
+      config = {} # doesnt seem like config is used
+      dispatch(nil, thor_args, nil, config)
+    end
+
+    # Hacky way to handle error for 'jets new' when no project name is passed in to avoid
+    # this error:
+    #
+    #   required arguments 'project_name' (Thor::RequiredArgumentMissingError)
+    def dispatch(command, given_args, given_opts, config)
+      if given_args.reject{|s| s =~ /^-/} == ['new'] # user forgot to pass a project name
+        given_args = ['help', 'new']
+      end
+      super
+    end
+
+    # Track all command subclasses.
+    def subclasses
+      @subclasses ||= []
+    end
+
+    def inherited(base)
+      super
+
+      if base.name
+        self.subclasses << base
+      end
+    end
+
+    # Useful for help menu when we need to have all the definitions loaded.
+    # Using constantize instead of require so we dont care about
+    # order. The eager load actually uses autoloading.
+    def eager_load!
+      base_path = File.expand_path("../../", __FILE__)
+      Dir.glob("#{base_path}/commands/**/*.rb").select do |path|
+        next if !File.file?(path) or path =~ /templates/ or path =~ %r{/markdown/}
+
+        class_name = path
+                      .sub(/\.rb$/,'')
+                      .sub(%r{.*/jets/commands}, 'jets/commands')
+                      .classify
+        class_name = special_class_map(class_name)
+        # NOTE: Weird thing where Jets::Commands::Db::Task => Thor::Command
+        # because Task is a class available to Thor I believe.
+        # puts "eager_load! loading path: #{path} class_name: #{class_name}" if ENV['JETS_DEBUG']
+        class_name.constantize # dont have to worry about order.
+      end
+    end
+    memoize :eager_load!
+
+    # Fully qualifed task names. Examples:
+    #   build
+    #   process:controller
+    #   dynamodb:migrate:down
+    def namespaced_commands
+      eager_load!
+      subclasses.map do |klass|
+        # This all_tasks is part of Thor not the lambda/dsl.rb
+        klass.all_tasks.keys.map do |task_name|
+          klass = klass.to_s.sub('Jets::Commands::','')
+          namespace = klass =~ /^Main/ ? nil : klass.underscore.gsub('/',':')
+          [namespace, task_name].compact.join(':')
+        end
+      end.flatten.sort
+    end
+
+    # Use Jets banner instead of Thor to account for namespaces in commands.
+    def banner(command, namespace = nil, subcommand = false)
+      namespace = namespace_from_class(self)
+      command_name = command.usage # set with desc when defining tht Thor class
+      namespaced_command = [namespace, command_name].compact.join(':')
+
+      "jets #{namespaced_command}"
+    end
+
+    def namespace_from_class(klass)
+      namespace = klass.to_s.sub('Jets::Commands::', '').underscore.gsub('/',':')
+      namespace unless namespace == "main"
+    end
+
+    def help_list(all=false)
+      # hack to show hidden comands when requested
+      Thor::HiddenCommand.class_eval do
+        def hidden?; false; end
+      end if all
+
+      list = []
+      eager_load!
+      subclasses.each do |klass|
+        commands = klass.printable_commands(true, false)
+        commands.reject! { |array| array[0].include?(':help') }
+        list += commands
+      end
+
+      list.sort_by! { |array| array[0] }
+    end
+
+    def klass_from_namespace(namespace)
+      if namespace.nil?
+        Jets::Commands::Main
+      else
+        class_name = namespace.gsub(':','/')
+        class_name = "Jets::Commands::#{class_name.classify}"
+        class_name = special_class_map(class_name)
+        class_name.constantize
+      end
+    end
+
+    def special_class_map(class_name)
+      map = {
+        'Jets::Commands::RakeTask' => 'Jets::Commands::RakeTasks',
+        'Jets::Commands::Gem' => 'Jets::Commands::Gems',
+      }
+      map[class_name] || class_name
+    end
+
+    # If this fails to find a match then return the original full command
+    def autocomplete(full_command)
+      return nil if full_command.nil? # jets help
+
+      eager_load!
+
+      words = full_command.split(':')
+      namespace = words[0..-2].join(':') if words.size > 1
+      command = words.last
+
+      # Thor's normalize_command_name autocompletes the command but then we need to add the namespace back
+      begin
+        thor_subclass = klass_from_namespace(namespace) # could NameError
+        command = thor_subclass.normalize_command_name(command) # could Thor::AmbiguousCommandError
+        [namespace, command].compact.join(':')
+      rescue NameError
+        full_command # return original full_command
+      rescue Thor::AmbiguousCommandError => e
+        puts "Unable to autodetect the command name. #{e.message}."
+        full_command # return original full_command
+      end
+    end
+  end
+end

data/lib/jets/commands/build.rb

@@ -0,0 +1,217 @@
+require 'digest'
+
+module Jets::Commands
+  class Build
+    include StackInfo
+
+    def initialize(options)
+      @options = options.dup
+    end
+
+    def run
+      puts "Building project for Lambda..."
+
+      return if @options[:noop]
+      # run gets called from the CLI and does not have all the stack_options yet.
+      # We compute it and change the options early here.
+      @options.merge!(stack_type: stack_type, s3_bucket: s3_bucket)
+      build
+    end
+
+    def build
+      build_code unless @options[:templates]
+      build_templates
+    end
+
+    def build_code
+      Jets::Builders::CodeBuilder.new.build unless @options[:noop]
+    end
+
+    def build_templates
+      puts "Building CloudFormation templates."
+      clean_templates
+      build_minimal_template
+      build_all_templates if full?
+    end
+
+    def full?
+      @options[:templates] || @options[:stack_type] == :full
+    end
+
+    def build_all_templates
+      # CloudFormation templates
+      # 1. Shared templates - child templates needs them
+      build_api_gateway_templates
+      # 2. Child templates - parent template needs them
+      build_app_child_templates
+      # 2. Child templates - parent template needs them
+      build_shared_resources_templates
+      # 4. Finally parent template
+      build_parent_template # must be called at the end
+    end
+
+    def build_minimal_template
+      Jets::Cfn::Builders::ParentBuilder.new(@options).build
+    end
+
+    def build_api_gateway_templates
+      Jets::Cfn::Builders::ApiGatewayBuilder.new(@options).build
+      Jets::Cfn::Builders::ApiDeploymentBuilder.new(@options).build
+    end
+
+    def build_app_child_templates
+      app_files.each do |path|
+        build_child_template(path)
+      end
+    end
+
+    def build_shared_resources_templates
+      Jets::Stack.subclasses.each do |subclass|
+        Jets::Cfn::Builders::SharedBuilder.new(subclass).build
+      end
+    end
+
+    # path: app/controllers/comments_controller.rb
+    # path: app/jobs/easy_job.rb
+    def build_child_template(path)
+      md = path.match(%r{app/(.*?)/}) # extract: controller, job or function
+      process_class = md[1].classify
+      builder_class = "Jets::Cfn::Builders::#{process_class}Builder".constantize
+
+      # Examples:
+      #   Jets::Cfn::Builders::ControllerBuilder.new(PostsController)
+      #   Jets::Cfn::Builders::JobBuilder.new(EasyJob)
+      #   Jets::Cfn::Builders::RuleBuilder.new(CheckRule)
+      #   Jets::Cfn::Builders::FunctionBuilder.new(Hello)
+      #   Jets::Cfn::Builders::FunctionBuilder.new(HelloFunction)
+      app_class = Jets::Klass.from_path(path)
+      builder = builder_class.new(app_class)
+      unless Jets.poly_only? && app_class == Jets::PreheatJob
+        builder.build
+      end
+    end
+
+    def build_parent_template
+      Jets::Cfn::Builders::ParentBuilder.new(@options).build
+    end
+
+    def clean_templates
+      FileUtils.rm_rf("#{Jets.build_root}/templates")
+    end
+
+    def app_files
+      self.class.app_files
+    end
+
+    # Crucial that the Dir.pwd is in the tmp_code because for
+    # because Jets.boot set ups autoload_paths and this is how project
+    # classes are loaded.
+    # TODO: rework code so that Dir.pwd does not have to be in tmp_code for build to work.
+    def self.app_files
+      paths = []
+      expression = "#{Jets.root}/app/**/**/*.rb"
+      Dir.glob(expression).each do |path|
+        return false unless File.file?(path)
+        next unless app_file?(path)
+
+        relative_path = path.sub("#{Jets.root}/", '')
+        # Rids of the Jets.root at beginning
+        paths << relative_path
+      end
+      paths += internal_app_files
+      paths
+    end
+
+    def shared_files
+      self.class.shared_files
+    end
+
+    def self.shared_files
+      paths = []
+      expression = "#{Jets.root}/app/**/**/*.rb"
+      Dir.glob(expression).each do |path|
+        return false unless File.file?(path)
+        next unless path.include?("app/shared/resources")
+
+        relative_path = path.sub("#{Jets.root}/", '')
+        # Rids of the Jets.root at beginning
+        paths << relative_path
+      end
+      paths
+    end
+
+    # Finds out of the app has polymorphic functions only and zero ruby functions.
+    # In this case, we can skip a lot of the ruby related building and speed up the
+    # deploy process.
+    def self.poly_only?
+      !app_has_ruby? && !shared_has_ruby?
+    end
+
+    def self.app_has_ruby?
+      has_ruby = app_files.detect do |path|
+        app_class = Jets::Klass.from_path(path)  # IE: PostsController, Jets::PublicController
+        langs = app_class.tasks.map(&:lang)
+        langs.include?(:ruby) && app_class != Jets::PreheatJob
+      end
+      !!has_ruby
+    end
+
+    def self.shared_has_ruby?
+      has_ruby = false
+      Jets::Stack.subclasses.each do |klass|
+        klass.functions.each do |fun|
+          if fun.lang == :ruby
+            has_ruby = true
+            break
+          end
+        end
+      end
+      has_ruby
+    end
+
+    # Add internal Jets controllers if they are being used
+    def self.internal_app_files
+      paths = []
+      controllers = File.expand_path("../../internal/app/controllers/jets", __FILE__)
+
+      public_catchall = Jets::Router.has_controller?("Jets::PublicController")
+      paths << "#{controllers}/public_controller.rb" if public_catchall
+
+      rack_catchall = Jets::Router.has_controller?("Jets::RackController")
+      paths << "#{controllers}/rack_controller.rb" if rack_catchall
+
+      if Jets.config.prewarm.enable
+        jobs = File.expand_path("../../internal/app/jobs/jets", __FILE__)
+        paths << "#{jobs}/preheat_job.rb"
+      end
+
+      paths
+    end
+
+    def self.app_file?(path)
+      return false unless File.extname(path) == ".rb"
+      # Do not define lamda functions for the application_controller.rb or
+      # application_job.rb
+      excludes = %w[
+        application_controller.rb
+        application_job.rb
+      ]
+      return false if excludes.detect { |p| path.include?(p) }
+
+      includes = %w[
+        app/controllers
+        app/jobs
+        app/functions
+        app/rules
+      ]
+      return true if includes.detect { |p| path.include?(p) }
+
+      false
+    end
+
+    def self.tmp_code(full_build_path=false)
+      full_build_path ? "#{Jets.build_root}/stage/code" : "stage/code"
+    end
+
+  end
+end