librarian 0.0.1

data/lib/librarian/dependency.rb

@@ -0,0 +1,44 @@
+require 'rubygems'
+
+module Librarian
+  class Dependency
+
+    class Requirement < Gem::Requirement
+    end
+
+    attr_reader :name, :requirement, :source
+
+    def initialize(name, requirement, source)
+      @name = name
+      @requirement = Requirement.create(requirement)
+      @source = source
+      @manifests = nil
+    end
+
+    def manifests
+      @manifests ||= cache_manifests!
+    end
+
+    def cache_manifests!
+      source.cache!([self])
+      source.manifests(self)
+    end
+
+    def satisfied_by?(manifest)
+      manifest.satisfies?(self)
+    end
+
+    def to_s
+      "#{name} (#{requirement}) <#{source}>"
+    end
+
+    def ==(other)
+      !other.nil? &&
+      self.class        == other.class        &&
+      self.name         == other.name         &&
+      self.requirement  == other.requirement  &&
+      self.source       == other.source
+    end
+
+  end
+end

data/lib/librarian/dsl.rb

@@ -0,0 +1,76 @@
+require 'librarian/dependency'
+require 'librarian/dsl/receiver'
+require 'librarian/dsl/target'
+
+module Librarian
+  class Dsl
+
+    class Error < Exception
+    end
+
+    class << self
+
+      def run(specfile = nil, precache_sources = [], &block)
+        new.run(specfile, precache_sources, &block)
+      end
+
+    private
+
+      def dependency(name)
+        dependency_name = name
+        dependency_type = Dependency
+        singleton_class = class << self; self end
+        singleton_class.instance_eval do
+          define_method(:dependency_name) { dependency_name }
+          define_method(:dependency_type) { dependency_type }
+        end
+      end
+
+      define_method(:source_types) { [] }
+
+      def source(options)
+        name = options.keys.first
+        type = options[name]
+        types = source_types
+        types << [name, type]
+        singleton_class = class << self; self end
+        singleton_class.instance_eval do
+          define_method(:source_types) { types }
+        end
+      end
+
+      define_method(:source_shortcuts) { {} }
+
+      def shortcut(name, options)
+        instances = source_shortcuts
+        instances[name] = options
+        singleton_class = class << self; self end
+        singleton_class.instance_eval do
+          define_method(:source_shortcuts) { instances }
+        end
+      end
+
+      def delegate_to_class(*names)
+        names.each do |name|
+          define_method(name) { self.class.send(name) }
+        end
+      end
+
+    end
+
+    delegate_to_class :dependency_name, :dependency_type, :source_types, :source_shortcuts
+
+    def run(specfile = nil, sources = [])
+      Target.new(self).tap do |target|
+        target.precache_sources(sources)
+        receiver = Receiver.new(target)
+        if block_given?
+          receiver.run(&Proc.new)
+        else
+          receiver.run(specfile)
+        end
+      end.to_spec
+    end
+
+  end
+end

data/lib/librarian/dsl/receiver.rb

@@ -0,0 +1,46 @@
+require 'librarian/specfile'
+
+module Librarian
+  class Dsl
+    class Receiver
+
+      def initialize(target)
+        singleton_class = class << self; self end
+        singleton_class.class_eval do
+          define_method(target.dependency_name) do |*args, &block|
+            target.dependency(*args, &block)
+          end
+          define_method(:source) do |*args, &block|
+            target.source(*args, &block)
+          end
+          target.source_types.each do |source_type|
+            name = source_type[0]
+            define_method(name) do |*args, &block|
+              target.source(name, *args, &block)
+            end
+          end
+        end
+      end
+
+      def run(specfile = nil)
+        if block_given?
+          instance_eval(&Proc.new)
+        else
+          case specfile
+          when Specfile
+            eval(specfile.path.read, instance_binding, specfile.path.to_s, 1)
+          when String
+            eval(specfile, instance_binding)
+          when Proc
+            instance_eval(&specfile)
+          end
+        end
+      end
+
+      def instance_binding
+        binding
+      end
+
+    end
+  end
+end

data/lib/librarian/dsl/target.rb

