hyperdoc 0.1.0 → 0.1.1

data/README.md

@@ -1,11 +1,15 @@
 hyperdoc
 ========
 
-hypertextual documents using plain old data structures
+This library helps build hypertextual documents using plain old data structures which are designed for use in a REST friendly ecosystem. I'll be adding more here as I port the ideas over from the old repo. This is also part of a the upcoming open sourced General Assembly platform.
+
+NOTE: This release is completely unoptimized! Work is being done to reduce the complexity of the behaviors Hyperdoc's exhibit before things are tuned.
 
 License
 -------
 
+Thanks goes out to constantcontact/dash for allowing me to open source an *very early* prototype of these ideas. While it has evolved quite a bit since then, the core ideas have remained the same.
+
 While it might be controversial, I'm going to give CC a shot for code. The [CC FAQ](http://wiki.creativecommons.org/Frequently_Asked_Questions#Can_I_apply_a_Creative_Commons_license_to_software.3F) does not usually recommend it, though their reasons seem based around problems that a similar MIT style license does not address either. GPL compatibility is not a concern here either since I'd rather not see this relicensed under a more viral contract.
 
-<a rel="license" href="http://creativecommons.org/licenses/by/3.0/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by/3.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">hyperdoc</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="http://generalassemb.ly/" property="cc:attributionName" rel="cc:attributionURL">General Assembly</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0 Unported License</a>.
+<a rel="license" href="http://creativecommons.org/licenses/by/3.0/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by/3.0/88x31.png" /></a><br /><span xmlns:dct="http://purl.org/dc/terms/" property="dct:title">hyperdoc</span> by <a xmlns:cc="http://creativecommons.org/ns#" href="http://generalassemb.ly/" property="cc:attributionName" rel="cc:attributionURL">General Assembly</a> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by/3.0/">Creative Commons Attribution 3.0 Unported License</a>.

data/checks/core/check_array.rb

