json-generator 0.0.1

data/lib/json-generator.rb

@@ -0,0 +1 @@
+require 'json/generator'

data/lib/json/generator.rb

@@ -0,0 +1,20 @@
+require "json/generator/version"
+
+require "json/generator/basic_attribute"
+require "json/generator/empty_attribute"
+require "json/generator/string_attribute"
+require "json/generator/integer_attribute"
+require "json/generator/array_attribute"
+require "json/generator/object_attribute"
+require "json/generator/boolean_attribute"
+require "json/generator/attribute_factory"
+require "json/generator/dereferencer"
+
+module JSON
+  module Generator
+    def self.generate(schema)
+      dereferenced_schema = Dereferencer.dereference(schema)
+      AttributeFactory.create(dereferenced_schema).generate
+    end
+  end
+end

data/lib/json/generator/array_attribute.rb

@@ -0,0 +1,11 @@
+module JSON
+  module Generator
+    class ArrayAttribute < BasicAttribute
+      def generate
+        (@attributes['minItems'] || 0).times.map do |index|
+          AttributeFactory.create(@attributes['items']).generate
+        end
+      end
+    end
+  end
+end

data/lib/json/generator/attribute_factory.rb

@@ -0,0 +1,18 @@
+module JSON
+  module Generator
+    class AttributeFactory
+      CLASSES = {
+        'string' => StringAttribute,
+        'object' => ObjectAttribute,
+        'integer' => IntegerAttribute,
+        'array' => ArrayAttribute,
+        'boolean' => BooleanAttribute,
+        nil => EmptyAttribute
+      }
+
+      def self.create(properties)
+        CLASSES[Array(properties['type']).first].new(properties)
+      end
+    end
+  end
+end

data/lib/json/generator/basic_attribute.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    class BasicAttribute
+      def initialize(attributes)
+        @attributes = attributes
+      end
+
+      def generate
+        @attributes['default'] || self.class::DEFAULT_VALUE
+      end
+
+      def required?
+        @attributes['required']
+      end
+    end
+  end
+end

data/lib/json/generator/boolean_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class BooleanAttribute < BasicAttribute
+      DEFAULT_VALUE = false
+    end
+  end
+end

data/lib/json/generator/dereferencer.rb

@@ -0,0 +1,22 @@
+module JSON
+  module Generator
+    class Dereferencer
+      def self.dereference(schema)
+        return schema unless schema.has_key?('properties')
+
+        definitions = schema.delete('definitions')
+        schema['properties'].each do |name, property|
+          next unless property.has_key?('$ref')
+
+          ref_name = property['$ref'].split('/').last
+          raise NameError, "definition for #{ref_name} not found" unless definitions.has_key?(ref_name)
+
+          property.merge!(definitions[ref_name])
+          property.delete('$ref')
+        end
+
+        schema
+      end
+    end
+  end
+end

data/lib/json/generator/empty_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class EmptyAttribute < BasicAttribute
+      DEFAULT_VALUE = nil
+    end
+  end
+end

data/lib/json/generator/integer_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class IntegerAttribute < BasicAttribute
+      DEFAULT_VALUE = 0
+    end
+  end
+end

data/lib/json/generator/object_attribute.rb

@@ -0,0 +1,18 @@
+module JSON
+  module Generator
+    class ObjectAttribute < BasicAttribute
+      def generate
+        return nil unless required?
+        return {} unless @attributes.has_key?('properties')
+
+        @attributes['properties'].inject({}) do |json, (property_name, property_attributes)|
+          attribute = AttributeFactory.create(property_attributes)
+          if attribute.required?
+            json[property_name] = attribute.generate
+          end
+          json
+        end
+      end
+    end
+  end
+end

data/lib/json/generator/string_attribute.rb

@@ -0,0 +1,7 @@
+module JSON
+  module Generator
+    class StringAttribute < BasicAttribute
+      DEFAULT_VALUE = "bar"
+    end
+  end
+end

