chronicle-etl 0.5.4 → 0.6.1

data/lib/chronicle/etl/authorizer.rb

@@ -7,7 +7,7 @@ module Chronicle
 
         # Macro for setting provider on an Authorizer
         def provider(provider_name)
-          @provider_name = provider_name
+          @provider_name = provider_name.to_sym
         end
 
         # From all loaded Authorizers, return the first one that matches
@@ -16,15 +16,14 @@ module Chronicle
         # @todo Have a proper identifier system for authorizers
         #   (to have more than one per plugin)
         def find_by_provider(provider)
-          ObjectSpace.each_object(::Class).select {|klass| klass < self }.find do |authorizer|
+          ObjectSpace.each_object(::Class).select { |klass| klass < self }.find do |authorizer|
             authorizer.provider_name == provider
           end
         end
       end
 
       # Construct a new authorizer
-      def initialize(args)
-      end
+      def initialize(args); end
 
       # Main entry-point for authorization flows. Implemented by subclass
       def authorize!

data/lib/chronicle/etl/cli/authorizations.rb

@@ -2,7 +2,6 @@
 
 require 'sinatra'
 require 'launchy'
-require 'pp'
 
 module Chronicle
   module ETL
@@ -12,11 +11,14 @@ module Chronicle
         default_task 'new'
         namespace :authorizations
 
-        desc "authorize", "Authorize with a third-party provider"
+        desc 'authorize', 'Authorize with a third-party provider'
         option :port, desc: 'Port to run authorization server on', type: :numeric, default: 4567
-        option :credentials, desc: 'Secrets namespace for where to read credentials from (default: PROVIDER)', type: :string, banner: 'NAMESPACE'
-        option :secrets, desc: 'Secrets namespace for where authorization should be saved to (default: PROVIDER)', type: :string, banner: 'NAMESPACE'
-        option :print, desc: 'Show authorization results (instead of just saving secrets)', type: :boolean, default: false
+        option :credentials, desc: 'Secrets namespace for where to read credentials from (default: PROVIDER)',
+          type: :string, banner: 'NAMESPACE'
+        option :secrets, desc: 'Secrets namespace for where authorization should be saved to (default: PROVIDER)',
+          type: :string, banner: 'NAMESPACE'
+        option :print, desc: 'Show authorization results (instead of just saving secrets)', type: :boolean,
+          default: false
         def new(provider)
           authorizer_klass = find_authorizer_klass(provider)
           credentials = load_credentials(provider: provider, credentials_source: options[:credentials])
@@ -30,19 +32,19 @@ module Chronicle
 
           cli_exit(message: "Authorization saved to '#{secrets_namespace}' secrets")
         rescue StandardError => e
-          cli_fail(message: "Authorization not successful.\n" + e.message, exception: e)
+          cli_fail(message: "Authorization not successful.\n#{e.message}", exception: e)
         end
 
         private
 
         def find_authorizer_klass(provider)
           # TODO: this assumes provider:plugin one-to-one
-          unless Chronicle::ETL::Registry::PluginRegistry.installed?(provider)
+          unless Chronicle::ETL::Registry::Plugins.installed?(provider)
             cli_fail(message: "Plugin for #{provider} is not installed.")
           end
 
           begin
-            Chronicle::ETL::Registry::PluginRegistry.activate(provider)
+            Chronicle::ETL::Registry::Plugins.activate(provider)
           rescue PluginError => e
             cli_fail(message: "Could not load plugin '#{provider}'.\n" + e.message, exception: e)
           end

data/lib/chronicle/etl/cli/connectors.rb

@@ -10,15 +10,15 @@ module Chronicle
         default_task 'list'
         namespace :connectors
 
-        desc "list", "Lists available connectors"
+        desc 'list', 'Lists available connectors'
         # Display all available connectors that chronicle-etl has access to
         def list