@@ -0,0 +1,154 @@
+require_relative '../setup'
+
+class ArrayTest < TestCase
+
+  def test_compact
+    obj = Hyperdoc.new('arr' => [1, nil, 2, nil, 3])
+    arr = obj.arr
+    compacted = arr.compact
+    assert_equal [1,2,3], compacted.meta.value
+    assert_equal arr.meta.parent, compacted.meta.parent
+    assert_equal arr.meta.key, compacted.meta.key
+  end
+
+  def test_compact_bang
+    arr = Hyperdoc.new([nil, 1, Hyperdoc.new(nil), 2, nil])
+    assert_equal arr, arr.compact!
+    assert_equal [1,2], arr.meta.value
+  end
+
+  def test_each
+    arr = Hyperdoc.new([{'a' => 'b'}, [3, 4]])
+    arr.each do |obj|
+      assert Hyperdoc::Type === obj
+    end
+    arr = Hyperdoc.new([0, 1])
+    arr.each do |obj|
+      assert !(Hyperdoc::Type === obj)
+    end
+  end
+
+  def test_first
+    arr = Hyperdoc.new([{'a' => 42}])
+    assert_equal 42, arr.first.a
+  end
+
+  def test_last
+    arr = Hyperdoc.new([0, 1, 2, 42])
+    assert_equal 42, arr.last
+    arr = Hyperdoc.new([0, 1, {}])
+    assert_equal 2, arr.last.meta.key
+  end
+
+  def test_map
+    arr = Hyperdoc.new([1,2,3])
+    assert_equal [-1,-2,-3], arr.map {|x| -x}.meta.value
+    arr = Hyperdoc.new([{'a' => 'b'}])
+    assert_equal ['a=b'], arr.map {|x| "a=#{x.a}"}.meta.value
+    obj = Hyperdoc.new({'arr' => [1,2,3]})
+    mapped_array = obj.arr.map {|x| -x}
+    assert_equal obj, mapped_array.meta.parent.box
+    assert_equal 'arr', mapped_array.meta.key
+  end
+
+  def test_map_bang
+    arr = Hyperdoc.new([{'a' => 1}, {'a' => 2}])
+    assert_equal arr, arr.map! {|x| x.a}
+    assert_equal [1,2], arr.meta.value
+  end
+
+  def test_push
+    arr = Hyperdoc.new([1,2,3])
+    arr.push(4)
+    arr << 5 << 6
+    assert_equal [1,2,3,4,5,6], arr.meta.value
+  end
+
+  def test_reduce
+    arr = Hyperdoc.new([0,1,2])
+    assert_equal 3, arr.reduce(:+)
+    assert_equal 3, arr.inject(:+)
+    assert_equal 0, arr.reduce(-3, :+)
+    assert_equal 3, arr.reduce {|x,y| x + y}
+    assert_equal 0, arr.reduce(-3) {|x,y| x + y}
+    assert_raise(ArgumentError) {arr.inject}
+  end
+
+  def test_reject
+    obj = Hyperdoc.new('arr' => (1..10).to_a)
+    arr = obj.arr
+    odds = arr.reject {|x| x % 2 == 0}
+    assert_equal [1,3,5,7,9], odds.meta.value
+    assert_equal arr.meta.parent, odds.meta.parent
+    assert_equal arr.meta.key, odds.meta.key
+  end
+
+  def test_reject_bang
+    arr = Hyperdoc.new([1,2,3,4])
+    assert_equal arr, arr.reject! {|x| x % 2 == 0}
+    assert_equal [1,3], arr.meta.value
+  end
+
+  def test_select
+    obj = Hyperdoc.new('arr' => (1..10).to_a)
+    arr = obj.arr
+    evens = arr.select {|x| x % 2 == 0}
+    assert_equal [2,4,6,8,10], evens.meta.value
+    assert_equal arr.meta.parent, evens.meta.parent
+    assert_equal arr.meta.key, evens.meta.key
+  end
+
+  def test_select_bang
+    arr = Hyperdoc.new([1,2,3,4])
+    assert_equal arr, arr.select! {|x| x % 2 == 0}
+    assert_equal [2,4], arr.meta.value
+  end
+
+  def test_sort
+    obj = Hyperdoc.new('arr' => [1,3,2,5,4])
+    arr = obj.arr
+    sorted = arr.sort
+    assert_equal [1,2,3,4,5], sorted.meta.value
+    assert_equal arr.meta.parent, sorted.meta.parent
+    assert_equal arr.meta.key, sorted.meta.key
+    sorted = arr.sort {|x, y| y <=> x}
+    assert_equal [5,4,3,2,1], sorted.meta.value
+  end
+
+  def test_sort_bang
+    arr = Hyperdoc.new([3,4,1,2])
+    assert_equal arr, arr.sort!
+    assert_equal [1,2,3,4], arr.meta.value
+  end
+
+  def test_sort_by
+    obj = Hyperdoc.new('arr' => [1,2,3,4])
+    arr = obj.arr
+    sorted = arr.sort_by {|x| -x}
+    assert_equal [4,3,2,1], sorted.meta.value
+    assert_equal arr.meta.parent, sorted.meta.parent
+    assert_equal arr.meta.key, sorted.meta.key
+  end
+
+  def test_sort_by_bang
+    arr = Hyperdoc.new([1,2,3,4])
+    assert_equal arr, arr.sort_by! {|x| -x}
+    assert_equal [4,3,2,1], arr.meta.value
+  end
+
+  def test_uniq
+    obj = Hyperdoc.new('arr' => [1,1,2,2,3,3])
+    arr = obj.arr
+    uniq = arr.uniq
+    assert_equal [1,2,3], uniq.meta.value
+    assert_equal arr.meta.parent, uniq.meta.parent
+    assert_equal arr.meta.key, uniq.meta.key
+  end
+
+  def test_uniq_bang
+    arr = Hyperdoc.new([1, 1, 2, 1, 1])
+    assert_equal arr, arr.uniq!
+    assert_equal [1,2], arr.meta.value
+  end
+
+end

data/checks/core/check_document.rb

@@ -0,0 +1,51 @@
+require_relative '../setup'
+
+class BoxTest < TestCase
+
+  def test_match_delegation
+    assert Hyperdoc.new('abc') =~ /abc/
+    assert Hyperdoc.new('abc') !~ /xyz/
+  end
+
+  def test_to_s_delegation
+    assert_equal '?'.to_s, Hyperdoc.new('?').to_s
+  end
+
+  def test_comparison
+    assert Hyperdoc.new(a: 42) == {a: 42}
+    assert Hyperdoc.new(42) > 41
+    assert_equal 0, Hyperdoc.new(42) <=> Hyperdoc.new(42)
+  end
+
+  def test_value_extraction
+    assert_equal [42], Hyperdoc.new([42]).meta.value
+    assert_equal 42, Hyperdoc.new(42)
+  end
+
+end
+
+class CustomBaseTest < TestCase
+
+  class X
+    include Hyperdoc::Type
+  end
+
+  def test_hash_construction
+    obj = X.new(a: 42)
+    assert Hyperdoc::Type === obj
+    assert_equal 42, obj.a
+  end
+
+  def test_array_construciton
+    obj = X.new([42])
+    assert Hyperdoc::Type === obj
+    assert_equal 42, obj.first
+  end
+
+  def test_value_construction
+    assert_equal 42, X.new(42)
+    assert_equal nil, X.new(nil)
+    assert_equal "42", X.new("42")
+  end
+
+end

