arli 0.8.3 → 0.9.0

data/lib/arli/cli/runner.rb

@@ -1,4 +1,3 @@
-require 'colored2'
 require 'arli/cli/app'
 require 'pp'
 module Arli

data/lib/arli/commands/base.rb

@@ -4,12 +4,12 @@ require 'open3'
 require 'arli'
 require 'arli/version'
 require 'arli/errors'
-require 'arli/output'
+require 'arli/helpers/output'
 
 module Arli
   module Commands
     class Base
-      include Arli::Output
+      include Arli::Helpers::Output
 
       attr_accessor :config, :name
 

data/lib/arli/commands/install.rb

@@ -6,38 +6,65 @@ require 'arli'
 require 'arduino/library'
 require_relative 'base'
 require_relative 'bundle'
+require 'arli/library'
 
 module Arli
   module Commands
-    class Install < Bundle
+    class Install < Base
       require 'arduino/library/include'
 
-      attr_accessor :library
+      attr_accessor :library,
+                    :arlifile,
+                    :install_argument,
+                    :install_method
+
+      include ::Arli::Library
 
       def setup
-        validate_argument
+        super
+
+        self.install_argument = runtime.argv.first
+        raise InvalidInstallSyntaxError,
+              "Missing installation argument: a name, a file or a URL." unless install_argument
 
-        self.library  = identify_library(runtime.argv.first)
-        validate_library
+        self.library = identify_library(install_argument)
+        raise Arli::Errors::LibraryNotFound,
+              "Library #{cfg.to_hash} was not found" unless library
 
-        self.arlifile = Arli::ArliFile.new(config: config, libraries: [library]) if library
+        self.arlifile = Arli::ArliFile.new(config: config, libraries: [ library ])
+        if config.trace
+          info("found library using #{install_method}:\n#{library.inspect}")
+        end
+      end
+
+      def run
+        arlifile.install
       end
 
       # arg can be 'Adafruit GFX Library'
       def identify_library(arg)
