arli 0.5.1 → 0.6.1

data/lib/arli/cli/command_finder.rb

@@ -0,0 +1,72 @@
+require 'forwardable'
+require 'optparse'
+
+require 'colored2'
+
+require_relative 'parser'
+require_relative 'parser_factory'
+require_relative '../commands'
+require_relative '../commands/search'
+require_relative '../commands/install'
+require_relative '../output'
+
+module Arli
+  module CLI
+    class CommandFinder
+
+      include Arli::Output
+
+      attr_accessor :argv, :config, :command_name, :command
+
+      def initialize(argv, config: Arli.config)
+        self.config = config
+        self.argv   = argv
+      end
+
+      def parse!
+        self.command_name = detect_command
+        parse_command_arguments!(command_name)
+        unless Arli.config.help
+          self.command = instantiate_command
+          if self.command
+            config.runtime.command.instance = command
+            config.runtime.command.name     = command_name
+          end
+        end
+        self
+      end
+
+      def parse_command_arguments!(cmd)
+        parser = factory.command_parser(cmd)
+        if parser
+          factory.parse_argv(parser, argv)
+        end
+      end
+
+      def instantiate_command
+        self.command_name = detect_command unless command_name
+        begin
+          name          = command_name.to_s.capitalize.to_sym
+          command_class = ::Arli::Commands.const_get(name)
+          raise_invalid_arli_command!(command_name) unless command_class
+          command_class.new(config: config) if command_class
+        end
+      end
+
+      def detect_command
+        return nil unless argv.first && argv.first !~ /^-.*$/
+        cmd = argv.shift.to_sym
+        if factory.valid_command?(cmd)
+          cmd
+        else
+          raise_invalid_arli_command!(cmd)
+        end
+      end
+
+      def factory
+        Arli::CLI::ParserFactory
+      end
+    end
+
+  end
+end

data/lib/arli/{parser.rb → cli/parser.rb}

@@ -1,21 +1,19 @@
-require 'arduino/library'
-require 'arli/config'
-require 'arli/version'
+require 'arli/configuration'
 
 module Arli
-  class CLI
+  module CLI
     class Parser < OptionParser
-      attr_accessor :output_lines, :command, :options, :arlifile
 
-      def initialize(command = nil)
+      attr_accessor :output_lines,
+                    :command,
+                    :config
+
+      def initialize(config: Arli.config, command: nil)
         super(nil, 22)
-        self.output_lines        = ::Array.new
-        self.command             = command
-        self.options             = ::Hashie::Mash.new
-        self.arlifile            = options[:arli_dir] ?
-                                     options[:arli_dir] + '/' + Arli::Config::DEFAULT_FILENAME :
-                                     Arli::Config::DEFAULT_FILENAME
-        self.options[:arlifile] = arlifile
+
+        self.config       = config
+        self.command      = command
+        self.output_lines = ::Array.new
       end
 
       def sep(text = nil)
@@ -23,17 +21,18 @@ module Arli
       end
 
       def option_dependency_file
-        on('-p', '--arli-path PATH',
+        on('-a', '--arli-path PATH',
            'Folder where ' + 'Arlifile'.green + ' is located,',
            "Defaults to the current directory.\n\n") do |v|
-          options[:arli_dir] = v
+          config.arlifile.path = v
         end
       end
 
       def option_lib_home
-        on('-l', '--libs PATH', 'Local folder where libraries are installed',
-           "Defaults to #{default_library_path}\n\n") do |v|
-          options[:lib_home] = v
+        on('-l', '--libraries PATH',
+           'Local folder where libraries are installed',
+           "Defaults to #{Arli.default_library_path}\n\n") do |v|
+          config.libraries.path = v
         end
       end
 
@@ -41,12 +40,13 @@ module Arli
         on('-d', '--database FILE/URL',
            'a JSON file name, or a URL that contains the index',
            'Defaults to the Arduino-maintained list') do |v|
-          options[:database] = v
+          config.database.path = v
         end
+
         on('-m', '--max NUMBER',
            'if provided, limits the result set to this number',
            'Defaults to 100') do |v|
-          options[:limit] = v.to_i if v
+          config.search.results.limit = v.to_i if v
         end
       end
 
@@ -56,47 +56,37 @@ module Arli
            'it will be overwritten or updated if possible.',
            'Alternatively you can either ' + 'abort'.bold.blue + ' or ' + 'backup'.bold.blue
         ) do |v|
