skippy 0.2.0.a → 0.3.0.a

data/lib/skippy/app.rb

@@ -40,9 +40,9 @@ class Skippy::App
   def templates
     result = []
     templates_source_path.entries.each { |entry|
-      template_path =  templates_source_path.join(entry)
+      template_path = templates_source_path.join(entry)
       next unless template_path.directory?
-      next if %w[. ..].include?(entry.basename.to_s)
+      next if %w(. ..).include?(entry.basename.to_s)
       result << entry.expand_path(templates_source_path)
     }
     result

data/lib/skippy/cli.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 require 'skippy/app'
 require 'skippy/command'
 require 'skippy/group'
@@ -41,14 +43,15 @@ class Skippy::CLI < Skippy::Command
   end
 
   # Verbatim copy from Thor::Runner:
-  # Override Thor#help so it can give information about any class and any method.
+  # Override Thor#help so it can give information about any class and any
+  # method.
   #
   def help(meth = nil)
-    if meth && !self.respond_to?(meth)
+    if meth && !respond_to?(meth)
       initialize_thorfiles(meth)
       klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
       self.class.handle_no_command_error(command, false) if klass.nil?
-      klass.start(['-h', command].compact, :shell => shell)
+      klass.start(['-h', command].compact, shell: shell)
     else
       super
     end
@@ -58,18 +61,22 @@ class Skippy::CLI < Skippy::Command
   # If a command is not found on Thor::Runner, method missing is invoked and
   # Thor::Runner is then responsible for finding the command in all classes.
   #
-  def method_missing(meth, *args)
+  def method_missing(meth, *args) # rubocop:disable Style/MethodMissing
     meth = meth.to_s
     initialize_thorfiles(meth)
     klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
     self.class.handle_no_command_error(command, false) if klass.nil?
     args.unshift(command) if command
-    klass.start(args, :shell => shell)
+    klass.start(args, shell: shell)
   end
 
   # Verbatim copy from Thor::Runner:
-  desc 'list [SEARCH]', "List the available #{$PROGRAM_NAME} commands (--substring means .*SEARCH)"
-  method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
+  desc 'list [SEARCH]',
+    "List the available #{$PROGRAM_NAME} commands (--substring means .*SEARCH)"
+  method_options substring: :boolean,
+                 group:     :string,
+                 all:       :boolean,
+                 debug:     :boolean
   def list(search = '')
     initialize_thorfiles
 
@@ -77,15 +84,13 @@ class Skippy::CLI < Skippy::Command
     search = /^#{search}.*/i
     group  = options[:group] || 'standard'
 
-    klasses = Thor::Base.subclasses.select do |k|
+    klasses = Thor::Base.subclasses.select { |k|
       (options[:all] || k.group == group) && k.namespace =~ search
-    end
+    }
 
     display_klasses(false, false, klasses)
   end
 
-  private
-
   # Based on Thor::Runner, with exception of program name.
   def self.banner(command, all = false, subcommand = false)
     "#{$PROGRAM_NAME} " + command.formatted_usage(self, all, subcommand)
@@ -96,6 +101,8 @@ class Skippy::CLI < Skippy::Command
     true
   end
 
+  private
+
   # This is one of the places this runner differ from Thor::Runner. It will
   # instead load files for the current project.
   #
@@ -107,7 +114,16 @@ class Skippy::CLI < Skippy::Command
     return unless project.exist?
     project.command_files { |filename|
       unless Thor::Base.subclass_files.keys.include?(File.expand_path(filename))
-        Thor::Util.load_thorfile(filename, nil, options[:debug])
+        begin
+          Thor::Util.load_thorfile(filename, nil, options[:debug])
+        rescue ScriptError, StandardError => error
+          command_path = Pathname.new(filename).relative_path_from(project.path)
+          say "Error loading: #{command_path} (#{error})", :red
+          if options[:debug]
+            say error.inspect, :red
+            say error.backtrace.join("\n"), :red
+          end
+        end
       end
     }
   end
