arli 0.5.1 → 0.6.1

data/lib/arli/actions/dir_name.rb

@@ -0,0 +1,66 @@
+require_relative 'action'
+
+module Arli
+  module Actions
+    # The purpose of this action is to fix the directory
+    # name of the library, that's possibly incorrect.
+    # For example, library "Adafruit Unified Sensor" installs
+    # into the folder 'Adafruit_Unified_Sensor'
+    # while the source files inside are 'Adafruit_Sensor.h'
+    # This action renames invalid library folders based on the
+    # source files found inside.
+    class DirName < Action
+      attr_accessor :sources, :headers
+
+      def act
+        find_source_files
+
+        # so "dir" is the 'Adafruit_Unified_Sensor'
+        # but we found header Adafruit_Sensor we should
+        # rename the folder
+
+        return if headers.include?(dir)
+        return if sources.include?(dir)
+
+        ___
+
+        # if we end up setting this, we'll also move the folder.
+        canonical_dir =
+            if_only_one(headers) ||
+            if_only_one(sources) ||
+            if_header_a_substring(headers)
+
+        if canonical_dir
+          library.canonical_dir = canonical_dir
+          FileUtils.rm_rf(canonical_dir) if Dir.exist?(canonical_dir)
+          ___ " (#{canonical_dir.bold.green}) "
+          FileUtils.mv(dir, library.canonical_dir)
+        end
+      end
+
+      def if_header_a_substring(files)
+        files.find { |file| dir.start_with?(file) }
+      end
+
+      def if_only_one(file_names)
+        if file_names.size == 1 && file_names.first != dir
+          file_names.first
+        end
+      end
+
+      def find_source_files
+        Dir.chdir(dir) do
+          self.sources = files_with_extension('**.{cpp,c}')
+          self.headers = files_with_extension('**.{h}')
+        end
+      end
+
+      EXT_REGEX = /\.(cpp|h|c)$/
+      EXT_CHOMP = ->(f) { f.gsub(EXT_REGEX, '') }
+
+      def files_with_extension(pattern)
+        Dir.glob(pattern).map(&EXT_CHOMP)
+      end
+    end
+  end
+end

data/lib/arli/actions/git_repo.rb

@@ -0,0 +1,43 @@
+require_relative 'action'
+module Arli
+  module Actions
+    class GitRepo < Action
+
+      def act
+        c = library.exists? ? git_update_command : git_clone_command
+        ___ 'running ' + c.blue + ' '
+        execute(c)
+        ok
+      rescue Exception => e
+        fuck
+        raise e
+      end
+
+      def git_update_command
+        "cd #{path} && git pull --rebase 2>&1"
+      end
+
+      def git_clone_command
+        "git clone -v #{library.url} #{path} 2>&1"
+      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 Arli.debug?
+        o, e, s = Open3.capture3(cmd)
+        info("\n" + o) if o if Arli.debug?
+        info("\n" + e.red) if e && Arli.debug?
+      rescue Exception => e
+        error "Error running [#{args.join(' ')}]\n" +
+                "Current folder is [#{Dir.pwd.yellow}]", e
+        raise e
+      end
+
+
+    end
+  end
+end

data/lib/arli/actions/zip_file.rb

@@ -0,0 +1,54 @@
+require 'archive/zip'
+require_relative 'action'
+
+module Arli
+  module Actions
+    class ZipFile < Action
+
+      def act
+        ___
+        library.rm_rf!
+        download!
+        if File.exist?(zip_archive)
+          ok; ___
+          FileUtils.rm_rf(zip_folder) if zip_folder
+          unzip(zip_archive, '.')
+          if Dir.exist?(zip_folder)
+            ok; ___
+            FileUtils.move(zip_folder, dir)
+            ok
+          end
+        end
+      rescue Exception => e
+        fuck
+        puts
+        raise(e)
+      ensure
+        delete_zip!
+      end
+
+      private
+
+      def delete_zip!
+        FileUtils.rm_f(zip_archive) if File.exist?(zip_archive)
+      end
+
+      def download!
+        File.write(zip_archive, Net::HTTP.get(URI.parse(library.url)))
+      end
+
+      def zip_archive
+        @zip_archive ||= File.basename(library.url)
+      end
+
+      # list the contents of the archive and grab the top level folder
+      def zip_folder
+        @zip_folder ||= `unzip -Z1 #{zip_archive} | awk 'BEGIN{FS="/"}{print $1}' | uniq | tail -1`.chomp
+      end
+
+      def unzip(file, destination)
+        `unzip -o #{file} -d #{destination}`
+      end
+    end
+  end
+end

data/lib/arli/arli_file.rb

@@ -8,60 +8,45 @@ module Arli
     require 'arduino/library/include'
 
     include Enumerable
-
     extend Forwardable
