mediator 0.0.0 → 0.0.1

data/README.md

@@ -1,43 +1,6 @@
 # Mediator
 
-## Notes on Render
-
-    # taken from the old notation in a bunch of different models, just
-    # examples of shit that needs to work
-
-    def render! r
-
-      # from Account
-
-      if context.root?
-        r.key :color
-        r.key :key, self[:domain]
-      end
-
-      if subject.is? :sso
-        r.key :sso, private: sso_private
-      end
-
-      # from Album
-
-      if inside? artist
-        r.key :artist, id: artist.id, name: artist.name
-      end
-
-      # from Artist
-
-      r.array :albums
-      r.obj   :contact
-
-      # from Collaborator
-
-      r.ids :tracks, tracks.active
-      r.id  :pro # WAS: a.set :pro, pro.id if pro
-
-      # from Model
-
-      r.key :created, from: :created_at
-    end
+I sit between your domain model and the cold, cruel world.
 
 ## TODO
 
@@ -49,17 +12,16 @@
 * For `r.ids`, just value.map(&:id). Should check for `_ids` shortcut
   first though, but only if an explicit value isn't provided.
 
-* For `r.id :pro`, should first check for `pro_id` and then
-  fall back on `pro.id`.
-
 * Nested collections should always exist in rendered output even if
   they're empty or missing.
 
 * Benchmarks and micro-opts, esp. around object allocation.
 
+* Decent doco.
+
 ## License (MIT)
 
-Copyright 2011 Audiosocket (tech@audiosocket.com)
+Copyright 2011 John Barnette (code@jbarnette.com)
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,4 +1,6 @@
 require "bundler/gem_tasks"
 
 desc "Run the tests."
-task(:default) { $: << "./lib"; Dir["test/*_test.rb"].each { |f| load f } }
+task(:test) { $: << "./lib"; Dir["test/*_test.rb"].each { |f| load f } }
+
+task :default => :test

data/lib/mediator/errors.rb

@@ -0,0 +1,7 @@
+class Mediator
+
+  # A RuntimeError subclass for Mediator exceptions.
+
+  class Error < RuntimeError
+  end
+end

data/lib/mediator/parser.rb

@@ -1,5 +1,7 @@
+require "mediator/processor"
+
 class Mediator
-  class Parser
+  class Parser < Processor
     attr_reader :data
     attr_reader :mediator
 
@@ -8,26 +10,45 @@ class Mediator
       @mediator = mediator
     end
 
-    def get name
-      data[name] || data[name.to_s]
+    def get name, options = nil
+      selector = (options && options[:from]) || name
+      (options && options[:value]) || data[selector] || data[selector.to_s]
     end
 
     def has? name
       !!get(name)
     end
 
+    def id name, options = {}
+      key "#{name}_id", options.merge(from: name)
+    end
+
     def key name, options = nil, &block
-      selector = (options && options[:from]) || name
-      value  ||= get(selector) || (options && options[:value])
+      if name[-1] == "?"
+        name = name[0..-2].intern
+      end
+
+      value = get name, options
+
+      return if empty? value, options
+      mediator.set name, block ? block[value] : value
+    end
+
+    def obj name, options = nil, &block
+      data = get name, options
+      subj = (options && options[:subject]) || mediator.get(name)
+
+      return if empty? data, options or subj.nil?
 
-      return if value.nil? or value.respond_to?(:empty?) && value.empty?
+      Mediator[subj, mediator].parse data
+      block[subj] if block
 
-      value = block[value] if block_given?
-      key! name, value
+      subj
     end
 
-    def key! name, value
-      mediator.set name, value
+    def union name, options = nil, &block
+      (options ||= {}).merge! value: self.data
+      obj name, options, &block
     end
   end
 end

data/lib/mediator/processor.rb

@@ -0,0 +1,8 @@
+class Mediator
+  class Processor
+    def empty? value, options = nil
+      !(options && options[:empty]) &&
+        (value.nil? || value.respond_to?(:empty?) && value.empty?)
+    end
+  end
+end

data/lib/mediator/registry.rb

