arli 0.7.0 → 0.8.3

data/lib/arli/configuration.rb

@@ -5,23 +5,28 @@ require 'yaml'
 module Arli
   class Configuration
 
-    DEFAULT_FILENAME    = 'Arlifile'.freeze
-    ACTIONS_WHEN_EXISTS = %i(backup overwrite abort)
-    ARLI_COMMAND        = 'arli'.freeze
+    DEFAULT_FILENAME      = 'Arlifile'.freeze
+    DEFAULT_LOCK_FILENAME = (DEFAULT_FILENAME + '.lock').freeze
+    ACTIONS_WHEN_EXISTS   = %i(backup overwrite abort)
+    ARLI_COMMAND          = 'arli'.freeze
+    DEFAULT_RESULTS_LIMIT = 100
 
     extend Dry::Configurable
 
     # These are populated during the parsing of the params
     setting :runtime do
       setting :argv
+      setting :pwd
       setting :command do
         setting :name
         setting :instance
       end
     end
 
+    # Default locations
     setting :libraries do
       setting :path, ::Arduino::Library::DefaultDatabase.library_path
+      setting :temp_dir
     end
 
     setting :database do
@@ -29,33 +34,47 @@ module Arli
       setting :url, ::Arduino::Library::DefaultDatabase.library_index_url
     end
 
-    setting :arlifile do
-      setting :path, ::Dir.pwd
-      setting :name, ::Arli::Configuration::DEFAULT_FILENAME
+    setting :if_exists do
+      setting :overwrite, true
+      setting :backup, false
+      setting :abort, false
     end
 
+    # Global flags
+    setting :debug, ENV['ARLI_DEBUG'] || false
+    setting :trace, false
+    setting :dry_run, false
+    setting :verbose, false
+    setting :help, false
+    setting :quiet, false
+
+    # Commands
     setting :search do
+      setting :argument
       setting :default_field, :name
       setting :results do
-        setting :limit, 100
+        setting :attrs
+        setting :limit, DEFAULT_RESULTS_LIMIT
         setting :format, :inspect
       end
     end
 
-    setting :install do
+    # Arlifile
+    setting :arlifile do
+      setting :path, ::Dir.pwd
+      setting :name, ::Arli::Configuration::DEFAULT_FILENAME
+      setting :lock_name, ::Arli::Configuration::DEFAULT_LOCK_FILENAME
+      setting :lock_format, :json
+    end
+
+    setting :bundle do
       setting :library_names, []
-      setting :if_exists do
-        setting :overwrite, true
-        setting :backup, false
-        setting :abort, false
-      end
     end
 
-    setting :debug, ENV['ARLI_DEBUG'] || false
-    setting :trace, false
-    setting :verbose, false
-    setting :help, false
-    setting :quiet, false
+    setting :install do
+      setting :library
+    end
+
   end
 end
 

data/lib/arli/errors.rb

@@ -6,6 +6,10 @@ module Arli
 
     class InvalidSyntaxError  < ArliError; end
 
+    class InvalidSearchSyntaxError  < InvalidSyntaxError; end
+
+    class InvalidInstallSyntaxError  < InvalidSyntaxError; end
+
     class AbstractMethodCalled < ArliError; end
 
     class ArliFileNotFound < ArliError; end
@@ -16,6 +20,8 @@ module Arli
 
     class InstallerError < ArliError; end
 
+    class TooManyMatchesError < ArliError; end
+
     class ZipFileError < InstallerError; end
   end
 end

data/lib/arli/library.rb

@@ -1,50 +1,8 @@
-require_relative 'installer'
-require_relative 'errors'
-
 module Arli