-    def_delegators :@dependencies, *(Array.new.methods - Object.methods)
-
-    attr_accessor :dependencies, :file_hash, :file, :lib_path, :resolved
 
-    def initialize(lib_path: Arli.library_path,
-                   arlifile_path: nil)
+    def_delegators :@dependencies, *(Array.new.methods - Object.methods)
 
-      self.lib_path = lib_path
-      self.file     = arlifile_path ? "#{arlifile_path}/#{Arli::Config::DEFAULT_FILENAME}" :
-                        Arli::Config::DEFAULT_FILENAME
-      raise(Arli::Errors::ArliFileNotFound, 'Arlifile could not be found') unless file || !File.exist?(file)
-      self.dependencies = []
+    attr_accessor :dependencies,
+                  :file_hash,
+                  :file,
+                  :library_path
 
-      parse!
-    end
+    def initialize(config: Arli.config)
+      self.library_path = config.libraries.path
+      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
 
-    def libraries
-      self.dependencies
+      FileUtils.mkpath(library_path) unless Dir.exist?(library_path)
+      self.dependencies = parse_file
     end
 
-    def within_lib_path
-      FileUtils.mkpath(lib_path) unless Dir.exist?(lib_path)
-      Dir.chdir(lib_path) do
+    def within_library_path
+      Dir.chdir(library_path) do
         yield if block_given?
       end
     end
 
-    def each_dependency(&_block)
-      within_lib_path do
-        dependencies.each do |dependency|
-          yield(dependency)
-        end
-      end
-    end
-
-    def error(*args)
-      STDERR.puts *args.join("\n")
-    end
-
-    def info(*args)
-      STDOUT.puts *args.join("\n") if Arli.debug?
+    def each_dependency(&block)
+      within_library_path { dependencies.each(&block) }
     end
 
     private
 
-    def parse!
-      self.file_hash    = ::YAML.load(::File.read(self.file))
-      self.dependencies = file_hash['dependencies'].map do |lib|
-        ::Arduino::Library::Model.from_hash(lib)
+    def parse_file
+      self.file_hash = ::YAML.load(::File.read(self.file))
+      file_hash['dependencies'].map do |lib|
+        ::Arli::Library.new(::Arduino::Library::Model.from(lib))
       end
     end
-
   end
 end

data/lib/arli/cli.rb

@@ -1,194 +1,8 @@
-require 'optparse'
-require 'hashie/mash'
-require 'hashie/extensions/symbolize_keys'
-require 'colored2'
-require 'arli'
-require 'arli/parser'
-require 'arli/commands/install'
-require 'arli/commands/search'
-
 module Arli
-  class CLI
-
-    COMMAND = 'arli'.freeze
-    PARSER  = ::Arli::CLI::Parser
-
-    attr_accessor :argv, :parser, :command_name, :command
-    attr_accessor :options
-
-    def initialize(argv = ARGV.dup)
-      self.argv    = argv
-      self.options = Hashie::Mash.new
-    end
-
-    def parse
-      if argv.first
-        if argv.first =~ /^-.*$/
-          self.parser = self.class.global
-        elsif command_detected?
-          self.parser = parse_command_options!
-        end
-      end
-
-      if parser
-        parser.parse!(argv)
-        parser.print
-        options.merge!(parser.options)
-      end
-
-      self.options = Hashie::Extensions::SymbolizeKeys.symbolize_keys!(options.to_h)
-
-      unless options[:help]
-        self.command = create_command if command_name
-        execute
-      end
-
-    rescue OptionParser::InvalidOption => e
-      report_exception(e, 'Command line usage error!')
-
-    rescue Arli::Errors::InvalidCommandError
-      report_exception(e, 'This command does not exist')
-
-    rescue Exception => e
-      report_exception(e)
-      raise e if options[:trace]
-    end
-
-    private
-
-    def report_exception(e, header = nil)
-      error header.bold.yellow if header
-      printf ' ☠   '
-      error e.message if e && e.respond_to?(:message)
-    end
-
-    def execute
-      if command
-        header
-        command.run
-      else
-        gp = self.class.global
-        gp.parse!(%w(--help))
-        gp.print
-        nil
-      end
-    rescue NameError => e
-      error e.inspect
-      error e.backtrace.join("\n") if options[:trace]
-    end
-
-    def create_command
-      command_class = ::Arli::Commands.const_get(command_name.to_s.capitalize)
-
-      options[:lib_home] ||= ::Arli.config.library_path
-      options[:argv]     = argv
+  module CLi
 
