arli 0.5.1 → 0.6.1

data/lib/arli/commands/install.rb

@@ -2,24 +2,29 @@ require 'json'
 require 'arli'
 require 'net/http'
 require_relative 'base'
-require_relative '../installers/zip_file'
+require_relative '../installer'
 
 module Arli
   module Commands
     class Install < Base
 
-      def initialize(options)
-        super(options)
-        self.arlifile = Arli::ArliFile.new(lib_path:      lib_path,
-                                           arlifile_path: options[:arli_dir])
+      attr_accessor :arlifile
+
+      def initialize(*args)
+        super(*args)
       end
 
-      def run
-        arlifile.each_dependency do |lib|
-          Arli::Installer.new(lib: lib, command: self).install
-        end
+      def setup
+        self.arlifile = Arli::ArliFile.new(config: config)
+      end
+
+      def params
+        arlifile.file
       end
 
+      def run
+        arlifile.each_dependency { |lib| lib.install }
+      end
     end
   end
 end

data/lib/arli/commands/search.rb

@@ -6,6 +6,7 @@ require 'arli/commands/base'
 require 'arli/errors'
 require 'arduino/library'
 require 'awesome_print'
+
 module Arli
   module Commands
     class Search < Base
@@ -13,41 +14,65 @@ module Arli
 
       attr_accessor :search_string,
                     :search_opts,
+                    :results,
                     :limit,
                     :database
 
-      def initialize(options)
-        super(options)
-        self.search_string = options[:argv].first
+      def initialize(*args)
+        super(*args)
+      end
+
+      def setup
+        search             = runtime.argv.first
 
-        puts "using search string [#{search_string}]" if search_string && Arli.debug?
-        self.limit = options[:limit] || 100
+        self.search_string = if search =~ /:/
+                               search
+                             elsif search
+                               "name: /#{search}/"
+                             end
 
-        raise Arli::Errors::InvalidSyntaxError, 'Please provide search string after the "search" command' \
-          unless search_string
+        self.limit = config.search.results.limit
+
+        unless search_string
+          raise Arli::Errors::InvalidSyntaxError,
+                'Please provide search string after the "search" command'
+        end
 
         begin
           self.search_opts = eval("{ #{search_string} }")
         rescue => e
           raise Arli::Errors::InvalidSyntaxError, "Search string '#{search_string}' is invalid.\n" +
-            e.message.red
+              e.message.red
         end
 
         unless search_opts.is_a?(::Hash) && search_opts.size > 0
           raise Arli::Errors::InvalidSyntaxError, "Search string '#{search_string}' did not eval to Hash.\n"
         end
 
-        self.database = options[:database] ? db_from(option[:database]) : db_default
+        self.database = db_default
 
         search_opts.merge!(limit: limit) if limit && limit > 0
+        search_opts.delete(:limit) if limit == 0
       end
 
       def run
-        ap search(database, **search_opts).map(&:to_hash)
+        self.results = search(database, **search_opts)
+        results.map do |lib|
+          puts pretty_library(lib)
+        end
+        puts "\nTotal matches: #{results.size.to_s.bold.magenta}"
       rescue Exception => e
         error e
         puts e.backtrace.join("\n") if ENV['DEBUG']
       end
+
+      def pretty_library(lib, **options)
+        "#{lib.name.bold.blue} (#{lib.version.yellow}), by #{lib.author.magenta}"
+      end
+
+      def params
+        search_opts
+      end
     end
   end
 end

data/lib/arli/configuration.rb

