skippy 0.1.1.a → 0.2.0.a

data/lib/skippy/config_accessors.rb

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

data/lib/skippy/error.rb

@@ -1,4 +1,4 @@
 module Skippy
   class Error < StandardError
   end
-end
+end

data/lib/skippy/helpers/file.rb

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

data/lib/skippy/lib_module.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+
+require 'skippy/library'
+
+class Skippy::LibModule
+
+  attr_reader :path
+
+  class ModuleNotFoundError < Skippy::Error; end
+
+  # @param [String] path
+  def initialize(path)
+    @path = Pathname.new(path)
+    raise ModuleNotFoundError, @path.to_s unless @path.file?
+  end
+
+  # @param [String]
+  def basename
+    path.basename('.*').to_s
+  end
+
+  # @return [Skippy::Library]
+  def library
+    Skippy::Library.new(library_path)
+  end
+
+  # @param [String]
+  def name
+    "#{library_name}/#{basename}"
+  end
+
+  # @param [String]
+  def to_s
+    name
+  end
+
+  private
+
+  def library_name
+    library_path.basename.to_s
+  end
+
+  def library_path
+    path.parent.parent
+  end
+
+end

data/lib/skippy/library.rb

@@ -0,0 +1,57 @@
+require 'json'
+require 'pathname'
+
+require 'skippy/helpers/file'
+require 'skippy/config'
+require 'skippy/config_accessors'
+require 'skippy/lib_module'
+
+class Skippy::Library
+
+  extend Skippy::ConfigAccessors
+
+  include Skippy::Helpers::File
+
+  CONFIG_FILENAME = 'skippy.json'.freeze
+
+  attr_reader :path
+
+  config_attr_reader :title, key: :name # TODO(thomthom): Clean up this kludge.
+  config_attr_reader :version
+
+  class LibraryNotFoundError < Skippy::Error; end
+
+  def initialize(path)
+    @path = Pathname.new(path)
+    raise LibraryNotFoundError, @path.to_s unless @path.directory?
+    # noinspection RubyResolve
+    @config = Skippy::Config.load(config_file)
+  end
+
+  def name
+    path.basename.to_s
+  end
+
+  def modules
+    libs = modules_path.children(false).select { |file|
+      file.extname.downcase == '.rb'
+    }
+    libs.map! { |lib|
+      path = modules_path.join(lib)
+      Skippy::LibModule.new(path)
+    }
+    libs
+  end
+
+  private
+
+  def config_file
+    path.join(CONFIG_FILENAME)
+  end
+
+  def modules_path
+    # TODO(thomthom): Make this configurable and default to 'lib'?
+    path.join('src')
+  end
+
+end

data/lib/skippy/library_manager.rb

@@ -0,0 +1,75 @@
+require 'json'
+require 'pathname'
+
+require 'skippy/helpers/file'
+require 'skippy/library'
+require 'skippy/project'
+
+class Skippy::LibraryManager
+
+  include Enumerable
+  include Skippy::Helpers::File
+
+  attr_reader :project
+
+  # @param [Skippy::Project] project
+  def initialize(project)
+    raise TypeError, 'expected a Project' unless project.is_a?(Skippy::Project)
+    @project = project
+  end
+
+  # @yield [Skippy::Library]
+  def each
+    directories(path).each { |lib_path|
+      yield Skippy::Library.new(lib_path)
+    }
+    self
+  end
+
+  def empty?
+    to_a.empty?
+  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 }
+    return nil if library.nil?
+    library.modules.find { |mod| mod.basename == module_name }
+  end
+
+  # @param [Pathname, String] source
+  def install(source)
+    raise Skippy::Project::ProjectNotSavedError unless project.exist?
+    library = Skippy::Library.new(source)
+
+    target = path.join(library.name)
+
+    FileUtils.mkdir_p(path)
+    FileUtils.copy_entry(source, target)
+
+    project.config.push(:libraries, {
+      name: library.name,
+      version: library.version,
+      source: source
+    })
+
+    project.save
+
+    library
+  end
+
+  # @return [Integer]
+  def length
+    to_a.length
+  end
+  alias :size :length
+
+  # @return [Pathname]
+  def path
+    project.path('.skippy/libs')
+  end
+
+end

data/lib/skippy/module_manager.rb

@@ -0,0 +1,103 @@
+require 'json'
+require 'pathname'
+
+require 'skippy/helpers/file'
+require 'skippy/lib_module'
+require 'skippy/project'
+
+class Skippy::ModuleManager
+
+  include Enumerable
+  include Skippy::Helpers::File
+
+  attr_reader :project
+
+  # @param [Skippy::Project] project
+  def initialize(project)
+    raise TypeError, 'expected a Project' unless project.is_a?(Skippy::Project)
+    @project = project
+  end
+
+  # @yield [Skippy::LibModule]
+  def each
+    directories(path).each { |library_path|
+      library_path.each_child { |module_file|
+        next unless module_file.file?
+        next unless module_file.extname == '.rb'
+        yield Skippy::LibModule.new(module_file)
+      }
+    }
+    self
+  end
+
+  def empty?
+    to_a.empty?
+  end
+
+  # @param [String] module_name
+  # @return [Skippy::LibModule, nil]
+  def find_module(module_name)
+    find { |lib_module| lib_module.name == module_name }
+  end
+
+  # @param [Skippy::LibModule, String] lib_module
+  def installed?(lib_module)
+    module_name = lib_module.is_a?(Skippy::LibModule) ? lib_module.name : lib_module
+    project = Skippy::Project.current
+    project && project.config.get(:modules, []).any? { |mod| mod == module_name }
+  end
+
+  # @param [String] module_name
+  # @return [Skippy::LibModule]
+  def use(module_name)
+    raise Skippy::Project::ProjectNotSavedError unless project.exist?
+
+    lib_module = project.libraries.find_module(module_name)
+    raise Skippy::LibModule::ModuleNotFoundError,
+          "module '#{module_name}' not found" if lib_module.nil?
+
+    source = lib_module.path
+    target = path.join(lib_module.library.name, lib_module.path.basename)
+
+    copy_module(source, target)
+
+    project.config.push(:modules, lib_module.to_s)
+
+    project.save
+
+    lib_module
+  end
+
+  # @return [Integer]
+  def length
+    to_a.length
+  end
+  alias :size :length
+
+  # @return [Pathname]
+  def path
+    project.path.join('src', project.namespace.to_underscore, 'vendor')
+  end
+
+  private
+
+  # @param [Pathname, String] source
+  # @param [Pathname, String] target
+  def copy_module(source, target)
+    FileUtils.mkdir_p(target.parent)
+    content = File.read(source)
+    transform_module(content)
+    File.write(target, content)
+  end
+
+  # Transform the module content with `SkippyLib` placeholder replaced with
+  # the project namespace.
+  #
+  # @param [String] content
+  # @return [String]
+  def transform_module(content)
+    content.gsub!('SkippyLib', project.namespace)
+    content
+  end
+
+end