@@ -0,0 +1,76 @@
+require "mediator/errors"
+
+class Mediator
+  module Registry
+
+    # Sugar for `register`.
+    #
+    #     class FooMediator < Mediator
+    #       accept Foo  # same as Mediator.register FooMediator, Foo
+    #     end
+
+    def accept *subjects, &block
+      register self, *subjects, &block
+    end
+
+    # Find and instantiate a mediator for `subject` by consulting
+    # `map`. Returns `nil` if no mediator can be found. Inheritance is
+    # respected for mediators registered by class, so:
+    #
+    #     A = Class.new
+    #     B = Class.new A
+    #     M = Class.new Mediator
+    #
+    #     M.subject A
+    #     Mediator.for B.new  #  => A
+    #
+    # Mediators are searched in reverse insertion order.
+
+    def for subject, context = nil
+      map.keys.reverse.each do |criteria|
+        return map[criteria].new subject, context if criteria === subject
+      end
+
+      raise Error, "Can't find a Mediator for #{subject.inspect}."
+    end
+
+    # Sugar for `for`.
+
+    def [] subject, context = nil
+      self.for subject, context
+    end
+
+    # A map from subject class or block to Mediator subclass.
+
+    def map
+      @@map ||= {}
+    end
+
+    # Sugar for creating and registering a Mediator subclass.
+
+    def mediate *subjects, &block
+      mediator = Class.new self, &block
+      register mediator, *subjects
+    end
+
+    # Register a Mediator subclass's interest in one or more subject
+    # classes. If more detailed selection behavior is necessary,
+    # `subject` can take a block instead. When the mediator for a
+    # subject is discovered with `Mediator.for` the given block will be
+    # passed the subject and can return `true` or `false`.
+
+    def register mklass, *subjects, &block
+      if block_given?
+        unless subjects.empty?
+          raise ArgumentError, "Can't provide both a subject and a block."
+        end
+
+        map[block] = mklass
+      end
+
+      subjects.each { |k| map[k] = mklass }
+
+      mklass
+    end
+  end
+end

data/lib/mediator/renderer.rb

@@ -0,0 +1,53 @@
+require "mediator/processor"
+
+class Mediator
+  class Renderer < Processor
+    attr_reader :data
+    attr_reader :mediator
+
+    def initialize mediator, data = nil
+      @data     = data || {}
+      @mediator = mediator
+    end
+
+    def get name, options = nil
+      selector = (options && options[:from]) || name
+      (options && options[:value]) || mediator.get(selector)
+    end
+
+    def id name, options = {}
+      key name, options.merge(from: "#{name}_id")
+    end
+
+    def key name, options = nil, &block
+      if name[-1] == "?"
+        (options ||= {})[:from] = name
+        name = name[0..-2].intern
+      end
+
+      value = get name, options
+      return if empty? value, options
+
+      data[name] = block ? block[value] : value
+    end
+
+    def obj name, options = nil, &block
+      value = get name, options
+      return if empty? value, options
+
+      if value
+        rendered = Mediator[value, mediator].render
+        munged   = block ? block[rendered] : rendered
+        merge    = options && options[:merge]
+
+        merge ? data.merge!(munged) : data[name] = munged
+        munged
+      end
+    end
+
+    def union name, options = nil, &block
+      (options ||= {}).merge! merge: true
+      obj name, options, &block
+    end
+  end
+end

data/lib/mediator.rb

@@ -1,15 +1,13 @@
+require "mediator/errors"
 require "mediator/parser"
+require "mediator/registry"
+require "mediator/renderer"
 
-# Helps translate an object to and from more primitive, untyped
-# forms. Mediators should subclass and implement `parse` and `render`,
-# or use the class-level helpers to declare the necessary
-# transformations.
+# Can't we all just get along? Mediators should subclass and implement
+# `parse!` and `render!`.
 
 class Mediator
-
-  # This lambda takes a single argument, does nothing, and returns `nil`.
-
-  NOTHING = lambda { |_| nil }
+  extend Registry
 
   # State information availble during `parse` and `render`. This is
   # often an application-specific object that provides authentication