-  class Library
-    attr_accessor :lib, :config, :canonical_dir
-
-    def initialize(lib, config: Arli.config)
-      self.lib           = lib
-      self.config        = config
-    end
-
-    def install
-      Arli::Installer.new(self).install
-    end
-
-    def rm_rf!
-      FileUtils.rm_rf(dir)
-    end
-
-    def libraries_home
-      config.libraries.path
-    end
-
-    def dir
-      lib.name.gsub(/ /, '_')
-    end
-
-    def path
-      libraries_home + '/' + dir
-    end
-
-    def canonical_path
-      libraries_home + '/' + canonical_dir
-    end
-
-    def exists?
-      Dir.exist?(path)
-    end
-
-    def method_missing(method, *args, &block)
-      if lib && lib.respond_to?(method)
-        lib.send(method, *args, &block)
-      else
-        super(method, *args, &block)
-      end
-    end
+  module Library
 
   end
 end
+
+require_relative 'library/proxy'
+require_relative 'library/installer'

data/lib/arli/library/installer.rb

@@ -0,0 +1,71 @@
+require 'forwardable'
+require 'arli'
+require 'arli/actions'
+require_relative 'proxy'
+
+module Arli
+  module Library
+    class Installer
+      include ::Arli::Output
+
+      extend Forwardable
+      def_delegators :@library, :exists?
+
+      attr_accessor :library, :config, :temp_dir
+
+      def initialize(library, config: Arli.config)
+        self.config   = config
+        self.library  = library
+        self.temp_dir = Arli.config.libraries.temp_dir
+      end
+
+      def install
+        ___ "#{library.name.blue} "
+        if library.nil? && library.library.nil?
+          ___ ' (no library) '
+          fuck
+        elsif library.url.nil?
+          ___ ' (no url) '
+          fuck
+        else
+          ___ "(#{library.version.green}) " if library.version
+          indent_cursor
+          actions(library).each do |action|
+            run_action(action)
+          end
+        end
+        ___ "\n"
+      end
+
+      def run_action(action_name)
+        klass = Arli::Actions.action(action_name)
+        if klass
+          action = klass.new(library, config: config)
+          if action.supported?
+            print_action_starting(action_name.to_s) do
+              action.run!
+            end
+            puts if verbose?
+          else
+            print_action_failure("unsupported", "missing pre-requisites: #{klass.command_name.bold.yellow} did not succeed")
+          end
+        else
+          print_action_failure("#{action_name.red} not found")
+        end
+      end
+
+      def verbose?
+        config.verbose
+      end
+
+      def actions(library)
+        actions = []
+        # First, how do we get the library?
+        actions << ((library.url =~ /\.zip$/i) ? :unzip_file : :git_repo)
+        actions << :dir_name
+        actions << :move_to_library_path
+        actions.flatten
+      end
+    end
+  end
+end

data/lib/arli/library/proxy.rb

@@ -0,0 +1,79 @@
+require_relative 'installer'
+require 'arli/errors'
+
+module Arli
+  module Library
+    # Represents a wrapper around Arduino::Library::Model instance
+    # and decorates with a few additional helpers.
+    class Proxy
+      attr_accessor :lib,
+                    :lib_dir,
+                    :canonical_dir,
+                    :config
+
+      def initialize(lib, config: Arli.config)
+        self.lib     = lib
+        self.config  = config
+        self.lib_dir = lib.name.gsub(/ /, '_')
+      end
+
+      def install
+        installer.install
+      end
+
+      def installer
+        @installer ||= Installer.new(self)
+      end
+
+      def libraries_home
+        config.libraries.path
+      end
+
+      def temp_dir
+        config.libraries.temp_dir
+      end
+
+      def dir
+        canonical_dir || lib_dir
+      end
+
+      def path
+        libraries_home + '/' + dir
+      end
+
+      def temp_path
+        temp_dir + '/' + dir
+      end
+
+      def exists?
+        Dir.exist?(path)
+      end
+
+      # Formats
+      def to_s_short
+        "#{lib.name.bold.blue} (#{lib.version.yellow}), by #{lib.author.magenta}"
+      end
+
+      def to_s_json
+        puts lib.to_json
+      end
+
+      def to_s_long
+        "#{lib.name.bold.blue} (#{lib.version.yellow}), by #{lib.author.magenta}}\n\t#{lib.description}"
+      end
+
+      def to_s_pretty(lib, **options)
+        "#{lib.name.bold.blue} (#{lib.version.yellow}), by #{lib.author.magenta}"
+      end
+
+      def method_missing(method, *args, &block)
+        if lib && lib.respond_to?(method)
+          lib.send(method, *args, &block)
+        else
+          super(method, *args, &block)
+        end
+      end
+
+    end
+  end
+end

