arli 0.3.2 → 0.5.1

data/lib/arli/commands/base.rb

@@ -3,89 +3,40 @@ require 'fileutils'
 require 'open3'
 require 'arli'
 require 'arli/version'
+require 'arli/errors'
 
 module Arli
   module Commands
     class Base
-      attr_accessor :lib_path, :arli_file, :abort_if_exists, :command
+      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.command         = self.class.name.gsub(/.*::/, '').downcase.to_sym
+        self.create_backup   = options[:create_backup]
+        self.debug           = options[:debug]
+        self.trace           = options[:trace]
+
+        self.command = self.class.name.gsub(/.*::/, '').downcase.to_sym
         setup
       end
 
-      def header
-        out  = "——————————————————————————————————————————————————————————\n"
-        out  <<  "Arli           : Version #{::Arli::VERSION.bold.yellow}\n"
-        out  << "Command        : #{command.to_s.bold.blue}\n" if command
-        out  << "Library Path   : #{lib_path.bold.green}\n" if lib_path
-        out  << "ArliFile       : #{arli_file.file.bold.magenta}\n" if
-          arli_file && arli_file.file
-        out << '——————————————————————————————————————————————————————————'
-
-        info out
-
-        self
-      end
-
-      # Commands implement #run method that uses helpers below:
-      protected
-
-      def all_dependencies(cmd, *args)
-        for_each_dependency do |dep|
-          begin
-            method_name = "#{cmd}_dependency".to_sym
-            argv        = args.map { |key| dep[key] }
-            if self.respond_to?(method_name)
-              info("dependency #{dep.inspect}: calling #{method_name} with args #{argv.inspect}") if Arli::DEBUG
-              self.send(method_name, *argv) do |system_command|
-                execute(system_command)
-              end
-            else
-              raise ArgumentError,
-                    "Method #{method_name.to_s.bold.blue} is not implemented on #{self.class.name.bold.red}"
-            end
-          end
-        end
-      rescue Exception => e
-        error "Error while running command #{cmd}:\n\n#{e.message.bold.red}"
-        if Arli::DEBUG
-          error e.backtrace.join("\n")
-        end
+      def name
+        self.class.name.gsub(/.*::/, '').downcase
       end
 
       def setup
         FileUtils.mkdir_p(lib_path)
       end
 
-      # @param <String> *args — list of arguments or a single string
-      def execute(*args)
-        cmd = args.join(' ')
-        info cmd.bold.green
-        o, e, s = Open3.capture3(cmd)
-        puts o if o
-        puts e.red if e
-        s
-      rescue Exception => e
-        error "Error running [#{cmd.bold.yellow}]\n" +
-                "Current folder is [#{Dir.pwd.bold.yellow}]", e
-        raise e
-      end
-
-      def for_each_dependency(&_block)
-        raise 'Library Path is nil!' unless lib_path
-        FileUtils.mkpath(lib_path) unless Dir.exist?(lib_path)
-        arli_file.each do |dependency|
-          Dir.chdir(lib_path) do
-            yield(dependency)
-          end
-        end
-      end
-
       def error(msg, exception = nil)
-        printf 'Runtime Error: '.bold.red + "\n#{msg}\n" if msg
+        printf 'Runtime Error: '.red + "\n#{msg}\n" if msg
         if exception
           puts
           printf 'Exception: '.red + "\n#{exception.inspect.red}\n\n"
@@ -94,7 +45,7 @@ module Arli
       end
 
       def info(msg, header = nil)
-        printf('%-20s', header.bold.blue) if header
+        printf('%-20s', header.blue) if header
         printf((header ? ' : ' : '') + msg + "\n") if msg
       end
 

data/lib/arli/commands/install.rb

@@ -1,37 +1,25 @@
 require 'json'
-require 'fileutils'
-require 'open3'
 require 'arli'
-require 'arli/commands/update'
+require 'net/http'
+require_relative 'base'
+require_relative '../installers/zip_file'
 
 module Arli
   module Commands
-    class Install < Update
+    class Install < Base
 
-      def run
-        all_dependencies(command, 'name', 'url')
+      def initialize(options)
+        super(options)
+        self.arlifile = Arli::ArliFile.new(lib_path:      lib_path,
+                                           arlifile_path: options[:arli_dir])
       end
 
-      def install_dependency(name, url)
-        cmd = if Dir.exist?(name)
-                if abort_if_exists
-                  raise <<-EOF
-                               Existing folder found for library #{name.red}. 
-                               Please use -u switch with 'install' command, 
-                               or invoke the 'update' command directly."
-                                EOF
-                          .gsub(/^\s+/, '')
-
-                else
-                  update_dependency(name)
-                end
-              else
-                "git clone -v #{url} #{name} 2>&1"
-              end
-        yield(cmd) if block_given?
-        cmd
+      def run
+        arlifile.each_dependency do |lib|
+          Arli::Installer.new(lib: lib, command: self).install
+        end
       end
-    end
 
+    end
   end
 end

data/lib/arli/commands/search.rb

@@ -3,6 +3,7 @@ require 'fileutils'
 require 'open3'
 require 'arli'
 require 'arli/commands/base'