data/checks/core/check_hash.rb

@@ -0,0 +1,50 @@
+require_relative '../setup'
+
+class AccessBehaviorTest < TestCase
+
+  def setup
+    @hash = Hyperdoc.new('a' => 42, b: 43)
+  end
+
+  def test_accessor_synthesis
+    assert @hash.a == 42
+    assert @hash.respond_to?(:a)
+    assert @hash.b == 43
+    assert @hash.respond_to?(:b)
+  end
+
+  def test_missing_accessor_synthesis
+    assert @hash.blahblah.nil?
+    assert @hash.respond_to?(:blahblah)
+  end
+
+  def test_query_synthesis
+    assert @hash.a?
+    assert @hash.respond_to?(:a?)
+    assert @hash.b?
+  end
+
+  def test_missing_query_synthesis
+    assert !@hash.blahblah?
+    assert @hash.respond_to?(:blahblah?)
+  end
+
+  def test_assignment_synthesis
+    @hash.answer = 42
+    assert_equal 42, @hash.answer
+    assert @hash.respond_to?(:answer=)
+  end
+
+end
+
+class BoxingBehaviorTest < TestCase
+
+  def test_assignment_should_unbox
+    hash = {'b' => 42}
+    object = Hyperdoc.new({})
+    object.a = Hyperdoc.new(hash)
+    object.a = object.a # assign a boxed value which should become unboxed
+    assert_equal hash.class, object.a.meta.value.class
+  end
+
+end

data/{test → checks}/setup.rb

@@ -1,3 +1,5 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../library'
 require 'hyperdoc'
 require 'test/unit'
+
+TestCase = Test::Unit::TestCase

data/hyperdoc.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |gem|
   gem.name = 'hyperdoc'
-  gem.version = '0.1.0'
+  gem.version = '0.1.1'
   gem.date = '2012-05-18'
   gem.summary = "hypertextual documents using plain old data structures"
-  gem.authors = ['strmpnk (Brian Mitchell)', 'John Paul Ashenfelter']
+  gem.authors = ['strmpnk (Brian Mitchell)', 'John Paul Ashenfelter', 'Robert Gleeson']
   gem.email = 'brian@generalassemb.ly'
   gem.homepage = 'https://github.com/generalassembly/hyperdoc'
   gem.require_paths = %w[library]

data/library/hyperdoc.rb

@@ -0,0 +1,21 @@
+module Hyperdoc
+
+  # value model
+  autoload :Array, 'hyperdoc/array'
+  autoload :Box, 'hyperdoc/box'
+  autoload :Factory, 'hyperdoc/factory'
+  autoload :Hash, 'hyperdoc/hash'
+  autoload :Type, 'hyperdoc/type'
+
+  # document model
+  autoload :Agent, 'hyperdoc/agent'
+  autoload :Meta, 'hyperdoc/meta'
+
+  # drivers
+  autoload :Couch, 'hyperdoc/couch'
+
+  def self.new(value)
+    Hyperdoc::Box.new(value)
+  end
+
+end

data/library/hyperdoc/array.rb

