librarianp 0.1.2

data/lib/librarian/cli.rb

@@ -0,0 +1,225 @@
+require 'thor'
+require 'thor/actions'
+
+require 'librarian'
+require 'librarian/error'
+require 'librarian/action'
+require "librarian/ui"
+
+module Librarian
+  class Cli < Thor
+
+    autoload :ManifestPresenter, "librarian/cli/manifest_presenter"
+
+    include Thor::Actions
+
+    module Particularity
+      def root_module
+        nil
+      end
+    end
+
+    extend Particularity
+
+    class << self
+      def bin!
+        status = with_environment { returning_status { start } }
+        exit status
+      end
+
+      def returning_status
+        yield
+        0
+      rescue Librarian::Error => e
+        environment.ui.error e.message
+        environment.ui.debug e.backtrace.join("\n")
+        e.respond_to?(:status_code) && e.status_code || 1
+      rescue Interrupt => e
+        environment.ui.error "\nQuitting..."
+        1
+      end
+
+      attr_accessor :environment
+
+      def with_environment
+        environment = root_module.environment_class.new
+        self.environment, orig_environment = environment, self.environment
+        yield(environment)
+      ensure
+        self.environment = orig_environment
+      end
+    end
+
+    def initialize(*)
+      super
+      the_shell = (options["no-color"] ? Thor::Shell::Basic.new : shell)
+      environment.ui = UI::Shell.new(the_shell)
+      environment.ui.be_quiet! if options["quiet"]
+      environment.ui.debug! if options["verbose"]
+      environment.ui.debug_line_numbers! if options["verbose"] && options["line-numbers"]
+
+      write_debug_header
+    end
+
+    desc "version", "Displays the version."
+    def version
+      say "librarian-#{environment.version}"
+      say "librarian-#{environment.adapter_name}-#{environment.adapter_version}"
+    end
+
+    desc "config", "Show or edit the config."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    option "global", :type => :boolean, :default => false
+    option "local", :type => :boolean, :default => false
+    option "delete", :type => :boolean, :default => false
+    def config(key = nil, value = nil)
+      if key
+        raise Error, "cannot set both value and delete" if value && options["delete"]
+        if options["delete"]
+          scope = config_scope(true)
+          environment.config_db[key, scope] = nil
+        elsif value
+          scope = config_scope(true)
+          environment.config_db[key, scope] = value
+        else
+          scope = config_scope(false)
+          if value = environment.config_db[key, scope]
+            prefix = scope ? "#{key} (#{scope})" : key
+            say "#{prefix}: #{value}"
+          end
+        end
+      else
+        environment.config_db.keys.each do |key|
+          say "#{key}: #{environment.config_db[key]}"
+        end
+      end
+    end
+
+    desc "clean", "Cleans out the cache and install paths."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def clean
+      ensure!
+      clean!
+    end
+
+    desc "update", "Updates and installs the dependencies you specify."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def update(*names)
+      ensure!
+      if names.empty?
+        resolve!(:force => true)
+      else
+        update!(:names => names)
+      end
+      install!
+    end
+
+    desc "outdated", "Lists outdated dependencies."
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    def outdated
+      ensure!
+      resolution = environment.lock
+      manifests = resolution.manifests.sort_by(&:name)
+      manifests.select(&:outdated?).each do |manifest|
+        say "#{manifest.name} (#{manifest.version} -> #{manifest.latest.version})"
+      end
+    end
+
+    desc "show", "Shows dependencies"
+    option "verbose", :type => :boolean, :default => false
+    option "line-numbers", :type => :boolean, :default => false
+    option "detailed", :type => :boolean
+    def show(*names)
+      ensure!
+      if environment.lockfile_path.file?
+        manifest_presenter.present(names, :detailed => options["detailed"])
+      else
+        raise Error, "Be sure to install first!"
+      end
+    end
+
+    desc "init", "Initializes the current directory."
+    def init
+      puts "Nothing to do."
+    end
+
+  private
+
+    def environment
+      self.class.environment
+    end
+
+    def ensure!(options = { })
+      Action::Ensure.new(environment, options).run
+    end
+
+    def clean!(options = { })
+      Action::Clean.new(environment, options).run
+    end
+
+    def install!(options = { })
+      Action::Install.new(environment, options).run
+    end
+
+    def resolve!(options = { })
+      Action::Resolve.new(environment, options).run
+    end
+
+    def update!(options = { })
+      Action::Update.new(environment, options).run
+    end
+
+    def manifest_presenter
+      ManifestPresenter.new(self, environment.lock.manifests)
+    end
+
+    def write_debug_header
+      debug { "Ruby Version: #{RUBY_VERSION}" }
+      debug { "Ruby Platform: #{RUBY_PLATFORM}" }
+      debug { "Rubinius Version: #{Rubinius::VERSION}" } if defined?(Rubinius)
+      debug { "JRuby Version: #{JRUBY_VERSION}" } if defined?(JRUBY_VERSION)
+      debug { "Rubygems Version: #{Gem::VERSION}" }
+      debug { "Librarian Version: #{environment.version}" }
+      debug { "Librarian Adapter: #{environment.adapter_name}"}
+      debug { "Librarian Adapter Version: #{environment.adapter_version}" }
+      debug { "Project: #{environment.project_path}" }
+      debug { "Specfile: #{relative_path_to(environment.specfile_path)}" }
+      debug { "Lockfile: #{relative_path_to(environment.lockfile_path)}" }
+      debug { "Git: #{Source::Git::Repository.bin}" }
+      debug { "Git Version: #{Source::Git::Repository.git_version}" }
+      debug { "Git Environment Variables:" }
+      git_env = ENV.to_a.select{|(k, v)| k =~ /\AGIT/}.sort_by{|(k, v)| k}
+      if git_env.empty?
+        debug { "  (empty)" }
+      else
+        git_env.each do |(k, v)|
+          debug { "  #{k}=#{v}"}
+        end
+      end
+    end
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+    def relative_path_to(path)
+      environment.logger.relative_path_to(path)
+    end
+
+    def config_scope(exclusive)
+      g, l = "global", "local"
+      if exclusive
+        options[g] ^ options[l] or raise Error, "must set either #{g} or #{l}"
+      else
+        options[g] && options[l] and raise Error, "cannot set both #{g} and #{l}"
+      end
+
+      options[g] ? :global : options[l] ? :local : nil
+    end
+
+  end
+end