@@ -18,7 +16,7 @@ class Mediator
   attr_reader :context
 
   # An optional parent mediator. Used during nested mediation: See
-  # `array`, `obj`, etc.
+  # `obj`, etc.
 
   attr_reader :parent
 
@@ -41,108 +39,131 @@ class Mediator
     end
   end
 
+  # Called during `get` if `subject` doesn't have a value for `name`
+  # during parsing. Subclasses can override to provide factories for
+  # dependent attributes. The default implementation returns `nil`.
+
+  def construct name
+  end
+
+  # Called before passing `data` to `parse`. Subclasses can override
+  # to transform raw incoming data. The default implementation returns
+  # `data` unchanged.
+
+  def incoming data
+    data
+  end
+
   # Is `subject` the subject of one of the ancestral mediators?
 
   def inside? subject
     parent && (parent.subject == subject || parent.inside?(subject))
   end
 
+  # Two-way mediation. Mediators whose parsing and rendering
+  # operations are identical should override and consistently call
+  # `super`. `mediator` will be `parser` or `renderer`. The default
+  # implementation raises NotImplementedError.
+
+  def mediate! mediator
+    raise NotImplementedError
+  end
+
   # Is this mediator nested inside a `parent`?
 
   def nested?
     !!parent
   end
 
+  # Called after rendering. Subclasses can override to transform raw
+  # outgoing data. The default implementation returns `data`
+  # unchanged.
+
+  def outgoing data
+    data
+  end
+
   # Folds, spindles, and mutilates `data`, then applies to `subject`
-  # and returns it. Subclasses should override `parse!` instead of
-  # this method.
+  # and returns it. Subclasses should generally override `parse!`
+  # instead of this method.
 
   def parse data
-    parse! Mediator::Parser.new(self, data)
+    parse! parser incoming data
     subject
   end
 
   # The actual parse implementation. Subclasses should override and
-  # consistently call `super`. Default implementation is empty.
+  # consistently call `super`. The default implementation calls
+  # `mediate!`.
 
   def parse! parser
+    mediate! parser
   end
 
-  # Create a more primitive representation of `subject`. Depending on
-  # app design and `context`, the output of `render` may not always be
-  # valid input to `parse`. Implement in subclasses.
+  # Construct a parser instance for `data`. The parser will be passed
+  # to the Mediator's `parse!` method. The default implementation
+  # returns a new instance of Mediator::Parser.
 
-  def render
-    raise NotImplementedError, "Implement #{self.class.name}#render."
+  def parser data
+    Mediator::Parser.new self, data
   end
 
-  # Set `name` to `value` on `subject`. The default implementation
-  # calls a matching mutator method.
+  # Create a more primitive representation of `subject`. Subclasses
+  # should generally override `render!` instead of this method.
 
-  def set name, value
-    subject.send "#{name}=", setting(name, value)
-  end
-
-  # Called when setting `name` to `value` on `subject`. Can be used to
-  # transform incoming values, e.g., trimming all strings. The default
-  # implementation returns `value` unchanged.
+  def render
+    r = renderer
+    render! r
 
-  def setting name, value
-    value
+    outgoing r.data
   end
 
-  # Find and instantiate a mediator for `subject` by consulting
-  # `map`. Returns `nil` if no mediator can be found. Inheritance is
-  # respected for mediators registered by class, so:
-  #
-  #     A = Class.new
-  #     B = Class.new A
-  #     M = Class.new Mediator
-  #
-  #     M.subject A
-  #     Mediator.for B.new  #  => A
-
-  def self.for subject, context = nil
-    map.each do |criteria, mediator|
-      return mediator.new subject, context if criteria === subject
-    end
+  # The actual render implementation. Subclasses should override and
+  # consistently call `super`. The default implementation calls
+  # `mediate!`.
 
-    nil
+  def render! renderer
+    mediate! renderer
   end
 
-  # An alias of `for`.
+  # Construct a renderer instance. The renderer will be passed to the
+  # Mediator's `render!` method. The default implementation returns a
+  # new instance of Mediator::Renderer.
 
-  def self.[] subject, context = nil
-    self.for subject, context
+  def renderer
+    Mediator::Renderer.new self
   end
 
-  # A Hash of mappings from subject to Mediator subclass.
+  # Gets the `name` property from `subject`. The default
+  # implementation calls the `name` method if it exists.
 
-  def self.map
-    @@map
-  end
+  def get name
+    value   = subject.send name if subject.respond_to? name
+    value ||= construct name
 
-  @@map = {}
+    getting name, value if value
+  end
 
-  # Register this Mediator subclass's interest in one or more subject
-  # classes. If more detailed selection behavior is necessary,
-  # `subject` can take a block instead. When the mediator for a
-  # subject is discovered with `Mediator.for` the given block will be
-  # passed the subject and can return `true` or `false`.
+  # Called when getting `name` from `subject`. Can be used to
+  # transform outgoing values, e.g., turning Time objects into epoch
+  # seconds. The default implementation returns `value` unchanged.
 
-  def self.subject *klasses, &block
-    raise "Only call subject on #{name} subclasses." if Mediator == self
+  def getting name, value
+    value
+  end
 
-    if block_given?
-      unless klasses.empty?
-        raise ArgumentError, "Can't provide both classes and a block."
-      end
+  # Set `name` to `value` on `subject`. The default implementation
+  # calls a matching mutator method.
 
-      map[block] = self
-    end
+  def set name, value
+    subject.send "#{name}=", setting(name, value)
+  end
 
-    klasses.each { |k| map[k] = self }
+  # Called when setting `name` to `value` on `subject`. Can be used to
+  # transform incoming values, e.g., trimming all strings. The default
+  # implementation returns `value` unchanged.
 
-    self
+  def setting name, value
+    value
   end
 end

data/mediator.gemspec

@@ -1,15 +1,15 @@
 Gem::Specification.new do |gem|
-  gem.authors       = ["Audiosocket"]
-  gem.email         = ["tech@audiosocket.com"]
+  gem.authors       = ["John Barnette"]
+  gem.email         = ["code@jbarnette.com"]
   gem.description   = "A go-between for models."
   gem.summary       = "Translates models to and from primitive representations."
-  gem.homepage      = "https://github.com/audiosocket/mediator"
+  gem.homepage      = "https://github.com/jbarnette/mediator"
 
   gem.files         = `git ls-files`.split "\n"
   gem.test_files    = `git ls-files -- test/*`.split "\n"
   gem.name          = "mediator"
   gem.require_paths = ["lib"]
-  gem.version       = "0.0.0"
+  gem.version       = "0.0.1"
 
   gem.required_ruby_version = ">= 1.9.2"
 end

data/test/mediator_parser_test.rb

@@ -5,6 +5,8 @@ require "ostruct"
 
 describe Mediator::Parser do
   before do
+    Mediator.map.clear
+
     @subject  = OpenStruct.new
     @mediator = Mediator.new @subject
   end
@@ -18,17 +20,35 @@ describe Mediator::Parser do
     assert_equal Hash.new, Mediator::Parser.new(:mediator).data
   end
 
-  describe "declaring keys explicitly" do
+  describe "id" do
+    it "translates name to subject.name_id" do
+      p = Mediator::Parser.new @mediator, foo: 42
+
+      p.id :foo
+      assert_equal 42, @subject.foo_id
+    end
+  end
+
+  describe "key" do
     before do
       @parser = Mediator::Parser.new @mediator,
-        emptystring: "", emptyarray: [], isnil: nil
+        emptystring: "", emptyarray: [], isnil: nil,
+        predicate: true
     end
 
-    it "sets unconditionally with key!" do
-      @parser.key! :foo, :bar
-      assert_equal :bar, @subject.foo
+    it "sets unconditionally with empty: true" do
+      @subject.foo = :foo
+
+      @parser.key :foo, empty: true
+      assert_nil @subject.foo
+    end
+
+    it "removes trailing '?' from predicates" do
+      @parser.key :predicate?
+      assert @subject.predicate
     end
 
