Class: Rage::CLI

Inherits:

Thor

• Object
• Thor
• Rage::CLI

Defined in:

lib/rage/cli.rb

Class Method Summary

• .exit_on_failure? ⇒ Boolean

Instance Method Summary

• #console ⇒ Object
• #events(*event_class_names) ⇒ Object
• #method_missing(method_name) ⇒ Object
• #middleware ⇒ Object
• #new(path = nil) ⇒ Object
• #respond_to_missing?(method_name, include_private = false) ⇒ Boolean
• #routes ⇒ Object
• #server ⇒ Object
• #tasks ⇒ Object
• #version ⇒ Object

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name) ⇒ Object

# File 'lib/rage/cli.rb', line 247

def method_missing(method_name, *, &)
  set_env({})

  if respond_to?(method_name)
    Rake::Task[method_name].invoke
  else
    suggestions = linked_rake_tasks.map(&:name)
    raise UndefinedCommandError.new(method_name.to_s, suggestions, nil)
  end
end

Class Method Details

.exit_on_failure? ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rage/cli.rb', line 64

def self.exit_on_failure?
  true
end

Instance Method Details

#console ⇒ Object

# File 'lib/rage/cli.rb', line 167

def console
  return help("console") if options.help?

  set_env(options)

  require "irb"
  environment
  patch_fiber_for_irb
  ARGV.clear
  IRB.start
end

#events(*event_class_names) ⇒ Object

# File 'lib/rage/cli.rb', line 190

def events(*event_class_names)
  return help("events") if options.help?

  environment
  Rage::Events.__eager_load_subscribers if Rage.env.development?

  event_classes = if event_class_names.any?
    event_class_names.flat_map { |name| name.split(",") }.map do |event_class_name|
      @last_event_class_name = event_class_name
      Object.const_get(event_class_name)
    end
  else
    registered_events = Rage::Events.__registered_subscribers.keys
    registered_events.reject do |event_class|
      registered_events.any? { |e| e.ancestors.include?(event_class) && e.ancestors.index(event_class) != 0 }
    end
  end

  event_classes.each { |event_class| print_event_subscribers_tree(event_class) }

rescue NameError
  if @last_event_class_name
    spell_checker = DidYouMean::SpellChecker.new(dictionary: Rage::Events.__registered_subscribers.keys)
    suggestion = DidYouMean.formatter.message_for(spell_checker.correct(@last_event_class_name))
    puts "Could not find the `#{@last_event_class_name}` event. #{suggestion}"
  else
    raise
  end
end

#middleware ⇒ Object

# File 'lib/rage/cli.rb', line 180

def middleware
  environment

  Rage.config.middleware.middlewares.each do |middleware|
    say "use #{middleware.first.name}"
  end
end

#new(path = nil) ⇒ Object

# File 'lib/rage/cli.rb', line 71

def new(path = nil)
  return help("new") if options.help? || path.nil?

  require "rage/all"
  CLINewAppGenerator.start([path, options[:database]])
end

#respond_to_missing?(method_name, include_private = false) ⇒ Boolean

Returns:

• (Boolean)

# File 'lib/rage/cli.rb', line 258

def respond_to_missing?(method_name, include_private = false)
  linked_rake_tasks.any? { |task| task.name == method_name.to_s } || super
end

#routes ⇒ Object

# File 'lib/rage/cli.rb', line 110

def routes
  return help("routes") if options.help?
  # the result would be something like this:
  # Verb  Path  Controller#Action
  # GET   /     application#index

  # load config/application.rb
  set_env(options)
  environment

  routes = Rage.__router.routes
  pattern = options[:grep]
  routes.unshift({ method: "Verb", path: "Path", meta: { raw_handler: "Controller#Action" } })

  grouped_routes = routes.each_with_object({}) do |route, memo|
    if pattern && !memo.empty?
      next unless route[:path].match?(pattern) || route[:meta][:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
    end

    key = [route[:path], route[:meta][:raw_handler]]

    if route[:meta][:mount]
      memo[key] = route.merge(method: "") unless route[:path].end_with?("*")
      next
    end

    if memo[key]
      memo[key][:method] += "|#{route[:method]}"
    else
      memo[key] = route
    end
  end

  longest_path = longest_method = 0
  grouped_routes.each do |_, route|
    longest_path = route[:path].length if route[:path].length > longest_path
    longest_method = route[:method].length if route[:method].length > longest_method
  end

  margin = 3
  longest_path += margin
  longest_method += margin

  grouped_routes.each_with_index do |(_, route), i|
    meta = route[:constraints]
    meta.merge!(route[:defaults]) if route[:defaults]

    handler = route[:meta][:raw_handler]
    handler = "#{handler} #{meta}" unless meta&.empty?

    puts format("%-#{longest_method}s%-#{longest_path}s%s", route[:method], route[:path], handler)
    puts "\n" if i == 0
  end
end

#server ⇒ Object

# File 'lib/rage/cli.rb', line 84

def server
  return help("server") if options.help?

  set_env(options)

  app = ::Rack::Builder.parse_file(options[:config] || "config.ru")
  app = app[0] if app.is_a?(Array)

  server_options = { service: :http, handler: app }

  server_options[:port] = options[:port] || ENV["PORT"] || Rage.config.server.port
  server_options[:address] = options[:binding] || (Rage.env.production? ? "0.0.0.0" : "localhost")
  server_options[:timeout] = Rage.config.server.timeout
  server_options[:max_clients] = Rage.config.server.max_clients
  server_options[:public] = Rage.config.public_file_server.enabled ? Rage.root.join("public").to_s : nil

  ::Iodine.listen(**server_options)
  ::Iodine.threads = Rage.config.server.threads_count
  ::Iodine.workers = Rage.config.server.workers_count

  ::Iodine.start
end

#tasks ⇒ Object

# File 'lib/rage/cli.rb', line 231

def tasks
  require "io/console"

  tasks = linked_rake_tasks
  return if tasks.empty?

  _, max_width = IO.console.winsize
  max_task_name = tasks.max_by { |task| task.name.length }.name.length + 2
  max_comment = max_width - max_task_name - 8

  tasks.each do |task|
    comment = task.comment.length <= max_comment ? task.comment : "#{task.comment[0...max_comment - 5]}..."
    puts sprintf("rage %-#{max_task_name}s # %s", task.name, comment)
  end
end

#version ⇒ Object

# File 'lib/rage/cli.rb', line 221

def version
  puts Rage::VERSION
end