data/lib/json/generator/version.rb

@@ -0,0 +1,5 @@
+module JSON
+  module Generator
+    VERSION = "0.0.1"
+  end
+end

data/spec/json/generator/array_attribute_spec.rb

@@ -0,0 +1,42 @@
+module JSON
+  module Generator
+    describe ArrayAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_a_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'with minItems' do
+          it 'should generate an array with two objects of the expected type' do
+            stubbed_item = stub('item', :generate => 'foo')
+            AttributeFactory.should_receive(:create).twice.
+              with('type' => 'dummy_type').
+              and_return(stubbed_item)
+
+            properties = {
+              'type' => 'array',
+              'minItems' => 2,
+              'items' => {
+                'type' => 'dummy_type'
+              }
+            }
+            described_class.new(properties).generate.should ==
+              [stubbed_item.generate, stubbed_item.generate]
+          end
+        end
+
+        context 'without minItems' do
+          it 'should generate an empty array' do
+            properties = {
+              'type' => 'array',
+              'items' => {
+                'type' => 'dummy_type'
+              }
+            }
+            described_class.new(properties).generate.should == []
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/attribute_factory_spec.rb

@@ -0,0 +1,72 @@
+module JSON
+  module Generator
+    describe AttributeFactory do
+      describe '.create' do
+        let(:attribute) { stub('attribute') }
+
+        context 'when type is a string' do
+          let(:properties) { {'type' => 'string'} }
+
+          it 'should create a StringAttribute' do
+            StringAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an object' do
+          let(:properties) { {'type' => 'object'} }
+
+          it 'should create an ObjectAttribute' do
+            ObjectAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an array' do
+          let(:properties) { {'type' => 'array'} }
+
+          it 'should create an ArrayAttribute' do
+            ArrayAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is an integer' do
+          let(:properties) { {'type' => 'integer'} }
+
+          it 'should create an IntegerAttribute' do
+            IntegerAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when type is a boolean' do
+          let(:properties) { {'type' => 'boolean'} }
+
+          it 'should create a BooleanAttribute' do
+            BooleanAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when we have an array of types' do
+          let(:properties) { {'type' => ['string', 'boolean']} }
+
+          it 'should create a the default attribute for the first type' do
+            StringAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+
+        context 'when there is no type' do
+          let(:properties) { {} }
+
+          it 'should create an EmptyAttribute' do
+            EmptyAttribute.should_receive(:new).with(properties).and_return(attribute)
+            described_class.create(properties).should == attribute
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/basic_attribute_spec.rb

@@ -0,0 +1,41 @@
+module JSON
+  module Generator
+    describe BasicAttribute do
+      describe '#generate' do
+        context 'with default value' do
+          let(:properties) { {'default' => stub('default')} }
+
+          it 'should return the default value' do
+            described_class.new(properties).generate.should == properties['default']
+          end
+        end
+      end
+
+      describe '#required?' do
+        context 'when required property is true' do
+          let(:properties) { {'required' => true} }
+
+          it 'should be required' do
+            described_class.new(properties).should be_required
+          end
+        end
+
+        context 'when required property is false' do
+          let(:properties) { {'required' => false} }
+
+          it 'should not be required' do
+            described_class.new(properties).should_not be_required
+          end
+        end
+
+        context 'when required property is not defined' do
+          let(:properties) { {} }
+
+          it 'should not be required' do
+            described_class.new(properties).should_not be_required
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/boolean_attribute_spec.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    describe BooleanAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'without a default value' do
+          it 'should return the default value' do
+            described_class.new({'type' => 'boolean'}).generate.should == false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/dereferencer_spec.rb

