librarianp 0.1.2

data/lib/librarian/environment.rb

@@ -0,0 +1,230 @@
+require "pathname"
+require 'net/http'
+require "uri"
+require "etc"
+
+require "librarian/helpers"
+require "librarian/support/abstract_method"
+
+require "librarian/error"
+require "librarian/config"
+require "librarian/lockfile"
+require "librarian/logger"
+require "librarian/specfile"
+require "librarian/resolver"
+require "librarian/dsl"
+require "librarian/source"
+require "librarian/version"
+require "librarian/environment/runtime_cache"
+
+module Librarian
+  class Environment
+
+    include Support::AbstractMethod
+
+    attr_accessor :ui
+    attr_reader :runtime_cache
+
+    abstract_method :specfile_name, :dsl_class, :install_path
+
+    def initialize(options = { })
+      @pwd = options.fetch(:pwd) { Dir.pwd }
+      @env = options.fetch(:env) { ENV.to_hash }
+      @home = options.fetch(:home) { default_home }
+      @project_path = options[:project_path]
+      @runtime_cache = RuntimeCache.new
+    end
+
+    def logger
+      @logger ||= Logger.new(self)
+    end
+
+    def config_db
+      @config_db ||= begin
+        Config::Database.new(adapter_name,
+          :pwd => @pwd,
+          :env => @env,
+          :home => @home,
+          :project_path => @project_path,
+          :specfile_name => default_specfile_name
+        )
+      end
+    end
+
+    def default_specfile_name
+      @default_specfile_name ||= begin
+        capped = adapter_name.capitalize
+        "#{capped}file"
+      end
+    end
+
+    def project_path
+      config_db.project_path
+    end
+
+    def specfile_name
+      config_db.specfile_name
+    end
+
+    def specfile_path
+      config_db.specfile_path
+    end
+
+    def specfile
+      Specfile.new(self, specfile_path)
+    end
+
+    def adapter_module
+      implementation? or return
+      self.class.name.split("::")[0 ... -1].inject(Object, &:const_get)
+    end
+
+    def adapter_name
+      implementation? or return
+      Helpers.camel_cased_to_dasherized(self.class.name.split("::")[-2])
+    end
+
+    def adapter_version
+      implementation? or return
+      adapter_module::VERSION
+    end
+
+    def lockfile_name
+      config_db.lockfile_name
+    end
+
+    def lockfile_path
+      config_db.lockfile_path
+    end
+
+    def lockfile
+      Lockfile.new(self, lockfile_path)
+    end
+
+    def ephemeral_lockfile
+      Lockfile.new(self, nil)
+    end
+
+    def resolver(options = { })
+      Resolver.new(self, resolver_options.merge(options))
+    end
+
+    def resolver_options
+      {
+        :cyclic => resolver_permit_cyclic_reslutions?,
+      }
+    end
+
+    def resolver_permit_cyclic_reslutions?
+      false
+    end
+
+    def tmp_path
+      part = config_db["tmp"] || "tmp"
+      project_path.join(part)
+    end
+
+    def cache_path
+      tmp_path.join("librarian/cache")
+    end
+
+    def scratch_path
+      tmp_path.join("librarian/scratch")
+    end
+
+    def project_relative_path_to(path)
+      Pathname.new(path).relative_path_from(project_path)
+    end
+
+    def spec
+      specfile.read
+    end
+
+    def lock
+      lockfile.read
+    end
+
+    def dsl(*args, &block)
+      dsl_class.run(self, *args, &block)
+    end
+
+    def dsl_class
+      adapter_module::Dsl
+    end
+
+    def version
+      VERSION
+    end
+
+    def config_keys
+      %[
+      ]
+    end
+
+    # The HTTP proxy specified in the environment variables:
+    # * HTTP_PROXY
+    # * HTTP_PROXY_USER
+    # * HTTP_PROXY_PASS
+    # Adapted from:
+    #   https://github.com/rubygems/rubygems/blob/v1.8.24/lib/rubygems/remote_fetcher.rb#L276-293
+    def http_proxy_uri
+      @http_proxy_uri ||= begin
+        keys = %w( HTTP_PROXY HTTP_PROXY_USER HTTP_PROXY_PASS )
+        env = Hash[ENV.
+          map{|k, v| [k.upcase, v]}.
+          select{|k, v| keys.include?(k)}.
+          reject{|k, v| v.nil? || v.empty?}]
+
+        uri = env["HTTP_PROXY"] or return
+        uri = "http://#{uri}" unless uri =~ /^(https?|ftp|file):/
+        uri = URI.parse(uri)
+        uri.user ||= env["HTTP_PROXY_USER"]
+        uri.password ||= env["HTTP_PROXY_PASS"]
+        uri
+      end
+    end
+
+    def net_http_class(host)
+      no_proxy?(host) ? Net::HTTP : net_http_default_class
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{__id__.to_s(16)}>"
+    end
+
+  private
+
+    def environment
+      self
+    end
+
+    def implementation?
+      self.class != ::Librarian::Environment
+    end
+
+    def default_home
+      File.expand_path(ENV["HOME"] || Etc.getpwnam(Etc.getlogin).dir)
+    end
+
+    def no_proxy_list
+      @no_proxy_list ||= begin
+        list = ENV['NO_PROXY'] || ENV['no_proxy'] || ""
+        list.split(/\s*,\s*/) + %w(localhost 127.0.0.1)
+      end
+    end
+
+    def no_proxy?(host)
+      no_proxy_list.any? do |host_addr|
+        host.end_with?(host_addr)
+      end
+    end
+
+    def net_http_default_class
+      @net_http_default_class ||= begin
+        p = http_proxy_uri
+        p ? Net::HTTP::Proxy(p.host, p.port, p.user, p.password) : Net::HTTP
+      end
+    end
+
+  end
+end

