arli 0.8.3 → 0.9.0

data/Rakefile

@@ -8,7 +8,7 @@ def shell(*args)
 end
 
 task :permissions do 
-  shell('rm -rf pkg/ tmp/' )
+  shell('rm -rf pkg/ tmp/ coverage/' )
   shell("chmod -v o+r,g+r * */* */*/* */*/*/* */*/*/*/* */*/*/*/*/*")
   shell("find . -type d -exec chmod o+x,g+x {} \\;")
 end

data/arli.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'arduino-library', '~> 0.5.4'
   spec.add_dependency 'colored2'
+  spec.add_dependency 'awesome_print'
   spec.add_dependency 'hashie'
   spec.add_dependency 'dry-types'
   spec.add_dependency 'dry-struct'

data/exe/arli

@@ -8,3 +8,4 @@ end
 require 'arli/cli/runner'
 Arli::CLI::Runner.new(ARGV.dup).execute!
 
+

data/lib/arli.rb

@@ -1,5 +1,5 @@
 require 'arduino/library'
-
+require 'arli/helpers/inherited'
 require 'arli/version'
 require 'arli/extensions'
 require 'arli/errors'

data/lib/arli/actions/action.rb

@@ -1,10 +1,14 @@
-require_relative '../output'
+require 'arli/helpers/output'
+require 'arli/helpers/inherited'
 
 module Arli
   module Actions
     # Represents an abstract action related to the library
     class Action
-      include Arli::Output
+      include Arli::Helpers::Output
+
+      include Arli::Helpers::Inherited
+      attr_assignable :check_command, :check_pattern, :description
 
       extend Forwardable
       def_delegators :@library,
@@ -15,37 +19,7 @@ module Arli
 
       class << self
         def inherited(base)
-
-          base.instance_eval do
-            class << self
-              attr_writer :check_command, :check_pattern, :description
-
-              def action_name
-                name.gsub(/.*::/, '').underscore.to_sym
-              end
-
-              def set_or_get(var_name, val = nil)
-                var = "@#{var_name}".to_sym
-                self.instance_variable_set(var, val) if val
-                self.instance_variable_get(var)
-              end
-
-              def check_pattern(val = nil)
-                set_or_get('check_pattern', val)
-              end
-
-              def check_command(val = nil)
-                set_or_get('check_command', val)
-              end
-
-              def description(val = nil)
-                set_or_get('description', val)
-              end
-            end
-          end
-
-          # Add to the list of actions
-          ::Arli::Actions.actions[base.action_name] = base
+          ::Arli::Actions.actions[base.short_name] = base
         end
       end
 

data/lib/arli/actions/unzip_file.rb

@@ -12,12 +12,7 @@ module Arli
         return if library.url !~ /\.zip$/i
 
         download!
-
-        if File.exist?(zip_archive)
-          FileUtils.rm_rf(top_dir_inside_zip) if top_dir_inside_zip
-          unzip(zip_archive, '.')
-          FileUtils.move(top_dir_inside_zip, dir) if Dir.exist?(top_dir_inside_zip)
-        end
+        move_in_place!
       rescue Exception => e
         fuck
         raise(e)
@@ -27,6 +22,14 @@ module Arli
 
       private
 
+      def move_in_place!
+        if File.exist?(zip_archive)
+          FileUtils.rm_rf(top_dir_inside_zip) if top_dir_inside_zip
+          unzip(zip_archive, '.')
+          FileUtils.move(top_dir_inside_zip, dir) if Dir.exist?(top_dir_inside_zip)
+        end
+      end
+
       def delete_zip!
         FileUtils.rm_f(zip_archive) if File.exist?(zip_archive)
       end

data/lib/arli/arli_file.rb

@@ -3,24 +3,41 @@ require 'yaml'
 require 'forwardable'
 require 'arduino/library'
 require 'hashie/mash'
+require 'hashie/extensions/symbolize_keys'
+require 'arli/library'
 
 module Arli
   class ArliFile
     require 'arduino/library/include'
 
     include Enumerable
-    extend Forwardable
 
+    extend Forwardable
     def_delegators :@dependencies, *(Array.new.methods - Object.methods)
 
+    include ::Arli::Library
+
     attr_accessor :dependencies,
                   :parsed_data,
-                  :arlifile_path
+                  :arlifile_path,
+                  :config
 
     def initialize(config: Arli.config, libraries: [])
-      self.arlifile_path             = "#{config.arlifile.path}/#{config.arlifile.name}"
-      self.dependencies              = read_dependencies(libraries)
-      Arli.config.libraries.temp_dir ||= Dir.mktmpdir
+      self.config = config
+      self.arlifile_path = "#{config.arlifile.path}/#{config.arlifile.name}"
+      self.dependencies = read_dependencies(libraries)
+
+      self.config.libraries.temp_dir ||= Dir.mktmpdir
+
+      if parsed_data
+        if parsed_data.libraries_path
+          self.config.libraries.path = parsed_data.libraries_path
+        end
+
+        if parsed_data.lock_format
+          Arli.config.arlifile.lock_format = parsed_data.lock_format
+        end
+      end
     end
 
     alias libraries dependencies