-        if File.exist?(arg)
-          begin
-            Arduino::Library::Model.from(arg)
-          rescue
-            nil
-          end
-        elsif arg =~ %r[https?://]
-          Arduino::Library::Model.from_hash(url: arg, name: File.basename(arg))
-        else
-          results = search(name: /^#{arg}$/i)
-          validate_search(arg, results)
-          results.sort.last if results && !results.empty?
-        end
+        results = if arg =~ %r[https?://]i
+                    self.install_method = :url
+                    r = search(url: /^#{arg}$/i)
+                    if r.empty?
+                      self.install_method = :website
+                      r = search(website: /^#{arg}$/i)
+                    end
+                    if r.empty?
+                      self.install_method = :custom
+                      r = [ Arduino::Library::Model.from_hash(url: arg, name: File.basename(arg)) ]
+                    end
+                    r
+                  elsif File.exist?(arg) || arg =~ /\.zip$/
+                    self.install_method = :archiveFileName
+                    search(archiveFileName: "#{File.basename(arg)}")
+                  else
+                    self.install_method = :name
+                    search(name: /^#{arg}$/)
+                  end
+
+        validate_search(arg, results)
+        results.sort.last if results && !results.empty?
       end
 
       def params
@@ -52,19 +79,10 @@ module Arli
 
       def validate_search(arg, results)
         raise Arli::Errors::LibraryNotFound,
-              "Can't find library by argument #{arg.bold.yellow}" if results.nil? || results.empty?
+              "Can't find library by argument #{arg.bold.yellow}, searching by #{install_method}" if results.nil? || results.empty?
+        dupes = results.map(&:name).uniq.size
         raise Arli::Errors::TooManyMatchesError,
-              "More than one match found for #{arg.bold.yellow}" if results.map(&:name).uniq.size > 1
-      end
-
-      def validate_library
-        raise Arli::Errors::LibraryNotFound,
-              "Library #{cfg.to_hash} was not found" unless library
-      end
-
-      def validate_argument
-        raise InvalidInstallSyntaxError,
-              "Missing installation argument: a name, a file or a URL." unless runtime.argv.first
+              "More than one match found for #{arg.bold.yellow} — #{dupes} libraries matched" if dupes > 1
       end
 
       def cfg

data/lib/arli/commands/search.rb

@@ -4,53 +4,42 @@ require 'open3'
 require 'arli'
 require 'arli/commands/base'
 require 'arli/errors'
+require 'arli/library/multi_version'
 require 'arduino/library'
 
+
 module Arli
   module Commands
     class Search < Base
 
-      LibraryWithVersion = Struct.new(:name, :versions)
-
       require 'arduino/library/include'
 
       attr_accessor :search_string,
                     :search_opts,
+                    :search_method,
                     :results,
                     :limit,
                     :database,
                     :format,
-                    :hash,
-                    :custom_print
+                    :unique_libraries
 
       def initialize(*args)
         super(*args)
-        self.format       = :short
-        self.hash         = Hash.new
-        self.custom_print = true
+        self.format = config.search.results.output_format
+        valid_methods = Arli::Library::MultiVersion.format_methods
+        raise Arli::Errors::InvalidSearchSyntaxError,
+              "invalid format #{format}" unless valid_methods.include?(format)
       end
 
       def run
-        self.search_opts = process_search_options!
-        self.results     = search(database, **search_opts).sort
-
-        results.map do |lib|
-          hash[lib.name] ||= LibraryWithVersion.new(lib.name, [])
-          hash[lib.name].versions << lib.version
-
-          method = "to_s_#{format}".to_sym
-          if lib.respond_to?(method)
-            self.custom_print = false
-            lib.send(method)
-          end
-        end
+        self.search_opts      = process_search_options!
+        self.results          = search(database, **search_opts).sort
+        self.unique_libraries = Set.new
 
-        if custom_print
-          previous = nil
-          results.each do |lib|
-            print_lib(hash[lib.name]) unless previous == lib.name
-            previous = lib.name
-          end
+        results.map { |lib| add_lib_or_version(lib) }
+
+        unique_libraries.each do |multi_version|
+          puts multi_version.send("to_s_#{format}".to_sym)
         end
         print_total_with_help
       rescue Exception => e
@@ -58,10 +47,13 @@ module Arli
         puts e.backtrace.join("\n") if ENV['DEBUG']
       end
 
-      def print_lib(lib)
-        $stdout.puts "#{lib.name.bold.magenta} " +
-           (lib.versions ?
-                "(#{lib.versions.size} versions: #{lib.versions.reverse[0..5].join(', ').blue})": '')
+      def add_lib_or_version(lib)
+        a_version = Arli::Library::MultiVersion.new(lib)
+        if unique_libraries.include?(a_version)
+          unique_libraries.find { |l| l.name == a_version.name }&.add_version(library: lib)
+        else
+          unique_libraries << a_version
+        end
       end
 
       def process_search_options!
@@ -71,9 +63,12 @@ module Arli
         self.limit  = config.search.results.limit
         search_opts = {}
         begin
-          search_opts = eval("{ #{search_string} }")
+          params_code = "{ #{search_string} }"
+          puts "Evaluating: [#{params_code.blue}]\nSearch Method: [#{search_method.to_s.green}]" if config.trace
+          search_opts = eval(params_code)
+
         rescue => e
-          handle_error(e)
+          handle_and_raise_error(e)
         end
 
         unless search_opts.is_a?(::Hash) && search_opts.size > 0
@@ -91,9 +86,19 @@ module Arli
       def extract_search_argument!
         search = runtime.argv.first
         if search =~ /:/
+          self.search_method = :ruby
           search
+        elsif search.start_with?('/')
+          self.search_method = :regex_name_and_url
+          # exact match
+          "#{config.search.default_field}: #{search}, archiveFileName: #{search}"
+        elsif search.start_with?('=')
+          self.search_method = :equals
+          # exact match
+          "#{config.search.default_field}: '#{search[1..-1]}'"
         elsif search
-          "#{config.search.default_field}: /^#{search}$/"
+          self.search_method = :regex
+          "#{config.search.default_field}: /#{search.downcase}/i"
         end
       end
 
@@ -118,10 +123,10 @@ module Arli
       def print_total_with_help
         puts "———————————————————————"
         puts "  Total Versions : #{results.size.to_s.bold.magenta}\n"
-        puts "Unique Libraries : #{hash.keys.size.to_s.bold.magenta}\n"
+        puts "Unique Libraries : #{unique_libraries.size.to_s.bold.magenta}\n"
         puts "———————————————————————"
         if results.size == Arli::Configuration::DEFAULT_RESULTS_LIMIT
-          puts "Hint: use #{'-m 0'.bold.green} to disable the limit, or set it to another value."
+          puts "Hint: use #{'-m 5'.bold.green} to limit the result set."
         end
       end
 

data/lib/arli/configuration.rb

@@ -9,7 +9,7 @@ module Arli
     DEFAULT_LOCK_FILENAME = (DEFAULT_FILENAME + '.lock').freeze
     ACTIONS_WHEN_EXISTS   = %i(backup overwrite abort)
     ARLI_COMMAND          = 'arli'.freeze
-    DEFAULT_RESULTS_LIMIT = 100
+    DEFAULT_RESULTS_LIMIT = 0
 
     extend Dry::Configurable
 
@@ -43,6 +43,7 @@ module Arli
     # Global flags
     setting :debug, ENV['ARLI_DEBUG'] || false
     setting :trace, false
+    setting :no_color, false
     setting :dry_run, false
     setting :verbose, false
     setting :help, false
@@ -55,7 +56,7 @@ module Arli
       setting :results do
         setting :attrs
         setting :limit, DEFAULT_RESULTS_LIMIT
-        setting :format, :inspect
+        setting :output_format, :short
       end
     end
 
@@ -64,7 +65,7 @@ module Arli
       setting :path, ::Dir.pwd
       setting :name, ::Arli::Configuration::DEFAULT_FILENAME
       setting :lock_name, ::Arli::Configuration::DEFAULT_LOCK_FILENAME
-      setting :lock_format, :json
+      setting :lock_format, :text
     end
 
     setting :bundle do

data/lib/arli/extensions.rb

@@ -6,4 +6,10 @@ class String
         tr('-', '_').
         downcase
   end
+
+  def reformat_wrapped(width = 70, indent_with = 8)
+    ind = (' ' * indent_with)
+    (ind + self.gsub(/\s+/, ' ').gsub(/(.{1,#{width}})( |\Z)/, "\\1\n" + ind))
+  end
+
 end

data/lib/arli/helpers/inherited.rb

@@ -0,0 +1,48 @@
+module Arli
+  module Helpers
+    module Inherited
+
+      module ClassMethods
+        def set_or_get(var_name, val = nil, set_nil = false)
+          var = "@#{var_name}".to_sym
+          self.instance_variable_set(var, val) if val
+          self.instance_variable_set(var, nil) if set_nil
+          self.instance_variable_get(var)
+        end
+
+        def short_name
+          name.gsub(/.*::/, '').underscore.to_sym
+        end
+
+        def attr_assignable(*attrs)
+          self.class.instance_eval do
+            attrs.each do |attribute|
+              send(:define_method, attribute) do |val = nil, **opts|
+                set_or_get(attribute, val, opts && opts[:nil])
+              end
+            end
+          end
+        end
+      end
+
+      module Subclassing
+        def included(klass)
+          klass.instance_eval do
+            class << self
+              include ::Arli::Helpers::Inherited
+            end
+          end
+        end
+      end
+
+      def self.included(base)
+        base.instance_eval do
+          class << self
+            include(::Arli::Helpers::Inherited::ClassMethods)
+          end
+        end
+        base.extend(Subclassing) if base.is_a?(Class)
+      end
+    end
+  end
+end

data/lib/arli/helpers/output.rb

@@ -0,0 +1,187 @@
+require 'colored2'
+require 'tty-cursor'
+
+module Arli
+  module Helpers
+    module Output
+      CHAR_FAILURE = '✖'.red
+      CHAR_SUCCESS = '✔'.green
+
+      class << self
+        attr_accessor :enabled, :cursor
+
+        def enable!
+          self.enabled = true
+        end
+
+        def enabled?
+          self.enabled
+        end
+
+        def disable!
+          self.enabled = false
+        end
+      end
+
+      self.enable!
+      self.cursor = TTY::Cursor
+
+      def cursor
+        Arli::Helpers::Output.cursor
+      end
+
+      def info(msg, header = nil)
+        __pf('%-20s', header.blue) if header
+        __pf((header ? ' : ' : '') + msg + "\n") if msg
+      end
+
+      def debug(msg)
+        __pf('%-20s', header.blue) if header
+        __pf((header ? ' : ' : '') + msg + "\n") if msg
+      end
+
+      def error(msg, exception = nil)
+        __pf "#{msg.to_s.red}\n" if msg
+        __pf "#{exception.inspect.red}\n\n" if exception
+      end
+
+      def report_exception(e, header = nil)
+        if header
+          __pf header.bold.yellow + ': '
+        else
+          __pf 'Error: '.bold.red
+        end
+        error e.message if (e && e.respond_to?(:message))
+        if e && Arli.config.trace
+          __pf "\n"
+          __pf 'Top 10 stack trace'.bold.yellow + "\n"
+          __pf e.backtrace.reverse[-10..-1].join("\n").red + "\n"
+        elsif e
+          __pf "\nUse -t (--trace) for detailed exception\n" +
+                   "or -D (--debug) to print Arli config\n"
+        end
+      end
+
+      def raise_invalid_arli_command!(cmd, e = nil)
+        raise Arli::Errors::InvalidCommandError.new(cmd)
+      end
+
+      # Shortcuts disabled in tests
+      def ___(msg = nil, newline = false)
+        return unless Arli::Helpers::Output.enabled?
+        __pf msg if msg
+        __pt if newline
+      end
+
+      def __pt(*args)
+        puts(*args) if Arli::Helpers::Output.enabled?
+      end
+
+      def __p(*args)
+        print(*args) if Arli::Helpers::Output.enabled?
+      end
+
+      def __pf(*args)
+        printf(*args) if Arli::Helpers::Output.enabled?
+      end
+
+
+      def print_target_dir(d, verb = 'installed')
+        print_action_success(d.green, "#{verb} #{d.green} ")
+      end
+
+      def print_action_starting(action_name)
+        if verbose?
+          indent_cursor
+          ___ "⇨  #{action_name.yellow} ... "
+        end
+        if block_given?
+          yield
+          ok if verbose?
+        end
+      end
+
+      def print_action_success(short, verbose = nil)
+        if verbose? && !quiet?
+          indent_cursor
+          ___ "⇨  #{verbose || short} #{CHAR_SUCCESS}"
+        elsif !quiet?
+          ___ "#{short} #{CHAR_SUCCESS} "
+        end
+      end
+
+      def print_action_failure(short, verbose = nil)
+        if verbose? && !quiet?
+          indent_cursor
+          ___ "⇨  #{verbose || short} #{CHAR_FAILURE}\n"
+        elsif !quiet?
+          ___ "#{short} #{CHAR_FAILURE} "
+        end
+      end
+
+      def action_fail(action, exception)
+        print_action_failure(action.class.short_name,
+                             "#{action.class.short_name} failed with #{exception.message.red}\n" +
+                                 "Action Description: #{action.class.description}")
+        raise(exception)
+      end
+
+      def action_ok(action)
+        print_action_success(action.action_name)
+      end
+
+      def ok
+        ___ " #{CHAR_SUCCESS} "
+      end
+
+      def fuck
+        ___ " #{CHAR_FAILURE} "
+      end
+
+      def header(command: nil)
+        out = "\n#{hr}\n"
+        out << "Arli (#{::Arli::VERSION.yellow})"
+        out << ", Command: #{command.name.to_s.magenta.bold}" if command
+        if command && command.params && Arli.config.verbose
+          out << "\n#{command.params.to_s.blue}\n"
+        end
+        out << "\nLibrary Path: #{Arli.default_library_path.green}\n"
+        out << "#{hr}\n"
+        info out
+      end
+
+      def hr
+        ('-' * (ENV['COLUMNS'] || 80)).red.dark
+      end
+
+      # Some shortcuts
+      def verbose?
+        config.verbose && !quiet?
+      end
+
+      def quiet?
+        config.quiet
+      end
+
+      def overwrite?
+        config.if_exists.overwrite
+      end
+
+      def backup?
+        config.if_exists.backup
+      end
+
+      def abort?
+        config.if_exists.abort
+      end
+
+      def debug?
+        config.debug
+      end
+
+      def indent_cursor(value = 40)
+        ___ cursor.column(value)
+      end
+    end
+  end
+end