librarianp 0.1.2

data/lib/librarian/dependency.rb

@@ -0,0 +1,153 @@
+require 'rubygems'
+
+module Librarian
+  class Dependency
+
+    class Requirement
+      def initialize(*args)
+        args = initialize_normalize_args(args)
+
+        self.backing = Gem::Requirement.create(*args)
+      end
+
+      def to_gem_requirement
+        backing
+      end
+
+      def satisfied_by?(version)
+        to_gem_requirement.satisfied_by?(version.to_gem_version)
+      end
+
+      def ==(other)
+        to_gem_requirement == other.to_gem_requirement
+      end
+
+      def to_s
+        to_gem_requirement.to_s
+      end
+
+      def inspect
+        "#<#{self.class} #{to_s}>"
+      end
+
+      COMPATS_TABLE = {
+        %w(=  = ) => lambda{|s, o| s == o},
+        %w(=  !=) => lambda{|s, o| s != o},
+        %w(=  > ) => lambda{|s, o| s >  o},
+        %w(=  < ) => lambda{|s, o| s <  o},
+        %w(=  >=) => lambda{|s, o| s >= o},
+        %w(=  <=) => lambda{|s, o| s <= o},
+        %w(=  ~>) => lambda{|s, o| s >= o && s.release < o.bump},
+        %w(!= !=) => true,
+        %w(!= > ) => true,
+        %w(!= < ) => true,
+        %w(!= >=) => true,
+        %w(!= <=) => true,
+        %w(!= ~>) => true,
+        %w(>  > ) => true,
+        %w(>  < ) => lambda{|s, o| s < o},
+        %w(>  >=) => true,
+        %w(>  <=) => lambda{|s, o| s < o},
+        %w(>  ~>) => lambda{|s, o| s < o.bump},
+        %w(<  < ) => true,
+        %w(<  >=) => lambda{|s, o| s > o},
+        %w(<  <=) => true,
+        %w(<  ~>) => lambda{|s, o| s > o},
+        %w(>= >=) => true,
+        %w(>= <=) => lambda{|s, o| s <= o},
+        %w(>= ~>) => lambda{|s, o| s < o.bump},
+        %w(<= <=) => true,
+        %w(<= ~>) => lambda{|s, o| s >= o},
+        %w(~> ~>) => lambda{|s, o| s < o.bump && s.bump > o},
+      }
+
+      def consistent_with?(other)
+        sgreq, ogreq = to_gem_requirement, other.to_gem_requirement
+        sreqs, oreqs = sgreq.requirements, ogreq.requirements
+        sreqs.all? do |sreq|
+          oreqs.all? do |oreq|
+            compatible?(sreq, oreq)
+          end
+        end
+      end
+
+      def inconsistent_with?(other)
+        !consistent_with?(other)
+      end
+
+      protected
+
+      attr_accessor :backing
+
+      private
+
+      def initialize_normalize_args(args)
+        args.map do |arg|
+          arg = arg.backing if self.class === arg
+          arg
+        end
+      end
+
+      def compatible?(a, b)
+        a, b = b, a unless COMPATS_TABLE.include?([a.first, b.first])
+        r = COMPATS_TABLE[[a.first, b.first]]
+        r = r.call(a.last, b.last) if r.respond_to?(:call)
+        r
+      end
+    end
+
+    attr_accessor :name, :requirement, :source
+    private :name=, :requirement=, :source=
+
+    def initialize(name, requirement, source)
+      assert_name_valid! name
+
+      self.name = name
+      self.requirement = Requirement.new(requirement)
+      self.source = source
+
+      @manifests = nil
+    end
+
+    def manifests
+      @manifests ||= cache_manifests!
+    end
+
+    def cache_manifests!
+      source.manifests(name)
+    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
+
+    def consistent_with?(other)
+      name != other.name || requirement.consistent_with?(other.requirement)
+    end
+
+    def inconsistent_with?(other)
+      !consistent_with?(other)
+    end
+
+  private
+
+    def assert_name_valid!(name)
+      name =~ /\A\S(?:.*\S)?\z/ and return
+
+      raise ArgumentError, "name (#{name.inspect}) must be sensible"
+    end
+
+  end
+end

data/lib/librarian/dsl/receiver.rb

@@ -0,0 +1,42 @@
+require "pathname"
+
+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)
+        specfile = Proc.new if block_given?
+
+        case specfile
+        when Pathname
+          instance_eval(File.read(specfile), specfile.to_s, 1)
+        when String
+          instance_eval(specfile)
+        when Proc
+          instance_eval(&specfile)
+        else
+          raise ArgumentError, "specfile must be a #{Pathname}, #{String}, or #{Proc} if no block is given (it was #{specfile.inspect})"
+        end
+      end
+
+    end
+  end
+end