@@ -43,26 +60,6 @@ module Arli
       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]
-        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
@@ -72,7 +69,7 @@ module Arli
 
     def read_dependencies(libraries)
       if libraries && !libraries.empty?
-        libraries.map { |lib| make_lib(lib) }
+        libraries.map {|lib| make_lib(lib)}
       else
         unless arlifile_path && File.exist?(arlifile_path)
           raise(Arli::Errors::ArliFileNotFound,
@@ -83,8 +80,15 @@ module Arli
     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) }
+      self.parsed_data = Hashie::Mash.new(
+          Hashie::Extensions::SymbolizeKeys.symbolize_keys(
+              ::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,18 +1,17 @@
 require 'forwardable'
 require 'optparse'
-require 'colored2'
 require 'tmpdir'
 require_relative 'parser'
 require_relative 'command_finder'
 require_relative 'parser_factory'
 require_relative '../commands'
-require_relative '../output'
+require 'arli/helpers/output'
 
 
 module Arli
   module CLI
     class App
-      include Arli::Output
+      include Arli::Helpers::Output
 
       attr_accessor :argv, :config, :command
 

data/lib/arli/cli/command_finder.rb

@@ -8,13 +8,13 @@ require_relative 'parser_factory'
 require_relative '../commands'
 require_relative '../commands/search'
 require_relative '../commands/install'
-require_relative '../output'
+require 'arli/helpers/output'
 
 module Arli
   module CLI
     class CommandFinder
 
-      include Arli::Output
+      include Arli::Helpers::Output
 
       attr_accessor :argv, :config, :command_name, :command
 

data/lib/arli/cli/parser.rb

@@ -69,15 +69,32 @@ module Arli
       def option_search
         on('-d', '--database URL',
            'a JSON(.gz) file path or a URL of the library database.',
-           'Defaults to the Arduino-maintained database.') do |v|
+           'Defaults to the Arduino-maintained database.' + "\n\n") do |v|
           config.database.path = v
         end
 
         on('-m', '--max NUMBER',
-           'if provided, limits the result set to this number',
-           'Set to 0 to disable. Default is 100.') do |v|
+           'if provided, limits the result set using the ',
+           'total number of the unique library name matches.',
+           'Default is 0, which means no limit.' + "\n\n") do |v|
           config.search.results.limit = v.to_i if v
         end
+
+        formats = Arli::Library::MultiVersion.format_methods
+
+        on('-f', '--format FMT',
+           "Optional format of the search results.",
+           "The default is #{'short'.bold.yellow}. Available ",
+           "formats: #{formats.join(', ').bold.yellow}\n\n") do |v|
+          if formats.include?(v.downcase.to_sym)
+            config.search.results.output_format = v.downcase.to_sym
+          else
+            raise ::OptionParser::InvalidOption,
+                  "#{v.yellow} is not a supported search result format"
+          end
+        end
+
+        option_search_attributes
       end
 
       def option_if_exists
@@ -115,6 +132,17 @@ module Arli
         end
       end
 
+      def option_search_attributes
+        on('-A', '--print-attrs', 'prints full list of available library',
+           'attributes that can be used in search strings.', ' ') do
+
+          ::Arli.config.help = true
+          output ''
+          header('Arduino Library Attributes:')
+          output "  • " + Arduino::Library::Types::LIBRARY_PROPERTIES.keys.join("\n  • ") + "\n\n"
+        end
+      end
+
       def header(string)
         output "#{string.bold.magenta}:"
         output
@@ -174,6 +202,7 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
         on('-C', '--no-color',
            'Disable any color output.') do |*|
           Colored2.disable! # if $stdout.tty?
+          config.no_color = true
         end
         on('-D', '--debug',
            'Print debugging info.') do |v|
@@ -183,10 +212,6 @@ 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
@@ -209,7 +234,7 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
 
       def output_command_description(command_name)
         command_hash = factory.command_parsers[command_name]
-        indent = '    '
+        indent       = '    '
 
         if command_hash
           if command_hash.description
@@ -218,7 +243,9 @@ See #{Arli::Configuration::ARLI_COMMAND.blue + ' command '.green + '--help'.yell
               output indent + command_hash.sentence.bold
               output ''
             end
-            output indent + Array(command_hash[:description]).map(&:dark).join('').gsub(/\n/, "\n#{indent}")
+
+            text = Array(command_hash[:description]).flatten.join(' ')
+            output text.reformat_wrapped(width = 70, indent_with = 8)
           end
         end
 

