skippy 0.2.0.a → 0.3.0.a

data/lib/skippy/installer/local.rb

@@ -0,0 +1,19 @@
+require 'pathname'
+
+require 'skippy/installer'
+require 'skippy/library'
+
+class Skippy::LocalLibraryInstaller < Skippy::LibraryInstaller
+
+  # @return [Skippy::Library]
+  def install
+    info "Installing #{source.basename} from #{source.origin}..."
+    library = Skippy::Library.new(source.origin)
+    target = path.join(library.name)
+    FileUtils.mkdir_p(path)
+    # Must remove the destination in order to ensure update installations works.
+    FileUtils.copy_entry(source.origin, target, false, false, true)
+    Skippy::Library.new(target, source: source)
+  end
+
+end

data/lib/skippy/lib_module.rb

@@ -4,14 +4,25 @@ require 'skippy/library'
 
 class Skippy::LibModule
 
-  attr_reader :path
+  attr_reader :path, :library
 
   class ModuleNotFoundError < Skippy::Error; end
 
+  # @param [Skippy::Library] library
   # @param [String] path
-  def initialize(path)
+  def initialize(library, path)
     @path = Pathname.new(path)
     raise ModuleNotFoundError, @path.to_s unless @path.file?
+    @library = library
+  end
+
+  def <=>(other)
+    other.is_a?(self.class) ? name <=> other.name : nil
+  end
+
+  def eql?(other)
+    # http://javieracero.com/blog/the-key-to-ruby-hashes-is-eql-hash
+    other.is_a?(self.class) && name.casecmp(other.name).zero?
   end
 
   # @param [String]
@@ -19,14 +30,13 @@ class Skippy::LibModule
     path.basename('.*').to_s
   end
 
-  # @return [Skippy::Library]
-  def library
-    Skippy::Library.new(library_path)
+  def hash
+    name.hash
   end
 
   # @param [String]
   def name
-    "#{library_name}/#{basename}"
+    "#{library.name}/#{basename}"
   end
 
   # @param [String]
@@ -34,14 +44,4 @@ class Skippy::LibModule
     name
   end
 
-  private
-
-  def library_name
-    library_path.basename.to_s
-  end
-
-  def library_path
-    path.parent.parent
-  end
-
 end

data/lib/skippy/lib_source.rb

@@ -0,0 +1,139 @@
+require 'digest'
+require 'net/http'
+require 'pathname'
+require 'uri'
+
+require 'skippy/error'
+require 'skippy/library'
+
+class Skippy::LibrarySource
+
+  attr_reader :origin, :options
+
+  class LibraryNotFoundError < Skippy::Error; end
+
+  # @param [Skippy::Project] project
+  # @param [Pathname, String] source
+  # @param [Hash] options
+  def initialize(project, source, options = {})
+    @project = project
+    @origin = resolve(source.to_s)
+    @options = options
+  end
+
+  def git?
+    git_source?(@origin)
+  end
+
+  def local?
+    local_source?(@origin)
+  end
+
+  def relative?
+    local? && Pathname.new(@origin).relative?
+  end
+
+  def absolute?
+    !relative?
+  end
+
+  # @return [String, nil]
+  def requirement
+    return nil if @options[:requirement].nil?
+    # Normalize the version requirement pattern.
+    parts = Gem::Requirement.parse(@options[:requirement])
+    # .parse will from '1.2.3' return ['=', '1.2.3']. Don't need that.
+    parts.delete('=')
+    parts.join(' ')
+  rescue Gem::Requirement::BadRequirementError
+    @options[:requirement]
+  end
+
+  # @return [String]
+  def branch
+    @options[:branch]
+  end
+
+  # @param [String]
+  def basename
+    if local?
+      Pathname.new(@origin).basename
+    else
+      uri = URI.parse(@origin)
+      Pathname.new(uri.path).basename('.git')
+    end
+  end
+
+  # @param [String]
+  def lib_path
+    if local?
+      source = File.expand_path(@origin)
+      hash_signature = Digest::SHA1.hexdigest(source)
+      "#{basename}_local_#{hash_signature}"
+    else
+      # https://github.com/thomthom/tt-lib.git
+      #         ^^^^^^^^^^ ^^^^^^^^ ^^^^^^
+      #        source_name  author  basename
+      uri = URI.parse(@origin)
+      source_name = uri.hostname.gsub(/[.]/, '-')
+      author = Pathname.new(uri.path).parent.basename
+      "#{basename}_#{author}_#{source_name}"
+    end
+  end
+
+  # @param [String]
+  def to_s
+    @origin.to_s
+  end
+
+  private
+
+  # @param [String] source
+  def resolve(source)
+    if git_source?(source)
+      resolve_from_git_uri(source)
+    elsif lib_name?(source)
+      resolve_from_lib_name(source, @project.sources)
+    else
+      source
+    end
+  end
+
+  # @param [String] source
+  def git_source?(source)
+    source.end_with?('.git') || Pathname.new(source).join('.git').exist?
+  end
+
+  # @param [String] source
+  def local_source?(source)
+    File.exist?(source)
+  end
+
+  # @param [String] source
+  def lib_name?(source)
+    !local_source?(source) && source =~ %r{^[^/]+/[^/]+$}
+  end
+
+  # @param [String] source
+  # @return [String]
+  def resolve_from_git_uri(source)
+    uri = URI.parse(source)
+    # When logged in, BitBucket will display a URI with the user's username.
+    uri.user = ''
+    uri.to_s
+  end
+
+  # @param [String] source
+  # @return [String]
+  def resolve_from_lib_name(source, domains)
+    domains.each { |domain|
+      uri_str = "https://#{domain}/#{source}.git"
+      uri = URI.parse(uri_str)
+      response = Net::HTTP.get_response(uri)
+      return uri_str if response.is_a?(Net::HTTPSuccess) ||
+                        response.is_a?(Net::HTTPRedirection)
+    }
+    raise LibraryNotFoundError, "Library '#{source}' not found"
+  end
+
+end