@@ -0,0 +1,158 @@
+module Hyperdoc::Array
+
+  def [](key)
+    box(key, meta.value[key])
+  end
+
+  def []=(key, value)
+    value = unbox(value)
+    meta.value[key] = unbox(value)
+  end
+
+  def compact
+    rebox meta.value.compact
+  end
+
+  def compact!
+    meta.value.reject! {|x| x.nil?}
+    self
+  end
+
+  def each
+    meta.value.each_with_index do |value, i|
+      yield box(i, value)
+    end
+    self
+  end
+
+  def first
+    box(0, meta.value.first)
+  end
+
+  def last
+    box(meta.value.size - 1, meta.value.last)
+  end
+
+  def map
+    arr = []
+    each do |box|
+      arr << unbox(yield(box))
+    end
+    rebox(arr)
+  end
+
+  def map!
+    meta.value.map!.with_index do |x, i|
+      unbox(yield box(i, x))
+    end
+    self
+  end
+
+  def push(item)
+    meta.value.push unbox(item)
+    self
+  end
+  alias_method :<<, :push
+
+  def reduce(*args, &block)
+    case args.size
+    when 0
+      initial = false
+      block_given? or raise ArgumentError,
+        "no block given"
+    when 1
+      initial = block_given?
+      block = args[0].to_proc unless initial
+    when 2
+      initial = true
+      block = args[1].to_proc
+    else
+      raise ArgumentError,
+        "Too many arguments: #{args.size} for 0 to 2"
+    end
+    memo = initial ? args[0] : nil
+    meta.value.each_with_index do |value, i|
+      # set an initial memo on first loop unless we were passed one
+      memo = (!initial && i == 0) ?
+        box(i, value) :
+        block.call(memo, box(i, value))
+    end
+    memo
+  end
+  alias inject reduce
+
+  def reject
+    selected = meta.value.reject.with_index do |x, i|
+      yield box(i, x)
+    end
+    rebox(selected)
+  end
+
+  def reject!
+    meta.value.reject!.with_index do |x, i|
+      yield box(i, x)
+    end
+    self
+  end
+
+  def size
+    meta.value.size
+  end
+
+  def select
+    selected = meta.value.select.with_index do |x, i|
+      yield box(i, x)
+    end
+    rebox(selected)
+  end
+
+  def select!
+    meta.value.select!.with_index do |x, i|
+      yield box(i, x)
+    end
+    self
+  end
+
+  def sort
+    if block_given?
+      # box everything once and then sort the boxes
+      sorted = meta.value.map.with_index do |v, i|
+        box(i, v)
+      end.sort do |a,b|
+        yield a,b
+      end
+    else
+      sorted = meta.value.sort
+    end
+    rebox(sorted)
+  end
+
+  def sort!
+    meta.value.sort!
+    self
+  end
+
+  def sort_by
+    sorted = meta.value.sort_by.with_index do |x, i|
+      yield box(i, x)
+    end
+    rebox(sorted)
+  end
+
+  def sort_by!
+    meta.value.sort_by!.with_index do |x, i|
+      yield box(i, x)
+    end
+    self
+  end
+
+  def uniq
+    rebox meta.value.uniq
+  end
+
+  def uniq!
+    meta.value.uniq!
+    self
+  end
+
+end

data/library/hyperdoc/box.rb

@@ -0,0 +1,5 @@
+# Empty box subclass for generated nodes
+class Hyperdoc::Box
+  include Hyperdoc::Type
+
+end

data/library/hyperdoc/document.rb

@@ -0,0 +1,68 @@
+class Hyperdoc::Document
+  include Comparable
+  include Hyperdoc::Generator
+
+  def self.generate(types)
+    return self if types.empty?
+    @cache[types]
+  end
+
+  def self.inherited(subclass)
+    # inherit schema
+    # setup caches for subclass
+  end
+
+  def self.inspect
+    return name if name
+    base = self
+    base = base.superclass until base.name
+    behaviors = ancestors[1..-1] - base.ancestors
+    behaviors.empty? ?
+      "#{base}":
+      "#{base}(#{behaviors.join(',')})"
+  end
+
+  def self.on(selectors)
+    selectors.each do |code, type|
+      schema.register(code, type)
+    end
+  end
+
+public
+
+  undef_method :=~
+  undef_method :nil?
+  undef_method :to_s
+
+  def <=>(other)
+    value <=> unbox(other)
+  end
+
+  def inspect
+    key ?
+      "#<#{self.class.inxpect}##{full_path.join('.')}: #{value.inspect}>":
+      "#<#{self.class.inspect}: #{value.inspect}>"
+  end
+
+private
+
+  attr_accessor :key, :parent, :schema
+  attr_reader :value
+
+  def box()
+
+  end
+
+  def initialize(value)
+    @value = value
+  end
+
+  def rebox()
+
+  end
+
+  def unbox()
+
+  end
+
+end

data/library/hyperdoc/factory.rb