@@ -0,0 +1,164 @@
+require 'librarian/spec'
+
+module Librarian
+  class Dsl
+    class Target
+
+      class SourceShortcutDefinitionReceiver
+        def initialize(target)
+          singleton_class = class << self; self end
+          singleton_class.class_eval do
+            define_method(:source) do |options|
+              target.source_from_options(options)
+            end
+            target.source_types.each do |source_type|
+              name = source_type[0]
+              define_method(name) do |*args|
+                args.push({}) unless Hash === args.last
+                target.source_from_params(name, *args)
+              end
+            end
+          end
+        end
+      end
+
+      SCOPABLES = [:sources]
+
+      attr_reader :dependency_name, :dependency_type
+      attr_reader :source_types, :source_types_map, :source_types_reverse_map, :source_type_names, :source_shortcuts
+      attr_reader :dependencies, :source_cache, *SCOPABLES
+
+      def initialize(dsl)
+        @dependency_name = dsl.dependency_name
+        @dependency_type = dsl.dependency_type
+        @source_types = dsl.source_types
+        @source_types_map = Hash[source_types]
+        @source_types_reverse_map = Hash[source_types.map{|pair| a, b = pair ; [b, a]}]
+        @source_type_names = source_types.map{|t| t[0]}
+        @source_cache = {}
+        @source_shortcuts = {}
+        @dependencies = []
+        SCOPABLES.each do |scopable|
+          instance_variable_set(:"@#{scopable}", [])
+        end
+        dsl.source_shortcuts.each do |name, param|
+          define_source_shortcut(name, param)
+        end
+      end
+
+      def to_spec
+        Spec.new(@sources.first, @dependencies)
+      end
+
+      def dependency(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source = source_from_options(options) || @sources.last
+        unless source
+          raise Error, "#{dependency_name} #{name} is specified without a source!"
+        end
+        dep = dependency_type.new(name, args, source)
+        @dependencies << dep
+      end
+
+      def source(name, param = nil, options = nil, &block)
+        if !(Hash === name) && [Array, Hash, Proc].any?{|c| c === param} && !options && !block
+          define_source_shortcut(name, param)
+        elsif !(Hash === name) && !param && !options
+          source = source_shortcuts[name]
+          scope_or_directive(block) do
+            @sources = @sources.dup << source
+          end
+        else
+          name, param, options = *normalize_source_options(name, param, options || {})
+          source = source_from_params(name, param, options)
+          scope_or_directive(block) do
+            @sources = @sources.dup << source
+          end
+        end
+      end
+
+      def precache_sources(sources)
+        sources.each do |source|
+          key = [source_types_reverse_map[source.class], *source.to_spec_args]
+          source_cache[key] = source
+        end
+      end
+
+      def scope
+        currents = { }
+        SCOPABLES.each do |scopable|
+          currents[scopable] = instance_variable_get(:"@#{scopable}").dup
+        end
+        yield
+      ensure
+        SCOPABLES.reverse.each do |scopable|
+          instance_variable_set(:"@#{scopable}", currents[scopable])
+        end
+      end
+
+      def scope_or_directive(scoped_block = nil)
+        unless scoped_block
+          yield
+        else
+          scope do
+            yield
+            scoped_block.call
+          end
+        end
+      end
+
+      def normalize_source_options(name, param, options)
+        if name.is_a?(Hash)
+          extract_source_parts(name)
+        else
+          [name, param, options]
+        end
+      end
+
+      def extract_source_parts(options)
+        if name = source_type_names.find{|name| options.key?(name)}
+          options = options.dup
+          param = options.delete(name)
+          [name, param, options]
+        else
+          nil
+        end
+      end
+
+      def source_from_options(options)
+        if options[:source]
+          source_shortcuts[options[:source]]
+        elsif source_parts = extract_source_parts(options)
+          source_from_params(*source_parts)
+        else
+          nil
+        end
+      end
+
+      def source_from_params(name, param, options)
+        source_cache[[name, param, options]] ||= begin
+          type = source_types_map[name]
+          type.new(param, options)
+        end
+      end
+
+      def source_from_source_shortcut_definition(definition)
+        case definition
+        when Array
+          source_from_params(*definition)
+        when Hash
+          source_from_options(definition)
+        when Proc
+          receiver = SourceShortcutDefinitionReceiver.new(self)
+          receiver.instance_eval(&definition)
+        end
+      end
+
+      def define_source_shortcut(name, definition)
+        source = source_from_source_shortcut_definition(definition)
+        source_shortcuts[name] = source
+      end
+
+    end
+  end
+end

data/lib/librarian/helpers.rb

@@ -0,0 +1,13 @@
+module Librarian
+  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
+
+  end
+end

data/lib/librarian/helpers/debug.rb

@@ -0,0 +1,35 @@
+require 'librarian/support/abstract_method'
+
+module Librarian
+  module Helpers
+    module Debug
+
+      include Support::AbstractMethod
+
+      LIBRARIAN_PATH = Pathname.new('../../../../').expand_path(__FILE__)
+
+      abstract_method :root_module
+
+    private
+
+      def relative_path_to(path)
+        root_module.project_relative_path_to(path)
+      end
+
+      def debug
+        if root_module.ui
+          if root_module.ui.respond_to? :debug_line_numbers and root_module.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
+            root_module.ui.debug { "[Librarian] #{yield} [#{loc}]" }
+          else
+            root_module.ui.debug { "[Librarian] #{yield}" }
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/librarian/lockfile.rb

@@ -0,0 +1,31 @@
+require 'librarian/helpers/debug'
+
+require 'librarian/lockfile/compiler'
+require 'librarian/lockfile/parser'
+
+module Librarian
+  class Lockfile
+
+    include Helpers::Debug
+
+    attr_reader :root_module, :path
+
+    def initialize(root_module, path)
+      @root_module = root_module
+      @path = path
+    end
+
+    def save(resolution)
+      Compiler.new(root_module).compile(resolution)
+    end
+
+    def load(string)
+      Parser.new(root_module).parse(string)
+    end
+
+    def read
+      load(path.read)
+    end
+
+  end
+end

data/lib/librarian/lockfile/compiler.rb

@@ -0,0 +1,69 @@
+require 'librarian/helpers/debug'
+
+module Librarian
+  class Lockfile
+    class Compiler
+
+      include Helpers::Debug
+
+      attr_reader :root_module
+
+      def initialize(root_module)
+        @root_module = root_module
+      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
+        root_module.dsl_class
+      end
+
+    end
+  end
+end