jets_bb_fork 0.0.4

data/lib/jets/cfn/upload.rb

@@ -0,0 +1,139 @@
+require 'action_view'
+require 'digest'
+
+module Jets::Cfn
+  class Upload
+    include Jets::AwsServices
+    include ActionView::Helpers::NumberHelper # number_to_human_size
+
+    attr_reader :bucket_name
+    def initialize(bucket_name)
+      @bucket_name = bucket_name
+    end
+
+    def upload
+      upload_cfn_templates
+      upload_zip_files
+      upload_assets
+    end
+
+    def upload_cfn_templates
+      puts "Uploading CloudFormation templates to S3."
+      expression = "#{Jets::Naming.template_path_prefix}-*"
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        key = "jets/cfn-templates/#{File.basename(path)}"
+        obj = s3_resource.bucket(bucket_name).object(key)
+        obj.upload_file(path)
+      end
+    end
+
+    def upload_zip_files
+      puts "Uploading code zip files to S3."
+      zip_area = "#{Jets.build_root}/stage/zips"
+      Dir.glob("#{zip_area}/*").each do |file|
+        upload_zip_file(file)
+      end
+    end
+
+    def upload_zip_file(path)
+      file_size = number_to_human_size(File.size(path))
+
+      puts "Uploading #{path} (#{file_size}) to S3"
+      start_time = Time.now
+      s3_key = "jets/code/#{File.basename(path)}"
+      obj = s3_resource.bucket(bucket_name).object(s3_key)
+      obj.upload_file(path)
+      puts "Uploaded to s3://#{bucket_name}/#{s3_key}".color(:green)
+      puts "Time to upload code to s3: #{pretty_time(Time.now-start_time).color(:green)}"
+    end
+
+    def upload_assets
+      puts "Checking for modified public assets and uploading to S3."
+      start_time = Time.now
+      upload_public_assets
+      puts "Time for public assets to s3: #{pretty_time(Time.now-start_time).color(:green)}"
+    end
+
+    def upload_public_assets
+      public_folders = %w[public]
+      public_folders = add_rack_assets(public_folders)
+      public_folders.each do |folder|
+        upload_asset_folder(folder)
+      end
+    end
+
+    def add_rack_assets(public_folders)
+      return public_folders unless Jets.rack?
+      public_folders + %w[rack/public]
+    end
+
+    def upload_asset_folder(folder)
+      expression = "#{Jets.root}/#{folder}/**/*"
+      group_size = 10
+      Dir.glob(expression).each_slice(group_size) do |paths|
+        threads = []
+        paths.each do |full_path|
+          next unless File.file?(full_path)
+
+          threads << Thread.new do
+            upload_to_s3(full_path)
+          end
+        end
+        threads.each(&:join)
+      end
+    end
+
+    def upload_to_s3(full_path)
+      return if identical_on_s3?(full_path)
+
+      key = s3_key(full_path)
+      obj = s3_resource.bucket(bucket_name).object(key)
+      puts "Uploading s3://#{bucket_name}/#{key}" # uncomment to see and debug
+      obj.upload_file(full_path, acl: "public-read", cache_control: cache_control)
+    end
+
+    def s3_key(full_path)
+      relative_path = full_path.sub("#{Jets.root}/", '')
+      "jets/#{relative_path}"
+    end
+
+    def identical_on_s3?(full_path)
+      local_md5 = ::Digest::MD5.file(full_path)
+      key = s3_key(full_path)
+      begin
+        resp = s3.head_object(bucket: bucket_name, key: key)
+      rescue Aws::S3::Errors::NotFound
+        return false
+      end
+
+      remote_md5 = resp.etag.delete_prefix('"').delete_suffix('"')
+      local_md5 == remote_md5
+    end
+
+    # If cache_control is provided, then it will set the entire cache-control header.
+    # If only max_age is provided, then we'll generate a cache_control header.
+    # Using max_age is the shorter and simply way of setting the cache_control header.
+    def cache_control
+      cache_control = Jets.config.assets.cache_control
+      unless cache_control
+        max_age = Jets.config.assets.max_age # defaults to 3600 in jets/application.rb
+        cache_control = "public, max-age=#{max_age}"
+      end
+      cache_control
+    end
+
+    # http://stackoverflow.com/questions/4175733/convert-duration-to-hoursminutesseconds-or-similar-in-rails-3-or-ruby
+    def pretty_time(total_seconds)
+      minutes = (total_seconds / 60) % 60
+      seconds = total_seconds % 60
+      if total_seconds < 60
+        "#{seconds.to_i}s"
+      else
+        "#{minutes.to_i}m #{seconds.to_i}s"
+      end
+    end
+
+  end
+end

data/lib/jets/cli.rb

@@ -0,0 +1,194 @@
+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
+    # Needs to be at the beginning to avoid boot_jets which causes some load errors
+    if version_requested?
+      puts Jets.version
+      return
+    end
+
+    # Need to boot jets at this point for commands like: jets routes, deploy, console, etc to work
+    boot_jets
+    command_class = lookup(full_command)
+    if command_class
+      command_class.perform(full_command, thor_args)
+    else
+      main_help
+    end
+  end
+
+  # The commands new and help do not call Jets.boot. Main reason is that Jets.boot should be run in a Jets project.
+  #
+  #   * 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
+    set_jets_env_from_cli_arg!
+    command = thor_args.first
+    unless %w[new help].include?(command)
+      Jets::Turbo.new.charge # handles Afterburner mode
+      Jets.boot
+    end
+  end
+
+  def version_requested?
+    #   jets --version
+    #   jets -v
+    version_flags = ["--version", "-v"]
+    @given_args.length == 1 && !(@given_args & version_flags).empty?
+  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 because `bundler_require` is called as part of the bootup process. It sets the Jets.env
+  # to whatever the JETS_ENV is at the time to require the right bundler group.
+  #
+  # Defaults to development when not set.
+  def set_jets_env_from_cli_arg!
+    # Pretty tricky, we need to use the raw @given_args as thor_args eventually calls Commands::Base#eager_load!
+    # which uses Jets.env before we get a chance to override ENV['JETS_ENV']
+    command, env = @given_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
+
+  def meth
+    return nil unless full_command
+
+    if full_command.include?(':')
+      full_command.split(':').pop
+    else
+      full_command
+    end
+  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 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/base.rb

@@ -0,0 +1,146 @@
+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
+
+    # 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.camelize}"
+        class_name.constantize
+      end
+    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
+
+    # For help menu to list all commands, we must eager load the command classes.
+    #
+    # There is special eager_load logic here because this is called super early as part of the CLI start.
+    # We cannot assume we have full access to to the project yet.
+    def eager_load!
+      return if Jets::Turbo.afterburner?
+
+      Jets.application.setup_auto_load_paths # in case an app/extension is defined
+      Jets::Autoloaders.once.eager_load
+    end
+    memoize :eager_load!
+  end
+end