arli 0.7.0 → 0.8.3

data/lib/arli/cli/parser_factory.rb

@@ -9,13 +9,13 @@ module Arli
         def default_help
           gp = global_parser
           gp.parse!(%w(--help))
-          gp.print
+          print_parser_help(gp)
         end
 
         def parse_argv(parser, argv)
           if parser
             parser.parse!(argv)
-            parser.print
+            print_parser_help(parser)
           end
         end
 
@@ -34,47 +34,95 @@ module Arli
 
         def command_parsers
           @command_parsers ||= {
-              install: {
-                  description: 'installs libraries defined in Arlifile or by -n flag',
-                  examples:    [
-                                   { desc: 'Install all libs defined in the ./Arlifile file',
-                                     cmd:  'arli install' },
-                                   { desc: 'Install a single library matched by the --name flag',
-                                     cmd:  'arli install -n "Adafruit GFX Library"' }
-                               ],
-
-                  parser:      -> (command_name) {
-                    make_parser(command_name) do |parser|
-                      parser.banner = usage_line 'install'
-                      parser.option_install
-                      parser.option_help(command_name: command_name)
-                    end
-                  } },
-
-              search:  {
-                  description: 'Flexible Search of the Arduino Library Database',
-                  examples:    [
-                                   { desc: 'Search using the regular expression containing the name:',
-                                     cmd:  'arli search AudioZero' },
-
-                                   { desc: 'Same exact search as above, but using advanced ruby hash arguments syntax:',
-                                     cmd:  %Q{arli search 'name: /AudioZero/'} },
-
-                                   { desc: 'Search using case insensitive name search:',
-                                     cmd:  %Q{arli search 'name: /adafruit/i'} },
-
-                                  { desc: 'Finally, search for the exact name match:',
-                                     cmd:  %Q{arli search '^Time$'} },
-                               ],
-
-                  parser:      -> (command_name) {
-                    make_parser(command_name) do |parser|
-                      parser.banner = usage_line 'search ' + '[ name | search-expression ]'.magenta
-                      parser.option_search
-                      parser.option_help(command_name: command_name)
-                    end
-                  }
-              }
+              search:  Hashie::Mash.new(
+                  {
+                      sentence:    'Search standard Arduino Library Database with over 4K entries',
+                      description: ["This command provides both the simple name-based search interface,\n",
+                                    "and the most sophisticated field-by-field search using a downloaded, \n",
+                                    "and locally cached Public Arduino Database JSON file, maintained\n",
+                                    "by Arduino and the Community. If you know of another database,\n",
+                                    "that's what the --database flag is for."],
+                      examples:    [
+                                       { desc: 'Search using the regular expression containing the name:',
+                                         cmd:  'arli search AudioZero' },
+
+                                       { desc: 'Same exact search as above, but using ruby hash syntax:',
+                                         cmd:  %Q{arli search 'name: /AudioZero/'} },
+
+                                       { desc: 'Lets get a particular version of the library',
+                                         cmd:  %Q{arli search 'name: "AudioZero", version: "1.0,2"'} },
+
+                                       { desc: 'Search using case insensitive name search, and :',
+                                         cmd:  %Q{arli search 'name: /adafruit/i'} },
+
+                                       { desc: 'Finally, search for the exact name match:',
+                                         cmd:  %Q{arli search '^Time$'} },
+                                   ],
+
+                      parser:      -> (command_name) {
+                        make_parser(command_name) do |parser|
+                          parser.banner = usage_line 'search ' + '[ name | search-expression ]'.magenta
+                          parser.option_search
+                          parser.option_help(command_name: command_name)
+                        end
+                      }
+                  }),
+
+              bundle:  Hashie::Mash.new(
+                  {
+                      sentence: 'Installs all libraries specified in Arlifile',
+                      description:
+                                [
+                                    "This command reads ", "Arlifile".bold.green, " (from the current folder, by default),\n",
+                                    "and then it installs all dependent libraries specified there, checking if \n",
+                                    "each already exists, and if not —  downloading them, and installing them into\n",
+                                    "your Arduino Library folder. Both the folder with the Arlifile, as well as the\n",
+                                    "destination library path folder can be changed with the command line flags.\n",
+                                ],
+                      examples: [
+                                    { desc: 'Install all libs defined in Arlifile:',
+                                      cmd:  'arli bundle ' },
+
+                                    { desc: 'Custom Arlifile location, and destination path:',
+                                      cmd:  'arli bundle -a ./src -l ./libraries' }
+                                ],
+
+                      parser:   -> (command_name) {
+                        make_parser(command_name) do |parser|
+                          parser.banner = usage_line 'bundle'
+                          parser.option_bundle
+                          parser.option_help(command_name: command_name)
+                        end
+                      } }),
+
+              install: Hashie::Mash.new(
+                  {
+                      sentence:    'Installs a single library either by searching, or url or local ZIP',
+                      description: [
+                                       "This command installs a single library into your library path\n",
+                                       "using the third argument to the command #{'arli install'.bold.white}\n".dark ,
+                                       "which can be a library name, local ZIP file, or a remote URL \n",
+                                       "(either ZIP or Git Repo)\n"
+
+                                   ],
+                      examples:    [
+                                       { desc: 'Install the latest version of this library',
+                                         cmd:  'arli install "Adafruit GFX Library"' },
+
+                                       { desc: 'Install the library from a Github URL',
+                                         cmd:  'arli install https://github.com/jfturcot/SimpleTimer' },
+
+                                       { desc: 'Install a local ZIP file',
+                                         cmd:  'arli install ~/Downloads/DHT-Library.zip' },
+                                   ],
+
+                      parser:      -> (command_name) {
+                        make_parser(command_name) do |parser|
+                          parser.banner = usage_line 'install' + ' [ "library name" | url | local-zip ] '.magenta
+                          parser.option_install
+                          parser.option_help(command_name: command_name)
+                        end
+                      } }),
           }
         end
 