data/lib/skippy/library.rb

@@ -14,44 +14,84 @@ class Skippy::Library
 
   CONFIG_FILENAME = 'skippy.json'.freeze
 
-  attr_reader :path
+  attr_reader :path, :source, :requirement
 
-  config_attr_reader :title, key: :name # TODO(thomthom): Clean up this kludge.
+  config_attr_reader :name
   config_attr_reader :version
 
   class LibraryNotFoundError < Skippy::Error; end
 
-  def initialize(path)
+  # @param [Pathname, String] path
+  # @param [Skippy::LibrarySource] source
+  def initialize(path, source: nil)
+    # TODO: Rename LibrarySource - it also contain requirement.
     @path = Pathname.new(path)
     raise LibraryNotFoundError, @path.to_s unless @path.directory?
-    # noinspection RubyResolve
+    raise LibraryNotFoundError, config_file.to_s unless config_file.exist?
     @config = Skippy::Config.load(config_file)
+    raise LibraryNotFoundError, 'Not a Skippy Library' unless @config[:library]
+    @source = source
   end
 
-  def name
-    path.basename.to_s
+  def <=>(other)
+    # TODO: This isn't taking into account version. Maybe take that into account
+    #       and implement Comparable.
+    other.is_a?(self.class) ? name <=> other.name : nil
   end
 
+  def eql?(other)
+    # http://javieracero.com/blog/the-key-to-ruby-hashes-is-eql-hash
+    # TODO: Compare using #hash.
+    other.is_a?(self.class) && name.casecmp(other.name).zero?
+  end
+
+  def hash
+    # TODO: This doesn't take into account version. Right now LibraryManager
+    #        relies on this to avoid listing the same lib multiple times.
+    #        But maybe this hash should reflect version differences and the
+    #        library manager enforce library uniqueness differently.
+    name.hash
+  end
+
+  # @return [Array<Skippy::LibModule>]
   def modules
+    # .rb files in the library's modules_path are considered modules.
     libs = modules_path.children(false).select { |file|
-      file.extname.downcase == '.rb'
+      file.extname.casecmp('.rb').zero?
     }
     libs.map! { |lib|
       path = modules_path.join(lib)
-      Skippy::LibModule.new(path)
+      Skippy::LibModule.new(self, path)
     }
     libs
   end
 
+  # @return [Hash]
+  def to_h
+    hash = {
+      name: name, # TODO: Could be issue as UUID if name changes...
+      version: version,
+      source: source.origin,
+    }
+    hash[:requirement] = source.requirement unless source.requirement.nil?
+    hash
+  end
+
+  # @return [String]
+  def to_s
+    name
+  end
+
   private
 
+  # @return [Pathname]
   def config_file
     path.join(CONFIG_FILENAME)
   end
 
+  # @return [Pathname]
   def modules_path
-    # TODO(thomthom): Make this configurable and default to 'lib'?
-    path.join('src')
+    path.join('modules')
   end
 
 end

data/lib/skippy/library_manager.rb

@@ -1,10 +1,24 @@
+require 'git'
 require 'json'
+require 'naturally'
 require 'pathname'
+require 'set'
 
 require 'skippy/helpers/file'
+require 'skippy/installer/git'
+require 'skippy/installer/local'
+require 'skippy/error'
+require 'skippy/lib_source'
 require 'skippy/library'
 require 'skippy/project'
 
+module Skippy
+
+  class LibraryNotFound < Skippy::Error; end
+  class UnknownSourceType < Skippy::Error; end
+
+end
+
 class Skippy::LibraryManager
 
   include Enumerable
@@ -16,13 +30,12 @@ class Skippy::LibraryManager
   def initialize(project)
     raise TypeError, 'expected a Project' unless project.is_a?(Skippy::Project)
     @project = project
+    @libraries = SortedSet.new(discover_libraries)
   end
 
   # @yield [Skippy::Library]
   def each
