accord 0.1.0

data/.gitignore

@@ -0,0 +1,7 @@
+bin/*
+coverage/
+pkg/*
+.bundle
+*.gem
+*.swp
+Session.vim

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'pry'
+gem 'pry-doc'
+gem 'simplecov', :require => false, :group => 'test'

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    accord (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (1.0.8)
+    diff-lcs (1.1.3)
+    method_source (0.8.1)
+    multi_json (1.6.1)
+    pry (0.9.12)
+      coderay (~> 1.0.5)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    pry-doc (0.4.4)
+      pry (>= 0.9.9.6)
+      yard (~> 0.8.1)
+    rspec (2.12.0)
+      rspec-core (~> 2.12.0)
+      rspec-expectations (~> 2.12.0)
+      rspec-mocks (~> 2.12.0)
+    rspec-core (2.12.2)
+    rspec-expectations (2.12.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.12.2)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    slop (3.4.3)
+    yard (0.8.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  accord!
+  pry
+  pry-doc
+  rspec
+  simplecov

data/accord.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "accord/version"
+
+Gem::Specification.new do |s|
+  s.name        = "accord"
+  s.version     = Accord::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["rcabralc"]
+  s.email       = ["rcabralc@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/accord"
+  s.summary     = %q{Contracts and adaptation for Ruby}
+  s.description = %q{Contracts and adaptation for Ruby}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency('rspec')
+end

data/lib/accord.rb

@@ -0,0 +1,4 @@
+require 'accord/exceptions'
+require 'accord/adapter_registry'
+require 'accord/subscription_registry'
+require 'accord/interfaces'

data/lib/accord/adapter_registry.rb

@@ -0,0 +1,106 @@
+require 'accord/interface'
+require 'accord/base_registry'
+
+module Accord
+  class AdapterLookup < BaseLookup
+    def first(required, provided, name='')
+      extendor = extendors.get(provided)
+      return unless extendor
+      return unless result = hash.detect_expansion(required) { |s| s.ancestors }
+      available = extendor.compact_map { |i| result[i] }
+      (available.detect { |h| h[name] } || {})[name]
+    end
+
+    def all(required, provided)
+      extendor = extendors.get(provided)
+      return {} unless extendor
+      hashes = hash.select_expansions(required + [provided]) do |key|
+        next key.ancestors.reverse if required.include?(key)
+        extendor.current.reverse
+      end
+      hashes.inject({}) { |result, h| result.merge(h) }
+    end
+  end
+
+  class AdapterRegistry < BaseRegistry
+    def self.lookup_class
+      AdapterLookup
+    end
+
+    def register(required, provided, name='', &value)
+      raise ArgumentError, "cannot register without a block" unless value
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      registrations.by_order(required.size)[[required, provided, name]] = value
+    end
+
+    def unregister(required, provided, name, value=nil)
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+
+      lookup = registrations.by_order(required.size)
+      key = [required, provided, name]
+      old = lookup[key]
+
+      return if old.nil?
+      return if !value.nil? && !old.equal?(value)
+
+      lookup.delete(key)
+    end
+
+    def first(options={})
+      required = normalize_interfaces(options[:required] || [nil])
+      provided = options[:provided] || Interface
+      name     = options[:name] || ''
+      registrations.by_order(required.size)[[required, provided, name]]
+    end
+
+    def all(options={})
+      required = normalize_interfaces(options[:required] || [nil])
+      provided = options[:provided] || Interface
+      registrations.by_order(required.size).partial(required, provided)
+    end
+
+    def lookup(required, provided, *args)
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      options  = args.last.is_a?(Hash) ? args.pop : {}
+      name     = args.last || ''
+      default  = options.delete(:default)
+      lookup   = registrations.by_order(required.size)
+      lookup.first(required, provided, name) || default
+    end
+
+    def lookup_all(required, provided)
+      required = normalize_interfaces(required || [nil])
+      provided ||= Interface
+      lookup   = registrations.by_order(required.size)
+      lookup.all(required, provided)
+    end
+
+    def get(objects, provided, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      name    = args.last || ''
+      default = options.delete(:default)
+      factory = lookup(map_provided_by(objects), provided, name, options)
+      return (factory.call(*objects) || default) if factory
+      default
+    end
+  end
+
+  class << self
+    def install_default_adapter_hook
+      install_adapter_hook(Proc.new { |provided, *objects|
+        default_adapter_registry.get(objects, provided)
+      })
+    end
+
+    def clear_default_adapter_hook
+      @default_adapter_registry = nil
+    end
+
+    def default_adapter_registry
+      @default_adapter_registry ||= AdapterRegistry.new
+    end
+  end
+end

data/lib/accord/base_registry.rb

@@ -0,0 +1,73 @@
+require 'accord/declarations'
+require 'accord/extendor_container'
+require 'accord/nested_key_hash'
+
+module Accord
+  class Registrations
+    def initialize(lookup_class)
+      @lookup_class = lookup_class
+    end
+
+    def by_order order
+      hash[order] ||= @lookup_class.new(order, extendors)
+    end
+
+  private
+
+    def hash
+      @hash ||= {}
+    end
+
+    def extendors
+      @extendors ||= ExtendorContainer.new
+    end
+  end
+
+  class BaseLookup
+    attr_reader :order, :extendors, :hash
+
+    def initialize(order, extendors)
+      @order = order
+      @extendors = extendors
+      @hash = NestedKeyHash.new
+      super()
+    end
+
+    def [](key)
+      required, provided, name = key
+      hash[required + [provided] + [name]]
+    end
+
+    def []=(key, value)
+      required, provided, name = key
+      extendors.add(provided)
+      hash[required + [provided] + [name]] = value
+    end
+
+    def partial(required, provided)
+      (hash[required + [provided]] || []).sort_by { |name, value| name }
+    end
+
+    def delete(key)
+      required, provided, name = key
+      extendors.delete(provided)
+      hash.delete(required + [provided] + [name])
+    end
+  end
+
+  class BaseRegistry
+    def map_provided_by(objects)
+      objects.map { |object| Accord::Declarations.provided_by(object) }
+    end
+
+  private
+
+    def registrations
+      @registrations ||= Registrations.new(self.class.lookup_class)
+    end
+
+    def normalize_interfaces(interfaces)
+      interfaces.map { |i| i.nil?? Accord::Interface : i }
+    end
+  end
+end

data/lib/accord/declarations.rb

@@ -0,0 +1,131 @@
+require 'accord/specification'
+
+module Accord
+  module Declarations
+    class Declaration < Specification
+      def extends?(interface)
+        super(interface) && interfaces.include?(interface)
+      end
+
+      def + other
+        Declaration.new(interfaces + other.interfaces)
+      end
+
+      def - other
+        Declaration.new(interfaces.select { |i|
+          !other.interfaces.any? { |j| i.extends?(j) }
+        })
+      end
+    end
+
+    class Implements < Declaration
+      attr_reader :name
+
+      def initialize(inherit)
+        @inherit = inherit
+        set_name(inherit)
+        @declared = []
+        super(bases_from_inherit)
+      end
+
+      def declare(*interfaces)
+        @declared.concat(normalized(interfaces)).uniq!
+        new_bases = @declared.dup
+        bases_from_inherit.each do |base|
+          new_bases << base if !@declared.include?(base)
+        end
+        self.bases = new_bases
+      end
+
+      def declare_only(*interfaces)
+        @declared = []
+        self.inherit = nil
+        declare(*interfaces)
+      end
+
+      def inspect
+        "#<Implemented by #{name}>"
+      end
+
+    private
+
+      attr_accessor :inherit
+
+      def set_name(inherit)
+        if inherit.respond_to?(:name)
+          if inherit.name.to_s != ''
+            @name = inherit.name
+          else
+            @name = inherit.inspect
+          end
+        else
+          @name = inherit.inspect
+        end
+      end
+
+      def bases_from_inherit
+        if inherit.is_a?(Module)
+          ancestors = inherit.ancestors
+          ancestors.delete(inherit)
+          ancestors.map { |ancestor| Declarations.implemented_by(ancestor) }
+        else
+          []
+        end
+      end
+
+      def normalized(args)
+        enum_for(:normalize, args).to_a
+      end
+
+      def normalize(args, &block)
+        if args.is_a?(InterfaceClass) || args.is_a?(Implements)
+          block.call(args)
+        else
+          args.each do |arg|
+            normalize(arg, &block)
+          end
+        end
+      end
+    end
+
+    class << self
+      def provided_by(object)
+        implemented_by(object.class) + directly_provided_by(object)
+      end
+
+      def directly_provided_by(object)
+        object.instance_eval do
+          @_accord_provides_ ||= Declaration.new
+        end
+      end
+
+      def implemented_by(factory)
+        factory.instance_eval do
+          @_accord_implements_ ||= Implements.new(self)
+        end
+      end
+
+      def implements(cls, *interfaces)
+        implemented_by(cls).declare(*interfaces)
+      end
+
+      def implements_only(cls, *interfaces)
+        implemented_by(cls).declare_only(*interfaces)
+      end
+
+      def directly_provides(object, *interfaces)
+        object.instance_eval do
+          @_accord_provides_ = Declaration.new(interfaces)
+        end
+      end
+
+      def also_provides(object, *interfaces)
+        directly_provides(object, directly_provided_by(object), *interfaces)
+      end
+
+      def no_longer_provides(object, interface)
+        directly_provides(object, directly_provided_by(object) - interface)
+      end
+    end
+  end
+end

data/lib/accord/exceptions.rb

@@ -0,0 +1,22 @@
+module Accord
+  class Error < StandardError; end
+
+  class Invalid < Error; end
+
+  class DoesNotImplement < Invalid
+    def initialize(interface)
+      @interface = interface
+    end
+  end
+
+  class BrokenImplementation < Invalid
+    def initialize(interface, method_name)
+      @interface = interface
+      @method_name = method_name
+    end
+
+    def to_s
+      "signature mismatch for #{@interface.inspect}##{@method_name}"
+    end
+  end
+end

data/lib/accord/extendor.rb

@@ -0,0 +1,36 @@
+module Accord
+  class Extendor
+    def initialize
+      @current = []
+    end
+
+    def add(new)
+      return if @current.include?(new)
+      @current = (
+        @current.select { |i| new.extends?(i) } +
+        [new] +
+        @current.select { |i| !new.extends?(i) }
+      )
+    end
+
+    def delete(old)
+      @current.delete_if { |i| i.equal?(old) }
+    end
+
+    def empty?
+      @current.empty?
+    end
+
+    def current
+      @current.dup
+    end
+
+    def compact_map
+      @current.map { |i| yield(i) }.compact
+    end
+
+    def flat_map
+      @current.flat_map { |i| yield(i) }
+    end
+  end
+end