-          connector_info = Chronicle::ETL::Registry.connectors.map do |connector_registration|
+          connector_info = Chronicle::ETL::Registry::Connectors.connectors.map do |connector_registration|
             {
               identifier: connector_registration.identifier,
               phase: connector_registration.phase,
               description: connector_registration.descriptive_phrase,
-              provider: connector_registration.provider,
+              source: connector_registration.source,
               core: connector_registration.built_in? ? '✓' : '',
               class: connector_registration.klass_name
             }
@@ -36,14 +36,14 @@ module Chronicle
           puts table.render(indent: 0, padding: [0, 2])
         end
 
-        desc "show PHASE IDENTIFIER", "Show information about a connector"
+        desc 'show PHASE IDENTIFIER', 'Show information about a connector'
         def show(phase, identifier)
-          unless ['extractor', 'transformer', 'loader'].include?(phase)
-            cli_fail(message: "Phase argument must be one of: [extractor, transformer, loader]")
+          unless %w[extractor transformer loader].include?(phase)
+            cli_fail(message: 'Phase argument must be one of: [extractor, transformer, loader]')
           end
 
           begin
-            connector = Chronicle::ETL::Registry.find_by_phase_and_identifier(phase.to_sym, identifier)
+            connector = Chronicle::ETL::Registry::Connectors.find_by_phase_and_identifier(phase.to_sym, identifier)
           rescue Chronicle::ETL::ConnectorNotAvailableError, Chronicle::ETL::PluginError => e
             cli_fail(message: "Could not find #{phase} #{identifier}", exception: e)
           end
@@ -51,9 +51,9 @@ module Chronicle
           puts connector.klass.to_s.bold
           puts "  #{connector.descriptive_phrase}"
           puts
-          puts "Settings:"
+          puts 'Settings:'
 
