argo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eec272ff117353e33f1c251074a13a9b80ee0133
+  data.tar.gz: 8849f7c278b5f83c27699d5e10a39bc3e32e68fa
+SHA512:
+  metadata.gz: d936009d4cb7595e92127e2b0ed8d47ec391a53b780fd66f59f68e12144ed00e72eb79beb648112167b84c634767fc24fe7283975b510f06b6b7164afd2fd2e6
+  data.tar.gz: adf136d679c8b065c63cc6ad9f388f907db1905468c44dbb9112d39dd8bdd1de1e8d88f20e154c8a4193334aa0e034a780a0a750d39074303df828fa55c94154

data/COPYING.txt

@@ -0,0 +1,13 @@
+Copyright (c) 2015 Paul Battley
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

data/lib/argo/array_property.rb

@@ -0,0 +1,12 @@
+require 'argo/property'
+
+module Argo
+  class ArrayProperty < Property
+    def initialize(items:, **kwargs)
+      super(**kwargs)
+      @items = items
+    end
+
+    attr_reader :items
+  end
+end

data/lib/argo/boolean_property.rb

@@ -0,0 +1,6 @@
+require 'argo/property'
+
+module Argo
+  class BooleanProperty < Property
+  end
+end

data/lib/argo/constraint_processor.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+
+module Argo
+  class ConstraintProcessor
+    extend Forwardable
+
+    NON_CONSTRAINT_PROPERTIES = %w[
+      description
+      items
+      type
+    ]
+
+    def initialize(dereferencer)
+      @dereferencer = dereferencer
+    end
+
+    def process(hash)
+      process_hash(
+        hash.reject { |k, _| NON_CONSTRAINT_PROPERTIES.include?(k) }
+      )
+    end
+
+  private
+
+    def_delegators :@dereferencer, :dereference, :reference?
+
+    def symbolize_key(k)
+      k.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }.to_sym
+    end
+
+    def process_object(obj)
+      case obj
+      when Hash
+        process_hash(obj)
+      when Array
+        obj.map { |v| process_object(v) }.freeze
+      else
+        obj.freeze
+      end
+    end
+
+    def process_hash(hash)
+      if reference?(hash)
+        dereference(hash)
+      else
+        hash.
+          map { |k, v| [symbolize_key(k), process_object(v)] }.
+          to_h.
+          freeze
+      end
+    end
+  end
+end

data/lib/argo/deferred_object.rb

@@ -0,0 +1,23 @@
+require 'delegate'
+
+module Argo
+  class DeferredObject < Delegator
+    instance_methods.each do |m|
+      unless m =~ /^__|^(respond_to\?|method_missing|object_id)$/
+        undef_method m
+      end
+    end
+
+    def initialize(&block)
+      @__delegator_block__ = block
+      @__mutex__ = Mutex.new
+    end
+
+    def __getobj__
+      @__mutex__.synchronize do
+        @__getobj__ ||= @__delegator_block__.call
+      end
+      @__getobj__
+    end
+  end
+end

data/lib/argo/dereferencer.rb