-    directories(path).each { |lib_path|
-      yield Skippy::Library.new(lib_path)
-    }
+    @libraries.each { |library| yield library }
     self
   end
 
@@ -30,34 +43,80 @@ class Skippy::LibraryManager
     to_a.empty?
   end
 
+  # @param [String] library_name
+  # @return [Skippy::LibModule, nil]
+  def find_library(library_name)
+    find { |lib| lib.name.casecmp(library_name).zero? }
+  end
+
   # @param [String] module_name
   # @return [Skippy::LibModule, nil]
   def find_module(module_name)
     library_name, module_name = module_name.split('/')
-    raise ArgumentError, 'expected a module path' if library_name.nil? || module_name.nil?
-    library = find { |lib| lib.name == library_name }
+    if library_name.nil? || module_name.nil?
+      raise ArgumentError, 'expected a module path'
+    end
+    library = find_library(library_name)
     return nil if library.nil?
-    library.modules.find { |mod| mod.basename == module_name }
+    library.modules.find { |mod| mod.basename.casecmp(module_name).zero? }
+  end
+
+  # @raise [Skippy::LibModule::ModuleNotFoundError]
+  # @param [String] module_name
+  # @return [Skippy::LibModule]
+  def find_module_or_fail(module_name)
+    lib_module = find_module(module_name)
+    if lib_module.nil?
+      raise Skippy::LibModule::ModuleNotFoundError,
+        "module '#{module_name}' not found"
+    end
+    lib_module
   end
 
   # @param [Pathname, String] source
-  def install(source)
+  # @return [Skippy::Library]
+  def install(source, options = {})
     raise Skippy::Project::ProjectNotSavedError unless project.exist?
-    library = Skippy::Library.new(source)
+    lib_source = Skippy::LibrarySource.new(project, source, options)
 
-    target = path.join(library.name)
+    installer = get_installer(lib_source)
+    if block_given?
+      installer.on_status { |type, message|
+        yield type, message
+      }
+    end
+    library = installer.install
 
-    FileUtils.mkdir_p(path)
-    FileUtils.copy_entry(source, target)
+    @libraries.delete(library)
+    @libraries << library
 
-    project.config.push(:libraries, {
-      name: library.name,
-      version: library.version,
-      source: source
-    })
+    project.modules.update(library)
 
-    project.save
+    library
+  end
 
+  # @param [Skippy::Library, String] source
+  # @return [Skippy::Library]
+  def uninstall(lib)
+    raise Skippy::Project::ProjectNotSavedError unless project.exist?
+    library = lib.is_a?(Skippy::Library) ? lib : find_library(lib)
+    raise Skippy::LibraryNotFound, 'Library not found' if library.nil?
+    # Uninstall modules first - using the module manager.
+    vendor_path = project.modules.vendor_path
+    vendor_module_path = vendor_path.join(library.name)
+    library.modules.each { |mod|
+      project.modules.remove(mod.name)
+    }
+    vendor_module_path.rmtree if vendor_module_path.exist?
+    # Remove the vendor path - no need to package unused directories.
+    if vendor_path.exist? && vendor_path.children.empty?
+      vendor_path.rmdir
+    end
+    raise 'Unable to remove vendor modules' if vendor_module_path.exist?
+    # Now the library itself is safe to remove.
+    library.path.rmtree if library.path.exist?
+    raise 'Unable to remove library' if library.path.exist?
+    @libraries.delete(library)
     library
   end
 
@@ -65,11 +124,50 @@ class Skippy::LibraryManager
   def length
     to_a.length
   end
-  alias :size :length
+  alias size length
 
   # @return [Pathname]
   def path
     project.path('.skippy/libs')
   end
 
+  private
+
+  # @return [Array<Skippy::Library>]
+  def discover_libraries
+    project.config.get(:libraries, []).map { |lib_config|
+      begin
+        library_from_config(lib_config)
+      rescue Skippy::Library::LibraryNotFoundError => error
+        # TODO: Revisit how to handle this.
+        warn "Unable to load library: #{error.message}"
+        nil
+      end
+    }.compact
+  end
+
+  # @param [Hash] config
+  def library_from_config(config)
+    options = {}
+    options[:requirement] = config[:requirement] if config[:requirement]
+    source = Skippy::LibrarySource.new(project, config[:source], options)
+    directories(path).each { |directory|
+      library = Skippy::Library.new(directory, source: source)
+      return library if library.name.casecmp(config[:name]).zero?
+    }
+    nil
+  end
+
+  # @param [Skippy::LibrarySource] lib_source
+  # @return [Skippy::Installer]
+  def get_installer(lib_source)
+    if lib_source.git?
+      Skippy::GitLibraryInstaller.new(project, lib_source)
+    elsif lib_source.local?
+      Skippy::LocalLibraryInstaller.new(project, lib_source)
+    else
+      raise Skippy::UnknownSourceType, "Unable to handle source: #{lib_source}"
+    end
+  end
+
 end