arli 0.7.0 → 0.8.3

data/lib/arli/actions/dir_name.rb

@@ -10,9 +10,13 @@ module Arli
     # This action renames invalid library folders based on the
     # source files found inside.
     class DirName < Action
+
+      description 'Auto-detects the canonical library folder name'
+
       attr_accessor :sources, :headers
 
-      def act
+      def execute
+
         find_source_files
 
         # so "dir" is the 'Adafruit_Unified_Sensor'
@@ -20,29 +24,27 @@ module Arli
         # rename the folder
 
         if headers.include?(dir) || sources.include?(dir)
-          print_target_dir(dir)
+          set_canonical_dir!(dir)
         else
-          # if we end up setting this, we'll also move the folder.
-          canonical_dir =
+          candidate =
               if_only_one(headers) ||
                   if_only_one(sources) ||
                   if_header_a_substring(headers)
 
-          if canonical_dir
-            library.canonical_dir = canonical_dir
-            mv(dir, library.canonical_dir)
-            print_target_dir(canonical_dir)
-          else
-            library.canonical_dir = dir
-            print_target_dir(dir)
-          end
+          set_canonical_dir!(candidate)
         end
-
-
       end
 
-      def print_target_dir(d)
-        ___ " installed to #{d.green} #{'✔'.green}" unless Arli.config.quiet
+      private
+
+      def set_canonical_dir!(canonical_dir)
+        if canonical_dir && canonical_dir != dir
+          mv(dir, canonical_dir)
+          library.canonical_dir = canonical_dir
+        else
+          library.canonical_dir = dir
+        end
+        print_target_dir(library.canonical_dir, 'installed to')
       end
 
       def if_header_a_substring(files)

data/lib/arli/actions/git_repo.rb

@@ -2,13 +2,13 @@ require_relative 'action'
 module Arli
   module Actions
     class GitRepo < Action
+      description 'Fetches or updates remote git repositories'
+      check_command 'git --version'
+      check_pattern 'git version'
 
-      def act
-        c = library.exists? ? git_update_command : git_clone_command
-        execute(c)
-      rescue Exception => e
-        fuck
-        raise e
+      def execute
+        run_system_command(git_clone_command)
+        print_action_success('cloned', "cloned from #{library.url}")
       end
 
       def git_update_command
@@ -22,7 +22,7 @@ module Arli
       protected
 
       # @param <String> *args — list of arguments or a single string
-      def execute(*args)
+      def run_system_command(*args)
         cmd = args.join(' ')
         raise 'No command to run was given' unless cmd
         info("\n" + cmd.green) if Arli.debug?
@@ -31,7 +31,7 @@ module Arli
         info("\n" + e.red) if e && Arli.debug?
       rescue Exception => e
         error "Error running [#{args.join(' ')}]\n" +
-                "Current folder is [#{Dir.pwd.yellow}]", e
+                  "Current folder is [#{Dir.pwd.yellow}]", e
         raise e
       end
     end

data/lib/arli/actions/move_to_library_path.rb

@@ -0,0 +1,54 @@
+require_relative 'action'
+
+module Arli
+  module Actions
+    class MoveToLibraryPath < Action
+      description 'Moves the downloaded library to the proper path, optionally creating a backup'
+
+      def execute
+        Dir.chdir(config.runtime.pwd) do
+
+          handle_preexisting_folder(path) if exists?
+
+          if Dir.exist?(temp_path) && !Dir.exist?(path)
+            FileUtils.mkdir_p(File.dirname(path))
+            ___ "current: #{Dir.pwd.yellow}\ntemp_path: #{temp_path.yellow}\nlibrary_path: #{path.yellow}\n" if debug?
+            mv(temp_path, path)
+          elsif Dir.exist?(path)
+            raise ::Arli::Errors::InstallerError,
+                  "Directory #{path} was not expected to still be there!"
+          elsif !Dir.exist?(temp_path)
+            raise ::Arli::Errors::InstallerError,
+                  "Directory #{temp_path} was expected to exist!"
+          end
+        end
+      end
+
+      private
+
+      def handle_preexisting_folder(to)
+        if Dir.exist?(to)
+          if abort?
+            raise ::Arli::Errors::LibraryAlreadyExists, "Directory #{to} already exists"
+          elsif backup?
+            backup!(to)
+          elsif overwrite?
+            FileUtils.rm_rf(to)
+          end
+        end
+      end
+
+      def backup!(p)
+        if Dir.exist?(p)
+          backup_path = "#{p}.arli-backup-#{Time.now.strftime('%Y%m%d%H%M%S')}"
+          FileUtils.mv(p, backup_path)
+          print_target_dir(backup_path, 'backed up')
+          if verbose?
+            ___ "\nNOTE: path #{p.blue} has been backed up to #{backup_path.bold.green}\n"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/arli/actions/{zip_file.rb → unzip_file.rb}