@@ -0,0 +1,72 @@
+module JSON
+  module Generator
+    describe Dereferencer do
+      describe '.dereference' do
+        let(:schema) do
+          {
+            'type' => 'object',
+            'properties' => {
+              'referencer' => referencer
+            },
+            'definitions' => definitions
+          }
+        end
+
+        let(:definitions) { {'referenced' => referenced} }
+
+        let(:referencer) do
+          {
+            'type' => 'object',
+            '$ref' => '#/definitions/referenced'
+          }
+        end
+
+        let(:referenced) do
+          {
+            'properties' => {
+              'message' => { 'type' => 'string' }
+            }
+          }
+        end
+
+        it 'should replace references with concrete definitions' do
+          described_class.dereference(schema).should == {
+            'type' => 'object',
+            'properties' => {
+              'referencer' => {
+                'type' => 'object',
+                'properties' => {
+                  'message' => { 'type' => 'string' }
+                }
+              }
+            }
+          }
+        end
+
+        context 'when the schema does not have any reference', 'but has definitions' do
+          let(:schema) { {'type' => 'object',  'properties' => {}, 'definitions' => {}} }
+
+          it 'should return the original schema without the definitions' do
+            described_class.dereference(schema).should == {'type' => 'object', 'properties' => {}}
+          end
+        end
+
+        context 'when the root element does not have properties' do
+          let(:schema) { {'type' => 'string'} }
+
+          it 'should return the original schema' do
+            described_class.dereference(schema).should == schema
+          end
+        end
+
+        context 'when a referenced definition does not exist' do
+          let(:definitions) { {} }
+
+          it 'should raise a name error' do
+            expect { described_class.dereference(schema) }.to raise_error NameError
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/empty_attribute_spec.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    describe EmptyAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new({}).should be_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'without a default value' do
+          it 'should return nil' do
+            described_class.new({}).generate.should be_nil
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/integer_attribute_spec.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    describe IntegerAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'without a default value' do
+          it 'should return the default value' do
+            described_class.new({'type' => 'integer'}).generate.should == 0
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/object_attribute_spec.rb