+
     it "can pull from the options hash" do
       @parser.key :foo, value: :bar
       assert_equal :bar, @subject.foo
@@ -48,7 +68,7 @@ describe Mediator::Parser do
     end
   end
 
-  describe "setting values from data" do
+  describe "key with actual data" do
     it "grabs from data like it's a Hash" do
       p = Mediator::Parser.new @mediator, foo: "bar"
       p.key :foo
@@ -77,4 +97,79 @@ describe Mediator::Parser do
       assert_equal "bar", @subject.foo
     end
   end
+
+  describe "obj" do
+    before do
+      Top  = Class.new OpenStruct
+      Nest = Class.new OpenStruct
+
+      Class.new Mediator do
+        accept Top
+
+        def parse! p
+          p.key :foo
+          p.obj :nest
+        end
+      end
+
+      Class.new Mediator do
+        accept Nest
+
+        def parse! p
+          p.key :baz
+          p.key :quux
+        end
+      end
+    end
+
+    it "delegates to a nested mediator" do
+      s = Top.new
+      s.nest = Nest.new
+
+      m = Mediator[s]
+      d = { foo: "foo!", nest: { baz: "baz!", quux: "quux!" } }
+
+      m.parse d
+
+      assert_equal d[:foo],         s.foo
+      assert_equal d[:nest][:baz],  s.nest.baz
+      assert_equal d[:nest][:quux], s.nest.quux
+    end
+  end
+
+  describe "union" do
+    it "uses the same data as its parent" do
+      First  = Class.new OpenStruct
+      Second = Class.new OpenStruct
+
+      Class.new Mediator do
+        accept First
+
+        def parse! p
+          p.key   :first
+          p.union :unioned
+        end
+      end
+
+      Class.new Mediator do
+        accept Second
+
+        def parse! p
+          p.key :second
+        end
+      end
+
+      f = First.new
+      s = Second.new
+
+      f.unioned = s
+
+      m = Mediator[f]
+
+      m.parse first: "foo", second: "bar"
+
+      assert_equal "foo", f.first
+      assert_equal "bar", s.second
+    end
+  end
 end

data/test/mediator_renderer_test.rb

@@ -0,0 +1,143 @@
+require "mediator"
+require "mediator/renderer"
+require "minitest/autorun"
+require "ostruct"
+
+describe Mediator::Renderer do
+  before do
+    Mediator.map.clear
+  end
+
+  it "has data" do
+    assert_equal Hash.new, Mediator::Renderer.new(nil).data
+  end
+
+  describe "key" do
+    it "grabs the value from the subject" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo
+        end
+      end
+
+      s = OpenStruct.new foo: "bar"
+      m = c.new s
+      d = m.render
+
+      assert_equal "bar", d[:foo]
+    end
+
+    it "removes trailing ? from predicates" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo?
+        end
+      end
+
+      s = OpenStruct.new :foo? => true
+      m = c.new s
+      d = m.render
+
+      assert d[:foo]
+    end
+
+    it "ignores nil or empty values" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo
+        end
+      end
+
+      s = OpenStruct.new
+      m = c.new s
+      d = m.render
+
+      assert_equal Hash.new, d
+    end
+
+    it "optionally allows empty values" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo, empty: true
+        end
+      end
+
+      s = OpenStruct.new
+      m = c.new s
+      d = m.render
+      e = { foo: nil }
+
+      assert_equal e, d
+    end
+
+    it "optionally maps names" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo, from: :bar
+        end
+      end
+
+      s = OpenStruct.new bar: "baz"
+      m = c.new s
+      d = m.render
+
+      assert_equal "baz", d[:foo]
+    end
+
+    it "can alter values" do
+      c = Class.new Mediator do
+        def render! r
+          r.key(:foo) { |v| v.upcase }
+        end
+      end
+
+      s = OpenStruct.new foo: "bar"
+      m = c.new s
+      r = Mediator::Renderer.new s
+      d = m.render
+
+      assert_equal "BAR", d[:foo]
+    end
+
+    it "can explicitly define a value" do
+      c = Class.new Mediator do
+        def render! r
+          r.key :foo, value: "bar"
+        end
+      end
+
+      s = OpenStruct.new
+      m = c.new s
+      d = m.render
+
+      assert_equal "bar", d[:foo]      
+    end
+  end
+
+  describe "obj" do
+    it "allows mediation of an associated object" do
+      c = Class.new Mediator do
+        def render! r
+          r.obj :foo
+        end
+      end
+
+      d = Class.new Mediator do
+        accept OpenStruct
+
+        def render! r
+          r.key :bar
+        end
+      end
+
+      x = OpenStruct.new bar: "baz"
+      s = OpenStruct.new foo: x
+
+      m = c.new s
+      d = m.render
+      e = { foo: { bar: "baz" } }
+
+      assert_equal e, d
+    end
+  end
+end