@@ -120,15 +136,20 @@ class Skippy::CLI < Skippy::Command
   end
 
   # Based on Thor::Runner:
-  def display_klasses(_with_modules = false, show_internal = false, klasses = Thor::Base.subclasses)
+  def display_klasses(_with_modules = false,
+    show_internal = false,
+    klasses = Thor::Base.subclasses)
+
     unless show_internal
       klasses -= [
         Thor, Thor::Runner, Thor::Group,
-        Skippy, Skippy::CLI, Skippy::Command, Skippy::Command::Group
+        Skippy, Skippy::CLI, Skippy::Command, Skippy::Command::Group,
       ]
     end
 
-    fail Error, "No #{$PROGRAM_NAME.capitalize} commands available" if klasses.empty?
+    if klasses.empty?
+      raise Error, "No #{$PROGRAM_NAME.capitalize} commands available"
+    end
 
     list = Hash.new { |h, k| h[k] = [] }
     groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
@@ -177,16 +198,16 @@ class Skippy::CLI < Skippy::Command
     # TODO(thomthom): Because of the odd issue with col_width mentioned in
     # `display_klasses` the table isn't truncated. Can probably re-enable if
     # the col_width issue is fixed.
-    #print_table(list, :truncate => true, :indent => 2, :colwidth => col_width)
+    # print_table(list, :truncate => true, :indent => 2, :colwidth => col_width)
     width = (col_width + 2) * 2
-    print_table(list, :indent => 2, :colwidth => width)
+    print_table(list, indent: 2, colwidth: width)
   end
-  alias_method :display_tasks, :display_commands
+  alias display_tasks display_commands
 
   # Based on Thor::Runner, skipping the yaml stuff:
   def show_modules
-    info  = []
-    labels = %w[Modules Namespaces]
+    info = []
+    labels = %w(Modules Namespaces)
 
     info << labels
     info << ['-' * labels[0].size, '-' * labels[1].size]

data/lib/skippy/command.rb

@@ -3,12 +3,10 @@ require 'thor'
 module Skippy
   class Command < Thor
 
-    protected
-
     # Customize the banner as we don't care for the 'skippy' prefix for each
     # item in the list.
-    def self.banner(command, namespace = nil, subcommand = false)
-      "#{command.formatted_usage(self, true, subcommand)}"
+    def self.banner(command, _namespace = nil, subcommand = false)
+      command.formatted_usage(self, true, subcommand).to_s
     end
 
   end

data/lib/skippy/config.rb

@@ -5,7 +5,7 @@ require 'skippy/error'
 
 class Skippy::Config < Hash
 
-  attr_accessor :path
+  attr_reader :path
 
   class MissingPathError < Skippy::Error; end
 
@@ -14,25 +14,11 @@ class Skippy::Config < Hash
       json = File.read(path)
       config = JSON.parse(json,
         symbolize_names: true,
-        object_class: self
-      )
+        object_class: self)
     else
-      config = self.new
+      config = new
     end
-    # Need to merge nested defaults.
-    config.merge!(defaults) { |_key, value, default|
-      if value.is_a?(Hash) && default.is_a?(Hash)
-        # Deep merge in order to merge nested hashes.
-        # Note: This currently doesn't merge arrays.
-        # http://stackoverflow.com/a/9381776/486990
-        merger = proc { |_k, v1, v2|
-          Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
-        }
-        default.merge(value, &merger)
-      else
-        value || default
-      end
-    }
+    config.merge_defaults(defaults)
     config.path = path
     config
   end
@@ -77,7 +63,7 @@ class Skippy::Config < Hash
     if hash.keys.first.is_a?(String)
       update_from_key_paths(hash)
     else
-      update_from_hash(hash)
+      deep_merge!(hash)
     end
     self
   end
@@ -86,11 +72,30 @@ class Skippy::Config < Hash
     "#{super}:#{self.class.name}"
   end
 