@@ -0,0 +1,62 @@
+require 'dry-configurable'
+require 'arduino/library'
+require 'yaml'
+
+module Arli
+  class Configuration
+
+    DEFAULT_FILENAME    = 'Arlifile'.freeze
+    ACTIONS_WHEN_EXISTS = %i(backup overwrite abort)
+    ARLI_COMMAND        = 'arli'.freeze
+
+    extend Dry::Configurable
+
+    # These are populated during the parsing of the params
+    setting :runtime do
+      setting :argv
+      setting :command do
+        setting :name
+        setting :instance
+      end
+    end
+
+    setting :libraries do
+      setting :path, ::Arduino::Library::DefaultDatabase.library_path
+    end
+
+    setting :database do
+      setting :path, ::Arduino::Library::DefaultDatabase.library_index_path
+      setting :url, ::Arduino::Library::DefaultDatabase.library_index_url
+    end
+
+    setting :arlifile do
+      setting :path, ::Dir.pwd
+      setting :name, ::Arli::Configuration::DEFAULT_FILENAME
+    end
+
+    setting :search do
+      setting :default_field, :name
+      setting :results do
+        setting :limit, 100
+        setting :format, :inspect
+      end
+    end
+
+    setting :install do
+      setting :library
+      setting :if_exists do
+        setting :overwrite, true
+        setting :backup, false
+        setting :abort, false
+      end
+    end
+
+    setting :debug, ENV['ARLI_DEBUG'] || false
+    setting :trace, false
+    setting :verbose, false
+    setting :help, false
+    setting :command_help, false
+  end
+end
+
+

data/lib/arli/extensions.rb

@@ -0,0 +1,9 @@
+class String
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        tr('-', '_').
+        downcase
+  end
+end

data/lib/arli/installer.rb

@@ -1,100 +1,52 @@
-require 'arli'
 require 'forwardable'
+require 'arli'
+require_relative 'actions'
+
 module Arli
   class Installer
-    extend Forwardable
-    attr_accessor :lib, :lib_dir, :lib_path, :command
+    include ::Arli::Output
 
-    def_delegators :@command, :info, :error, :debug
+    extend Forwardable
+    def_delegators :@library, :exists?
 
-    def initialize(lib:, command:, lib_path: Arli.library_path)
-      self.lib      = lib
-      self.command  = command
-      self.lib_dir  = lib.name.gsub(/ /, '_')
-      self.lib_path = lib_path
-    end
+    attr_accessor :library, :config
 
-    def exists?
-      Dir.exist?(target_lib_path)
+    def initialize(library, config: Arli.config)
+      self.config  = config
+      self.library = library
     end
 
     def install
-      action = self.exists? ? 'replacing' : 'installing'
-      backup! if command.create_backup
-      abort! if exists? && command.abort_if_exists
+      ___ "#{library.name.blue} "
 
-      s "#{action} #{lib.name.blue}"
-      library = ::Arduino::Library::Resolver.resolve(lib)
-
-      if library.nil?
-        s ' ❌ ' + "\n"
+      if library.nil? && library.library.nil?
+        ___ ' (no library) '
+        fuck
       elsif library.url.nil?
-        s ' ❌ ' + "\n"
+        ___ ' (no url) '
+        fuck
       else
-        s "(#{library.version.blue})" if library.version
-        s '✔ '.bold.green
-        if library.url =~ /\.zip$/i
-          s 'unpacking zip...'
-          Arli::Installers::ZipFile.new(lib: library).install
-          s '✔ '.bold.green
-        else
-          c = exists? ? git_update_command : git_clone_command
-          s 'running git...'
-          execute(c)
-          s '✔ '.bold.green
+        ___ "(#{library.version.green}) " if library.version
+        actions(library).each do |action|
+          run_action(action)
         end
       end
-      s nil, true
-    end
-
-
-    def git_update_command
-      "cd #{lib_dir} && git pull --rebase 2>&1"
-    end
-
-    def git_clone_command
-      "git clone -v #{lib.url} #{lib_dir} 2>&1"
-    end
-
-    def backup_lib_path
-      target_lib_path + ".#{Time.now.strftime('%Y%m%d%H%M%S')}"
+      ___ "\n"
     end
 
-    def target_lib_path
-      "#{lib_path}/#{lib_dir}"
+    def run_action(action)
+      klass = Arli::Actions.action(action)
+      klass.new(library, config: config).act if klass
     end
 
-    def backup!
-      FileUtils.cp_r(target_lib_path, backup_lib_path) if exists?
+    def actions(library)
+      actions = []
+      actions << :backup if exists?
+      # First, how do we get the library?
+      actions << ((library.url =~ /\.zip$/i) ? :zip_file : :git_repo)
+      actions << :dir_name
+      actions
     end
-
-    def abort!
-      raise Arli::Errors::LibraryAlreadyExists,
-            "Library #{target_lib_path} already exists!"
-    end
-
-    def s(msg, newline = false)
-      printf msg + ' ' if msg
-      puts if newline
-    end
-
-    protected
-
-    # @param <String> *args — list of arguments or a single string
-    def execute(*args)
-      cmd = args.join(' ')
-      raise 'No command to run was given' unless cmd
-      info("\n" + cmd.green) if self.debug
-      o, e, s = Open3.capture3(cmd)
-      info("\n" + o) if o if self.debug
-      info("\n" + e.red) if e && self.debug
-      s
-    rescue Exception => e
-      error "Error running [#{args.join(' ')}]\n" +
-              "Current folder is [#{Dir.pwd.yellow}]", e
-      raise e
-    end
-
   end
 end
 

data/lib/arli/library.rb

@@ -0,0 +1,49 @@
+require_relative 'installer'
+
+module Arli
+  class Library
+    attr_accessor :lib, :config, :canonical_dir
+
+    def initialize(lib, config: Arli.config)
+      self.lib           = lib
+      self.config        = config
+    end
+
+    def install
+      Arli::Installer.new(self).install
+    end
+
+    def rm_rf!
+      FileUtils.rm_rf(dir)
+    end
+
+    def libraries_home
+      config.libraries.path
+    end
+
+    def dir
+      lib.name.gsub(/ /, '_')
+    end
+
+    def path
+      libraries_home + '/' + dir
+    end
+
+    def canonical_path
+      libraries_home + '/' + canonical_dir
+    end
+
+    def exists?
+      Dir.exist?(path)
+    end
+
+    def method_missing(method, *args, &block)
+      if lib && lib.respond_to?(method)
+        lib.send(method, *args, &block)
+      else
+        super(method, *args, &block)
+      end
+    end
+
+  end
+end

data/lib/arli/output.rb

@@ -0,0 +1,94 @@
+require 'colored2'
+
+module Arli
+  module Output
+
+    class << self
+      attr_accessor :enabled
+      def enable!
+        self.enabled = true
+      end
+      def enabled?
+        self.enabled
+      end
+      def disable!
+        self.enabled = false
+      end
+    end
+
+    self.enable!
+
+    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)
+      __pf header.bold.yellow + ': ' if header
+      error e.message if (e && e.respond_to?(:message))
+      if e && Arli.config.trace
+        __pf e.backtrace.reverse.join("\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::Output.enabled?
+      __pf msg if msg
+      __p '.'.green if msg.nil?
+      __pt if newline
+    end
+
+    def __pt(*args)
+      puts(*args) if Arli::Output.enabled?
+    end
+
+    def __p(*args)
+      print(*args) if Arli::Output.enabled?
+    end
+
+    def __pf(*args)
+      printf(*args) if Arli::Output.enabled?
+    end
+
+    def ok
+      ___ '.'.bold.green
+    end
+
+    def fuck
+      ___ '✖'.bold.red
+    end
+
+    def header(command: nil)
+      out = "\n#{hr}\n"
+      out << "Arli (#{::Arli::VERSION.yellow})"
+      out << " running #{command.name.to_s.magenta.bold}" if command
+      out << " for #{command.params.to_s.blue}\n" if command
+      out << "Library Path: #{Arli.default_library_path.green}\n"
+      out << "#{hr}\n"
+      info out
+    end
+
+    def hr
+      '——————————————————————————————————————————————————————————'.red
+    end
+
+  end
+end