data/lib/librarian/config/database.rb

@@ -0,0 +1,205 @@
+require "pathname"
+
+require "librarian/config/file_source"
+require "librarian/config/hash_source"
+
+module Librarian
+  module Config
+    class Database
+
+      class << self
+        def library
+          name.split("::").first.downcase
+        end
+      end
+
+      attr_accessor :adapter_name
+      private :adapter_name=
+
+      attr_accessor :root, :assigned_specfile_name
+      private :root=, :assigned_specfile_name=
+
+      attr_accessor :underlying_env, :underlying_pwd, :underlying_home
+      private :underlying_env=, :underlying_pwd=, :underlying_home=
+
+      def initialize(adapter_name, options = { })
+        self.adapter_name = adapter_name or raise ArgumentError, "must provide adapter_name"
+
+        options[:project_path] || options[:pwd] or raise ArgumentError, "must provide project_path or pwd"
+
+        self.root = options[:project_path] && Pathname(options[:project_path])
+        self.assigned_specfile_name = options[:specfile_name]
+        self.underlying_env = options[:env] or raise ArgumentError, "must provide env"
+        self.underlying_pwd = options[:pwd] && Pathname(options[:pwd])
+        self.underlying_home = options[:home] && Pathname(options[:home])
+      end
+
+      def global
+        memo(__method__) { new_file_source(global_config_path) }
+      end
+
+      def env
+        memo(__method__) { HashSource.new(adapter_name, :name => "environment", :raw => env_source_data) }
+      end
+
+      def local
+        memo(__method__) { new_file_source(local_config_path) }
+      end
+
+      def [](key, scope = nil)
+        case scope
+        when "local", :local then local[key]
+        when "env", :env then env[key]
+        when "global", :global then global[key]
+        when nil then local[key] || env[key] || global[key]
+        else raise Error, "bad scope"
+        end
+      end
+
+      def []=(key, scope, value)
+        case scope
+        when "local", :local then local[key] = value
+        when "global", :global then global[key] = value
+        else raise Error, "bad scope"
+        end
+      end
+
+      def keys
+        [local, env, global].inject([]){|a, e| a.concat(e.keys) ; a}.sort.uniq
+      end
+
+      def project_path
+        root || specfile_path.dirname
+      end
+
+      def specfile_path
+        if root
+          root + (assigned_specfile_name || default_specfile_name)
+        else
+          env_specfile_path || default_specfile_path
+        end
+      end
+
+      def specfile_name
+        specfile_path.basename.to_s
+      end
+
+      def lockfile_path
+        project_path + lockfile_name
+      end
+
+      def lockfile_name
+        "#{specfile_name}.lock"
+      end
+
+    private
+
+      def new_file_source(config_path)
+        return unless config_path
+
+        FileSource.new(adapter_name,
+          :config_path => config_path,
+          :forbidden_keys => [config_key, specfile_key]
+        )
+      end
+
+      def global_config_path
+        env_global_config_path || default_global_config_path
+      end
+
+      def env_global_config_path
+        memo(__method__) { env[config_key] }
+      end
+
+      def default_global_config_path
+        underlying_home && underlying_home + config_name
+      end
+
+      def local_config_path
+        root_local_config_path || env_local_config_path || default_local_config_path
+      end
+
+      def root_local_config_path
+        root && root + config_name
+      end
+
+      def env_specfile_path
+        memo(__method__) do
+          path = env[specfile_key]
+          path && Pathname(path)
+        end
+      end
+
+      def default_specfile_path
+        default_project_root_path + (assigned_specfile_name || default_specfile_name)
+      end
+
+      def env_local_config_path
+        return unless env_specfile_path
+
+        env_specfile_path.dirname + config_name
+      end
+
+      def default_local_config_path
+        default_project_root_path + config_name
+      end
+
+      def default_project_root_path
+        if root
+          root
+        else
+          path = underlying_pwd
+          path = path.dirname until project_root_path?(path) || path.dirname == path
+          project_root_path?(path) ? path : underlying_pwd
+        end
+      end
+
+      def project_root_path?(path)
+        File.file?(path + default_specfile_name)
+      end
+
+      def config_key
+        "config"
+      end
+
+      def specfile_key
+        "#{adapter_name}file"
+      end
+
+      def default_specfile_name
+        "#{adapter_name.capitalize}file"
+      end
+
+      def library
+        self.class.library
+      end
+
+      def config_name_prefix
+        ".#{library}"
+      end
+
+      def config_name
+        File.join(*[config_name_prefix, adapter_name, "config"])
+      end
+
+      def raw_key_prefix
+        "#{library.upcase}_#{adapter_name.upcase}_"
+      end
+
+      def env_source_data
+        prefix = raw_key_prefix
+
+        data = underlying_env.dup
+        data.reject!{|k, _| !k.start_with?(prefix) || k.size <= prefix.size}
+        data
+      end
+
+      def memo(key)
+        key = "@#{key}"
+        instance_variable_set(key, yield) unless instance_variable_defined?(key)
+        instance_variable_get(key)
+      end
+
+    end
+  end
+end