@@ -0,0 +1,44 @@
+module Hyperdoc::Factory
+
+  def inspect
+    return name if name
+    base = self
+    base = base.superclass until base.name
+    behaviors = ancestors[1..-1] - base.ancestors
+    behaviors.empty? ?
+      "#{base}":
+      "#{base}(#{behaviors.join(',')})"
+  end
+
+  def new(value)
+    # NOTE: this is unoptimized. Specialization will get more complex
+    # once selectors are added back. We'll delay optimizing this till
+    # after that feature is complete.
+    sub = Class.new(self)
+    type = value_type(value)
+    return value if type.nil?
+    sub.class_eval do
+      include type
+      undef_method :=~
+    end
+    sub.allocate.tap {|inst|
+      inst.meta.value = inst.send(:unbox, value)
+      inst.meta.box = inst
+      yield inst if block_given?
+      inst.send(:initialize)}
+  end
+
+private
+
+  def value_type(value)
+    case value
+    when ::Hash
+      Hyperdoc::Hash
+    when ::Array
+      Hyperdoc::Array
+    else
+      nil
+    end
+  end
+
+end

data/library/hyperdoc/hash.rb

@@ -0,0 +1,69 @@
+module Hyperdoc::Hash
+
+  def [](key)
+    if meta.value.has_key?(key)
+      # Check natural type
+      box(key, meta.value[key])
+    elsif String === key
+      # Check symbol form
+      sym_key = key.to_sym
+      box(key, meta.value[sym_key])
+    else
+      # Check string form
+      str_key = key.to_s
+      box(key, meta.value[str_key])
+    end
+  end
+
+  def []=(key, value)
+    str_key = key.to_s
+    sym_key = key.to_sym
+    if meta.value.has_key?(sym_key)
+      if meta.value.has_key?(str_key)
+        meta.value[key] = unbox(value)
+      else
+        meta.value[sym_key] = unbox(value)
+      end
+    else
+      meta.value[str_key] = unbox(value)
+    end
+  end
+
+  def has_key?(key)
+    return true if meta.value.has_key?(key)
+    if String === key
+      meta.value.has_key?(key.to_sym)
+    else
+      meta.value.has_key?(key.to_s)
+    end
+  end
+
+private
+
+  def access_call(symbol, key)
+    cached_call(symbol) {box(key, self[key])}
+  end
+
+  def assign_call(symbol, key)
+    cached_call(symbol) {|v| self[key] = v}
+  end
+
+  def method_missing(symbol, *args, &blk)
+    case symbol
+    when /(.*)=$/
+      key = $1
+      assign_call(symbol, key).call(*args, &blk)
+    when /(.*)\?$/
+      key = $1
+      query_call(symbol, key).call(*args, &blk)
+    else
+      key = symbol.to_s
+      access_call(symbol, key).call(*args, &blk)
+    end
+  end
+
+  def query_call(symbol, key)
+    cached_call(symbol) {has_key?(key) && !!box(key, self[key])}
+  end
+
+end

data/library/hyperdoc/meta.rb

@@ -0,0 +1,14 @@
+class Hyperdoc::Meta
+  attr_accessor :key, :value, :box, :parent
+
+  def inspect
+    "value=#{value.inspect}"
+  end
+
+  def path
+    path = parent ? (parent.path << key) : []
+    return if path.empty?
+    path.join('.')
+  end
+
+end

data/library/hyperdoc/type.rb

@@ -0,0 +1,86 @@
+=begin
+# Overview
+
+Hyperdoc::Type is included in classes which intend on constructing
+document instances. It transforms the new() interface into a sort of
+factory which generates a class with the appropriate sort of
+combination of modules based on what it's wrapping. This is don't
+rather than subclassing for precisely that sort of late-bound behavior.
+
+## Why Hyperdoc::Type and not some other name?
+
+While it was originally going to be implemented directly on the
+Hyperdoc module itself, this was a problem for constant lookup since
+Hyperdoc implements many common constant names like Array and Hash, which
+leads to a sort of ambiguity. This protects us somewhat by not creating
+unintended ambiguity for those that include Hyperdoc::Type.
+
+Type itself was chosen because it helps describe what it is. It's a sort of
+Hyperdoc and will read well: Hyperdoc::Type === … Though we'll probably add
+a simple implementation for Hyperdoc.=== which will delegate to
+Hyperdoc::Type
+
+=end
+
+module Hyperdoc::Type
+  include Comparable
+
+  def self.append_features(_class)
+    Class === _class or raise ArgumentError,
+      "Hyperdoc::Type can only be included directly into a class, not a module"
+    super
+    _class.extend Hyperdoc::Factory
+  end
+
+public
+
+  def <=>(other)
+    meta.value <=> unbox(other)
+  end
+
+  def inspect
+    meta.path ?
+      "#<#{self.class.inspect}##{meta.path}: #{meta.inspect}>":
+      "#<#{self.class.inspect}: #{meta.inspect}>"
+  end
+
+  def meta
+    @hyperdoc_meta ||= Hyperdoc::Meta.new
+  end
+
+  def to_s(*a)
+    meta.value.to_s(*a)
+  end
+
+private
+
+  def box(key, value)
+    Hyperdoc::Box.new(value) { |box|
+      box.meta.key = key
+      box.meta.parent = meta
+    }
+  end
+
+  def rebox(value)
+    self.dup.tap { |box|
+      box.meta.value = value
+      box.meta.box = box
+    }
+  end
+
+  def unbox(object)
+    Hyperdoc::Type === object ? unbox(object.meta.value) : object
+  end
+
+  def cached_call(symbol, &proc)
+    unless self.respond_to?(symbol, true)
+      self.class.class_eval {define_method(symbol, &proc)}
+    end
+    proc
+  end
+
+  def scrub_call(symbol)
+    self.class.class_eval {undef_method symbol}
+  end
+
+end

