arli 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43e1909fb095e1501d093f53991d7272281c9bb5
-  data.tar.gz: ade74d5c96106dc1e1bea96716332fcdbe7648b8
+  metadata.gz: c4bcc7bfa074f09ae70dbf449ebe1112c6029bc2
+  data.tar.gz: 5cd8d400ae0861d24d041d39bb2fa46fcc847685
 SHA512:
-  metadata.gz: 4c9daf3b81b26a8ce323b03f71d14f70523566a6cf39cf29a1292a64f60f8812c5b819414542e43c0fac8c482a756b219f23fec025b8a1ce46efc2ad36a8fd5e
-  data.tar.gz: d5f564e8272beead7287ebd6b773456ecb42a02af44a61e3ab2a935a33805517390678dc4ae992fadd2f6ade61f71cd79ddfa0c0ebac4756cdf3c3da06d36513
+  metadata.gz: aef1c241150fadc67b359d8e337d2a3998d70b6e50181800a44b5c202348bcb11f4f9894826361f63455372bdd303404042da4e14f2765de311138ffa4e7ce5c
+  data.tar.gz: 4206dd840bf013f68ee1bb5b64400d3f9ee9225767b23957ad9c02bb728931f15c4faea3cff19b23df3ef98e8129b38d22044a2793f9f755d7e20bb7ab5aa498

data/README.md

@@ -6,7 +6,7 @@ Arli is a simple and easy to use installer of dependencies that can be
 declared in a JSON file of the following format:
 
 