data/test/mediator_test.rb

@@ -43,15 +43,32 @@ describe Mediator do
   end
 
   describe "parsing" do
-    it "is a noop by default" do
+    it "raises NotImplementedError by default" do
       m = Mediator.new :subject
-      m.parse :data
+
+      assert_raises NotImplementedError do
+        m.parse :data
+      end
     end
 
     it "builds a Parser and delegates to parse!" do
       c = Class.new Mediator do
-        def parse! parser
-          parser.key :foo
+        def parse! p
+          p.key :foo
+        end
+      end
+
+      s = OpenStruct.new
+      m = c.new s
+
+      m.parse foo: :bar
+      assert_equal :bar, s.foo
+    end
+
+    it "falls back on mediate!" do
+      c = Class.new Mediator do
+        def mediate! m
+          m.key :foo
         end
       end
 
@@ -64,22 +81,57 @@ describe Mediator do
 
     it "always returns the subject" do
       c = Class.new Mediator do
-        def self.parser
-          lambda { |p| :useless! }
+        def parse! p
         end
       end
 
       m = c.new :subject
       assert_equal :subject, m.parse(:data)
     end
+
+    it "can define a custom parser" do
+      c = Class.new Mediator do
+        def parse! p
+          p.poke
+        end
+
+        def parser data
+          p = Struct.new(:subject) do
+            def poke
+              subject.poked = true
+            end
+          end
+
+          p.new subject
+        end
+      end
+
+      s = OpenStruct.new
+      m = c.new s
+
+      m.parse nil
+      assert s.poked
+    end
   end
 
-  it "will render at some point" do
-    ex = assert_raises NotImplementedError do
-      Mediator.new(:s).render
+  describe "getting values from the subject" do
+    it "calls a getter by default" do
+      s = OpenStruct.new foo: :bar
+      m = Mediator.new s
+
+      assert_equal :bar, m.get(:foo)
     end
 
-    assert_equal "Implement Mediator#render.", ex.message
+    it "can construct missing values" do
+      c = Class.new Mediator do
+        def construct name
+          "HELLO" if :foo == name
+        end
+      end
+
+      m = c.new OpenStruct.new
+      assert_equal "HELLO", m.get(:foo)
+    end
   end
 
   describe "setting values on the subject" do
@@ -109,9 +161,20 @@ describe Mediator do
     end
   end
 
+  describe ".accept" do
+    it "is just subclass sugar for .register" do
+      c = Class.new Mediator
+      c.accept Symbol
+
+      assert_instance_of c, Mediator[:foo]
+    end
+  end
+
   describe ".for" do
     it "gets a mediator by class" do
-      c = Class.new(Mediator) { subject Symbol }
+      c = Class.new Mediator
+      Mediator.register c, Symbol
+
       m = Mediator.for :foo
 
       assert_instance_of c, m
@@ -120,61 +183,89 @@ describe Mediator do
     it "gets a mediator for a subclass" do
       x = Class.new
       y = Class.new x
-      c = Class.new(Mediator) { subject x }
+
+      c = Class.new Mediator
+      Mediator.register c, x
+
       m = Mediator.for y.new
 
       assert_instance_of c, m
     end
 
     it "gets a mediator by block eval" do