@@ -0,0 +1,26 @@
+require 'argo/deferred_object'
+
+module Argo
+  class Dereferencer
+    def initialize(&block)
+      @block = block
+    end
+
+    def dereference(hash)
+      path = hash.fetch('$ref')
+      fragments = path.split(/\//)
+      unless fragments[0] == '#'
+        raise "Can't dereference non-root-anchored path '#{path}'"
+      end
+      DeferredObject.new {
+        fragments.drop(1).inject(@block.call) { |schema, fragment|
+          schema.schemas.fetch(fragment)
+        }
+      }
+    end
+
+    def reference?(hash)
+      hash.key?('$ref')
+    end
+  end
+end

data/lib/argo/immutable_keyword_struct.rb

@@ -0,0 +1,32 @@
+module Argo
+  class ImmutableKeywordStruct
+    # Disable these metrics here as gnarly metaprogramming is inherently ugly
+    # and splitting it up won't help much.
+    #
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def self.new(default_parameters, &block)
+      Class.new do
+        define_method :initialize do |**kwargs|
+          unknown_keys = kwargs.keys - __defaults__.keys
+          if unknown_keys.any?
+            raise ArgumentError, "unknown keyword: #{unknown_keys.first}"
+          end
+          __defaults__.each do |key, default|
+            instance_variable_set("@#{key}", kwargs.fetch(key, default).freeze)
+          end
+        end
+
+        attr_reader(*default_parameters.keys)
+
+        class_eval(&block) if block
+
+      private
+
+        define_method :__defaults__ do
+          default_parameters
+        end
+      end
+    end
+  end
+end

data/lib/argo/integer_property.rb

@@ -0,0 +1,6 @@
+require 'argo/property'
+
+module Argo
+  class IntegerProperty < Property
+  end
+end

data/lib/argo/number_property.rb

@@ -0,0 +1,6 @@
+require 'argo/property'
+
+module Argo
+  class NumberProperty < Property
+  end
+end

data/lib/argo/object_property.rb

@@ -0,0 +1,6 @@
+require 'argo/property'
+
+module Argo
+  class ObjectProperty < Property
+  end
+end

data/lib/argo/parser.rb

@@ -0,0 +1,20 @@
+require 'argo/dereferencer'
+require 'argo/schema_factory'
+
+module Argo
+  class Parser
+    def initialize(source)
+      @source = source
+    end
+
+    def root
+      @root ||= SchemaFactory.new(dereferencer).build(@source)
+    end
+
+  private
+
+    def dereferencer
+      @dereferencer ||= Dereferencer.new { root }
+    end
+  end
+end

data/lib/argo/property.rb

@@ -0,0 +1,11 @@
+require 'argo/immutable_keyword_struct'
+
+module Argo
+  Property = ImmutableKeywordStruct.new(
+    constraints: {},
+    description: nil,
+    required: false
+  ) do
+    alias_method :required?, :required
+  end
+end

data/lib/argo/property_factory.rb

@@ -0,0 +1,91 @@
+require 'forwardable'
+
+require 'argo/array_property'
+require 'argo/boolean_property'
+require 'argo/integer_property'
+require 'argo/number_property'
+require 'argo/object_property'
+require 'argo/string_property'
+
+require 'argo/constraint_processor'
+
+module Argo
+  class PropertyFactory
+    extend Forwardable
+
+    TYPE_MAP = {
+      'array' => ArrayProperty,
+      'boolean' => BooleanProperty,
+      'integer' => IntegerProperty,
+      'number' => NumberProperty,
+      'object' => ObjectProperty,
+      'string' => StringProperty
+    }
+
+    def initialize(dereferencer, required_fields = [])
+      @dereferencer = dereferencer
+      @required_fields = required_fields
+    end
+
+    def_delegators :@dereferencer, :dereference, :reference?
+
+    def build(body, name: nil)
+      class_for_type(body).new(
+        constraints: constraints(body),
+        description: body['description'],
+        required: required?(name),
+        **additional_properties(body)
+      )
+    end
+
+  private
+
+    def class_for_type(body)
+      klass = explicit_class(body) || implicit_class(body)
+      raise "No type found in #{body.inspect}" unless klass
+      klass
+    end
+
+    def explicit_class(body)
+      return nil unless body.key?('type')
+      type = body.fetch('type')
+      raise "Unknown property type '#{type}'" unless TYPE_MAP.key?(type)
+      TYPE_MAP.fetch(type)
+    end
+
+    def implicit_class(body)
+      if body.key?('enum')
+        StringProperty
+      elsif (body.keys & %w[ oneOf anyOf ]).any?
+        ObjectProperty
+      end
+    end
+
+    def additional_properties(body)
+      if class_for_type(body) == ArrayProperty
+        additional_properties_for_array(body)
+      else
+        {}
+      end
+    end
+
+    def additional_properties_for_array(body)
+      items = [body.fetch('items')].flatten.first
+      if reference?(items)
+        value = dereference(items)
+      else
+        factory = PropertyFactory.new(@dereferencer)
+        value = factory.build(items)
+      end
+      { items: value }
+    end
+
+    def required?(name)
+      @required_fields.include?(name)
+    end
+
+    def constraints(hash)
+      ConstraintProcessor.new(@dereferencer).process(hash)
+    end
+  end
+end

data/lib/argo/schema.rb

@@ -0,0 +1,13 @@
+require 'argo/immutable_keyword_struct'
+
+module Argo
+  Schema = ImmutableKeywordStruct.new(
+    description: nil,
+    properties: [],
+    schemas: {},
+    spec: nil,
+    title: nil,
+    type: :object,
+    route: nil
+  )
+end

data/lib/argo/schema_factory.rb

@@ -0,0 +1,71 @@
+require 'forwardable'
+require 'argo/schema'
+require 'argo/property_factory'
+
+module Argo
+  class SchemaFactory
+    extend Forwardable
+
+    def initialize(dereferencer)
+      @dereferencer = dereferencer
+    end
+
+    def_delegators :@dereferencer, :dereference, :reference?
+
+    def build(subgraph, route = [])
+      Schema.new(
+        description: extract_one(subgraph, :description),
+        title: extract_one(subgraph, :title),
+        schemas: subschemas(subgraph, route),
+        type: type(subgraph),
+        properties: properties(subgraph),
+        spec: extract_one(subgraph, :$schema),
+        route: route
+      )
+    end
+
+    NON_SUBSCHEMA_PROPERTIES = %w[
+      $schema
+      additionalItems
+      additionalProperties
+      description
+      id
+      properties
+      required
+      title
+      type
+    ]
+
+    def element_kind(key)
+      NON_SUBSCHEMA_PROPERTIES.include?(key) ? key.to_sym : :subschema
+    end
+
+    def extract(subgraph, kind)
+      subgraph.select { |k, _| element_kind(k) == kind }
+    end
+
+    def extract_one(subgraph, kind, default: nil)
+      _, v = subgraph.find { |k, _| element_kind(k) == kind }
+      v || default
+    end
+
+    def subschemas(subgraph, route)
+      extract(subgraph, :subschema).
+        inject({}) { |h, (k, v)| h.merge(k => build(v, route + [k])) }
+    end
+
+    def type(subgraph)
+      extract_one(subgraph, :type, default: :object).to_sym
+    end
+
+    def properties(subgraph)
+      required_fields = extract_one(subgraph, :required, default: [])
+      factory = PropertyFactory.new(@dereferencer, required_fields)
+      extract_one(subgraph, :properties, default: {}).
+        map { |k, v|
+          [k, reference?(v) ? dereference(v) : factory.build(v, name: k)]
+        }.
+        to_h
+    end
+  end
+end

data/lib/argo/string_property.rb

@@ -0,0 +1,6 @@
+require 'argo/property'
+
+module Argo
+  class StringProperty < Property
+  end
+end

data/lib/argo/version.rb

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

data/spec/integration/array_reference_spec.rb

@@ -0,0 +1,37 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'array reference' do
+  subject {
+    json = read_fixture('array_reference.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  describe 'property with reference' do
+    subject { super().properties.fetch('a') }
+
+    it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+
+    describe 'items' do
+      subject { super().items }
+
+      it 'has one property' do
+        expect(subject.properties.keys).to eq(%w[ thing_id ])
+      end
+    end
+  end
+
+  describe 'property with array containing one reference' do
+    subject { super().properties.fetch('b') }
+
+    it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+
+    describe 'items' do
+      subject { super().items }
+
+      it 'has one property' do
+        expect(subject.properties.keys).to eq(%w[ thing_id ])
+      end
+    end
+  end
+end

data/spec/integration/basic_example_spec.rb

@@ -0,0 +1,61 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'Example schemata' do
+  # See http://json-schema.org/examples.html
+
+  subject {
+    json = read_fixture('basic_example.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has a title' do
+    expect(subject.title).
+      to eq('Example Schema')
+  end
+
+  it 'is an object' do
+    expect(subject.type).
+      to eq(:object)
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has three items' do
+      expect(subject.length).to eq(3)
+    end
+
+    describe 'firstName' do
+      subject { super().fetch('firstName') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'has no description' do
+        expect(subject.description).to be_nil
+      end
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+    end
+
+    describe 'age' do
+      subject { super().fetch('age') }
+
+      it { is_expected.to be_kind_of(Argo::IntegerProperty) }
+
+      it 'has a description' do
+        expect(subject.description).to eq('Age in years')
+      end
+
+      it 'is not required' do
+        expect(subject).not_to be_required
+      end
+
+      it 'has constraints' do
+        expect(subject.constraints).to eq(minimum: 0)
+      end
+    end
+  end
+end

data/spec/integration/core_nested_schema_spec.rb

@@ -0,0 +1,48 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'Core spec section 3.4 nested schema' do
+  # See http://json-schema.org/latest/json-schema-core.html
+
+  subject {
+    json = read_fixture('core_nested_schema.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has the title "root"' do
+    expect(subject.title).to eq('root')
+  end
+
+  it 'has an empty route' do
+    expect(subject.route).to eq([])
+  end
+
+  describe 'nested schema' do
+    subject { super().schemas.fetch('otherSchema') }
+
+    it 'has the title "nested"' do
+      expect(subject.title).to eq('nested')
+    end
+
+    it 'has a one-element route' do
+      expect(subject.route).to eq(%w[ otherSchema ])
+    end
+
+    describe 'doubly nested schema' do
+      subject { super().schemas.fetch('anotherSchema') }
+
+      it 'has the title "alsoNested"' do
+        expect(subject.title).to eq('alsoNested')
+      end
+
+      it 'has a two-element route' do
+        expect(subject.route).to eq(%w[ otherSchema anotherSchema ])
+      end
+    end
+  end
+
+  it 'is an object' do
+    expect(subject.type).
+      to eq(:object)
+  end
+end

data/spec/integration/core_simple_schema_spec.rb

@@ -0,0 +1,19 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'Core spec section 3.4 simple schema' do
+  # See http://json-schema.org/latest/json-schema-core.html
+
+  subject {
+    json = read_fixture('core_simple_schema.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has a title' do
+    expect(subject.title).to eq('root')
+  end
+
+  it 'is an object' do
+    expect(subject.type).to eq(:object)
+  end
+end

data/spec/integration/disk_device_spec.rb

@@ -0,0 +1,51 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'diskDevice' do
+  # See http://json-schema.org/example2.html
+
+  subject {
+    json = read_fixture('diskDevice.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has no title' do
+    expect(subject.title).to be_nil
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has two items' do
+      expect(subject.length).to eq(2)
+    end
+
+    describe 'type' do
+      subject { super().fetch('type') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has an enum constraint' do
+        expect(subject.constraints).to eq(enum: %w[ disk ])
+      end
+    end
+
+    describe 'device' do
+      subject { super().fetch('device') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has a pattern constraint' do
+        expect(subject.constraints).to eq(pattern: '^/dev/[^/]+(/[^/]+)*$')
+      end
+    end
+  end
+end

data/spec/integration/disk_uuid_spec.rb

@@ -0,0 +1,53 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'diskUUID' do
+  # See http://json-schema.org/example2.html
+
+  subject {
+    json = read_fixture('diskUUID.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has no title' do
+    expect(subject.title).to be_nil
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has two items' do
+      expect(subject.length).to eq(2)
+    end
+
+    describe 'type' do
+      subject { super().fetch('type') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has an enum constraint' do
+        expect(subject.constraints).to eq(enum: %w[ disk ])
+      end
+    end
+
+    describe 'label' do
+      subject { super().fetch('label') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has a pattern constraint' do
+        expect(subject.constraints).to eq(
+          pattern: '^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}$'
+        )
+      end
+    end
+  end
+end

data/spec/integration/entry_schema_spec.rb

@@ -0,0 +1,115 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'entry-schema' do
+  # See http://json-schema.org/example2.html
+
+  subject {
+    json = read_fixture('entry-schema.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has a description' do
+    expect(subject.description).
+      to eq('schema for an fstab entry')
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has four items' do
+      expect(subject.length).to eq(4)
+    end
+
+    describe 'storage' do
+      subject { super().fetch('storage') }
+
+      it { is_expected.to be_kind_of(Argo::ObjectProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      describe 'one_of constraint' do
+        subject { super().constraints.fetch(:one_of) }
+
+        it 'has four entries' do
+          expect(subject.length).to eq(4)
+        end
+
+        describe 'first' do
+          subject { super().fetch(0) }
+
+          it { is_expected.to be_kind_of(Argo::Schema) }
+
+          describe 'properties' do
+            subject { super().properties }
+
+            it 'has two items' do
+              expect(subject.length).to eq(2)
+            end
+
+            describe 'type' do
+              subject { super().fetch('type') }
+
+              it { is_expected.to be_kind_of(Argo::StringProperty) }
+            end
+
+            describe 'device' do
+              subject { super().fetch('device') }
+
+              it { is_expected.to be_kind_of(Argo::StringProperty) }
+            end
+          end
+        end
+      end
+    end
+
+    describe 'fstype' do
+      subject { super().fetch('fstype') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is not required' do
+        expect(subject).not_to be_required
+      end
+
+      it 'has an enum constraint' do
+        expect(subject.constraints).to eq(enum: %w[ ext3 ext4 btrfs ])
+      end
+    end
+
+    describe 'options' do
+      subject { super().fetch('options') }
+
+      it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+
+      describe 'items' do
+        subject { super().items }
+
+        it { is_expected.to be_kind_of(Argo::StringProperty) }
+      end
+
+      it 'is not required' do
+        expect(subject).not_to be_required
+      end
+
+      it 'has minimum items and uniqueness constraints' do
+        expect(subject.constraints).to eq(
+          min_items: 1,
+          unique_items: true
+        )
+      end
+    end
+
+    describe 'readonly' do
+      subject { super().fetch('readonly') }
+
+      it { is_expected.to be_kind_of(Argo::BooleanProperty) }
+
+      it 'is not required' do
+        expect(subject).not_to be_required
+      end
+    end
+  end
+end

data/spec/integration/nfs_spec.rb

@@ -0,0 +1,71 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'nfs' do
+  # See http://json-schema.org/example2.html
+
+  subject {
+    json = read_fixture('nfs.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has no title' do
+    expect(subject.title).to be_nil
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has three items' do
+      expect(subject.length).to eq(3)
+    end
+
+    describe 'type' do
+      subject { super().fetch('type') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has an enum constraint' do
+        expect(subject.constraints).to eq(enum: %w[ nfs ])
+      end
+    end
+
+    describe 'remotePath' do
+      subject { super().fetch('remotePath') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has a pattern constraint' do
+        expect(subject.constraints).to eq(pattern: '^(/[^/]+)+$')
+      end
+    end
+
+    describe 'server' do
+      subject { super().fetch('server') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has a one-of constraint' do
+        expect(subject.constraints).to eq(
+          one_of: [
+            { format: 'host-name' },
+            { format: 'ipv4' },
+            { format: 'ipv6' }
+          ]
+        )
+      end
+    end
+  end
+end

data/spec/integration/property_reference_spec.rb

@@ -0,0 +1,27 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'property reference' do
+  subject {
+    json = read_fixture('property_reference.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  describe 'a' do
+    subject { super().properties.fetch('a') }
+
+    it { is_expected.to be_kind_of(Argo::Schema) }
+  end
+
+  describe 'b' do
+    subject { super().properties.fetch('b') }
+
+    it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+  end
+
+  describe 'c' do
+    subject { super().properties.fetch('c') }
+
+    it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+  end
+end

data/spec/integration/simple_example_spec.rb

@@ -0,0 +1,114 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'Example schemata' do
+  subject {
+    json = read_fixture('simple_example.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has a title' do
+    expect(subject.title).to eq('Product')
+  end
+
+  it 'is an object' do
+    expect(subject.type).to eq(:object)
+  end
+
+  it 'refers to the draft specification v4' do
+    expect(subject.spec).to eq('http://json-schema.org/draft-04/schema#')
+  end
+
+  it 'has a description' do
+    expect(subject.description).to eq("A product from Acme's catalog")
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has four items' do
+      expect(subject.length).to eq(4)
+    end
+
+    describe 'id' do
+      subject { super().fetch('id') }
+
+      it { is_expected.to be_kind_of(Argo::IntegerProperty) }
+
+      it 'has a description' do
+        expect(subject.description).
+          to eq('The unique identifier for a product')
+      end
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has no constraints' do
+        expect(subject.constraints).to be_empty
+      end
+    end
+
+    describe 'name' do
+      subject { super().fetch('name') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'has a description' do
+        expect(subject.description).to eq('Name of the product')
+      end
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has no constraints' do
+        expect(subject.constraints).to be_empty
+      end
+    end
+
+    describe 'price' do
+      subject { super().fetch('price') }
+
+      it { is_expected.to be_kind_of(Argo::NumberProperty) }
+
+      it 'has no description' do
+        expect(subject.description).to be_nil
+      end
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has constraints' do
+        expect(subject.constraints).
+          to eq(minimum: 0, exclusive_minimum: true)
+      end
+    end
+
+    describe 'tags' do
+      subject { super().fetch('tags') }
+
+      it { is_expected.to be_kind_of(Argo::ArrayProperty) }
+
+      it 'has no description' do
+        expect(subject.description).to be_nil
+      end
+
+      it 'is not required' do
+        expect(subject).not_to be_required
+      end
+
+      it 'has constraints' do
+        expect(subject.constraints).
+          to eq(min_items: 1, unique_items: true)
+      end
+
+      describe 'items' do
+        subject { super().items }
+
+        it { is_expected.to be_kind_of(Argo::StringProperty) }
+      end
+    end
+  end
+end

data/spec/integration/tmpfs_spec.rb

@@ -0,0 +1,51 @@
+require 'argo/parser'
+require 'json'
+
+RSpec.describe 'tmpfs' do
+  # See http://json-schema.org/example2.html
+
+  subject {
+    json = read_fixture('tmpfs.json')
+    Argo::Parser.new(JSON.parse(json)).root
+  }
+
+  it 'has no title' do
+    expect(subject.title).to be_nil
+  end
+
+  describe 'properties' do
+    subject { super().properties }
+
+    it 'has two items' do
+      expect(subject.length).to eq(2)
+    end
+
+    describe 'type' do
+      subject { super().fetch('type') }
+
+      it { is_expected.to be_kind_of(Argo::StringProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has constraints' do
+        expect(subject.constraints).to eq(enum: %w[ tmpfs ])
+      end
+    end
+
+    describe 'sizeInMB' do
+      subject { super().fetch('sizeInMB') }
+
+      it { is_expected.to be_kind_of(Argo::IntegerProperty) }
+
+      it 'is required' do
+        expect(subject).to be_required
+      end
+
+      it 'has constraints' do
+        expect(subject.constraints).to eq(minimum: 16, maximum: 512)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+RSpec.configure do |config|
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+
+  Kernel.srand config.seed
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+
+  def read_fixture(name)
+    File.read(File.expand_path("../fixtures/#{name}", __FILE__))
+  end
+end

data/spec/unit/deferred_object_spec.rb

@@ -0,0 +1,29 @@
+require 'argo/deferred_object'
+
+RSpec.describe Argo::DeferredObject do
+  subject { described_class.new { receiver.delegee } }
+  let(:receiver) { double(delegee: delegee) }
+  let(:delegee) { double(message: nil) }
+
+  it 'does not call the block at initialization time' do
+    expect(receiver).to receive(:delegee).never
+    subject
+  end
+
+  it 'calls the block when a method is called' do
+    expect(delegee).to receive(:message)
+    subject.message
+  end
+
+  it 'delegates the value to the receiver' do
+    allow(delegee).to receive(:message).and_return('VALUE')
+    expect(subject.message).to eq('VALUE')
+  end
+
+  it 'evaluates the block only once' do
+    expect(receiver).to receive(:delegee).once.and_return(delegee)
+    2.times do
+      subject.message
+    end
+  end
+end

data/spec/unit/immutable_keyword_struct_spec.rb

@@ -0,0 +1,54 @@
+require 'argo/immutable_keyword_struct'
+
+RSpec.describe Argo::ImmutableKeywordStruct do
+  let(:klass) {
+    described_class.new(a: nil, b: 'foo') do
+      def hello
+        "hello #{b}"
+      end
+    end
+  }
+
+  context 'with defaults' do
+    subject { klass.new }
+
+    it 'assigns properties with defaults' do
+      expect(subject.a).to be_nil
+      expect(subject.b).to eq('foo')
+    end
+
+    it 'freezes values' do
+      expect {
+        subject.b << ' oops'
+      }.to raise_exception(RuntimeError)
+    end
+
+    it 'allows method definition in a block' do
+      expect(subject.hello).to eq('hello foo')
+    end
+  end
+
+  context 'with assigned values' do
+    subject { klass.new(b: 'bar') }
+
+    it 'overrides defaults' do
+      expect(subject.b).to eq('bar')
+    end
+
+    it 'freezes values' do
+      expect {
+        subject.b << ' oops'
+      }.to raise_exception(RuntimeError)
+    end
+
+    it 'allows method definition in a block' do
+      expect(subject.hello).to eq('hello bar')
+    end
+  end
+
+  it 'raises an exception with an unrecognised keyword' do
+    expect {
+      klass.new(c: 1)
+    }.to raise_exception(ArgumentError)
+  end
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification
+name: argo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Battley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.32'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.32'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Expand JSON Schema(s) into introspectable Ruby objects
+email: pbattley@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- COPYING.txt
+files:
+- COPYING.txt
+- lib/argo/array_property.rb
+- lib/argo/boolean_property.rb
+- lib/argo/constraint_processor.rb
+- lib/argo/deferred_object.rb
+- lib/argo/dereferencer.rb
+- lib/argo/immutable_keyword_struct.rb
+- lib/argo/integer_property.rb
+- lib/argo/number_property.rb
+- lib/argo/object_property.rb
+- lib/argo/parser.rb
+- lib/argo/property.rb
+- lib/argo/property_factory.rb
+- lib/argo/schema.rb
+- lib/argo/schema_factory.rb
+- lib/argo/string_property.rb
+- lib/argo/version.rb
+- spec/integration/array_reference_spec.rb
+- spec/integration/basic_example_spec.rb
+- spec/integration/core_nested_schema_spec.rb
+- spec/integration/core_simple_schema_spec.rb
+- spec/integration/disk_device_spec.rb
+- spec/integration/disk_uuid_spec.rb
+- spec/integration/entry_schema_spec.rb
+- spec/integration/nfs_spec.rb
+- spec/integration/property_reference_spec.rb
+- spec/integration/simple_example_spec.rb
+- spec/integration/tmpfs_spec.rb
+- spec/spec_helper.rb
+- spec/unit/deferred_object_spec.rb
+- spec/unit/immutable_keyword_struct_spec.rb
+homepage: https://github.com/threedaymonk/argo
+licenses:
+- ISC
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: JSON Schema expander
+test_files: []