@@ -1,24 +1,28 @@
-require 'archive/zip'
 require_relative 'action'
 
 module Arli
   module Actions
-    class ZipFile < Action
-      def act
-        # TODO: verify that this works if backup option is provided
-        library.rm_rf!
+    class UnzipFile < Action
+      description 'Downloads and unzip remote ZIP archives'
+      check_command 'unzip -h'
+      check_pattern 'extract files to pipe'
+
+      def execute
+        return if library.url.nil?
+        return if library.url !~ /\.zip$/i
+
         download!
+
         if File.exist?(zip_archive)
-          FileUtils.rm_rf(zip_folder) if zip_folder
+          FileUtils.rm_rf(top_dir_inside_zip) if top_dir_inside_zip
           unzip(zip_archive, '.')
-          FileUtils.move(zip_folder, dir) if Dir.exist?(zip_folder)
+          FileUtils.move(top_dir_inside_zip, dir) if Dir.exist?(top_dir_inside_zip)
         end
       rescue Exception => e
         fuck
-        puts
         raise(e)
       ensure
-        delete_zip!
+        delete_zip! rescue nil
       end
 
       private
@@ -36,7 +40,7 @@ module Arli
       end
 
       # list the contents of the archive and grab the top level folder
-      def zip_folder
+      def top_dir_inside_zip
         @zip_folder ||= `unzip -Z1 #{zip_archive} | awk 'BEGIN{FS="/"}{print $1}' | uniq | tail -1`.chomp
       end
 

data/lib/arli/arli_file.rb

@@ -2,6 +2,7 @@ require 'arli'
 require 'yaml'
 require 'forwardable'
 require 'arduino/library'
+require 'hashie/mash'
 
 module Arli
   class ArliFile
@@ -13,58 +14,77 @@ module Arli
     def_delegators :@dependencies, *(Array.new.methods - Object.methods)
 
     attr_accessor :dependencies,
-                  :file_hash,
-                  :file,
-                  :library_path
+                  :parsed_data,
+                  :arlifile_path
 
     def initialize(config: Arli.config, libraries: [])
-      self.library_path = config.libraries.path
-      FileUtils.mkpath(library_path) unless Dir.exist?(library_path)
-
-      if libraries && !libraries.empty?
-        self.dependencies = libraries.map{ |lib| make_lib(lib) }
-      else
-        self.file         = "#{config.arlifile.path}/#{config.arlifile.name}"
-        unless file && File.exist?(file)
-          raise(Arli::Errors::ArliFileNotFound,
-                "Arlifile could not be found at\n#{file.bold.yellow}")
-        end
-        self.dependencies = parse_file
-      end
+      self.arlifile_path             = "#{config.arlifile.path}/#{config.arlifile.name}"
+      self.dependencies              = read_dependencies(libraries)
+      Arli.config.libraries.temp_dir ||= Dir.mktmpdir
     end
 
-    def within_library_path
-      Dir.chdir(library_path) do
-        yield if block_given?
-      end
-    end
+    alias libraries dependencies
 
-    def each_dependency(&block)
-      within_library_path { dependencies.each(&block) }
+    def install
+      each_in_temp_path do |lib|
+        lib.install
+      end
     end
 
     private
 
-    def parse_file
-      self.file_hash = ::YAML.load(::File.read(self.file))
-      file_hash['dependencies'].map { |lib| make_lib(lib) }
+    def within_temp_path(&block)
+      within_path(Arli.config.libraries.temp_dir, &block)
     end
 
-    def make_lib(lib)
-      ::Arli::Library.new(library_model(lib))
+    def each_in_temp_path(&block)
+      within_temp_path do
+        dependencies.each(&block)
+      end
     end
 
+
     def library_model(lib)
+      return lib if lib.is_a?(::Arduino::Library::Model)
+
       ::Arduino::Library::Model.from(lib).tap do |model|
         if model.nil?
           lib_output = (lib && lib['name']) ? lib['name'] : lib.inspect
           raise Arli::Errors::LibraryNotFound, 'Error: '.bold.red +