-      c = Class.new Mediator do
-        subject do |s|
-          "hello" == s
-        end
+      c = Class.new Mediator
+
+      Mediator.register c do |s|
+        "hello" == s
       end
 
       assert_instance_of c, Mediator.for("hello")
-      assert_nil Mediator.for "Hello!"
     end
 
     it "is also available as []" do
-      c = Class.new(Mediator) { subject Symbol }
+      c = Class.new Mediator
+      Mediator.register c, Symbol
+
       assert_instance_of c, Mediator[:foo]
     end
-  end
 
-  describe ".subject" do
-    it "can only be called on subclasses" do
-      ex = assert_raises RuntimeError do
-        Mediator.subject
+    it "raises when there's no mediator" do
+      ex = assert_raises Mediator::Error do
+        Mediator.for :foo
       end
 
-      assert_equal "Only call subject on Mediator subclasses.", ex.message
+      assert_equal "Can't find a Mediator for :foo.", ex.message
     end
+  end
+
+  describe ".mediate" do
+    it "is just sugar for subclass creation and registration" do
+      A = Class.new OpenStruct
+      B = Class.new A
 
-    it "can register a class" do
       c = Class.new Mediator do
-        subject Symbol
+        accept A
+
+        def parse! p
+          p.key :foo
+        end
       end
 
+      c.mediate B do
+        def parse! p
+          super
+          p.key :bar
+        end
+      end
+
+      i = B.new
+
+      Mediator[i].parse foo: "foo", bar: "bar"
+
+      assert_equal "foo", i.foo
+      assert_equal "bar", i.bar
+    end
+  end
+
+  describe ".register" do
+    it "can register a class" do
+      c = Class.new Mediator
+      Mediator.register c, Symbol
+
       assert_equal c, Mediator.map[Symbol]
     end
 
     it "can register multiple classes" do
-      c = Class.new Mediator do
-        subject String, Symbol
-      end
+      c = Class.new Mediator
+      Mediator.register c, String, Symbol
 
       assert_equal c, Mediator.map[String]
       assert_equal c, Mediator.map[Symbol]
     end
 
     it "can register with a block" do
-      c = Class.new Mediator do
-        subject do |s|
-          Symbol === s
-        end
-      end
+      c = Class.new Mediator
+      Mediator.register(c) { |s| Symbol === s }
 
       b = Mediator.map.keys.first
       refute_nil b
@@ -185,19 +276,17 @@ describe Mediator do
 
     it "doesn't allow classes and a block to be mixed" do
       ex = assert_raises ArgumentError do
-        Class.new Mediator do
-          subject String do
-            # ...
-          end
+        Mediator.register :whatev, String do
+          # ...
         end
       end
 
-      assert_equal "Can't provide both classes and a block.", ex.message
+      assert_equal "Can't provide both a subject and a block.", ex.message
     end
 
-    it "returns self" do
+    it "returns the registered thing" do
       c = Class.new Mediator
-      assert_equal c, c.subject
+      assert_equal c, Mediator.register(c, String)
     end
   end
 end

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: mediator
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
   prerelease: 
 platform: ruby
 authors:
-- Audiosocket
+- John Barnette
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-09 00:00:00.000000000Z
+date: 2012-01-17 00:00:00.000000000Z
 dependencies: []
 description: A go-between for models.
 email:
-- tech@audiosocket.com
+- code@jbarnette.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -24,11 +24,16 @@ files:
 - README.md
 - Rakefile
 - lib/mediator.rb
+- lib/mediator/errors.rb
 - lib/mediator/parser.rb
+- lib/mediator/processor.rb
+- lib/mediator/registry.rb
+- lib/mediator/renderer.rb
 - mediator.gemspec
 - test/mediator_parser_test.rb
+- test/mediator_renderer_test.rb
 - test/mediator_test.rb
-homepage: https://github.com/audiosocket/mediator
+homepage: https://github.com/jbarnette/mediator
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -54,4 +59,5 @@ specification_version: 3
 summary: Translates models to and from primitive representations.
 test_files:
 - test/mediator_parser_test.rb
+- test/mediator_renderer_test.rb
 - test/mediator_test.rb