@@ -93,21 +141,28 @@ module Arli
         end
 
         def global_usage(command)
-          "Usage:\n    " + Arli::Configuration::ARLI_COMMAND.blue +
-              ' [ options ] '.yellow + '[ ' + (command || 'command').green +
-              ' [ options ] '.yellow + ' ]' + "\n"
+          'Usage:'.magenta.bold +
+              "\n    " + arli_command + ' options '.yellow +
+              "\n    " + arli_command + ' ' + ((command || 'command')).green + ' [ options ] '.yellow + "\n"
+        end
+
+        def arli_command
+          @arli_command ||= Arli::Configuration::ARLI_COMMAND.blue.bold
         end
 
         def command_usage(command)
-          "Usage:\n    " + Arli::Configuration::ARLI_COMMAND.blue + ' ' +
-              command.green +
-              ' [options]'.yellow + "\n\n" +
-              'Command Options'
+          'Usage:'.magenta.bold +
+              "\n    " + arli_command + ' ' + command.green + ' [options]'.yellow + "\n\n" +
+              'Options'.magenta.bold
         end
 
         def usage_line(command = nil)
           command ? command_usage(command) : global_usage(command)
         end
+
+        def print_parser_help(parser)
+          parser.print
+        end
       end
 
 

data/lib/arli/cli/runner.rb

@@ -17,12 +17,13 @@ module Arli
           $stdout = @stdout
 
           Arli::CLI::App.new(@argv).start
+          print_debug_info
           0
         rescue StandardError => e
           b = e.backtrace
-          @stderr.puts("#{b.shift.bold}:\n")
+          @stderr.puts("#{b.shift.bold}:\n") if Arli.config.debug
           @stderr.puts("#{e.message.bold.red} (#{e.class.name.yellow})")
-          @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n")).red
+          @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n").red)
           1
         rescue SystemExit => e
           e.status
@@ -30,11 +31,14 @@ module Arli
           $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
+
+      def print_debug_info
+        $stdout.puts JSON.pretty_generate(Arli.config.to_hash).gsub(/("\w+":)/, '\1'.bold.blue) \
+          if Arli.config.debug
+      end
     end
   end
-
 end

data/lib/arli/commands.rb

@@ -5,4 +5,5 @@ end
 
 require_relative 'commands/base'
 require_relative 'commands/search'
+require_relative 'commands/bundle'
 require_relative 'commands/install'

data/lib/arli/commands/base.rb

@@ -15,14 +15,9 @@ module Arli
 
       def initialize(config: Arli.config)
         self.config = config
-        FileUtils.mkdir_p(library_path) unless Dir.exist?(library_path)
         setup
       end
 
-      def run(*args)
-        raise ArgumentError, 'This method must be implemented in subclasses'
-      end
-
       def runtime
         config.runtime
       end
@@ -35,12 +30,22 @@ module Arli
         config.libraries.path
       end
 
+      def temp_path
+        config.libraries.temp_dir
+      end
+
       def setup
+        FileUtils.mkdir_p(library_path) unless Dir.exist?(library_path)
+        FileUtils.mkdir_p(temp_path) unless Dir.exist?(temp_path)
+      end
 
+      def run(*args)
+        raise Arli::Errors::AbstractMethodCalled,
+          'This method must be implemented in subclasses'
       end
 
       def params
-
+        ''
       end
     end
   end

data/lib/arli/commands/bundle.rb

@@ -0,0 +1,43 @@
+require 'json'
+require 'arli'
+require 'net/http'
+require_relative 'base'
+require_relative '../arli_file'
+require_relative '../lock/formats'
+require_relative '../lock/file'
+
+module Arli
+  module Commands
+    class Bundle < Base
+
+      attr_accessor :arlifile, :lock_file
+
+      def setup
+        super
+        self.arlifile = Arli::ArliFile.new(config: config)
+        self.lock_file = Arli::Lock::File.new(config: config)
+      end
+
+      def params
+        if arlifile&.libraries
+          "libraries: \n • " + arlifile.libraries.map(&:name).join("\n • ")
+        end
+      end
+
+      def run
+        install_with_arli_file
+      end
+
+      protected
+
+      def install_with_arli_file
+        arlifile.install
+        post_install
+      end
+
+      def post_install
+        lock_file.lock!(*arlifile.libraries)
+      end
+    end
+  end
+end