-          headers = ['name', 'default', 'required'].map{ |h| h.to_s.upcase.bold }
+          headers = %w[name default required].map { |h| h.to_s.upcase.bold }
 
           settings = connector.klass.settings.map do |name, setting|
             [

data/lib/chronicle/etl/cli/jobs.rb

@@ -1,4 +1,5 @@
-require 'pp'
+# frozen_string_literal: true
+
 require 'tty-prompt'
 
 module Chronicle
@@ -6,43 +7,67 @@ module Chronicle
     module CLI
       # CLI commands for working with ETL jobs
       class Jobs < SubcommandBase
-        default_task "start"
+        default_task 'start'
         namespace :jobs
 
-        class_option :extractor, aliases: '-e', desc: "Extractor class. Default: stdin", banner: 'NAME'
+        class_option :extractor, aliases: '-e', desc: 'Extractor class. Default: stdin', banner: 'NAME'
         class_option :'extractor-opts', desc: 'Extractor options', type: :hash, default: {}
-        class_option :transformer, aliases: '-t', desc: 'Transformer class. Default: null', banner: 'NAME'
-        class_option :'transformer-opts', desc: 'Transformer options', type: :hash, default: {}
+        class_option :transformer,
+          aliases: '-t',
+          desc: 'Transformer identifier. Default: null',
+          banner: 'NAME',
+          type: 'array',
+          repeatable: true
         class_option :loader, aliases: '-l', desc: 'Loader class. Default: table', banner: 'NAME'
         class_option :'loader-opts', desc: 'Loader options', type: :hash, default: {}
 
         # This is an array to deal with shell globbing
-        class_option :input, aliases: '-i', desc: 'Input filename or directory', default: [], type: 'array', banner: 'FILENAME'
-        class_option :since, desc: "Load records SINCE this date (or fuzzy time duration)", banner: 'DATE'
-        class_option :until, desc: "Load records UNTIL this date (or fuzzy time duration)", banner: 'DATE'
-        class_option :limit, desc: "Only extract the first LIMIT records", banner: 'N'
+        class_option :input,
+          aliases: '-i',
+          desc: 'Input filename or directory',
+          default: [],
+          type: 'array',
+          banner: 'FILENAME'
+        class_option :since, desc: 'Load records SINCE this date (or fuzzy time duration)', banner: 'DATE'
+        class_option :until, desc: 'Load records UNTIL this date (or fuzzy time duration)', banner: 'DATE'
+        class_option :limit, desc: 'Only extract the first LIMIT records', banner: 'N'
+
+        class_option :schema,
+          desc: 'Which Schema to transform',
+          banner: 'SCHEMA_NAME',
+          type: 'string',
+          enum: %w[chronicle activitystream schemaorg chronobase]
+        class_option :format,
+          desc: 'How to serialize results',
+          banner: 'SCHEMA_NAME',
+          type: 'string',
+          enum: %w[jsonapi jsonld]
 
         class_option :output, aliases: '-o', desc: 'Output filename', type: 'string'
         class_option :fields, desc: 'Output only these fields', type: 'array', banner: 'field1 field2 ...'
+        class_option :'fields-limit', desc: 'Output first N fields', type: :numeric
+        class_option :filter, desc: 'Filter records', type: 'array', banner: 'field=value'
         class_option :header_row, desc: 'Output the header row of tabular output', type: 'boolean'
 
         # Thor doesn't like `run` as a command name
         map run: :start
-        desc "run", "Start a job"
+        desc 'run', 'Start a job'
         option :dry_run, desc: 'Only run the extraction and transform steps, not the loading', type: :boolean
         long_desc <<-LONG_DESC
           This will run an ETL job. Each job needs three parts:
 
             1. #{'Extractor'.underline}: pulls data from an external source. By default, this is stdout. Other common options including pulling data from an API or reading JSON from a file.
 
-            2. #{'Transformer'.underline}: transforms data into a new format. If none is specified, we use the `null` transformer which does nothing to the data.
+            2. #{'Transformers'.underline}: transform data into a new format. If none is specified, we use the `null` transformer which does nothing to the data.
 
             3. #{'Loader'.underline}: takes that transformed data and loads it externally. This can be an API, flat files, (or by default), stdout. With the --dry-run option, this step won't be run.
 
             If you do not want to use the command line flags, you can also configure a job with a .yml config file. You can either specify the path to this file or use the filename and place the file in ~/.config/chronicle/etl/jobs/NAME.yml and call it with `--job NAME`
-LONG_DESC
+        LONG_DESC
         # Run an ETL job
-        def start(name = nil)
+        def start(*args)
+          name = args.first
+
           # If someone runs `$ chronicle-etl` with no arguments, show help menu.
           # TODO: decide if we should check that there's nothing in stdin pipe
           # in case user wants to actually run this sort of job stdin->null->stdout
@@ -52,7 +77,7 @@ LONG_DESC
             cli_exit
           end
 
-          cli_fail(message: "Job '#{name}' does not exist") if name && !Chronicle::ETL::Config.exists?("jobs", name)
+          cli_fail(message: "Job '#{name}' does not exist") if name && !Chronicle::ETL::Config.exists?('jobs', name)
 
           job_definition = build_job_definition(name, options)
 
@@ -66,7 +91,7 @@ LONG_DESC
 
           run_job(job_definition)
         rescue Chronicle::ETL::JobDefinitionError => e
-          message = ""
+          message = ''
           job_definition.errors.each_pair do |category, errors|
             message << "Problem with #{category}:\n  - #{errors.map(&:to_s).join("\n  - ")}"
           end
@@ -74,14 +99,14 @@ LONG_DESC
         end
 
         option :'skip-confirmation', aliases: '-y', type: :boolean
-        desc "save", "Save a job"
+        desc 'save', 'Save a job'
         # Create an ETL job
         def save(name)
           write_config = true
           job_definition = build_job_definition(name, options)
           job_definition.validate!
 
-          if Chronicle::ETL::Config.exists?("jobs", name) && !options[:'skip-confirmation']
+          if Chronicle::ETL::Config.exists?('jobs', name) && !options[:'skip-confirmation']
             prompt = TTY::Prompt.new
             write_config = false
             message = "Job '#{name}' exists already. Ovewrite it?"
@@ -92,34 +117,50 @@ LONG_DESC
           end
 
           if write_config
-            Chronicle::ETL::Config.write("jobs", name, job_definition.definition)
+            Chronicle::ETL::Config.write('jobs', name, job_definition.definition)
             cli_exit(message: "Job saved. Run it with `$ chronicle-etl jobs:run #{name}`")
           else
             cli_fail(message: "\nJob not saved")
           end
         rescue Chronicle::ETL::JobDefinitionError => e
-          cli_fail(message: "Job definition error", exception: e)
+          cli_fail(message: 'Job definition error', exception: e)
         end
 
-        desc "show", "Show details about a job"
+        desc 'show', 'Show details about a job'
         # Show an ETL job
         def show(name = nil)
-          cli_fail(message: "Job '#{name}' does not exist") if name && !Chronicle::ETL::Config.exists?("jobs", name)
+          cli_fail(message: "Job '#{name}' does not exist") if name && !Chronicle::ETL::Config.exists?('jobs', name)
 
           job_definition = build_job_definition(name, options)
           job_definition.validate!
           puts Chronicle::ETL::Job.new(job_definition)
         rescue Chronicle::ETL::JobDefinitionError => e
-          cli_fail(message: "Job definition error", exception: e)
+          cli_fail(message: 'Job definition error', exception: e)
+        end
+
+        desc 'edit', 'Edit a job in default editor ($EDITOR)'
+        def edit(name = nil)
+          cli_fail(message: "Job '#{name}' does not exist") if name && !Chronicle::ETL::Config.exists?('jobs', name)
+
+          filename = Chronicle::ETL::Config.path('jobs', name)
+          system "${VISUAL:-${EDITOR:-vi}} \"#{filename}\""
+
+          definition = Chronicle::ETL::JobDefinition.new
+          definition.add_config(load_job_config(name))
+          definition.validate!
+
+          cli_exit(message: "Job '#{name}' saved")
+        rescue Chronicle::ETL::JobDefinitionError => e
+          cli_fail(message: 'Job definition error', exception: e)
         end
 
-        desc "list", "List all available jobs"
+        desc 'list', 'List all available jobs'
         # List available ETL jobs
         def list
           jobs = Chronicle::ETL::Config.available_jobs
 
           job_details = jobs.map do |job|
-            r = Chronicle::ETL::Config.load("jobs", job)
+            r = Chronicle::ETL::Config.load('jobs', job)
 
             extractor = r[:extractor][:name] if r[:extractor]
             transformer = r[:transformer][:name] if r[:transformer]
@@ -128,9 +169,9 @@ LONG_DESC
             [job, extractor, transformer, loader]
           end
 
-          headers = ['name', 'extractor', 'transformer', 'loader'].map { |h| h.upcase.bold }
+          headers = %w[name extractor transformer loader].map { |h| h.upcase.bold }
 
-          puts "Available jobs:"
+          puts 'Available jobs:'
           table = TTY::Table.new(headers, job_details)
           puts table.render(indent: 0, padding: [0, 2])
         rescue Chronicle::ETL::ConfigError => e
@@ -148,18 +189,19 @@ LONG_DESC
           runner = Chronicle::ETL::Runner.new(job)
           runner.run!
         rescue RunnerError => e
-          cli_fail(message: "#{e.message}", exception: e)
+          cli_fail(message: e.message.to_s, exception: e)
         end
 
         # TODO: probably could merge this with something in cli/plugin
         def install_missing_plugins(missing_plugins)
           prompt = TTY::Prompt.new
           message = "Plugin#{'s' if missing_plugins.count > 1} specified by job not installed.\n"
-          message += "Do you want to install "
-          message += missing_plugins.map { |name| "chronicle-#{name}".bold}.join(", ")
-          message += " and start the job?"
+          message += 'Do you want to install '
+          message += missing_plugins.map { |name| "chronicle-#{name}".bold }
+            .join(', ')
+          message += ' and start the job?'
           will_install = prompt.yes?(message)
-          cli_fail(message: "Must install #{missing_plugins.join(", ")} plugin to run job") unless will_install
+          cli_fail(message: "Must install #{missing_plugins.join(', ')} plugin to run job") unless will_install
 
           Chronicle::ETL::CLI::Plugins.new.install(*missing_plugins)
         end
@@ -172,43 +214,78 @@ LONG_DESC
           definition
         end
 
-        def load_job_config name
+        def load_job_config(name)
           Chronicle::ETL::Config.read_job(name)
         end
 
         # Takes flag options and turns them into a runner config
         # TODO: this needs a lot of refactoring
-        def process_flag_options options
-          extractor_options = options[:'extractor-opts'].transform_keys(&:to_sym).merge({
-            input: (options[:input] if options[:input].any?),
-            since: options[:since],
-            until: options[:until],
-            limit: options[:limit]
-          }.compact)
-
-          transformer_options = options[:'transformer-opts'].transform_keys(&:to_sym)
-
-          loader_options = options[:'loader-opts'].transform_keys(&:to_sym).merge({
-            output: options[:output],
-            header_row: options[:header_row],
-            fields: options[:fields]
-          }.compact)
-
-          {
+        def process_flag_options(options)
+          extractor_options = options[:'extractor-opts'].transform_keys(&:to_sym).merge(
+            {
+              input: (options[:input] if options[:input].any?),
+              since: options[:since],
+              until: options[:until],
+              limit: options[:limit]
+            }.compact
+          )
+
+          loader_options = options[:'loader-opts'].transform_keys(&:to_sym).merge(
+            {
+              output: options[:output],
+              header_row: options[:header_row]
+            }.compact
+          )
+
+          processed_options = {
             dry_run: options[:dry_run],
             extractor: {
               name: options[:extractor],
               options: extractor_options
             }.compact,
-            transformer: {
-              name: options[:transformer],
-              options: transformer_options
-            }.compact,
             loader: {
               name: options[:loader],
               options: loader_options
             }.compact
           }
+
+          add_transformer(processed_options, 'chronicle') if options[:schema]
+          add_transformer(processed_options, options[:schema]) if options[:schema] && options[:schema] != 'chronicle'
+          add_transformers_from_option(processed_options, options[:transformer]) if options[:transformer]&.any?
+          if options[:filter]
+            add_transformer(processed_options, :filter, { filters: options[:filter].to_h do |f|
+                                                                     f.split('=')
+                                                                   end })
+          end
+          add_transformer(processed_options, :format, { format: options[:format] }) if options[:format]
+          add_transformer(processed_options, :filter_fields, { fields: options[:fields] }) if options[:fields]
+          if options[:'fields-limit']
+            add_transformer(processed_options, :fields_limit,
+              { limit: options[:'fields-limit'] })
+          end
+
+          processed_options
+        end
+
+        def add_transformer(processed_options, name, options = {})
+          processed_options[:transformers] ||= []
+          processed_options[:transformers] << { name:, options: }
+        end
+
+        def add_transformers_from_option(processed_options, transformer_option)
+          processed_options[:transformers] ||= []
+          processed_options[:transformers] += transformer_option.map do |transformer_args|
+            transformer_name, *transformer_options = transformer_args
+            transformer_options = transformer_options.filter { |opt| opt.include?('=') }
+
+            {
+              name: transformer_name,
+              options: transformer_options.to_h do |opt|
+                key, value = opt.split('=')
+                [key.to_sym, value]
+              end
+            }
+          end
         end
       end
     end

data/lib/chronicle/etl/cli/main.rb

@@ -13,7 +13,7 @@ module Chronicle
         class_option :silent, desc: 'Silence all output', type: :boolean
         class_option :'no-color', desc: 'Disable colour output', type: :boolean
 
-        default_task "jobs"
+        default_task 'jobs'
 
         desc 'connectors:COMMAND', 'Connectors available for ETL jobs', hide: true
         subcommand 'connectors', Connectors
@@ -45,49 +45,49 @@ module Chronicle
           true
         end
 
-        desc "version", "Show version"
-        map %w(--version -v) => :version
+        desc 'version', 'Show version'
+        map %w[--version -v] => :version
         def version
           shell.say "chronicle-etl #{Chronicle::ETL::VERSION}"
         end
 
         # Displays help options for chronicle-etl
-        def help(meth = nil, subcommand = false)
+        def help(meth = nil, _subcommand = false)
           if meth && !respond_to?(meth)
             klass, task = ::Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
-            klass.start(['-h', task].compact, shell: shell)
+            klass.start(['-h', task].compact, shell:)
           else
-            shell.say "ABOUT:".bold
+            shell.say 'ABOUT:'.bold
             shell.say "  #{'chronicle-etl'.italic} is a toolkit for extracting and working with your digital"
-            shell.say "  history. 📜"
+            shell.say '  history. 📜'
             shell.say
             shell.say "  A job #{'extracts'.underline} personal data from a source, #{'transforms'.underline} it (Chronicle"
             shell.say "  Schema or preserves raw data), and then #{'loads'.underline} it to a destination. Use"
-            shell.say "  built-in extractors (json, csv, stdin) and loaders (csv, json, table,"
-            shell.say "  rest) or use plugins to connect to third-party services."
+            shell.say '  built-in extractors (json, csv, stdin) and loaders (csv, json, table,'
+            shell.say '  rest) or use plugins to connect to third-party services.'
             shell.say
-            shell.say "  Plugins: https://github.com/chronicle-app/chronicle-etl#currently-available"
+            shell.say '  Plugins: https://github.com/chronicle-app/chronicle-etl#currently-available'
             shell.say
-            shell.say "USAGE:".bold
-            shell.say "  # Basic job usage:".italic.light_black
-            shell.say "  $ chronicle-etl --extractor NAME --transformer NAME --loader NAME"
+            shell.say 'USAGE:'.bold
+            shell.say '  # Basic job usage:'.italic.light_black
+            shell.say '  $ chronicle-etl --extractor NAME --transformer NAME --loader NAME'
             shell.say
-            shell.say "  # Read test.csv and display it to stdout as a table:".italic.light_black
-            shell.say "  $ chronicle-etl --extractor csv --input data.csv --loader table"
+            shell.say '  # Read test.csv and display it to stdout as a table:'.italic.light_black
+            shell.say '  $ chronicle-etl --extractor csv --input data.csv --loader table'
             shell.say
-            shell.say "  # Show available plugins:".italic.light_black
-            shell.say "  $ chronicle-etl plugins:list"
+            shell.say '  # Show available plugins:'.italic.light_black
+            shell.say '  $ chronicle-etl plugins:list'
             shell.say
-            shell.say "  # Save an access token as a secret and use it in a job:".italic.light_black
-            shell.say "  $ chronicle-etl secrets:set pinboard access_token username:foo123"
-            shell.say "  $ chronicle-etl secrets:list"
-            shell.say "  $ chronicle-etl -e pinboard --since 1mo"
+            shell.say '  # Save an access token as a secret and use it in a job:'.italic.light_black
+            shell.say '  $ chronicle-etl secrets:set pinboard access_token username:foo123'
+            shell.say '  $ chronicle-etl secrets:list'
+            shell.say '  $ chronicle-etl -e pinboard --since 1mo'
             shell.say
-            shell.say "  # Show full job options:".italic.light_black
-            shell.say "  $ chronicle-etl jobs help run"
+            shell.say '  # Show full job options:'.italic.light_black
+            shell.say '  $ chronicle-etl jobs help run'
             shell.say
-            shell.say "FULL DOCUMENTATION:".bold
-            shell.say "  https://github.com/chronicle-app/chronicle-etl".blue
+            shell.say 'FULL DOCUMENTATION:'.bold
+            shell.say '  https://github.com/chronicle-app/chronicle-etl'.blue
             shell.say
 
             list = []
@@ -95,17 +95,17 @@ module Chronicle
               list += thor_class.printable_tasks(false)
             end
             list.sort! { |a, b| a[0] <=> b[0] }
-            list.unshift ["help", "# This help menu"]
+            list.unshift ['help', '# This help menu']
 
             shell.say
             shell.say 'ALL COMMANDS:'.bold
             shell.print_table(list, indent: 2, truncate: true)
             shell.say
-            shell.say "VERSION:".bold
+            shell.say 'VERSION:'.bold
             shell.say "  #{Chronicle::ETL::VERSION}"
             shell.say
-            shell.say "  Display current version:".italic.light_black
-            shell.say "  $ chronicle-etl --version"
+            shell.say '  Display current version:'.italic.light_black
+            shell.say '  $ chronicle-etl --version'
           end
         end
 

data/lib/chronicle/etl/cli/plugins.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "tty-prompt"
-require "tty-spinner"
+require 'tty-prompt'
+require 'tty-spinner'
 
 module Chronicle
   module ETL
@@ -11,60 +11,63 @@ module Chronicle
         default_task 'list'
         namespace :plugins
 
-        desc "install", "Install a plugin"
+        desc 'install', 'Install a plugin'
         def install(*plugins)
-          cli_fail(message: "Please specify a plugin to install") unless plugins.any?
+          cli_fail(message: 'Please specify a plugin to install') unless plugins.any?
 
           installed, not_installed = plugins.partition do |plugin|
-            Chronicle::ETL::Registry::PluginRegistry.installed?(plugin)
+            Chronicle::ETL::Registry::Plugins.installed?(plugin)
           end
 
-          puts "Already installed: #{installed.join(", ")}" if installed.any?
+          puts "Already installed: #{installed.join(', ')}" if installed.any?
           cli_exit unless not_installed.any?
 
-          spinner = TTY::Spinner.new("[:spinner] Installing #{not_installed.join(", ")}...", format: :dots_2)
+          spinner = TTY::Spinner.new("[:spinner] Installing #{not_installed.join(', ')}...", format: :dots_2)
           spinner.auto_spin
 
           not_installed.each do |plugin|
             spinner.update(title: "Installing #{plugin}")
-            Chronicle::ETL::Registry::PluginRegistry.install(plugin)
-
+            Chronicle::ETL::Registry::Plugins.install(plugin)
           rescue Chronicle::ETL::PluginError => e
-            spinner.error("Error".red)
+            spinner.error('Error'.red)
             cli_fail(message: "Plugin '#{plugin}' could not be installed", exception: e)
           end
 
           spinner.success("(#{'successful'.green})")
         end
 
-        desc "uninstall", "Unintall a plugin"
+        desc 'uninstall', 'Unintall a plugin'
         def uninstall(name)
           spinner = TTY::Spinner.new("[:spinner] Uninstalling plugin #{name}...", format: :dots_2)
           spinner.auto_spin
-          Chronicle::ETL::Registry::PluginRegistry.uninstall(name)
+          Chronicle::ETL::Registry::Plugins.uninstall(name)
           spinner.success("(#{'successful'.green})")
         rescue Chronicle::ETL::PluginError => e
-          spinner.error("Error".red)
+          spinner.error('Error'.red)
           cli_fail(message: "Plugin '#{name}' could not be uninstalled (was it installed?)", exception: e)
         end
 
-        desc "list", "Lists available plugins"
+        desc 'list', 'Lists available plugins'
         # Display all available plugins that chronicle-etl has access to
         def list
-          plugins = Chronicle::ETL::Registry::PluginRegistry.all_installed_latest
-
-          info = plugins.map do |plugin|
-            {
-              name: plugin.name.sub("chronicle-", ""),
-              description: plugin.description,
-              version: plugin.version
-            }
+          values = Chronicle::ETL::Registry::Plugins.all
+            .map do |plugin|
+            [
+              plugin.name,
+              plugin.description,
+              plugin.installed ? '✓' : '',
+              plugin.version
+            ]
           end
 
-          headers = ['name', 'description', 'version'].map{ |h| h.to_s.upcase.bold }
-          table = TTY::Table.new(headers, info.map(&:values))
-          puts "Installed plugins:"
-          puts table.render(indent: 2, padding: [0, 0])
+          headers = %w[name description installed version].map { |h| h.to_s.upcase.bold }
+          table = TTY::Table.new(headers, values)
+          puts 'Available plugins:'
+          puts table.render(
+            indent: 2,
+            padding: [0, 0],
+            alignments: %i[left left center left]
+          )
         end
       end
     end