+require 'arli/errors'
 require 'arduino/library'
 require 'awesome_print'
 module Arli
@@ -15,30 +16,30 @@ module Arli
                     :limit,
                     :database
 
-      class InvalidOptionError < ArgumentError; end
-
       def initialize(options)
         super(options)
-        self.search_string = options[:search]
-        self.limit         = options[:limit] || 100
+        self.search_string = options[:argv].first
+
+        puts "using search string [#{search_string}]" if search_string && Arli.debug?
+        self.limit = options[:limit] || 100
 
-        raise InvalidOptionError, 'Please provide search string with --search' \
+        raise Arli::Errors::InvalidSyntaxError, 'Please provide search string after the "search" command' \
           unless search_string
 
         begin
           self.search_opts = eval("{ #{search_string} }")
         rescue => e
-          raise InvalidOptionError "Search string '#{search_string}' is invalid.\n" +
+          raise Arli::Errors::InvalidSyntaxError, "Search string '#{search_string}' is invalid.\n" +
             e.message.red
         end
 
         unless search_opts.is_a?(::Hash) && search_opts.size > 0
-          raise InvalidOptionError, "Search string '#{search_string}' did not eval to Hash.\n"
+          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
 
-        search_opts.merge!(limit: limit) if limit
+        search_opts.merge!(limit: limit) if limit && limit > 0
       end
 
       def run

data/lib/arli/config.rb

@@ -0,0 +1,16 @@
+module Arli
+  class Config
+    DEFAULT_FILENAME = 'Arlifile'.freeze
+    PARAMS           = %i(
+                          library_path
+                          library_index_path
+                          library_index_url
+                          logger
+                          debug
+                          )
+
+    class << self
+      attr_accessor *PARAMS
+    end
+  end
+end

data/lib/arli/errors.rb

@@ -0,0 +1,19 @@
+module Arli
+  module Errors
+    class ArliError < StandardError; end
+
+    class InvalidCommandError < ArliError; end
+
+    class InvalidSyntaxError  < ArliError; end
+
+    class AbstractMethodCalled < ArliError; end
+
+    class ArliFileNotFound < ArliError; end
+
+    class LibraryAlreadyExists < ArliError; end
+
+    class InstallerError < ArliError; end
+
+    class ZipFileError < InstallerError; end
+  end
+end

data/lib/arli/installer.rb

@@ -0,0 +1,100 @@
+require 'arli'
+require 'forwardable'
+module Arli
+  class Installer
+    extend Forwardable
+    attr_accessor :lib, :lib_dir, :lib_path, :command
+
+    def_delegators :@command, :info, :error, :debug
+
+    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
+
+    def exists?
+      Dir.exist?(target_lib_path)
+    end
+
+    def install
+      action = self.exists? ? 'replacing' : 'installing'
+      backup! if command.create_backup
+      abort! if exists? && command.abort_if_exists
+
+      s "#{action} #{lib.name.blue}"
+      library = ::Arduino::Library::Resolver.resolve(lib)
+
+      if library.nil?
+        s ' ❌ ' + "\n"
+      elsif library.url.nil?
+        s ' ❌ ' + "\n"
+      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
+        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')}"
+    end
+
+    def target_lib_path
+      "#{lib_path}/#{lib_dir}"
+    end
+
+    def backup!
+      FileUtils.cp_r(target_lib_path, backup_lib_path) if exists?
+    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/installers/zip_file.rb

@@ -0,0 +1,61 @@
+require 'archive/zip'
+
+module Arli
+  module Installers
+    class ZipFile
+      attr_accessor :lib, :lib_dir
+
+      def initialize(lib:)
+        self.lib     = lib
+        self.lib_dir = lib.name.gsub(/ /, '_')
+        raise 'Invalid URL for this installer: ' + lib.url unless lib.url =~ /\.zip$/i
+      end
+
+      def install
+        download!
+
+        remove_library!
+        remove_library_versions!
+
+        unzip(zip_archive, '.')
+
+        dir = dirs_matching(lib_dir).first
+
+        FileUtils.move(dir, lib_dir) if dir
+
+        FileUtils.rm_f(zip_archive) if File.exist?(zip_archive)
+      end
+
+      def remove_library!
+        FileUtils.rm_rf(lib_dir)
+      end
+
+      def remove_library_versions!
+        dirs = dirs_matching(lib_dir)
+        dirs.delete(lib_dir) # we don't want to delete the actual library
+        dirs.each { |d| FileUtils.rm_f(d) }
+      end
+
+      private
+
+      def dirs_matching(name)
+        Dir.glob("#{name}*").select { |d| File.directory?(d)  }
+      end
+
+      def zip_archive
+        @zip_archive ||= File.basename(lib.url)
+      end
+
+      def download!
+        File.write(zip_archive, Net::HTTP.get(URI.parse(lib.url)))
+      end
+
+      # def unzip(file, destination)
+      #   Archive::Zip.extract(file, destination, on_error: :skip)
+      # end
+      def unzip(file, destination)
+        `unzip -o #{file} -d #{destination}`
+      end
+    end
+  end
+end