-      info "created command #{command_name.to_s.green},\noptions: #{options.inspect.blue}" if Arli.debug?
-
-      command_class.new(options)
-    end
-
-    def header
-       out = ''
-       out << "Arli (#{::Arli::VERSION.yellow})"
-       out << " running #{command.name.to_s.blue}" if command
-       out << "\n"
-       out << "Library Folder: #{options[:lib_home].gsub(/#{ENV['HOME']}/, '~').green}\n" if options[:lib_home]
-       out << '——————————————————————————————————————————————————————————'
-       info out
-     end
-
-    def info(*args)
-      self.class.output(*args)
-    end
-
-    def error(*args)
-      self.class.output(*(args.compact.map { |a| a.to_s.red }))
-    end
-
-    def parse_command_options!
-      self.class.parser_for(command_name)
-    end
-
-    def command_detected?
-      self.command_name = argv.shift if argv.first && argv.first !~ /^-.*$/
-      if self.command_name
-        self.command_name = command_name.to_sym
-        unless self.class.commands.key?(command_name)
-          raise Arli::Errors::InvalidCommandError, "Error: #{command_name ? command_name.to_s.red : 'nil'} is not a valid arli command_name!"
-        end
-      end
-      self.command_name
-    end
-
-    class << self
-
-      def output(*args)
-        puts args.join("\n") unless args.empty?
-      end
-
-      def global
-        @global ||= PARSER.new do |parser|
-          parser.banner = usage_line
-          parser.sep
-          parser.option_help(commands: true)
-        end
-      end
-
-      def usage_line(command = nil)
-        command ? command_usage(command) : global_usage(command)
-      end
-
-      def global_usage(command)
-        "Usage:\n    " + COMMAND.blue +
-          ' [options] '.yellow + '[ ' + (command || 'command').green +
-          ' [options] '.yellow + ' ]' + "\n"
-      end
-
-      def command_usage(command)
-        "Usage:\n    " + COMMAND.blue + ' ' +
-          command.green +
-          ' [options]'.yellow + "\n\n" +
-          'Command Options'
-      end
-
-      def commands
-        @commands ||= {
-          install: {
-            description: 'installs libraries defined in Arlifile',
-            parser:      -> (command_name) {
-              PARSER.new do |parser|
-                parser.banner = usage_line 'install'
-                parser.option_lib_home
-                parser.option_dependency_file
-                parser.option_abort_if_exists
-                parser.option_help(command_name: command_name)
-              end
-            } },
-
-          search:  {
-            description: 'Flexible Search of the Arduino Library Database',
-            example:     'arli search '.green + %Q['name: /AudioZero/, version: "1.0.1"'].green,
-            parser:      -> (command_name) {
-              PARSER.new do |parser|
-                parser.banner = usage_line 'search ' + '<query>'.magenta
-                parser.option_search
-                parser.option_help(command_name: command_name)
-              end
-            }
-          }
-        }
-      end
-
-      def parser_for(cmd)
-        if commands[cmd]
-          cmd_hash = commands[cmd]
-          commands[cmd][:parser][cmd_hash]
-        else
-          raise(Arli::Errors::InvalidCommandError,
-                "'#{cmd}' is not a valid command_name.\nSupported commands are:\n\t#{commands.keys.join("\n\t")}")
-        end
-      end
-    end
   end
 end
+
+require_relative 'cli/parser_factory'
+require_relative 'cli/runner'

data/lib/arli/cli/app.rb

@@ -0,0 +1,73 @@
+require 'forwardable'
+require 'optparse'
+require 'colored2'
+
+require_relative 'parser'
+require_relative 'command_finder'
+require_relative 'parser_factory'
+require_relative '../commands'
+require_relative '../output'
+
+
+module Arli
+  module CLI
+    class App
+      include Arli::Output
+
+      attr_accessor :argv, :config, :command
+
+      def initialize(argv, config: Arli.config)
+        self.argv                = argv
+        self.config              = config
+        self.config.runtime.argv = argv
+      end
+
+      def start
+        if argv.empty?
+          factory.default_help
+          return
+        end
+
+        parse_global_flags
+        return if Arli.config.help
+
+        finder = CommandFinder.new(argv, config: config)
+        finder.parse!
+        return if Arli.config.help
+
+        if finder.command
+          self.command = finder.command
+          execute!
+        else
+          factory.default_help
+        end
+      rescue OptionParser::InvalidOption => e
+        report_exception(e, 'Invalid flags or options')
+      rescue Arli::Errors::InvalidCommandError => e
+        report_exception(e, 'Unknown command')
+      rescue Exception => e
+        report_exception(e)
+      end
+
+      def parse_global_flags
+        if argv.first && argv.first.start_with?('-')
+          parser = factory.global_parser
+          factory.parse_argv(parser, argv)
+        end
+      end
+
+      def execute!
+        if command
+          header(command: command) if config.verbose
+          command.run
+        else
+          factory.default_help
+        end
+      end
+
+      def factory
+        Arli::CLI::ParserFactory
+      end
+    end
+  end
+end