+  # @param [Hash] defaults
+  def merge_defaults(defaults)
+    merge!(defaults) { |_key, value, default|
+      if value.is_a?(Hash) && default.is_a?(Hash)
+        # Deep merge in order to merge nested hashes.
+        # Note: This currently doesn't merge arrays.
+        # http://stackoverflow.com/a/9381776/486990
+        merger = proc { |_k, v1, v2|
+          v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2
+        }
+        default.merge(value, &merger)
+      else
+        # TODO(thomthom): Should `merger` include this logic?
+        value || default
+      end
+    }
+  end
+
   private
 
-  def update_from_hash(hash)
+  # @param [Hash] hash
+  def deep_merge!(hash)
     merger = proc { |_key, v1, v2|
-      Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2
+      v1.is_a?(Hash) && v2.is_a?(Hash) ? v1.merge(v2, &merger) : v2
     }
     merge!(hash, &merger)
   end
@@ -105,7 +110,7 @@ class Skippy::Config < Hash
     if key_path.is_a?(Symbol)
       [key_path]
     else
-      key_path.split('/').map { |key| key.intern }
+      key_path.split('/').map(&:intern)
     end
   end
 

data/lib/skippy/config_accessors.rb

@@ -5,38 +5,38 @@ module Skippy::ConfigAccessors
 
   private
 
-  def config_attr(*symbols, key: nil, type: nil)
-    config_attr_reader(*symbols, key: key, type: type)
+  def config_attr(*symbols, key: nil, default: nil, type: nil)
+    config_attr_reader(*symbols, key: key, type: type, default: default)
     config_attr_writer(*symbols, key: key, type: type)
     nil
   end
 
-  def config_attr_reader(*symbols, key: nil, type: nil)
-    self.class_eval {
+  def config_attr_reader(*symbols, key: nil, default: nil, type: nil)
+    class_eval do
       symbols.each { |symbol|
         raise TypeError unless symbol.is_a?(Symbol)
-        define_method(symbol) {
-          value = @config.get(key || symbol)
+        define_method(symbol) do
+          value = @config.get(key || symbol, default)
           value = type.new(value) if type && !value.is_a?(type)
           value
-        }
+        end
       }
-    }
+    end
     nil
   end
 
   def config_attr_writer(*symbols, key: nil, type: nil)
-    self.class_eval {
+    class_eval do
       symbols.each { |symbol|
         raise TypeError unless symbol.is_a?(Symbol)
         symbol_set = "#{symbol}=".intern
-        define_method(symbol_set) { |value|
+        define_method(symbol_set) do |value|
           value = type.new(value) if type && !value.is_a?(type)
           @config.set(key || symbol, value)
           value
-        }
+        end
       }
-    }
+    end
     nil
   end
 

data/lib/skippy/group.rb

@@ -5,12 +5,10 @@ require 'skippy/command'
 module Skippy
   class Command::Group < Thor::Group
 
-    protected
-
     # Customize the banner as we don't care for the 'skippy' prefix for each
     # item in the list.
     def self.banner
-      "#{self_command.formatted_usage(self, false)}"
+      self_command.formatted_usage(self, false).to_s
     end
 
   end

data/lib/skippy/helpers/file.rb

@@ -1,13 +1,13 @@
 module Skippy::Helpers
   module File
 
+    extend self
+
     # @param [Pathname]
     # @return [Array<Pathname>]
     def directories(pathname)
       return [] unless pathname.exist?
-      pathname.children.select { |child|
-        child.directory?
-      }
+      pathname.children.select(&:directory?)
     end
 
   end

data/lib/skippy/installer.rb

@@ -0,0 +1,49 @@
+require 'skippy/lib_source'
+require 'skippy/library'
+require 'skippy/project'
+
+class Skippy::LibraryInstaller
+
+  attr_reader :project, :source
+
+  # @param [Skippy::Project] project
+  # @param [Skippy::LibrarySource] source
+  def initialize(project, lib_source)
+    @project = project
+    @source = lib_source
+    @messager = nil
+  end
+
+  def on_status(&block)
+    @messager = block
+  end
+
+  # @return [Skippy::Library]
+  def install
+    raise NotImplementedError
+  end
+
+  private
+
+  # @param [Symbol] type
+  # @param [String] message
+  def status(type, message)
+    @messager.call(type, message) if @messager
+  end
+
+  # @param [String] message
+  def info(message)
+    status(:info, message)
+  end
+
+  # @param [String] message
+  def warning(message)
+    status(:warning, "Warning: #{message}")
+  end
+
+  # @return [Pathname]
+  def path
+    project.libraries.path
+  end
+
+end