data/lib/librarian/config/file_source.rb

@@ -0,0 +1,47 @@
+require "yaml"
+
+require "librarian/config/source"
+
+module Librarian
+  module Config
+    class FileSource < Source
+
+      attr_accessor :config_path
+      private :config_path=
+
+      def initialize(adapter_name, options = { })
+        super
+
+        self.config_path = options.delete(:config_path) or raise ArgumentError, "must provide config_path"
+      end
+
+      def to_s
+        config_path
+      end
+
+    private
+
+      def load
+        return { } unless File.file?(config_path)
+
+        raw = YAML.load_file(config_path)
+        return { } unless Hash === raw
+
+        translate_raw_to_config(raw)
+      end
+
+      def save(config)
+        raw = translate_config_to_raw(config)
+
+        if config.empty?
+          File.delete(config_path) if File.file?(config_path)
+        else
+          config_dir = File.dirname(config_path)
+          FileUtils.mkpath(config_dir) unless File.directory?(config_dir)
+          File.open(config_path, "wb"){|f| YAML.dump(raw, f)}
+        end
+      end
+
+    end
+  end
+end

data/lib/librarian/config/hash_source.rb

@@ -0,0 +1,33 @@
+require "librarian/source"
+
+module Librarian
+  module Config
+    class HashSource < Source
+
+      attr_accessor :name, :raw
+      private :name=, :raw=
+
+      def initialize(adapter_name, options = { })
+        super
+
+        self.name = options.delete(:name) or raise ArgumentError, "must provide name"
+        self.raw = options.delete(:raw) or raise ArgumentError, "must provide raw"
+      end
+
+      def to_s
+        name
+      end
+
+    private
+
+      def load
+        translate_raw_to_config(raw)
+      end
+
+      def save(config)
+        raise Error, "nonsense!"
+      end
+
+    end
+  end
+end

data/lib/librarian/config/source.rb

@@ -0,0 +1,149 @@
+require "librarian/error"
+
+module Librarian
+  module Config
+    class Source
+
+      RAW_KEY_SUFFIX_VALIDITY_PATTERN =
+        /\A[A-Z0-9_]+\z/
+      CONFIG_KEY_VALIDITY_PATTERN =
+        /\A[a-z][a-z0-9\-]+(?:\.[a-z0-9\-]+)*\z/
+
+      class << self
+        def raw_key_suffix_validity_pattern
+          RAW_KEY_SUFFIX_VALIDITY_PATTERN
+        end
+        def config_key_validity_pattern
+          CONFIG_KEY_VALIDITY_PATTERN
+        end
+      end
+
+      attr_accessor :adapter_name
+      private :adapter_name=
+
+      def initialize(adapter_name, options = { })
+        self.adapter_name = adapter_name
+
+        self.forbidden_keys = options.delete(:forbidden_keys) || []
+      end
+
+      def [](key)
+        load!
+
+        data[key]
+      end
+
+      def []=(key, value)
+        key_permitted?(key) or raise Error, "key not permitted: #{key.inspect}"
+        value_permitted?(key, value) or raise Error, "value for key #{key.inspect} not permitted: #{value.inspect}"
+
+        load!
+        if value.nil?
+          data.delete(key)
+        else
+          data[key] = value
+        end
+        save(data)
+      end
+
+      def keys
+        load!
+
+        data.keys
+      end
+
+    private
+
+      attr_accessor :data, :forbidden_keys
+
+      def load!
+        self.data = load unless data
+      end
+
+      def key_permitted?(key)
+        String === key &&
+        config_key_validity_pattern === key &&
+        !forbidden_keys.any?{|k| k === key}
+      end
+
+      def value_permitted?(key, value)
+        return true if value.nil?
+
+        String === value
+      end
+
+      def raw_key_valid?(key)
+        return false unless key.start_with?(raw_key_prefix)
+
+        suffix = key[raw_key_prefix.size..-1]
+        raw_key_suffix_validity_pattern =~ suffix
+      end
+
+      def raw_key_suffix_validity_pattern
+        self.class.raw_key_suffix_validity_pattern
+      end
+
+      def config_key_valid?(key)
+        config_key_validity_pattern === key
+      end
+
+      def config_key_validity_pattern
+        self.class.config_key_validity_pattern
+      end
+
+      def raw_key_prefix
+        @key_prefix ||= "LIBRARIAN_#{adapter_name.upcase}_"
+      end
+
+      def assert_raw_keys_valid!(raw)
+        bad_keys = raw.keys.reject{|k| raw_key_valid?(k)}
+        unless bad_keys.empty?
+          config_path_s = config_path.to_s.inspect
+          bad_keys_s = bad_keys.map(&:inspect).join(", ")
+          raise Error, "config #{to_s} has bad keys: #{bad_keys_s}"
+        end
+      end
+
+      def assert_config_keys_valid!(config)
+        bad_keys = config.keys.reject{|k| config_key_valid?(k)}
+        unless bad_keys.empty?
+          bad_keys_s = bad_keys.map(&:inspect).join(", ")
+          raise Error, "config has bad keys: #{bad_keys_s}"
+        end
+      end
+
+      def assert_values_valid!(data)
+        bad_data = data.reject{|k, v| String === v}
+        bad_keys = bad_data.keys
+
+        unless bad_keys.empty?
+          bad_keys_s = bad_keys.map(&:inspect).join(", ")
+          raise Error, "config has bad values for keys: #{bad_keys_s}"
+        end
+      end
+
+      def translate_raw_to_config(raw)
+        assert_raw_keys_valid!(raw)
+        assert_values_valid!(raw)
+
+        Hash[raw.map do |key, value|
+          key = key[raw_key_prefix.size .. -1]
+          key = key.downcase.gsub(/__/, ".").gsub(/_/, "-")
+          [key, value]
+        end]
+      end
+
+      def translate_config_to_raw(config)
+        assert_config_keys_valid!(config)
+        assert_values_valid!(config)
+
+        Hash[config.map do |key, value|
+          key = key.gsub(/\./, "__").gsub(/\-/, "_").upcase
+          key = "#{raw_key_prefix}#{key}"
+          [key, value]
+        end]
+      end
+
+    end
+  end
+end

data/lib/librarian/config.rb

@@ -0,0 +1,7 @@
+require "librarian/config/database"
+
+module Librarian
+  module Config
+
+  end
+end