data/lib/arli/lock/file.rb

@@ -0,0 +1,65 @@
+require 'arli'
+require 'yaml'
+require 'forwardable'
+require 'arduino/library'
+require 'hashie/mash'
+
+require_relative 'formats'
+
+module Arli
+  module Lock
+    class File
+      attr_accessor :lock_file_path,
+                    :config,
+                    :formatter,
+                    :file,
+                    :format
+
+      def initialize(config: Arli.config)
+        self.config         = config
+        self.lock_file_path = "#{config.arlifile.path}/#{config.arlifile.lock_name}"
+        self.format         = config.arlifile.lock_format
+        self.formatter      = set_formatter(format)
+        self.file           = ::File.open(lock_file_path, 'w')
+
+        append(formatter.header)
+      end
+
+      def lock(*libraries)
+        libraries.each do |lib|
+          append(formatter.format(lib))
+        end
+      end
+
+      def lock!(*args)
+        lock(*args)
+      ensure
+        close
+      end
+
+      def close
+        append(formatter.footer)
+      ensure
+        file.close
+        FileUtils.cp(lock_file_path, "#{lock_file_path}.#{format}")
+      end
+
+      def append(line = nil)
+        return unless line
+        line.end_with?("\n") ? file.print(line) : file.puts(line)
+      end
+
+      private
+
+      def set_formatter(format)
+        klass = format.to_s.capitalize.to_sym
+        klazz = ::Arli::Lock::Formats.const_get(klass)
+        klazz.new(self)
+      rescue NameError
+        raise Arli::Errors::ArliError,
+              "invalid format #{format}, Arli::Lock::Formats::#{klass} does not exist"
+      end
+    end
+  end
+end
+

data/lib/arli/lock/formats.rb

@@ -0,0 +1,4 @@
+require_relative 'formats/cmake'
+require_relative 'formats/json'
+require_relative 'formats/yaml'
+require_relative 'formats/text'

data/lib/arli/lock/formats/base.rb

@@ -0,0 +1,26 @@
+
+module Arli
+  module Lock
+    module Formats
+      class Base
+        attr_accessor :lock_file
+
+        def initialize(lock_file)
+          self.lock_file = lock_file
+        end
+
+        # Optional header
+        def header
+        end
+
+        def format(library)
+          raise Arli::Errors::AbstractMethodCalled, "#format on Base"
+        end
+
+        # Optional footer
+        def footer
+        end
+      end
+    end
+  end
+end

data/lib/arli/lock/formats/cmake.rb

@@ -0,0 +1,24 @@
+require_relative 'base'
+
+module Arli
+  module Lock
+    module Formats
+      class Cmake < Base
+
+        def header
+          "# vi:syntax=cmake\n" +
+          "set(ARLI_LIBRARIES)"
+        end
+
+        def format(library)
+          "# Library #{library.name}, version #{library.version}, url: #{library.url}\n" +
+              "prepend(ARDUINO_ARLI_LIBS ${ARDUINO_ARLI_LIBS} #{library.canonical_dir})"
+        end
+
+        def footer
+          "set(ARLI_LIBRARIES $ARLI_LIBRARIES PARENT_SCOPE)"
+        end
+      end
+    end
+  end
+end

data/lib/arli/lock/formats/json.rb

@@ -0,0 +1,25 @@
+require_relative 'base'
+
+module Arli
+  module Lock
+    module Formats
+      class Json < Base
+        attr_accessor :hash
+
+        def header
+          self.hash = {}
+          nil
+        end
+
+        def format(library)
+          hash[library.canonical_dir] = library.to_hash
+          nil
+        end
+
+        def footer
+          JSON.pretty_generate(hash)
+        end
+      end
+    end
+  end
+end