data/lib/skippy/installer/git.rb

@@ -0,0 +1,115 @@
+require 'git'
+require 'naturally'
+require 'pathname'
+
+require 'skippy/error'
+require 'skippy/installer'
+require 'skippy/library'
+
+module Skippy
+
+  class BranchNotFound < Skippy::Error; end
+  class TagNotFound < Skippy::Error; end
+
+end
+
+class Skippy::GitLibraryInstaller < Skippy::LibraryInstaller
+
+  # @return [Skippy::Library]
+  def install
+    info "Installing #{source.basename} from #{source.origin}..."
+    target = path.join(source.lib_path)
+    previous_commit = nil
+    if target.directory?
+      git, previous_commit = update_repository(target)
+    else
+      git = clone_repository(source.origin, target)
+    end
+    begin
+      checkout_branch(git, source.branch) if source.branch
+      checkout_tag(git, source.requirement) unless edge_version?(source.requirement)
+    rescue Skippy::Error
+      git.checkout(previous_commit) if previous_commit
+      raise
+    end
+    library = Skippy::Library.new(target, source: source)
+    library
+  end
+
+  private
+
+  # @param [URI] uri
+  # @param [Pathname] target
+  # @return [Git::Base]
+  def clone_repository(uri, target)
+    info 'Cloning...'
+    Git.clone(uri, target.basename, path: target.parent)
+  end
+
+  # @param [Pathname] target
+  # @return [Array(Git::Base, Git::Commit)]
+  def update_repository(target)
+    info 'Updating...'
+    library = Skippy::Library.new(target)
+    info "Current version: #{library.version}"
+    git = Git.open(target)
+    previous_commit = git.object('HEAD^').class
+    git.reset_hard
+    git.pull
+    [git, previous_commit]
+  end
+
+  # @param [Git::Base]
+  # @param [String] branch
+  def checkout_branch(git, branch)
+    branches = git.braches.map(&:name)
+    info "Branches: #{branches.inspect}"
+    unless branches.include?(branch)
+      raise Skippy::BranchNotFound, "Found no branch named: '#{branch}'"
+    end
+    git.checkout(branch)
+    nil
+  end
+
+  # @param [Git::Base]
+  # @param [String] version
+  def checkout_tag(git, version)
+    tags = Naturally.sort_by(git.tags, :name)
+    tag = latest_version?(version) ? tags.last : resolve_tag(tags, version)
+    raise Skippy::TagNotFound, "Found no version: '#{version}'" if tag.nil?
+    git.checkout(tag)
+    # Verify the library version with the tagged version.
+    target = path.join(source.lib_path)
+    library = Skippy::Library.new(target)
+    unless library.version.casecmp(tag.name).zero?
+      warning "skippy.json version (#{library.version}) differ from "\
+              "tagged version (#{tag.name})"
+    end
+    nil
+  end
+
+  # Resolve version numbers like RubyGem.
+  #
+  # @param [Array<Git::Tag>] tags List of tags sorted with newest first
+  # @param [String] version
+  # @return [Git::Tag]
+  def resolve_tag(tags, version)
+    requirement = Gem::Requirement.new(version)
+    tags.reverse.find { |tag|
+      next false unless Gem::Version.correct?(tag.name)
+      tag_version = Gem::Version.new(tag.name)
+      requirement.satisfied_by?(tag_version)
+    }
+  end
+
+  # @param [String] version
+  def edge_version?(version)
+    version && version.casecmp('edge').zero?
+  end
+
+  # @param [String] version
+  def latest_version?(version)
+    version.nil? || version.casecmp('latest').zero?
+  end
+
+end