json-schema-generator 0.0.3 → 0.0.4

data/.gitmodules

@@ -1,3 +1,3 @@
-[submodule "tests"]
-	path = tests
-	url = git://github.com/maxlinc/json-schema-kata.git
+[submodule "kata"]
+	path = kata
+	url = https://github.com/maxlinc/json-schema-kata.git

data/.travis.yml

@@ -4,9 +4,5 @@ rvm:
 - 1.9.3
 - jruby-19mode
 - rbx-19mode
-env:
-  EXCLUDE_SCHEMA_VERSION=draft4
-  JSON_GENERATOR="bundle exec json_schema_generator"
 before_install:
   - git submodule update --init --recursive
-  - cd tests && bundle install

data/README.md

@@ -1,43 +1,14 @@
 # JSON::SchemaGenerator
 
-A very basic json-schema generator.  Currently only has draft-03 support.
-The tests, including draft-04 tests, are in the json-schema-kata submodule.
+JSON::SchemaGenerator tries to save you some time writing [json-schemas](http://json-schema.org/) based on existing data.  I know that there are multiple valid json-schemas that could be generated for any given sample, so I won't generate the exact schema you want.  Our goal is just to make reasonable assumptions that get you close, so you can generate the basic structure and then customize your schema, rather than writing hundreds of lines by hand.
 
-## Installation
-
-Add this line to your application's Gemfile:
+There are [many json-schema validators], but only a few generators.  The best generator I've found is a closed-source web app so you can't embed it.  I couldn't find anything to embed within an open-source Ruby project ([Pacto](https://github.com/thoughtworks/pacto)), so I hacked one together quickly.
 
-    gem 'json-schema-generator'
+My quick, yak-shaving implementaiton wasn't designed for maintainability, but I wrote a test suite that gives me the confidence to rewrite or even port to other languages.  The tests are in [json-schema-kata](https://github.com/maxlinc/json-schema-kata).  I called it a kata for a reason:
 
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install json-schema-generator
-
-## Usage
-
-JSON::SchemaGenerator.generate name, data, version
-
-e.g.
-
-JSON::SchemaGenerator.generate 'sample_file.json', File.read('sample_file.json'), 'draft3'
-
-## Testing
-
-The tests are actually in a reusable submodule of platform agnostic json-schema tests.
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
-TODO: Write a gem description
+> Code Kata is an attempt to bring this element of practice to software development. A kata is an exercise in karate where you repeat a form many, many times, making little improvements in each. The intent behind code kata is similar.
+>
+> Dave Thomas [Code Kata](http://codekata.pragprog.com/2007/01/code_kata_backg.html)
 
 ## Installation
 
@@ -55,46 +26,50 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Command line:
+```sh
+# Usage: json-schema-generator --help
+# Simple example:
+$ json-schema-generator my_sample.json --schema-version draft3
+```
 
-TODO: Write a gem description
+Ruby:
+```ruby
+file = 'my_sample.json' # or any identifier for the description
+JSON::SchemaGenerator.generate file, File.read(file), {:schema_version => 'draft3'}
+```
 
-## Installation
+## Features
 
-Add this line to your application's Gemfile:
+JSON::SchemaGenerate has the following features or assumptions for generating "best-guess" schemas:
 
-    gem 'json-schema-generator'
+* **Schema Versions**: Support draft3 and draft4 of json-schema.
+* **Options**:
+  * **Defaults**: Can generate default values.
+  * **Descriptions**: Can generate a description indicating where the schema came from.
+* **Features/Assumptions**:
+  * **Detecting optional properties:** if you have an array of hashes, then will detect which hash keys exist in every instance of the hash and which ones only exist in some, and use this data to decide if the key is required or optional in the schema.
+  * **Assume required:** in all other cases, I assume everything I find in the sample is required.  I believe it is better to generate a schema that is too strict than too lenient.  It is easy to review and fix false negatives, by updating the schema to mark those items as optional.  A false positive will go unnoticed and will not point you towards a solution.
+  * **Detect types:** I detect objects, arrays, strings, integers, numbers and booleans.
 
-And then execute:
+## Known issues
 
-    $ bundle
+* Currently assumes the root element is a hash.  Generation will fail for data that has an array as the root.
 
-Or install it yourself as:
+## Tests
 
-    $ gem install json-schema-generator
+This was a [yak shaving](http://en.wiktionary.org/wiki/yak_shaving) project.  I needed to generate schemas for a ruby project.  I wanted to embed a schema generator within a larger open-source project ([Pacto](https://github.com/thoughtworks/pacto)), and couldn't find one I could use.  So I wrote one.
 
-## Usage
+There are [many json-schema validators], but only a few generators.  The best generator I've found is a closed-source Web app so you can't embed it.  I'm hoping more people will write generators in more languages.  I also hope someone replaces my quick "yak-shaving" implementation
+There are many json-schema validators available in many different programming languages.  However, there are only a few generators.  I hacked this together quickly because I wanted one I could easily use in Ruby.  My implementaiton is yak-shaving, not a well-design and maintainable solution.  So I wanted acceptance tests that are fully decoupled from the implementation - even the programming language - so I can completely re-write my solution or port it to other languages.
 
-TODO: Write usage instructions here
+The tests are in the json-schema-kata project.  The test runner is ruby, but it makes no assumptions about the implementation language.  Feel free to use my tests to port to any language.
 
 ## Contributing
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-TODO: Write usage instructions here
+Contributions Welcome!  It's easy to contribute tests to the json-schema-kata project.  You just need to add a sample and what you think the generated schema should look like for each supported json-schema version (draft3, draft4, etc).
 
-## Contributing
+Rewrites, ports, tutorials: I called the tests a "kata" because it is a small problem that is good for practicing programming skills, but could be solved many different ways.  Can you implement a generator using functional programming?  An internal DSL?  JSONPath?  Seven languages in seven Weeks?  Try it out, hone your skills, and share your results.
 
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)

data/Rakefile

@@ -3,9 +3,13 @@ require "bundler/gem_tasks"
 task :default => :test
 
 task :test do
-  ENV['JSON_GENERATOR'] = 'bundle exec json_schema_generator'
   ENV['PATH'] = ENV['PATH'] + File::PATH_SEPARATOR + File.expand_path('bin', Dir.pwd)
   puts ENV['PATH']
-  system 'cd tests && bundle exec rake'
+  Bundler.with_clean_env do
+    Dir.chdir 'kata' do
+      system 'bundle install'
+      system 'bundle exec rake'
+    end
+  end
   fail 'Tests did not pass!' unless $?.success?
 end

data/lib/json/schema_generator.rb

@@ -4,19 +4,31 @@ module JSON
   class SchemaGenerator
     DRAFT3 = 'draft-03'
     DRAFT4 = 'draft-04'
+    DEFAULT_VERSION = 'draft3'
+    SUPPORTED_VERSIONS = ['draft3', 'draft4']
 
     class << self
-      def generate name, data, version
-        generator = JSON::SchemaGenerator.new name, version
+      def generate name, data, opts = {}
+        generator = JSON::SchemaGenerator.new name, opts
         generator.generate data
       end
     end
 
-    def initialize name, version = 'draft3'
+    def initialize name, opts = {}
+      version = opts[:schema_version] || DEFAULT_VERSION
+      # Unfortunately json-schema.org and json-schema (gem) use different version strings
+      if ['draft3', 'draft-03'].include? version.to_s.downcase
+        @version = DRAFT3
+      elsif ['draft4', 'draft-04'].include? version.to_s.downcase
+        @version = DRAFT4
+      else
+        abort "Unsupported schema version: #{version}"
+      end
+
+      @defaults = opts[:defaults]
+
       @buffer = StringIO.new
       @name = name
-      @version = DRAFT3 if version == 'draft3'
-      @version = DRAFT4 if version == 'draft4'
     end
 
     def generate raw_data
@@ -53,12 +65,11 @@ module JSON
 
       statement_group.add "\"type\": \"#{type}\""
       statement_group.add "\"required\": #{required}" if @version == DRAFT3
-      # statement_group.add "\"default\": #{value.inspect}"
+      statement_group.add "\"default\": #{value.inspect}" if @defaults
     end
 
     def create_values(key, value, required_keys = nil, in_array = false)
       statement_group = StatementGroup.new key
-      # buffer.puts "\"#{key}\": {"
       case value
       when NilClass
       when TrueClass, FalseClass, String, Integer, Float
@@ -78,13 +89,12 @@ module JSON
     end
 
     def create_hash(statement_group, data, required_keys)
-      # statement_group = StatementGroup.new
       statement_group.add '"type": "object"'
       statement_group.add '"required": true' if @version == DRAFT3
       if @version == DRAFT4
         required_keys ||= []
         required_string = required_keys.map(&:inspect).join ', '
-        statement_group.add "\"required\": [#{required_string}]"
+        statement_group.add "\"required\": [#{required_string}]" unless required_keys.empty?
       end
       statement_group.add create_hash_properties data, required_keys
       statement_group
@@ -99,7 +109,6 @@ module JSON
     end
 
     def create_array(statement_group, data, required_keys)
-      # statement_group = StatementGroup.new
       statement_group.add '"type": "array"'
       statement_group.add '"required": true' if @version == DRAFT3
       if data.size == 0

data/lib/json/schema_generator/version.rb

@@ -1,5 +1,5 @@
 module JSON
   class SchemaGenerator
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

data/lib/json/schema_generator_cli.rb

@@ -1,12 +1,34 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
 class JSON::SchemaGeneratorCLI
   def initialize(argv, stdin=STDIN, stdout=STDOUT, stderr=STDERR, kernel=Kernel)
     @argv, @stdin, @stdout, @stderr, @kernel = argv, stdin, stdout, stderr, kernel
   end
 
   def execute!
+    default_version = JSON::SchemaGenerator::DEFAULT_VERSION
+    supported_versions = JSON::SchemaGenerator::SUPPORTED_VERSIONS
+
+    options = {
+      :schema_version => default_version,
+      :defaults => false
+    }
+
+
+
+    OptionParser.new do |opts|
+      opts.on("--defaults", "Record default values in the generated schema") { options[:defaults] = true }
+      opts.on("--schema-version [VERSION]", [:draft3, :draft4],
+        "Version of json-schema to generate (#{supported_versions.join ', '}).  Default: #{default_version}") do |schema_version|
+          options[:schema_version] = schema_version
+        end
+      opts.parse!
+    end
+
     file = ARGV.shift
-    version = ARGV.shift || 'draft3'
-    schema = JSON.parse(JSON::SchemaGenerator.generate file, File.read(file), version)
+    schema = JSON.parse(JSON::SchemaGenerator.generate file, File.read(file), options)
     @stdout.puts JSON.pretty_generate schema
     @kernel.exit(0)
   end

data/scripts/challenges/generate_defaults

@@ -0,0 +1,3 @@
+#!/bin/bash
+file=$1
+bundle exec json-schema-generator $1 --schema-version draft4 --defaults

data/scripts/challenges/generate_draft3

@@ -0,0 +1,3 @@
+#!/bin/bash
+file=$1
+bundle exec json-schema-generator $1

data/scripts/challenges/generate_draft4

@@ -0,0 +1,3 @@
+#!/bin/bash
+file=$1
+bundle exec json-schema-generator $1 --schema-version draft4

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: json-schema-generator
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-06 00:00:00.000000000 Z
+date: 2013-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -111,7 +111,7 @@ description: A very basic json-schema generator
 email:
 - max@devopsy.com
 executables:
-- json_schema_generator
+- json-schema-generator
 extensions: []
 extra_rdoc_files: []
 files:
@@ -122,13 +122,16 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- bin/json_schema_generator
+- bin/json-schema-generator
 - json-schema-generator.gemspec
 - lib/json-schema-generator.rb
 - lib/json/schema_generator.rb
 - lib/json/schema_generator/statement_group.rb
 - lib/json/schema_generator/version.rb
 - lib/json/schema_generator_cli.rb
+- scripts/challenges/generate_defaults
+- scripts/challenges/generate_draft3
+- scripts/challenges/generate_draft4
 homepage: ''
 licenses:
 - MIT
@@ -142,12 +145,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2342599026484996065
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -2342599026484996065
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -155,4 +164,3 @@ signing_key:
 specification_version: 3
 summary: A very basic json-schema generator
 test_files: []
-has_rdoc: