accord 0.1.0

data/lib/accord/nested_key_hash.rb

@@ -0,0 +1,66 @@
+module Accord
+  class NestedKeyHash
+    def [](keys)
+      keys = keys.dup
+      last_key = keys.pop
+      last_hash = keys.inject(hash) do |partial, key|
+        return nil unless partial.has_key?(key)
+        partial[key]
+      end
+      last_hash[last_key]
+    end
+
+    def []=(keys, value)
+      keys = keys.dup
+      last_key = keys.pop
+      last_hash = keys.inject(hash) { |partial, key| partial[key] ||= {} }
+      last_hash[last_key] = value
+    end
+
+    def delete(keys)
+      keys = keys.dup
+      last_hash = {}
+      result = nil
+      while last_hash.size == 0 && keys.any?
+        last_key = keys.pop
+        last_hash = keys.inject(hash) { |partial, key| partial[key] || {} }
+        partial_result = last_hash.delete(last_key)
+        result ||= partial_result
+      end
+      result
+    end
+
+    def detect_expansion(keys)
+      keys.inject(hash) do |partial, part|
+        expansion = yield(part)
+        valid_key = expansion.detect { |key| partial.has_key?(key) }
+        return unless valid_key
+        partial[valid_key]
+      end
+    end
+
+    def select_expansions(keys, partial=hash, results=[], &block)
+      if keys.size == 1
+        expansion = block.call(keys.first)
+        valid_expansions = expansion.select { |key| partial.has_key?(key) }
+        valid_expansions.each { |key| results << partial[key] }
+        return results
+      end
+      keys = keys.dup
+      first_key = keys.shift
+      expansion = block.call(first_key)
+      valid_expansions = expansion.select { |key| partial.has_key?(key) }
+      return results unless valid_expansions.any?
+      valid_expansions.each do |key|
+        select_expansions(keys, partial[key], results, &block)
+      end
+      results
+    end
+
+  private
+
+    def hash
+      @hash ||= {}
+    end
+  end
+end

data/lib/accord/ro.rb

@@ -0,0 +1,65 @@
+module Accord
+  class RO
+    CACHE_IVAR_NAME = :@_accord_ro_cache_
+
+    def initialize(item, &block)
+      @item = item
+      @block = block
+    end
+
+    def resolve
+      cached = from_cache
+      return cached if cached
+
+      bases = block.call(item)
+      bases_ros = bases.map { |b| RO.new(b, &block).resolve }
+      merge([[item]] + bases_ros + [bases]).tap { |ro| cache(ro) }
+    end
+
+    def changed
+      invalidate
+      resolve
+    end
+
+  private
+
+    attr_reader :item
+    attr_reader :block
+
+    def from_cache
+      item.instance_variable_get(CACHE_IVAR_NAME)
+    end
+
+    def cache(ro)
+      item.instance_variable_set(CACHE_IVAR_NAME, ro)
+    end
+
+    def invalidate
+      item.instance_variable_set(CACHE_IVAR_NAME, nil)
+    end
+
+    def merge(sequences)
+      sequences = sequences.map { |seq| seq.dup }
+      result = []
+
+      loop do
+        sequences.delete_if { |sequence| sequence.empty? }
+        return result unless sequences.any?
+
+        good = sequences.detect do |current|
+          sequences.all? { |seq| !tail(seq).include?(current.first) }
+        end
+
+        raise TypeError, "inconsistent hierarchy" unless good
+
+        head = good.first
+        sequences.each { |seq| seq.shift if seq.first == head }
+        result << head
+      end
+    end
+
+    def tail(array)
+      array[1..-1] || []
+    end
+  end
+end

data/lib/accord/signature_info.rb

@@ -0,0 +1,76 @@
+module Accord
+  UNSPECIFIED = Object.new.tap do |o|
+    o.define_singleton_method(:inspect) { 'UNSPECIFIED' }
+  end
+
+  class SignatureInfo
+    def arguments
+      @arguments ||= []
+    end
+
+    def param(arg)
+      if arg.is_a?(Symbol) || arg.is_a?(String)
+        arg = { name: arg.to_sym }
+      elsif arg.is_a?(Hash) && arg.size == 1
+        arg = { name: arg.keys.first, default: arg.values.first }
+      else
+        raise ArgumentError, "bad argument: #{arg.inspect}."
+      end
+      arguments << arg
+    end
+
+    def splat(name)
+      arguments << { name: name.to_sym, splat: true }
+    end
+
+    def block(name=nil)
+      if name
+        @block = name.to_sym
+      else
+        @block
+      end
+    end
+
+    def match?(params)
+      args = normalized_arguments
+      match_without_all_required_args(args, params) ||
+        match_without_all_required_args(args, without_last_defaults(params))
+    end
+
+  private
+
+    def normalized_arguments
+      (arguments + (block ? [{ name: block, block: true }] : [])).map do |arg|
+        if arg[:splat]
+          :rest
+        elsif arg[:block]
+          :block
+        elsif arg.has_key?(:default)
+          :opt
+        else
+          :req
+        end
+      end
+    end
+
+    def without_last_defaults(params)
+      params = params.dup
+      params.pop if params.any? && params.last.first == :block
+      params.pop while params.any? && params.last.first == :opt
+      params
+    end
+
+    def match_without_all_required_args(args, params)
+      return false unless args.size == params.size
+      args.each_with_index do |arg, index|
+        if arg == :req && [:req, :opt].include?(params[index].first)
+          next
+        elsif params[index].first == arg
+          next
+        end
+        return false
+      end
+      true
+    end
+  end
+end

data/lib/accord/specification.rb

@@ -0,0 +1,83 @@
+require 'set'
+require 'accord/ro'
+
+module Accord
+  class Specification
+    def initialize(*args)
+      if args.size == 2 || args.first.is_a?(String) || args.first.is_a?(Symbol)
+        @name = args.first.to_s
+        bases = (args.size == 2 ? (args[1] || []) : [])
+      else
+        @name = '?'
+        bases = args.first || []
+      end
+      @dependents = Set.new
+      @ro = Accord::RO.new(self) { |spec| spec.bases }
+      self.bases = bases
+    end
+
+    def bases
+      (@bases || []).dup
+    end
+
+    def bases= new_bases
+      new_bases = new_bases.uniq
+      new_bases.each do |base|
+        raise TypeError,
+          'cannot use something other than Specification as a base' \
+          unless base.is_a?(Specification)
+      end
+
+      bases.each { |base| base.unsubscribe(self) }
+      new_bases.each { |base| base.subscribe(self) }
+
+      @bases = new_bases
+
+      changed(self)
+    end
+
+    def each_interface
+      seen = Set.new
+      @bases.each do |base|
+        base.each_interface do |interface|
+          next if seen.include?(interface)
+          seen << interface
+          yield(interface)
+        end
+      end
+    end
+
+    def interfaces
+      enum_for(:each_interface).to_a
+    end
+
+    def ancestors
+      @ro.resolve
+    end
+
+    def extends?(other)
+      ancestors.include?(other)
+    end
+
+    def inspect
+      "<Specification #{@name.inspect}>"
+    end
+
+  protected
+
+    def changed(originally_changed)
+      @ro.changed
+      @dependents.each do |dependent|
+        dependent.changed(originally_changed)
+      end
+    end
+
+    def subscribe(dependent)
+      @dependents << dependent
+    end
+
+    def unsubscribe(dependent)
+      @dependents.delete(dependent)
+    end
+  end
+end

data/lib/accord/subscription_registry.rb

@@ -0,0 +1,76 @@
+require 'accord/interface'
+require 'accord/base_registry'
+
+module Accord
+  class SubscriberLookup < BaseLookup
+    def all(required, provided)
+      extendor = extendors.get(provided)
+      return [] unless extendor
+      hash.select_expansions(required + [provided, '']) do |key|
+        if required.include?(key)
+          key.ancestors.reverse
+        elsif key.equal?(provided)
+          extendor.current.reverse
+        else
+          ['']
+        end
+      end.flatten
+    end
+  end
+
+  class SubscriptionRegistry < BaseRegistry
+    def self.lookup_class
+      SubscriberLookup
+    end
+
+    def subscribe(required, provided, &value)
+      raise ArgumentError, "cannot subscribe without a block" unless value
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      key = [required, provided, '']
+      (registrations.by_order(required.size)[key] ||= []) << value
+    end
+
+    def unsubscribe(required, provided, value=nil)
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      lookup = registrations.by_order(required.size)
+      key = [required, provided, '']
+      old = lookup[key] || []
+
+      return if old.empty?
+
+      new = value.nil?? [] : old.select { |v| !v.equal?(value) }
+      if new.any?
+        lookup[key] = new
+      else
+        lookup.delete(key)
+      end
+    end
+
+    def all(options={})
+      required = normalize_interfaces(options[:required] || [nil])
+      provided = options[:provided] || Interface
+      registrations.by_order(required.size)[[required, provided, '']] || []
+    end
+
+    def lookup(required, provided)
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      lookup = registrations.by_order(required.size)
+      lookup.all(required, provided)
+    end
+
+    def get(objects, provided=Interface)
+      lookup(map_provided_by(objects), provided).map do |subscriber|
+        subscriber.call(*objects)
+      end.compact
+    end
+
+    def call(objects, provided=Interface)
+      lookup(map_provided_by(objects), provided).each do |subscriber|
+        subscriber.call(*objects)
+      end
+    end
+  end
+end

data/lib/accord/tags.rb