-          if v =~ /abort/i
-            options[:abort_if_exists] = true
-          elsif v =~ /backup/
-            options[:create_backup] = true
-            elsif v =~ /replace/
+          if v == 'abort'
+            config.install.if_exists.abort     = true
+            config.install.if_exists.overwrite = false
+          elsif v == 'backup'
+            config.install.if_exists.backup = true
           end
         end
         sep ' '
       end
 
       def option_help(commands: false, command_name: nil)
-        on('-D', '--debug',
-           'Print debugging info.') do |v|
-          options[:debug] = true
-        end
-        on('-t', '--trace',
-           'Print exception stack traces.') do |v|
-          options[:trace] = v
-        end
-        on('-v', '--verbose',
-           'Print more information.') do |v|
-          options[:verbose] = true
-        end
-        on('-V', '--version',
-           'Print current version and exit') do |v|
-          output 'Version: ' + Arli::VERSION
-          options[:help] = true
-        end
+        common_help_options
+
         on('-h', '--help', 'prints this help') do
-          output 'Description:' if command_name
-          output ' ' * 4 + command_name[:description].green if command_name
-          output ''
+          ::Arli.config.help = true
+
+          command_hash = factory.command_parsers[command_name]
+
+          if command_hash && command_hash[:description]
+            output 'Description:'
+            output '    ' + command_hash[:description]
+            output ''
+          end
+
           output_help
           output_command_help if commands
 
-          if command_name && command_name[:example]
+          if command_hash && command_hash[:example]
             output 'Example:'
-            output ' ' * 4 + command_name[:example]
+            output '     ' + command_hash[:example]
           end
-
-          options[:help] = true
         end
       end
 
@@ -113,14 +103,14 @@ module Arli
       end
 
       def command_help
-        subtext = "Available Commands:\n"
 
-        ::Arli::CLI.commands.each_pair do |command, config|
-          subtext << %Q/#{sprintf('    %-12s', command.to_s).green} : #{sprintf('%s', config[:description]).yellow}\n/
+        subtext = "Available Commands:\n"
+        factory.command_parsers.each_pair do |command, config|
+          subtext << %Q/#{sprintf('    %-12s', command.to_s).green} — #{sprintf('%s', config[:description]).blue}\n/
         end
         subtext << <<-EOS
-        
-See #{COMMAND.blue + ' <command> '.green + '--help'.yellow} for more information on a specific command.
+
+See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yellow} for more information on a specific command.
 
         EOS
         subtext
@@ -135,8 +125,28 @@ See #{COMMAND.blue + ' <command> '.green + '--help'.yellow} for more information
         puts output.join("\n") unless output.empty?
       end
 