data/lib/arli/cli/parser_factory.rb

@@ -28,6 +28,7 @@ module Arli
           @global ||= make_parser do |parser|
             parser.banner = usage_line
             parser.sep
+            parser.option_search_attributes
             parser.option_help(commands: true)
           end
         end
@@ -36,32 +37,38 @@ module Arli
           @command_parsers ||= {
               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."],
+                      sentence:    'Search standard Arduino Library Database with over 4K entries ',
+                      description: %Q[This command provides both the simple name-based search interface,
+                                    and the most sophisticated attribute-specific search using a downloaded, 
+                                    and locally cached Public Arduino Database JSON file, maintained 
+                                    by the Arduino Community. If you know of another database, 
+                                    that's what the #{'--database'.blue} flag is for.
+                                    Note that you can print the list of available attributes by 
+                                    running arli with #{'--print-attrs'.blue} flag.
+                                    ],
                       examples:    [
-                                       { desc: 'Search using the regular expression containing the name:',
-                                         cmd:  'arli search AudioZero' },
+                                       { desc: 'Finds any library with name matching a given string, case insensitively',
+                                         cmd:  'arli search audiozero' },
 
-                                       { desc: 'Same exact search as above, but using ruby hash syntax:',
-                                         cmd:  %Q{arli search 'name: /AudioZero/'} },
+                                       { desc: 'If the first character is "/", then the argument is assumed to be regex',
+                                         cmd:  %Q{arli search /AudioZero$/  } },
 
-                                       { desc: 'Lets get a particular version of the library',
-                                         cmd:  %Q{arli search 'name: "AudioZero", version: "1.0,2"'} },
+                                       { desc: 'If the first character is "=", then the rest is assumed to be exact name',
+                                         cmd:  %Q{arli search =Time  } },
 
-                                       { desc: 'Search using case insensitive name search, and :',
-                                         cmd:  %Q{arli search 'name: /adafruit/i'} },
+                                       { desc: 'Lets get a particular version of the library using another attribute',
+                                         cmd:  %Q{arli search 'name: "AudioZero", version: "1.0.2"'} },
 
-                                       { desc: 'Finally, search for the exact name match:',
-                                         cmd:  %Q{arli search '^Time$'} },
+                                       { desc: 'Search using case insensitive search for the author',
+                                         cmd:  %Q{arli search 'author: /adafruit/i'} },
+
+                                       { desc: 'Finally, search for regex match for "WiFi" in a sentence or a paragraph',
+                                         cmd:  %Q{arli search 'sentence: /wifi/i, paragraph: /wifi/i'} },
                                    ],
 
                       parser:      -> (command_name) {
                         make_parser(command_name) do |parser|
-                          parser.banner = usage_line 'search ' + '[ name | search-expression ]'.magenta
+                          parser.banner = usage_line 'search ' + '[ -A | search-expression ] '.magenta
                           parser.option_search
                           parser.option_help(command_name: command_name)
                         end
@@ -71,15 +78,13 @@ module Arli
               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",
+                      description: %Q[This command reads #{'Arlifile'.bold.green} (from the current folder, by default),
+                                    and then it installs all dependent libraries specified there, checking if
+                                    each already exists, and if not — downloading them, and installing them into
+                                    your Arduino Library folder. Both the folder with the Arlifile, as well as the
+                                    destination library path folder can be changed with the command line flags.
                                 ],
-                      examples: [
+                      example: [
                                     { desc: 'Install all libs defined in Arlifile:',
                                       cmd:  'arli bundle ' },
 
@@ -98,27 +103,24 @@ module Arli
               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"
-
+                      description: %Q[This command installs a single library into your library path
+                                       (which can be set with #{'--lib-path'.blue} flag).
+                                       Arli interpretes the third argument to #{'arli install'.bold.blue}
+                                       as either an exact library name, or a remote URL
+                                       (either ZIP or Git Repo). You can use #{'search'.bold.green} command
+                                       to first find the right library name, and then pass it to the install command.
                                    ],
                       examples:    [
-                                       { desc: 'Install the latest version of this library',
-                                         cmd:  'arli install "Adafruit GFX Library"' },
+                                       { desc: 'Install the latest version of this library locally',
+                                         cmd:  'arli install "Adafruit GFX Library" -l ./libraries' },
 
                                        { 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' },
+                                         cmd:  'arli install https://github.com/jfturcot/SimpleTimer' }
                                    ],
 
                       parser:      -> (command_name) {
                         make_parser(command_name) do |parser|
-                          parser.banner = usage_line 'install' + ' [ "library name" | url | local-zip ] '.magenta
+                          parser.banner = usage_line 'install' + ' [ "Exact Library Name" | url ] '.magenta
                           parser.option_install
                           parser.option_help(command_name: command_name)
                         end