@@ -0,0 +1,25 @@
+module Accord
+  class Tags
+    def initialize
+      @hash = {}
+    end
+
+    def []=(tag, value)
+      @hash[tag.to_sym] = value
+    end
+
+    def [](tag)
+      @hash[tag.to_sym]
+    end
+
+    def fetch(tag, default=Tags.marker)
+      return @hash[tag] if @hash.has_key?(tag)
+      return default unless default.equal?(self.class.marker)
+      raise ArgumentError, "tag #{tag.inspect} not found."
+    end
+
+    def self.marker
+      @marker ||= Object.new
+    end
+  end
+end

data/lib/accord/version.rb

@@ -0,0 +1,3 @@
+module Accord
+  VERSION = '0.1.0'
+end

data/spec/adapter_registry_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+require 'accord/adapter_registry'
+
+module Accord
+  describe AdapterRegistry do
+    subject { AdapterRegistry.new }
+
+    let(:adapter_factory)       { Proc.new {} }
+    let(:other_adapter_factory) { Proc.new {} }
+
+
+    let(:i1) { stub_interface }
+    let(:i2) { stub_interface }
+
+    def stub_interface(*bases)
+      stub.tap do |interface|
+        interface.stub(
+          :iro => [interface],
+          :ancestors => [interface]
+        )
+        interface.stub(:extends?).and_return(false)
+        interface.stub(:extends?).with(interface).and_return(true)
+        bases.each do |base|
+          interface.iro << base
+          interface.ancestors << base
+          interface.stub(:extends?).with(base).and_return(true)
+        end
+      end
+    end
+
+    describe "#first" do
+      it "returns no adapter when registry is empty" do
+        expect(subject.first).to be_nil
+      end
+
+      context "registered most simple single adapter" do
+        it "returns that if no arguments are passed" do
+          subject.register([Interface], Interface, '', &adapter_factory)
+          expect(subject.first).to be adapter_factory
+        end
+      end
+
+      it "hits right adapter factory if matches" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(
+          subject.first(required: [i1], provided: nil, name: '')
+        ).to be adapter_factory
+      end
+
+      it "miss adapter factory if none matches" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(
+          subject.first(required: [i2], provided: nil, name: '')
+        ).to be_nil
+      end
+    end
+
+    describe "#all" do
+      it "returns no adapter when empty" do
+        expect(subject.all).to be_empty
+      end
+
+      context "registered most simple single adapter" do
+        before do
+          subject.register([Interface], Interface, '', &adapter_factory)
+        end
+
+        it "returns that if no arguments are passed" do
+          expect(subject.all).to eq [['', adapter_factory]]
+        end
+      end
+
+      context "selection in registration for multiple names" do
+        it "returns all registered adapters" do
+          subject.register([nil], nil, &adapter_factory)
+          subject.register([nil], nil, 'other name', &other_adapter_factory)
+          expect(subject.all(required: [nil], provided: nil)).to eq [
+            ['',           adapter_factory],
+            ['other name', other_adapter_factory]
+          ]
+        end
+      end
+    end
+
+    describe "#register" do
+      it "complains if registration happens without block" do
+        expect {
+          subject.register([Interface], Interface, '')
+        }.to raise_error(ArgumentError)
+      end
+
+      it "allows registering a null adapter" do
+        subject.register([], i1, '', &adapter_factory)
+        expect(
+          subject.first(required: [], provided: i1, name:'')
+        ).to be adapter_factory
+      end
+
+      context "when using [nil] and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.register([nil], nil, '', &adapter_factory)
+          expect(
+            subject.first(required: [Interface], provided: Interface, name: '')
+          ).to be adapter_factory
+        end
+      end
+
+      context "when using nil and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.register(nil, nil, '', &adapter_factory)
+          expect(
+            subject.first(required: [Interface], provided: Interface, name: '')
+          ).to be adapter_factory
+        end
+      end
+
+      context "registration without name" do
+        it "defaults to empty name" do
+          subject.register([nil], nil, &adapter_factory)
+          expect(
+            subject.first(required: [nil], provided: nil, name: '')
+          ).to be adapter_factory
+        end
+      end
+    end
+
+    describe "#lookup" do
+      it "returns no adapter when registry is empty" do
+        expect(subject.lookup([], nil)).to be_nil
+      end
+
+      context "registered most simple single adapter" do
+        before do
+          subject.register([Interface], Interface,
+                           '', &adapter_factory)
+        end
+
+        it "returns that if required is nil and provided is nil" do
+          expect(subject.lookup(nil, nil)).to be adapter_factory
+        end
+
+        it "returns that if required is [nil] and provided is nil" do
+          expect(subject.lookup([nil], nil)).to be adapter_factory
+        end
+      end
+
+      it "hits right adapter factory if matches exactly" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(
+          subject.lookup([i1], nil, '')
+        ).to be adapter_factory
+      end
+
+      it "defaults name to empty string" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup([i1], nil)).to be adapter_factory
+      end
+
+      it "hits right adapter factory if required extends some registered" do
+        i12 = stub_interface(i1)
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup([i12], nil, '')).to be adapter_factory
+      end
+
+      it "miss adapter factory if none matches" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup([i2], nil, '')).to be_nil
+      end
+
+      it "returns default value if missed" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup([i2], nil, default: 'default')).to eq 'default'
+      end
+    end
+
+    describe "#lookup_all" do
+      it "returns no adapter when registry is empty" do
+        expect(subject.lookup_all([], nil)).to be_empty
+      end
+
+      context "registered most simple single adapter" do
+        before do
+          subject.register([Interface], Interface, '', &adapter_factory)
+        end
+
+        it "returns that if required is nil and provided is nil" do
+          expect(subject.lookup_all(nil, nil)).to eq({'' => adapter_factory})
+        end
+
+        it "returns that if required is [nil] and provided is nil" do
+          expect(subject.lookup_all([nil], nil)).to eq({'' => adapter_factory})
+        end
+      end
+
+      it "hits right adapter factory if matches" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup_all([i1], nil)).to eq({'' => adapter_factory})
+      end
+
+      it "hits right adapter factory if required extends some registered" do
+        i12 = stub_interface(i1)
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup_all([i12], nil)).to eq({'' => adapter_factory})
+      end
+
+      it "hits right adapter factory if provided is extended by some registered" do
+        i12 = stub_interface(i1)
+        subject.register([nil], i12, '', &adapter_factory)
+        expect(subject.lookup_all([nil], i1)).to eq({'' => adapter_factory})
+      end
+
+      it "in the face of ambiguity, brings the most specific for required" do
+        i12 = stub_interface(i1)
+        subject.register([i1], nil, '', &other_adapter_factory)
+        subject.register([i12], nil, '', &adapter_factory)
+        expect(subject.lookup_all([i12], nil)).to eq({'' => adapter_factory})
+      end
+
+      it "in the face of ambiguity, brings the most specific for provided" do
+        i12 = stub_interface(i1)
+        subject.register([nil], i1, '', &other_adapter_factory)
+        subject.register([nil], i12, '', &adapter_factory)
+        expect(subject.lookup_all([nil], i12)).to eq({'' => adapter_factory})
+      end
+
+      it "miss adapter factory if none matches" do
+        subject.register([i1], nil, '', &adapter_factory)
+        expect(subject.lookup_all([i2], nil)).to be_empty
+      end
+    end
+
+    describe "#unregister" do
+      it "doesn't complain when unregistering empty registry" do
+        expect { subject.unregister([nil], nil, '') }.to_not raise_error
+      end
+
+      it "keeps registered if required doesn't match on unregistration" do
+        subject.register([i1], nil, '', &adapter_factory)
+        subject.unregister([i2], nil, '')
+        expect(
+          subject.first(required: [i1], provided: nil, name: '')
+        ).to be adapter_factory
+      end
+
+      it "keeps registered if provided doesn't match on unregistration" do
+        subject.register([nil], i1, '', &adapter_factory)
+        subject.unregister([nil], i2, '')
+        expect(
+          subject.first(required: [nil], provided: i1, name: '')
+        ).to be adapter_factory
+      end
+
+      it "keeps registered if name doesn't match on unregistration" do
+        subject.register([i1], nil, '', &adapter_factory)
+        subject.unregister([i1], nil, 'other name')
+        expect(
+          subject.first(required: [i1], provided: nil, name: '')
+        ).to be adapter_factory
+      end
+
+      it "keeps registered if value is passed but doesn't match on "\
+         "unregistration" do
+        subject.register([i1], nil, '', &adapter_factory)
+        subject.unregister([i1], nil, '', stub)
+        expect(
+          subject.first(required: [i1], provided: nil, name: '')
+        ).to be adapter_factory
+      end
+
+      it "unregisters if value not passed and everything else matches "\
+         "previous registration" do
+        subject.register([i1], nil, '', &adapter_factory)
+        subject.unregister([i1], nil, '')
+        expect(
+          subject.first(required: [i1], provided: nil, name: '')
+        ).to be_nil
+      end
+
+      context "when using [nil] and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.register([Interface], Interface, '', &adapter_factory)
+          subject.unregister([nil], nil, '')
+          expect(subject.first).to be_nil
+        end
+      end
+
+      context "when using nil and nil for required and provided" do
+        it "defaults to most simple single adapter" do
+          subject.register([Interface], Interface, '', &adapter_factory)
+          subject.unregister(nil, nil, '')
+          expect(subject.first).to be_nil
+        end
+      end
+    end
+  end
+end