-```json
+```js
 {
   "dependencies": [
     {
@@ -43,14 +43,13 @@ $ sudo gem install arli
 
 Run `arli --help` for more information:
 
-```
+```bash
 Usage:
     arli [options] [command [options]]
 
-    -L, --lib-home HOME              Specify a local directory where libraries are installed
-    -h, --help                       prints this help
+    -h, --help             prints this help
 
-  Available Commands:
+Available Commands:
     install      : installs libraries defined in the JSON file
     update       : updates libraries defined in the JSON file
     library      : Install, update, or remove a single library
@@ -60,9 +59,13 @@ See arli <command> --help for more information on a specific command.
 
 #### Install Command
 
-`install` is currently the only implemented command, and it should be used as follows:
+Use this command to install libraries for the first time. 
 
-```
+NOTE: you are allowed to pass `-u` flag to automatically fallback
+to updating any existing folders. So `arli install -u` will either install 
+or update all dependencies.
+
+```bash
 Description:
     installs libraries defined in the JSON file
 
@@ -70,11 +73,31 @@ Usage:
     arli install [options]
 
 Command Options
-    -L, --lib-home HOME              Specify a local directory where libraries are installed
-    -a, --arli-json FILE             JSON file with dependencies (defaults to arli.json)
-    -h, --help                       prints this help
+    -l, --lib-home HOME    Local folder where libraries are installed
+                           Default: ~/Documents/Arduino/Libraries
+    -j, --json FILE        JSON file with dependencies (defaults to arli.json)
+    -u, --update-existing  Update a library that already exists
+    -h, --help             prints this help
+
 ```
 
+#### Update Command
+
+To upate previously checked out libraries, use the `update` command:
+
+```
+Description:
+    updates libraries defined in the JSON file
+
+Usage:
+    arli update [options]
+
+Command Options
+    -l, --lib-home HOME    Local folder where libraries are installed
+                           Default: ~/Documents/Arduino/Libraries
+    -j, --json FILE        JSON file with dependencies (defaults to arli.json)
+    -h, --help             prints this help
+```
 
 ## Development
 

data/lib/arli.rb

@@ -1,10 +1,27 @@
 require 'arli/version'
 require 'arli/cli'
+require 'logger'
 
 module Arli
-  DEFAULT_JSON_FILE_ENV    = 'ARDUINO_ARLI_LIBRARY_FILE'.freeze
-  DEFAULT_JSON_FILE        = ENV[DEFAULT_JSON_FILE_ENV] || 'arli.json'.freeze
+  DEFAULT_JSON_FILE_ENV = 'ARDUINO_ARLI_LIBRARY_FILE'.freeze
+  DEFAULT_JSON_FILE     = ENV[DEFAULT_JSON_FILE_ENV] || 'arli.json'.freeze
 
   DEFAULT_LIBRARY_PATH_ENV = 'ARDUINO_CUSTOM_LIBRARY_PATH'.freeze
   DEFAULT_LIBRARY_PATH     = ENV[DEFAULT_LIBRARY_PATH_ENV] || (ENV['HOME'] + '/Documents/Arduino/Libraries')
+
+  DEBUG = ENV['DEBUG'] ? true : false
+
+  @logger       = Logger.new(STDOUT)
+  @logger.level = Logger::INFO
+
+  class << self
+    attr_accessor :logger
+
+    %i(debug info error warn fatal).each do |level|
+      define_method level do |*args|
+        self.logger.send(level, *args) if self.logger
+      end
+    end
+  end
 end
+

data/lib/arli/cli.rb

@@ -4,6 +4,7 @@ require 'hashie/extensions/symbolize_keys'
 require 'colored2'
 require 'arli'
 require 'arli/parser'
+require 'arli/commands/update'
 require 'arli/commands/install'
 
 module Arli
@@ -37,27 +38,37 @@ module Arli
         options.merge!(parser.options)
       end
 
-      @options = Hashie::Extensions::SymbolizeKeys.symbolize_keys!(options.to_h)
+      self.options = Hashie::Extensions::SymbolizeKeys.symbolize_keys!(options.to_h)
 
       run_command! unless options[:help]
 
     rescue InvalidCommandError => e
-      puts e.message
+      output e.message
+    end
+
+    def self.output(*args)
+      puts args.join("\n") unless args.empty?
+    end
+
+    def output(*args)
+      self.class.output(*args)
     end
 
     private
 
     def run_command!
       if command
-        command_class       = ::Arli::Commands.const_get(command.to_s.capitalize)
+        command_class = ::Arli::Commands.const_get(command.to_s.capitalize)
 
         options[:arli_json] ||= ::Arli::DEFAULT_JSON_FILE
         options[:lib_home]  ||= ::Arli::DEFAULT_LIBRARY_PATH
 
+        output "run_command #{command.to_s.bold.green}, options: #{options.inspect.bold.blue}" if Arli::DEBUG
         command_class.new(options).run
       end
     rescue NameError => e
-      puts "Unfortunately command #{command.to_s.red} is not yet implemented.\n\n"
+      output e.inspect
+      output "Unfortunately command #{command.to_s.red} is not yet implemented.\n\n"
     end
 
     def parse_command_options!
@@ -106,6 +117,7 @@ module Arli
                 parser.banner = usage_line 'install'
                 parser.option_lib_home
                 parser.option_dependency_file
+                parser.option_update_if_exists
                 parser.option_help(command: command)
               end
             } },

data/lib/arli/commands/base.rb

@@ -0,0 +1,106 @@
+require 'json'
+require 'fileutils'
+require 'open3'
+require 'arli'
+require 'arli/version'
+
+module Arli
+  module Commands
+    class Base
+      attr_accessor :lib_path, :json_file, :update_if_exists, :command
+
+      def initialize(options)
+        self.lib_path         = options[:lib_home]
+        self.json_file        = options[:arli_json]
+        self.update_if_exists = options[:update_if_exists]
+        self.command          = self.class.name.gsub(/.*::/, '').downcase.to_sym
+        setup
+      end
+
+
+      # Commands implement #run method that uses helpers below:
+      protected
+
+      def header
+        info   "Arli            : Version #{::Arli::VERSION.bold.yellow}\n" +
+               "Running command : #{command.to_s.bold.blue}\n" +
+               "Library Path    : #{lib_path.bold.green}\n" +
+               "JSON File       : #{json_file.bold.magenta}\n" +
+               '———————————————————————————————————————————————————————'
+      end
+
+      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
+      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)
+        dependencies['dependencies'].each do |dependency|
+          Dir.chdir(lib_path) do
+            yield(dependency)
+          end
+        end
+      end
+
+      def dependencies
+        @deps ||= begin
+          JSON.load(File.read(json_file))
+        rescue Errno::ENOENT => e
+          error("File #{json_file.bold.yellow} could not be found!", e)
+          { 'dependencies' => [] }
+        end
+      end
+
+      def error(msg, exception = nil)
+        printf 'Runtime Error: '.bold.red + "\n#{msg}\n" if msg
+        if exception
+          puts
+          printf 'Exception: '.red + "\n#{exception.inspect.red}\n\n"
+        end
+        puts
+      end
+
+      def info(msg, header = nil)
+        printf('%-20s', header.bold.blue) if header
+        printf((header ? ' : ' : '') + msg + "\n") if msg
+      end
+
+    end
+  end
+end

data/lib/arli/commands/install.rb

@@ -2,50 +2,37 @@ require 'json'
 require 'fileutils'
 require 'open3'
 require 'arli'
+require 'arli/commands/update'
 
 module Arli
   module Commands
-
-    class Install
-      attr_accessor :lib_path, :json_file
-
-      def initialize(options)
-
-        self.lib_path  = options[:lib_home]
-        self.json_file = options[:arli_json]
-
-        setup
-      end
+    class Install < Update
 
       def run
-        libs = JSON.load(File.read(json_file))
-        puts "Installing into #{lib_path.bold.green}"
-
-        Dir.chdir(lib_path) do
-          libs['dependencies'].each do |dependency|
-            name = dependency['name']
-            url  = dependency['git']
-            printf 'processing library: ' + name.yellow.bold + "\n"
-            unless Dir.exist?(name)
-              cmd = "git clone -v #{url} #{name} 2>&1"
-            else
-              cmd = "cd #{name} && git pull --rebase 2>&1"
-            end
-            puts 'command: ' + cmd.bold.blue
-            o, e, s = Open3.capture3(cmd)
-            puts o if o
-            puts e.red if e
-          end
-        end
+        header
+        all_dependencies(command, 'name', 'git')
       end
 
-      private
-
-      def setup
-        FileUtils.mkdir_p(lib_path)
-        yield self if block_given?
-        self
+      def install_dependency(name, url)
+        cmd = if Dir.exist?(name)
+                if update_if_exists
+                  update_dependency(name)
+                else
+                  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+/, '')
+
+                end
+              else
+                "git clone -v #{url} #{name} 2>&1"
+              end
+        yield(cmd) if block_given?
+        cmd
       end
     end
+
   end
 end

data/lib/arli/commands/update.rb

@@ -0,0 +1,23 @@
+require 'json'
+require 'fileutils'
+require 'open3'
+require 'arli'
+require_relative 'base'
+
+module Arli
+  module Commands
+    class Update < Base
+
+      def run
+        header
+        all_dependencies(command, 'name')
+      end
+
+      def update_dependency(name)
+        cmd = "cd #{name} && git pull --rebase 2>&1"
+        yield(cmd) if block_given?
+        cmd
+      end
+    end
+  end
+end

data/lib/arli/parser.rb

@@ -4,11 +4,10 @@ module Arli
       attr_accessor :output_lines, :command, :options
 
       def initialize(command = nil)
-        super
+        super(nil, 22)
         self.output_lines = Array.new
         self.command      = command
         self.options = Hashie::Mash.new
-
       end
 
       def sep(text = nil)
@@ -16,7 +15,24 @@ module Arli
       end
 
       def option_dependency_file
-        on('-a FILE', '--arli-json FILE', "JSON file with dependencies (defaults to #{DEFAULT_JSON_FILE.bold.magenta})") { |v| options[:arli_json] = v }
+        on('-j', '--json FILE',
+           "JSON file with dependencies (defaults to #{DEFAULT_JSON_FILE.bold.magenta})\n\n") do |v|
+          options[:arli_json] = v
+        end
+      end
+
+      def option_lib_home
+        on('-l', '--lib-home HOME', 'Local folder where libraries are installed',
+          "Default: #{Arli::DEFAULT_LIBRARY_PATH.gsub(%r(#{ENV['HOME']}), '~').blue}\n\n") do |v|
+          options[:lib_home] = v
+        end
+      end
+
+      def option_update_if_exists
+        on('-u', '--update-existing',
+           'Update a library that already exists') do |v|
+          options[:update_if_exists] = true
+        end
       end
 
       def option_help(commands: false, command: nil)
@@ -30,12 +46,8 @@ module Arli
         end
       end
 
-      def option_lib_home
-        on('-L', '--lib-home HOME', 'Specify a local directory where libraries are installed') { |v| options[:lib_home] = v }
-      end
-
       def option_library
-        on('-l', '--lib LIBRARY', 'Library Name') { |v| options[:library_name] = v }
+        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 }
@@ -56,12 +68,10 @@ module Arli
       end
 
       def command_help
-        subtext = "  Available Commands:\n"
+        subtext = "Available Commands:\n".bold
 
         ::Arli::CLI.commands.each_pair do |command, config|
-          subtext << <<-EOS
-#{sprintf('    %-12s', command.to_s).green} : #{sprintf('%-70s', config[:description]).yellow}
-          EOS
+          subtext << %Q/#{sprintf('    %-12s', command.to_s).green} : #{sprintf('%s', config[:description]).yellow}\n/
         end
         subtext << <<-EOS
         
@@ -77,7 +87,7 @@ See #{COMMAND.bold.blue + ' <command> '.bold.green + '--help'.bold.yellow} for m
       end
 
       def print
-        puts output.join("\n")
+        puts output.join("\n") unless output.empty?
       end
     end
   end

data/lib/arli/version.rb

@@ -1,3 +1,3 @@
 module Arli
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.2.2'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arli
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Konstantin Gredeskoul
@@ -130,9 +130,10 @@ files:
 - bin/setup
 - exe/arli
 - lib/arli.rb
-- lib/arli/app.rb
 - lib/arli/cli.rb
+- lib/arli/commands/base.rb
 - lib/arli/commands/install.rb
+- lib/arli/commands/update.rb
 - lib/arli/parser.rb
 - lib/arli/version.rb
 homepage: https://github.com/kigster/arli

data/lib/arli/app.rb

@@ -1,46 +0,0 @@
-require 'colored2'
-require 'optparse'
-require 'hashie/mash'
-require 'saves/cli/parser'
-require 'forwardable'
-module Saves
-  module CLI
-    class App
-      extend Forwardable
-      def_delegators :@parser, :options, :output
-
-      attr_accessor :args, :command, :parser, :options, :output
-
-      def initialize(args)
-        if args.nil? || args.empty?
-          self.args = %w[--help]
-        else
-          self.args = args.dup
-        end
-
-        self.parser  = ::Saves::CLI::Parser
-        self.options = parser.options
-        self.output  = parser.output
-      end
-
-      def parse!
-        if args.first =~ /^-/
-          parser.global.parse!(args)
-        else
-          cmd = self.args.shift.to_sym
-          begin
-            Parser.parser_for(cmd).parse!(args)
-            self.command = cmd # did not raise exception, so valid command.
-          rescue Saves::CLI::InvalidCommandError => e
-            options[:errors] = [e.message]
-          end
-        end
-      end
-
-      def out
-        output.join("\n")
-      end
-
-    end
-  end
-end