data/lib/librarian/error.rb

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

data/lib/librarian/helpers.rb

@@ -0,0 +1,29 @@
+module Librarian
+
+  # PRIVATE
+  #
+  # Adapters must not rely on these methods since they will change.
+  #
+  # Adapters requiring similar methods ought to re-implement them.
+  module Helpers
+    extend self
+
+    # [active_support/core_ext/string/strip]
+    def strip_heredoc(string)
+      indent = string.scan(/^[ \t]*(?=\S)/).min
+      indent = indent.respond_to?(:size) ? indent.size : 0
+      string.gsub(/^[ \t]{#{indent}}/, '')
+    end
+
+    # [active_support/inflector/methods]
+    def camel_cased_to_dasherized(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1-\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1-\2')
+      word.downcase!
+      word
+    end
+
+  end
+
+end

data/lib/librarian/linter/source_linter.rb

@@ -0,0 +1,55 @@
+module Librarian
+  module Linter
+    class SourceLinter
+
+      class << self
+        def lint!(klass)
+          new(klass).lint!
+        end
+      end
+
+      attr_accessor :klass
+      private :klass=
+
+      def initialize(klass)
+        self.klass = klass
+      end
+
+      def lint!
+        lint_class_responds_to! *[
+          :lock_name,
+          :from_spec_args,
+          :from_lock_options,
+        ]
+
+        lint_instance_responds_to! *[
+          :to_spec_args,
+          :to_lock_options,
+          :manifests,
+          :fetch_version,
+          :fetch_dependencies,
+          :pinned?,
+          :unpin!,
+          :install!,
+        ]
+      end
+
+    private
+
+      def lint_class_responds_to!(*names)
+        missing = names.reject{|name| klass.respond_to?(name)}
+        return if missing.empty?
+
+        raise "class must respond to #{missing.join(', ')}"
+      end
+
+      def lint_instance_responds_to!(*names)
+        missing = names - klass.public_instance_methods.map(&:to_sym)
+        return if missing.empty?
+
+        raise "instance must respond to #{missing.join(', ')}"
+      end
+
+    end
+  end
+end

data/lib/librarian/lockfile/compiler.rb

@@ -0,0 +1,66 @@
+module Librarian
+  class Lockfile
+    class Compiler
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def compile(resolution)
+        out = StringIO.new
+        save_sources(out, resolution.manifests)
+        save_dependencies(out, resolution.dependencies)
+        out.string
+      end
+
+    private
+
+      def save_sources(out, manifests)
+        dsl_class.source_types.map{|t| t[1]}.each do |type|
+          type_manifests = manifests.select{|m| type === m.source}
+          sources = type_manifests.map{|m| m.source}.uniq.sort_by{|s| s.to_s}
+          sources.each do |source|
+            source_manifests = type_manifests.select{|m| source == m.source}
+            save_source(out, source, source_manifests)
+          end
+        end
+      end
+
+      def save_source(out, source, manifests)
+        out.puts "#{source.class.lock_name}"
+        options = source.to_lock_options
+        remote = options.delete(:remote)
+        out.puts "  remote: #{remote}"
+        options.to_a.sort_by{|a| a[0].to_s}.each do |o|
+          out.puts "  #{o[0]}: #{o[1]}"
+        end
+        out.puts "  specs:"
+        manifests.sort_by{|a| a.name}.each do |manifest|
+          out.puts "    #{manifest.name} (#{manifest.version})"
+          manifest.dependencies.sort_by{|a| a.name}.each do |dependency|
+            out.puts "      #{dependency.name} (#{dependency.requirement})"
+          end
+        end
+        out.puts ""
+      end
+
+      def save_dependencies(out, dependencies)
+        out.puts "DEPENDENCIES"
+        dependencies.sort_by{|a| a.name}.each do |d|
+          res = "#{d.name}"
+          res << " (#{d.requirement})" if d.requirement
+          out.puts "  #{res}"
+        end
+        out.puts ""
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+    end
+  end
+end

data/lib/librarian/lockfile/parser.rb

@@ -0,0 +1,123 @@
+require 'librarian/manifest'
+require 'librarian/dependency'
+require 'librarian/manifest_set'
+
+module Librarian
+  class Lockfile
+    class Parser
+
+      class ManifestPlaceholder
+        attr_reader :source, :name, :version, :dependencies
+        def initialize(source, name, version, dependencies)
+          @source, @name, @version, @dependencies = source, name, version, dependencies
+        end
+      end
+
+      attr_accessor :environment
+      private :environment=
+
+      def initialize(environment)
+        self.environment = environment
+      end
+
+      def parse(string)
+        lines = string.lines.map{|l| l.sub(/\s+\z/, '')}.reject(&:empty?)
+        sources = extract_and_parse_sources(lines)
+        manifests = compile(sources)
+        manifests_index = Hash[manifests.map{|m| [m.name, m]}]
+        raise StandardError, "Expected DEPENDENCIES topic!" unless lines.shift == "DEPENDENCIES"
+        dependencies = extract_and_parse_dependencies(lines, manifests_index)
+        Resolution.new(dependencies, manifests)
+      end
+
+    private
+
+      def extract_and_parse_sources(lines)
+        sources = []
+        while source_type_names.include?(lines.first)
+          source = {}
+          source_type_name = lines.shift
+          source[:type] = source_type_names_map[source_type_name]
+          options = {}
+          while lines.first =~ /^ {2}([\w-]+):\s+(.+)$/
+            lines.shift
+            options[$1.to_sym] = $2
+          end
+          source[:options] = options
+          lines.shift # specs
+          manifests = {}
+          while lines.first =~ /^ {4}([\w-]+) \((.*)\)$/
+            lines.shift
+            name = $1
+            manifests[name] = {:version => $2, :dependencies => {}}
+            while lines.first =~ /^ {6}([\w-]+) \((.*)\)$/
+              lines.shift
+              manifests[name][:dependencies][$1] = $2.split(/,\s*/)
+            end
+          end
+          source[:manifests] = manifests
+          sources << source
+        end
+        sources
+      end
+
+      def extract_and_parse_dependencies(lines, manifests_index)
+        dependencies = []
+        while lines.first =~ /^ {2}([\w-]+)(?: \((.*)\))?$/
+          lines.shift
+          name, requirement = $1, $2.split(/,\s*/)
+          dependencies << Dependency.new(name, requirement, manifests_index[name].source)
+        end
+        dependencies
+      end
+
+      def compile_placeholder_manifests(sources_ast)
+        manifests = {}
+        sources_ast.each do |source_ast|
+          source_type = source_ast[:type]
+          source = source_type.from_lock_options(environment, source_ast[:options])
+          source_ast[:manifests].each do |manifest_name, manifest_ast|
+            manifests[manifest_name] = ManifestPlaceholder.new(
+              source,
+              manifest_name,
+              manifest_ast[:version],
+              manifest_ast[:dependencies].map{|k, v| Dependency.new(k, v, nil)}
+            )
+          end
+        end
+        manifests
+      end
+
+      def compile(sources_ast)
+        manifests = compile_placeholder_manifests(sources_ast)
+        manifests = manifests.map do |name, manifest|
+          dependencies = manifest.dependencies.map do |d|
+            Dependency.new(d.name, d.requirement, manifests[d.name].source)
+          end
+          real = Manifest.new(manifest.source, manifest.name)
+          real.version = manifest.version
+          real.dependencies = manifest.dependencies
+          real
+        end
+        ManifestSet.sort(manifests)
+      end
+
+      def dsl_class
+        environment.dsl_class
+      end
+
+      def source_type_names_map
+        @source_type_names_map ||= begin
+          Hash[dsl_class.source_types.map{|t| [t[1].lock_name, t[1]]}]
+        end
+      end
+
+      def source_type_names
+        @source_type_names ||= begin
+          dsl_class.source_types.map{|t| t[1].lock_name}
+        end
+      end
+
+    end
+  end
+end

data/lib/librarian/lockfile.rb

@@ -0,0 +1,29 @@
+require 'librarian/lockfile/compiler'
+require 'librarian/lockfile/parser'
+
+module Librarian
+  class Lockfile
+
+    attr_accessor :environment
+    private :environment=
+    attr_reader :path
+
+    def initialize(environment, path)
+      self.environment = environment
+      @path = path
+    end
+
+    def save(resolution)
+      Compiler.new(environment).compile(resolution)
+    end
+
+    def load(string)
+      Parser.new(environment).parse(string)
+    end
+
+    def read
+      load(path.read)
+    end
+
+  end
+end

data/lib/librarian/logger.rb

@@ -0,0 +1,46 @@
+module Librarian
+  class Logger
+
+    librarian_path = Pathname(__FILE__)
+    librarian_path = librarian_path.dirname until librarian_path.join("lib").directory?
+    LIBRARIAN_PATH = librarian_path
+
+    attr_accessor :environment
+    private :environment=
+
+    def initialize(environment)
+      self.environment = environment
+    end
+
+    def info(string = nil, &block)
+      return unless ui
+
+      ui.info(string || yield)
+    end
+
+    def debug(string = nil, &block)
+      return unless ui
+
+      if ui.respond_to?(:debug_line_numbers) && ui.debug_line_numbers
+        loc = caller.find{|l| !(l =~ /in `debug'$/)}
+        if loc =~ /^(.+):(\d+):in `(.+)'$/
+          loc = "#{Pathname.new($1).relative_path_from(LIBRARIAN_PATH)}:#{$2}:in `#{$3}'"
+        end
+        ui.debug { "[Librarian] #{string || yield} [#{loc}]" }
+      else
+        ui.debug { "[Librarian] #{string || yield}" }
+      end
+    end
+
+    def relative_path_to(path)
+      environment.project_relative_path_to(path)
+    end
+
+    private
+
+    def ui
+      environment.ui
+    end
+
+  end
+end