-                "Library #{lib_output.yellow} ".red + "was not found.\n\n".red +
-                    %Q[  HINT: run #{"arli search 'name: /#{lib_output}/'".green}\n] +
-                    %Q[        to find the exact name of the library you are trying\n] +
-                    %Q[        to install. Alternatively, provide a url: field.\n]
+              "Library #{lib_output.yellow} ".red + "was not found.\n\n".red +
+              %Q[  HINT: run #{"arli search 'name: /#{lib_output}/'".green}\n] +
+              %Q[        to find the exact name of the library you are trying\n] +
+              %Q[        to install. Alternatively, provide a url: field.\n]
+        end
+      end
+    end
+
+    def make_lib(lib)
+      ::Arli::Library::Proxy.new(library_model(lib))
+    end
+
+    def within_path(p, &_block)
+      FileUtils.mkpath(p) unless Dir.exist?(p)
+      Dir.chdir(p) do
+        yield if block_given?
+      end
+    end
+
+    def read_dependencies(libraries)
+      if libraries && !libraries.empty?
+        libraries.map { |lib| make_lib(lib) }
+      else
+        unless arlifile_path && File.exist?(arlifile_path)
+          raise(Arli::Errors::ArliFileNotFound,
+                "Arlifile could not be found at\n#{arlifile_path.bold.yellow}")
         end
+        parse_yaml_file
       end
     end
+
+    def parse_yaml_file
+      self.parsed_data = Hashie::Mash.new(::YAML.load(::File.read(self.arlifile_path)))
+      parsed_data.dependencies.map { |lib| make_lib(lib) }
+    end
   end
 end

data/lib/arli/cli/app.rb

@@ -1,7 +1,7 @@
 require 'forwardable'
 require 'optparse'
 require 'colored2'
-
+require 'tmpdir'
 require_relative 'parser'
 require_relative 'command_finder'
 require_relative 'parser_factory'
@@ -17,9 +17,11 @@ module Arli
       attr_accessor :argv, :config, :command
 
       def initialize(argv, config: Arli.config)
-        self.argv                = argv
-        self.config              = config
-        self.config.runtime.argv = argv
+        self.argv                      = argv
+        self.config                    = config
+        self.config.runtime.argv       = argv
+        self.config.runtime.pwd        = ::Dir.pwd
+        Arli.config.libraries.temp_dir = ::Dir.mktmpdir
       end
 
       def start
@@ -47,8 +49,13 @@ module Arli
         report_exception(e, 'Invalid flags or options')
       rescue Arli::Errors::InvalidCommandError => e
         report_exception(e, 'Unknown command')
+      rescue Arli::Errors::InvalidSyntaxError => e
+        report_exception(e, 'Incorrect command usage')
       rescue Exception => e
         report_exception(e)
+      ensure
+        d = Arli.config.libraries.temp_dir
+        FileUtils.rm_rf(d) if Dir.exist?(d) rescue nil
       end
 
       def parse_global_flags

data/lib/arli/cli/command_finder.rb

@@ -36,11 +36,19 @@ module Arli
         self
       end
 
+      def detect_command
+        return nil unless non_flag_argument?
+        cmd = argv.shift.to_sym
+        if factory.valid_command?(cmd)
+          cmd
+        else
+          raise_invalid_arli_command!(cmd)
+        end
+      end
+
       def parse_command_arguments!(cmd)
         parser = factory.command_parser(cmd)
-        if parser
-          factory.parse_argv(parser, argv)
-        end
+        factory.parse_argv(parser, argv) if parser
       end
 
       def instantiate_command
@@ -53,14 +61,9 @@ module Arli
         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
+
+      def non_flag_argument?
+        argv.first && argv.first !~ /^-.*$/
       end
 
       def factory

data/lib/arli/cli/parser.rb

@@ -1,8 +1,10 @@
 require 'arli/configuration'
+require 'colored2'
+require 'optionparser'
 
 module Arli
   module CLI
-    class Parser < OptionParser
+    class Parser < ::OptionParser
 
       attr_accessor :output_lines,
                     :command,
@@ -21,38 +23,51 @@ module Arli
       end
 
       def option_install
-        option_library_name
         option_lib_home
-        option_dependency_file
         option_if_exists
       end
 
-      def option_dependency_file
+      def option_bundle
+        option_lib_home
+        option_arlifile_path
+        option_arlifile_lock_format
+        option_if_exists
+      end
+
+      def option_arlifile_path
         on('-a', '--arli-path PATH',
-           'Folder where ' + 'Arlifile'.green + ' is located,',
+           'An alternate folder with the ' + 'Arlifile'.green + ' file.',
            "Defaults to the current directory.\n\n") do |v|
           config.arlifile.path = v
         end
       end
 
-      def option_library_name
-        on('-n', '--name NAME',
-           'If provided a library name is searched and, if found',
-           'installed. In this mode Arlifile not used.' + "\n\n") do |v|
-          config.install.library_names << { name: v }
+      SUPPORTED_FORMATS = %w[cmake text json yaml]
+
+      def option_arlifile_lock_format
+        on('-f', '--format FMT',
+           "Arli writes an #{'Arlifile.lock'.green} with resolved info.",
+           "The default format is #{'text'.bold.yellow}. Use -f to set it",
+           "to one of: #{SUPPORTED_FORMATS.join(', ').bold.yellow}\n\n") do |v|
+          if SUPPORTED_FORMATS.include?(v.downcase)
+            config.arlifile.lock_format = v.downcase.to_sym
+          else
+            raise ::OptionParser::InvalidOption,
+                  "#{v.yellow} is not a supported lock file format"
+          end
         end
       end
 
       def option_lib_home
-        on('-l', '--libraries PATH',
-           'Local folder where custom Arduino libraries are installed',
-           "Defaults to #{Arli.default_library_path}\n\n") do |v|
+        on('-l', '--lib-path PATH',
+           'Destination: typically your Arduino libraries folder',
+           "Defaults to #{'~/Documents/Arduino/Libraries'.green}\n\n") do |v|
           config.libraries.path = v
         end
       end
 
       def option_search
-        on('-d', '--database FILE/URL',
+        on('-d', '--database URL',
            'a JSON(.gz) file path or a URL of the library database.',
            'Defaults to the Arduino-maintained database.') do |v|
           config.database.path = v
@@ -72,10 +87,10 @@ module Arli
            'Alternatively you can either ' + 'abort'.bold.blue + ' or ' + 'backup'.bold.blue
         ) do |v|
           if v == 'abort'
-            config.install.if_exists.abort     = true
-            config.install.if_exists.overwrite = false
+            config.if_exists.abort     = true
+            config.if_exists.overwrite = false
           elsif v == 'backup'
-            config.install.if_exists.backup = true
+            config.if_exists.backup = true
           end
         end
         sep ' '
@@ -87,13 +102,7 @@ module Arli
         on('-h', '--help', 'prints this help') do
           ::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
+          command_hash = output_command_description(command_name)
 
           output_help
           output_command_help if commands
@@ -106,9 +115,14 @@ module Arli
         end
       end
 
+      def header(string)
+        output "#{string.bold.magenta}:"
+        output
+      end
+
       def output_examples(examples)
-        output 'Examples:'
-        indent = '     '
+        header 'Examples'
+        indent = '    '
         examples.each do |example|
           output
           output indent + '# ' + example[:desc]
@@ -131,9 +145,10 @@ module Arli
 
       def command_help
 
-        subtext = "Available Commands:\n"
+        header 'Available Commands'
+        subtext = ''
         factory.command_parsers.each_pair do |command, config|
-          subtext << %Q/#{sprintf('    %-12s', command.to_s).green} — #{sprintf('%s', config[:description]).blue}\n/
+          subtext << %Q/#{sprintf('    %-12s', command.to_s).green} — #{sprintf('%s', config[:sentence]).blue}\n/
         end
         subtext << <<-EOS
 
@@ -156,6 +171,10 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
       end
 
       def common_help_options
+        on('-C', '--no-color',
+           'Disable any color output.') do |*|
+          Colored2.disable! # if $stdout.tty?
+        end
         on('-D', '--debug',
            'Print debugging info.') do |v|
           config.debug = true
@@ -164,6 +183,10 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
            'Print exception stack traces.') do |v|
           config.trace = v
         end
+#        on('-n', '--dry-run',
+#           'Only print actions, but do not do them.') do |v|
+#          config.trace = v
+#        end
         on('-v', '--verbose',
            'Print more information.') do |v|
           config.verbose = true
@@ -181,7 +204,25 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
 
       def print_version_copyright
         output << Arli::Configuration::ARLI_COMMAND.bold.yellow + ' (' + Arli::VERSION.bold.green + ')' +
-            " © 2017 Konstantin Gredeskoul, MIT License."
+            ' © 2017 Konstantin Gredeskoul, MIT License.'.dark unless Arli.config.quiet
+      end
+
+      def output_command_description(command_name)
+        command_hash = factory.command_parsers[command_name]
+        indent = '    '
+
+        if command_hash
+          if command_hash.description
+            header 'Description'
+            if command_hash.sentence
+              output indent + command_hash.sentence.bold
+              output ''
+            end
+            output indent + Array(command_hash[:description]).map(&:dark).join('').gsub(/\n/, "\n#{indent}")
+          end
+        end
+
+        command_hash
       end
     end
   end