data/lib/arli/logger.rb

@@ -0,0 +1,13 @@
+module Arli
+  module Logger
+    def self.included(base)
+      base.instance_eval do
+        %i(debug info error warn fatal).each do |level|
+          define_method "_#{level}" do |*args|
+            Arli.logger.send(level, *args) if Arli.logger
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arli/parser.rb

@@ -1,14 +1,21 @@
 require 'arduino/library'
+require 'arli/config'
+require 'arli/version'
+
 module Arli
   class CLI
     class Parser < OptionParser
-      attr_accessor :output_lines, :command, :options
+      attr_accessor :output_lines, :command, :options, :arlifile
 
       def initialize(command = nil)
         super(nil, 22)
-        self.output_lines = Array.new
-        self.command      = command
-        self.options      = Hashie::Mash.new
+        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
       end
 
       def sep(text = nil)
@@ -16,66 +23,83 @@ module Arli
       end
 
       def option_dependency_file
-        on('-a', '--arli-file FILE',
-           'ArliFile.yml'.bold.green + ' is the file listing the dependencies',
-           "Default filename is #{DEFAULT_ARLI_FILE.bold.magenta})\n\n") do |v|
-          options[:arli_file] = v
+        on('-p', '--arli-path PATH',
+           'Folder where ' + 'Arlifile'.green + ' is located,',
+           "Defaults to the current directory.\n\n") do |v|
+          options[:arli_dir] = v
         end
       end
 
       def option_lib_home
-        on('-l', '--lib-home HOME', 'Local folder where libraries are installed',
-           "Default: #{default_library_path}\n\n") do |v|
+        on('-l', '--libs PATH', 'Local folder where libraries are installed',
+           "Defaults to #{default_library_path}\n\n") do |v|
           options[:lib_home] = v
         end
       end
 
-
       def option_search
-        on('-s', '--search TERMS', 'ruby-style hash arguments to search for',
-           %Q(eg: -s "name: 'AudioZero', version: /^1.0/")) do |v|
-          options[:search] = v
-        end
-        on('-d', '--database SOURCE',
+        on('-d', '--database FILE/URL',
            'a JSON file name, or a URL that contains the index',
-           'By default, the Arduino-maintained list is searched') do |v|
+           'Defaults to the Arduino-maintained list') do |v|
           options[:database] = v
         end
-        on('-m', '--max LIMIT',
+        on('-m', '--max NUMBER',
            'if provided, limits the result set to this number',
-           'Default value is 100') do |v|
-             options[:limit] = v.to_i 
+           'Defaults to 100') do |v|
+          options[:limit] = v.to_i if v
         end
       end
 
       def option_abort_if_exists
-        on('-e', '--abort-on-exiting',
-           'Abort if a library folder already exists',
-           'instead of updating it.') do |v|
-          options[:abort_if_exists] = true
+        on('-e', '--if-exists ACTION',
+           'If a library folder already exists, by default',
+           '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/
+          end
         end
+        sep ' '
       end
 
-      def option_help(commands: false, command: nil)
+      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
         on('-h', '--help', 'prints this help') do
-          puts 'Description:'.bold if command
-          output ' ' * 4 + command[:description].bold.green if command
+          output 'Description:' if command_name
+          output ' ' * 4 + command_name[:description].green if command_name
           output ''
           output_help
           output_command_help if commands
+
+          if command_name && command_name[:example]
+            output 'Example:'
+            output ' ' * 4 + command_name[:example]
+          end
+
           options[:help] = true
         end
       end
 
-      def option_library
-        on('-n', '--lib-name LIBRARY', 'Library Name') { |v| options[:library_name] = v }
-        on('-f', '--from FROM', 'A git or https URL') { |v| options[:library_from] = v }
-        on('-v', '--version VERSION', 'Library Version, i.e. git tag') { |v| options[:library_version] = v }
-        on('-i', '--install', 'Install a library') { |v| options[:library_action] = :install }
-        on('-r', '--remove', 'Remove a library') { |v| options[:library_action] = :remove }
-        on('-u', '--update', 'Update a local library') { |v| options[:library_action] = :update }
-      end
-
       def option_help_with_subtext
         option_help
       end
@@ -89,14 +113,14 @@ module Arli
       end
 
       def command_help
-        subtext = "Available Commands:\n".bold
+        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/
         end
         subtext << <<-EOS
         
-See #{COMMAND.bold.blue + ' <command> '.bold.green + '--help'.bold.yellow} for more information on a specific command.
+See #{COMMAND.blue + ' <command> '.green + '--help'.yellow} for more information on a specific command.
 
         EOS
         subtext
@@ -112,9 +136,8 @@ See #{COMMAND.bold.blue + ' <command> '.bold.green + '--help'.bold.yellow} for m
       end
 
       def default_library_path
-        Arduino::Library::DEFAULT_ARDUINO_LIBRARY_PATH.gsub(%r(#{ENV['HOME']}), '~').blue
+        ::Arli.config.library_path.gsub(%r(#{ENV['HOME']}), '~').blue
       end
-
     end
   end
 end