-      def default_library_path
-        ::Arli.config.library_path.gsub(%r(#{ENV['HOME']}), '~').blue
+      def factory
+        Arli::CLI::ParserFactory
+      end
+
+      def common_help_options
+        on('-D', '--debug',
+           'Print debugging info.') do |v|
+          config.debug = true
+        end
+        on('-t', '--trace',
+           'Print exception stack traces.') do |v|
+          config.trace = v
+        end
+        on('-v', '--verbose',
+           'Print more information.') do |v|
+          config.verbose = true
+        end
+        on('-V', '--version',
+           'Print current version and exit') do |v|
+          puts 'Version: ' + Arli::VERSION
+          exit
+        end
       end
     end
   end

data/lib/arli/cli/parser_factory.rb

@@ -0,0 +1,97 @@
+require_relative 'parser'
+
+module Arli
+  module CLI
+    module ParserFactory
+
+      class << self
+
+        def default_help
+          gp = global_parser
+          gp.parse!(%w(--help))
+          gp.print
+        end
+
+        def parse_argv(parser, argv)
+          if parser
+            parser.parse!(argv)
+            parser.print
+          end
+        end
+
+        def make_parser(command = nil, &block)
+          ::Arli::CLI::Parser.new(command: command,
+                                  config: Arli.config, &block)
+        end
+
+        def global_parser
+          @global ||= make_parser do |parser|
+            parser.banner = usage_line
+            parser.sep
+            parser.option_help(commands: true)
+          end
+        end
+
+        def command_parsers
+          @command_parsers ||= {
+              install: {
+                  description: 'installs libraries defined in Arlifile',
+                  parser:      -> (command_name) {
+                    make_parser(command_name) do |parser|
+                      parser.banner = usage_line 'install'
+                      parser.option_lib_home
+                      parser.option_dependency_file
+                      parser.option_abort_if_exists
+                      parser.option_help(command_name: command_name)
+                    end
+                  } },
+
+              search:  {
+                  description: 'Flexible Search of the Arduino Library Database',
+                  example:     'arli search '.green + %Q['name: /AudioZero/, version: "1.0.1"'].green,
+                  parser:      -> (command_name) {
+                    make_parser(command_name) do |parser|
+                      parser.banner = usage_line 'search ' + '[ name-match | expression ]'.magenta
+                      parser.option_search
+                      parser.option_help(command_name: command_name)
+                    end
+                  }
+              }
+          }
+        end
+
+        def commands
+          command_parsers.keys
+        end
+
+        def valid_command?(command)
+          commands.include?(command)
+        end
+
+        def command_parser(cmd)
+          cmd_hash = command_parsers[cmd]
+          cmd_hash ? cmd_hash[:parser].call(cmd) : nil
+        end
+
+        def global_usage(command)
+          "Usage:\n    " + Arli::Configuration::ARLI_COMMAND.blue +
+              ' [ options ] '.yellow + '[ ' + (command || 'command').green +
+              ' [ options ] '.yellow + ' ]' + "\n"
+        end
+
+        def command_usage(command)
+          "Usage:\n    " + Arli::Configuration::ARLI_COMMAND.blue + ' ' +
+              command.green +
+              ' [options]'.yellow + "\n\n" +
+              'Command Options'
+        end
+
+        def usage_line(command = nil)
+          command ? command_usage(command) : global_usage(command)
+        end
+      end
+
+
+    end
+  end
+end

data/lib/arli/cli/runner.rb

@@ -0,0 +1,40 @@
+require 'colored2'
+require 'arli/cli/app'
+require 'pp'
+module Arli
+  module CLI
+    # For the reasons this file is the way it is, please refer to
+    # https://github.com/erikhuda/thor/wiki/Integrating-with-Aruba-In-Process-Runs
+    class Runner
+      def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR, kernel = Kernel)
+        @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
+      end
+
+      def execute!
+        exit_code = begin
+          $stderr = @stderr
+          $stdin  = @stdin
+          $stdout = @stdout
+
+          Arli::CLI::App.new(@argv).start
+          0
+        rescue StandardError => e
+          b = e.backtrace
+          @stderr.puts("#{b.shift.bold}:\n")
+          @stderr.puts("#{e.message.bold.red} (#{e.class.name.yellow})")
+          @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n")).red
+          1
+        rescue SystemExit => e
+          e.status
+        ensure
+          $stderr = STDERR
+          $stdin  = STDIN
+          $stdout = STDOUT
+          ap(Arli.config.to_hash, indent: 6, index: false) if Arli.config.debug
+        end
+        @kernel.exit(exit_code)
+      end
+    end
+  end
+
+end

data/lib/arli/commands.rb

@@ -0,0 +1,8 @@
+module Arli
+  module Commands
+  end
+end
+
+require_relative 'commands/base'
+require_relative 'commands/search'
+require_relative 'commands/install'

data/lib/arli/commands/base.rb

@@ -4,51 +4,44 @@ require 'open3'
 require 'arli'
 require 'arli/version'
 require 'arli/errors'
+require 'arli/output'
 
 module Arli
   module Commands
     class Base
-      attr_accessor :lib_path,
-                    :arlifile,
-                    :abort_if_exists,
-                    :create_backup,
-                    :command,
-                    :debug,
-                    :trace
-
-      def initialize(options)
-        self.lib_path        = options[:lib_home]
-        self.abort_if_exists = options[:abort_if_exists]
-        self.create_backup   = options[:create_backup]
-        self.debug           = options[:debug]
-        self.trace           = options[:trace]
-
-        self.command = self.class.name.gsub(/.*::/, '').downcase.to_sym
+      include Arli::Output
+
+      attr_accessor :config, :name
+
+      def initialize(config: Arli.config)
+        self.config = config
+        FileUtils.mkdir_p(library_path) unless Dir.exist?(library_path)
         setup
       end
 
-      def name
-        self.class.name.gsub(/.*::/, '').downcase
+      def run(*args)
+        raise ArgumentError, 'This method must be implemented in subclasses'
       end
 
-      def setup
-        FileUtils.mkdir_p(lib_path)
+      def runtime
+        config.runtime
       end
 
-      def error(msg, exception = nil)
-        printf 'Runtime Error: '.red + "\n#{msg}\n" if msg
-        if exception
-          puts
-          printf 'Exception: '.red + "\n#{exception.inspect.red}\n\n"
-        end
-        puts
+      def name
+        @name ||= self.class.name.gsub(/.*::/, '').downcase.to_sym
       end
 
-      def info(msg, header = nil)
-        printf('%-20s', header.blue) if header
-        printf((header ? ' : ' : '') + msg + "\n") if msg
+      def library_path
+        config.libraries.path
       end
 
+      def setup
+
+      end
+
+      def params
+
+      end
     end
   end
 end