@@ -0,0 +1,100 @@
+module JSON
+  module Generator
+    describe ObjectAttribute do
+      describe '#generate' do
+        context 'when not required' do
+          let(:attributes) { {'type' => 'object', 'properties' => {}} }
+
+          it 'should return nil' do
+            described_class.new(attributes).generate.should be_nil
+          end
+        end
+
+        context 'without properties' do
+          let(:attributes) { {'type' => 'object', 'required' => true} }
+
+          it 'should generate an empty object' do
+            described_class.new(attributes).generate.should == {}
+          end
+        end
+
+        context 'with empty properties' do
+          let(:attributes) do
+            {
+              'type' => 'object',
+              'properties' => {},
+              'required' => true
+            }
+          end
+
+          it 'should generate an empty object' do
+            described_class.new(attributes).generate.should == {}
+          end
+        end
+
+        context 'with one property' do
+          let(:attributes) do
+            {
+              'type' => 'object',
+              'properties' => {
+                'foo' => property_attributes
+              },
+              'required' => true
+            }
+          end
+          let(:property_attributes) { double('property attributes') }
+          let(:property) { double('property', :required? => true) }
+          let(:generated_property) { double('generated property') }
+
+          it 'should generate an object with one attribute' do
+            AttributeFactory.should_receive(:create).with(property_attributes).and_return(property)
+            property.should_receive(:generate).and_return(generated_property)
+
+            described_class.new(attributes).generate.should == {
+              'foo' => generated_property
+            }
+          end
+        end
+
+        context 'with many properties' do
+          let(:attributes) do
+            {
+              'type' => 'object',
+              'properties' => {
+                'foo' => foo_attributes,
+                'bar' => bar_attributes,
+                'not_required' => not_required_attributes
+              },
+              'required' => true
+            }
+          end
+          let(:foo_attributes) { double('foo attributes') }
+          let(:foo_property) { double('foo property', :required? => true) }
+          let(:generated_foo) { double('generated foo') }
+
+          let(:bar_attributes) { double('bar attributes') }
+          let(:bar_property) { double('bar property', :required? => true) }
+          let(:generated_bar) { double('generated bar') }
+
+          let(:not_required_attributes) { double('not required attributes') }
+          let(:not_required_property) { double('not required property', :required? => false) }
+
+          it 'should generate an object with many attributes' do
+            AttributeFactory.should_receive(:create).with(foo_attributes).and_return(foo_property)
+            foo_property.should_receive(:generate).and_return(generated_foo)
+
+            AttributeFactory.should_receive(:create).with(bar_attributes).and_return(bar_property)
+            bar_property.should_receive(:generate).and_return(generated_bar)
+
+            AttributeFactory.should_receive(:create).with(not_required_attributes).and_return(not_required_property)
+
+            described_class.new(attributes).generate.should == {
+              'foo' => generated_foo,
+              'bar' => generated_bar
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator/string_attribute_spec.rb

@@ -0,0 +1,17 @@
+module JSON
+  module Generator
+    describe StringAttribute do
+      it 'should be a BasicAttribute' do
+        described_class.new(nil).should be_kind_of(BasicAttribute)
+      end
+
+      describe '#generate' do
+        context 'without a default value' do
+          it 'should return the default value' do
+            described_class.new({'type' => 'string'}).generate.should == 'bar'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/json/generator_spec.rb

@@ -0,0 +1,20 @@
+module JSON
+  describe Generator do
+    describe '.generate' do
+      let(:attribute) { double('attribute') }
+      let(:schema) { double('schema') }
+      let(:dereferenced_schema) { double('dereferenced schema') }
+      let(:generated_json) { double('generated json') }
+
+      it 'should dereference a given schema and generate valid JSON for it' do
+        JSON::Generator::Dereferencer.should_receive(:dereference).
+          with(schema).
+          and_return(dereferenced_schema)
+        Generator::AttributeFactory.should_receive(:create).with(dereferenced_schema).and_return(attribute)
+        attribute.should_receive(:generate).and_return(generated_json)
+
+        described_class.generate(schema).should == generated_json
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'json'
+require 'json-schema'
+require 'json-generator'

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: json-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- ThoughtWorks & Abril
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json-schema
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generates a valid JSON document for a given JSON Schema
+email:
+- abril_vejasp_dev@thoughtworkgem.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json/generator/array_attribute.rb
+- lib/json/generator/attribute_factory.rb
+- lib/json/generator/basic_attribute.rb
+- lib/json/generator/boolean_attribute.rb
+- lib/json/generator/dereferencer.rb
+- lib/json/generator/empty_attribute.rb
+- lib/json/generator/integer_attribute.rb
+- lib/json/generator/object_attribute.rb
+- lib/json/generator/string_attribute.rb
+- lib/json/generator/version.rb
+- lib/json/generator.rb
+- lib/json-generator.rb
+- spec/json/generator/array_attribute_spec.rb
+- spec/json/generator/attribute_factory_spec.rb
+- spec/json/generator/basic_attribute_spec.rb
+- spec/json/generator/boolean_attribute_spec.rb
+- spec/json/generator/dereferencer_spec.rb
+- spec/json/generator/empty_attribute_spec.rb
+- spec/json/generator/integer_attribute_spec.rb
+- spec/json/generator/object_attribute_spec.rb
+- spec/json/generator/string_attribute_spec.rb
+- spec/json/generator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tmattia/json-generator
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1314970676245074753
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1314970676245074753
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Generates a valid JSON document for a given JSON Schema
+test_files:
+- spec/json/generator/array_attribute_spec.rb
+- spec/json/generator/attribute_factory_spec.rb
+- spec/json/generator/basic_attribute_spec.rb
+- spec/json/generator/boolean_attribute_spec.rb
+- spec/json/generator/dereferencer_spec.rb
+- spec/json/generator/empty_attribute_spec.rb
+- spec/json/generator/integer_attribute_spec.rb
+- spec/json/generator/object_attribute_spec.rb
+- spec/json/generator/string_attribute_spec.rb
+- spec/json/generator_spec.rb
+- spec/spec_helper.rb