data/lib/librarian/dsl/target.rb

@@ -0,0 +1,171 @@
+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 = [:source, :sources]
+
+      attr_accessor :dsl
+      private :dsl=
+
+      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)
+        self.dsl = 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, @dependencies)
+      end
+
+      def dependency(name, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        source = source_from_options(options) || @source
+        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
+            @source = source
+            @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
+            @source = source
+            @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.from_spec_args(environment, 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
+
+      def environment
+        dsl.environment
+      end
+
+    end
+  end
+end

data/lib/librarian/dsl.rb

@@ -0,0 +1,102 @@
+require 'librarian/dependency'
+require 'librarian/dsl/receiver'
+require 'librarian/dsl/target'
+
+module Librarian
+  class Dsl
+
+    class Error < Exception
+    end
+
+    attr_accessor :environment
+    private :environment=
+
+    class << self
+
+      def run(environment, specfile = nil, precache_sources = [], &block)
+        new(environment).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 initialize(environment)
+      self.environment = environment
+    end
+
+    def run(specfile = nil, sources = [])
+      specfile, sources = nil, specfile if specfile.kind_of?(Array) && sources.empty?
+
+      Target.new(self).tap do |target|
+        target.precache_sources(sources)
+        debug_named_source_cache("Pre-Cached Sources", target)
+
+        specfile ||= Proc.new if block_given?
+        receiver = Receiver.new(target)
+        receiver.run(specfile)
+
+        debug_named_source_cache("Post-Cached Sources", target)
+      end.to_spec
+    end
+
+    def debug_named_source_cache(name, target)
+      source_cache = target.source_cache
+      debug { "#{name}:" }
+      source_cache.each do |key, value|
+        type = key[0]
+        attributes = key[1...key.size]
+        debug { "  #{key.inspect}" }
+      end
+    end
+
+  private
+
+    def debug(*args, &block)
+      environment.logger.debug(*args, &block)
+    end
+
+  end
+end

data/lib/librarian/environment/runtime_cache.rb

@@ -0,0 +1,101 @@
+require "librarian/error"
+
+module Librarian
+  class Environment
+    class RuntimeCache
+
+      class KeyspaceCache
+
+        class << self
+          private
+
+          def delegate_to_backing_cache(*methods)
+            methods.each do |method|
+              define_method "#{method}" do |*args, &block|
+                # TODO: When we drop ruby-1.8.7 support, use #public_send.
+                runtime_cache.send(method, keyspace, *args, &block)
+              end
+            end
+          end
+        end
+
+        attr_reader :runtime_cache, :keyspace
+
+        def initialize(runtime_cache, keyspace)
+          self.runtime_cache = runtime_cache
+          self.keyspace = keyspace
+        end
+
+        delegate_to_backing_cache *[
+          :include?,
+          :get,
+          :put,
+          :delete,
+          :memo,
+          :once,
+          :[],
+          :[]=,
+        ]
+
+        private
+
+        attr_writer :runtime_cache, :keyspace
+
+      end
+
+      def initialize
+        self.data = {}
+      end
+
+      def include?(keyspace, key)
+        data.include?(combined_key(keyspace, key))
+      end
+
+      def get(keyspace, key)
+        data[combined_key(keyspace, key)]
+      end
+
+      def put(keyspace, key, value = nil)
+        data[combined_key(keyspace, key)] = block_given? ? yield : value
+      end
+
+      def delete(keyspace, key)
+        data.delete(combined_key(keyspace, key))
+      end
+
+      def memo(keyspace, key)
+        put(keyspace, key, yield) unless include?(keyspace, key)
+        get(keyspace, key)
+      end
+
+      def once(keyspace, key)
+        memo(keyspace, key) { yield ; nil }
+      end
+
+      def [](keyspace, key)
+        get(keyspace, key)
+      end
+
+      def []=(keyspace, key, value)
+        put(keyspace, key, value)
+      end
+
+      def keyspace(keyspace)
+        KeyspaceCache.new(self, keyspace)
+      end
+
+      private
+
+      attr_accessor :data
+
+      def combined_key(keyspace, key)
+        keyspace.kind_of?(String) or raise Error, "keyspace must be a string"
+        keyspace.size > 0 or raise Error, "keyspace must not be empty"
+        keyspace.size < 2**16 or raise Error, "keyspace must not be too large"
+        key.kind_of?(String) or raise Error, "key must be a string"
+        [keyspace.size.to_s(16).rjust(4, "0"), keyspace, key].join
+      end
+
+    end
+  end
+end