data/lib/arli/commands/install.rb

@@ -1,31 +1,74 @@
+require 'hashie/mash'
+require 'net/http'
 require 'json'
 require 'arli'
-require 'net/http'
+
+require 'arduino/library'
 require_relative 'base'
-require_relative '../installer'
+require_relative 'bundle'
 
 module Arli
   module Commands
-    class Install < Base
+    class Install < Bundle
+      require 'arduino/library/include'
+
+      attr_accessor :library
 
-      attr_accessor :arlifile
+      def setup
+        validate_argument
+
+        self.library  = identify_library(runtime.argv.first)
+        validate_library
 
-      def initialize(*args)
-        super(*args)
+        self.arlifile = Arli::ArliFile.new(config: config, libraries: [library]) if library
       end
 
-      def setup
-        self.arlifile = Arli::ArliFile.new(
-            config:    config,
-            libraries: Arli.config.install.library_names)
+      # 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
       end
 
       def params
-        "libraries: \n • " + arlifile.dependencies.map(&:name).join("\n • ")
+        " • #{library.to_s}"
+      end
+
+      def post_install
+        #
+      end
+
+      private
+
+      def validate_search(arg, results)
+        raise Arli::Errors::LibraryNotFound,
+              "Can't find library by argument #{arg.bold.yellow}" if results.nil? || results.empty?
+        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
       end
 
-      def run
-        arlifile.each_dependency { |lib| lib.install }
+      def cfg
+        config.install
       end
     end
   end

data/lib/arli/commands/search.rb

@@ -5,69 +5,124 @@ require 'arli'
 require 'arli/commands/base'
 require 'arli/errors'
 require 'arduino/library'
-require 'awesome_print'
 
 module Arli
   module Commands
     class Search < Base
+
+      LibraryWithVersion = Struct.new(:name, :versions)
+
       require 'arduino/library/include'
 
       attr_accessor :search_string,
                     :search_opts,
                     :results,
                     :limit,
-                    :database
+                    :database,
+                    :format,
+                    :hash,
+                    :custom_print
 
       def initialize(*args)
         super(*args)
+        self.format       = :short
+        self.hash         = Hash.new
+        self.custom_print = true
       end
 
-      def setup
-        search             = runtime.argv.first
+      def run
+        self.search_opts = process_search_options!
+        self.results     = search(database, **search_opts).sort
 
-        self.search_string = if search =~ /:/
-                               search
-                             elsif search
-                               "name: /#{search}/"
-                             end
+        results.map do |lib|
+          hash[lib.name] ||= LibraryWithVersion.new(lib.name, [])
+          hash[lib.name].versions << lib.version
 
-        self.limit = config.search.results.limit
+          method = "to_s_#{format}".to_sym
+          if lib.respond_to?(method)
+            self.custom_print = false
+            lib.send(method)
+          end
+        end
 
-        unless search_string
-          raise Arli::Errors::InvalidSyntaxError,
-                'Please provide search string after the "search" command'
+        if custom_print
+          previous = nil
+          results.each do |lib|
+            print_lib(hash[lib.name]) unless previous == lib.name
+            previous = lib.name
+          end
         end
+        print_total_with_help
+      rescue Exception => e
+        error e
+        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})": '')
+      end
+
+      def process_search_options!
+        self.search_string = extract_search_argument!
+        raise_error_unless_search_string!
+
+        self.limit  = config.search.results.limit
+        search_opts = {}
         begin
-          self.search_opts = eval("{ #{search_string} }")
+          search_opts = eval("{ #{search_string} }")
         rescue => e
-          raise Arli::Errors::InvalidSyntaxError, "Search string '#{search_string}' is invalid.\n" +
-              e.message.red
+          handle_error(e)
         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"
+          raise Arli::Errors::InvalidSearchSyntaxError,
+                "Search string '#{search_string}' did not eval to Hash.\n"
         end
 
         self.database = db_default
 
         search_opts.merge!(limit: limit) if limit && limit > 0
         search_opts.delete(:limit) if limit == 0
+        search_opts
       end
 
-      def run
-        self.results = search(database, **search_opts)
-        results.sort.map do |lib|
-          puts pretty_library(lib)
+      def extract_search_argument!
+        search = runtime.argv.first
+        if search =~ /:/
+          search
+        elsif search
+          "#{config.search.default_field}: /^#{search}$/"
         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}"
+      def raise_error_unless_search_string!
+        unless search_string
+          raise Arli::Errors::InvalidSyntaxError,
+                'Expected an argument or a flag to follow the command ' + 'search'.bold.green
+        end
+      end
+
+      def handle_and_raise_error(e)
+        message = e.message
+        if message =~ /undefined method.*Arduino::Library::Model/
+          message = "Invalid attributed search. Possible values are:" +
+              "\n#{Arduino::Library::Types::LIBRARY_PROPERTIES.keys}"
+        end
+        raise Arli::Errors::InvalidSearchSyntaxError,
+              "Search string '#{search_string}' is invalid.\n" +
+                  message.red
+      end
+
+      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 "———————————————————————"
+        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."
+        end
       end
 
       def params