data/lib/skippy/namespace.rb

@@ -1,3 +1,5 @@
+require 'skippy/error'
+
 class Skippy::Namespace
 
   def initialize(namespace)
@@ -13,12 +15,10 @@ class Skippy::Namespace
 
   def open
     @open ||= to_a.map { |part| "module #{part}" }.join("\n")
-    @open
   end
 
   def close
     @close ||= to_a.reverse.map { |part| "end # module #{part}" }.join("\n")
-    @close
   end
 
   def to_a
@@ -33,6 +33,10 @@ class Skippy::Namespace
     @namespace.dup
   end
 
+  def to_str
+    to_s
+  end
+
   def to_underscore
     basename_words(basename).map { |word| word.downcase }.join('_')
   end
@@ -52,4 +56,4 @@ class Skippy::Namespace
     parts(namespace).all? { |part| /^[[:upper:]]/.match(part) }
   end
 
-end
+end

data/lib/skippy/project.rb

@@ -1,14 +1,43 @@
 require 'json'
 require 'pathname'
 
+require 'skippy/helpers/file'
+require 'skippy/config'
+require 'skippy/config_accessors'
+require 'skippy/error'
+require 'skippy/library_manager'
 require 'skippy/namespace'
+require 'skippy/module_manager'
 
 class Skippy::Project
 
+  extend Skippy::ConfigAccessors
+
+  include Skippy::Helpers::File
+
   PROJECT_FILENAME = 'skippy.json'.freeze
 
-  attr_reader :name, :namespace, :path, :author, :copyright, :license
-  attr_accessor :description
+  attr_reader :config
+  attr_reader :libraries
+  attr_reader :modules
+
+  config_attr :author, :copyright, :description, :license, :name
+  config_attr :namespace, type: Skippy::Namespace
+
+  class ProjectNotFoundError < Skippy::Error; end
+  class ProjectNotSavedError < Skippy::Error; end
+
+  # @return [Skippy::Project, nil]
+  def self.current
+    Skippy::Project.new(Dir.pwd)
+  end
+
+  # @return [Skippy::Project]
+  def self.current_or_fail
+    project = self.current
+    raise ProjectNotFoundError unless project.exist?
+    project
+  end
 
   # Initialize a project for the provided path. If the path is within a project
   # path the base path of the project will be found. Otherwise it's assumed that
@@ -17,12 +46,10 @@ class Skippy::Project
   # @param [Pathname, String] path
   def initialize(path)
     @path = find_project_path(path) || Pathname.new(path)
-    @namespace = Skippy::Namespace.new('Untitled')
-    @name = ''
-    @description = ''
-    @author = 'Unknown'
-    @copyright = "Copyright (c) #{Time.now.year}"
-    @license = 'None'
+    # noinspection RubyResolve
+    @config = Skippy::Config.load(filename, defaults)
+    @libraries = Skippy::LibraryManager.new(self)
+    @modules = Skippy::ModuleManager.new(self)
   end
 
   # @yield [filename]
@@ -36,42 +63,44 @@ class Skippy::Project
 
   # Checks if a project exist on disk. If not it's just transient.
   def exist?
-    File.exist?(filename)
+    filename.exist?
   end
 
   # Full path to the project's configuration file. This file may not exist.
-  # @return [String]
+  # @return [Pathname]
   def filename
-    File.join(path, PROJECT_FILENAME)
-  end
-
-  # @return [String]
-  def name
-    @name.empty? ? namespace.to_name : @name
+    path.join(PROJECT_FILENAME)
   end
 
-  # @param [String] namespace
-  def namespace=(namespace)
-    @namespace = Skippy::Namespace.new(namespace)
+  # @param [Pathname, String] sub_path
+  # @return [Pathname]
+  def path(sub_path = '')
+    @path.join(sub_path)
   end
 
   # Commits the project to disk.
   def save
-    File.write(filename, to_json)
+    @config.save_as(filename)
   end
 
   # @return [String]
   def to_json
-    project_config = {
-      namespace: namespace,
-      name: name,
-      description: description
-    }
-    JSON.pretty_generate(project_config)
+    JSON.pretty_generate(@config)
   end
 
   private
 
+  def defaults
+    {
+      name: 'Untitled',
+      description: '',
+      namespace: Skippy::Namespace.new('Untitled'),
+      author: 'Unknown',
+      copyright: "Copyright (c) #{Time.now.year}",
+      license: 'None',
+    }
+  end
+
   # Finds the root of a project based on any path within the project.
   #
   # @param [String] path