data/rakefile

@@ -1,23 +1,16 @@
 task default: [:test, :build]
 
-task compile: 'lib/dash/selector.kpeg.rb'
-
 desc "check tests"
-task :test => :compile do
-  ruby ENV['ONLY'] || 'test/check_all.rb'
+task :test do
+  ruby ENV['ONLY'] || 'checks/all.rb'
 end
 
 desc "build dash gem"
-task :build => :compile do
-  sh 'gem build dash.gemspec'
+task :build do
+  sh 'gem build hyperdoc.gemspec'
 end
 
 desc "clean build artifacts"
 task :clean do
-  rm 'lib/dash/selector.kpeg.rb'
-  rm 'dash-*.gem'
-end
-
-file 'lib/dash/selector.kpeg.rb' => 'lib/dash/selector.kpeg' do
-  sh "kpeg --stand-alone --force --output lib/dash/selector.kpeg.rb lib/dash/selector.kpeg"
-end
+  rm 'hyperdoc-*.gem'
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: hyperdoc
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
 - strmpnk (Brian Mitchell)
 - John Paul Ashenfelter
+- Robert Gleeson
 autorequire: 
 bindir: bin
 cert_chain: []
@@ -14,7 +15,7 @@ date: 2012-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
-  requirement: &70332263351580 !ruby/object:Gem::Requirement
+  requirement: &70245880712420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +23,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70332263351580
+  version_requirements: *70245880712420
 - !ruby/object:Gem::Dependency
   name: excon
-  requirement: &70332263350860 !ruby/object:Gem::Requirement
+  requirement: &70245880711820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +34,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70332263350860
+  version_requirements: *70245880711820
 - !ruby/object:Gem::Dependency
   name: yajl-ruby
-  requirement: &70332263350020 !ruby/object:Gem::Requirement
+  requirement: &70245880711180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +45,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70332263350020
+  version_requirements: *70245880711180
 - !ruby/object:Gem::Dependency
   name: kpeg
-  requirement: &70332263349300 !ruby/object:Gem::Requirement
+  requirement: &70245880710740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,29 +56,34 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70332263349300
+  version_requirements: *70245880710740
 description: 
 email: brian@generalassemb.ly
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- checks/all.rb
+- checks/core/check_array.rb
+- checks/core/check_document.rb
+- checks/core/check_hash.rb
+- checks/setup.rb
 - hyperdoc.gemspec
+- library/hyperdoc/agent.rb
 - library/hyperdoc/array.rb
 - library/hyperdoc/box.rb
+- library/hyperdoc/couch/database.rb
+- library/hyperdoc/couch/document.rb
+- library/hyperdoc/couch/view.rb
 - library/hyperdoc/couch.rb
+- library/hyperdoc/document.rb
+- library/hyperdoc/factory.rb
 - library/hyperdoc/hash.rb
-- library/hyperdoc/link.rb
 - library/hyperdoc/meta.rb
-- library/hyperdoc/nop.rb
-- library/hyperdoc/schema.rb
-- library/hyperdoc/selector.rb
-- library/hyperdoc/value.rb
+- library/hyperdoc/type.rb
 - library/hyperdoc.rb
 - rakefile
 - README.md
-- test/check_all.rb
-- test/setup.rb
 homepage: https://github.com/generalassembly/hyperdoc
 licenses: []
 post_install_message: