jimmy 0.5.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 189b5833da044ec29e5cf06d708960564a08a47f
+  data.tar.gz: 30c672d61e39c2e84e131404b6efdf5c4bdcecad
+SHA512:
+  metadata.gz: 1e225b091d344c3c72fd660e3672821c49c2be5403a8b43db54f2f22b2b0cf3fe2ce4867c3371d6462fed1ca7395c274fed29ef7f634ebb012ba9e3ebe161204
+  data.tar.gz: 3ee1e87f5329b4296ceaa9b664f8aa13c10ffcf7f72ffdbd1b486829e77b603a8a2e467552057e0801ccd458d566c375b914e82de62d480503fdb56c9ed3fca2

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.rspec
+*.gem

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2015 OrionVM Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,151 @@
+# Jimmy the Gem
+
+Meet your mate Jimmy. He's a top bloke.
+
+Writing JSON schemas is as tedious as a tax audit. But now, thanks to everyone's new best friend Jimmy, it's easier than shooting the side of a barn with a very easy-to-use projectile weapon.
+
+## Getting hooked up
+
+You guessed it:
+
+```bash
+$ gem install jimmy
+```
+
+Here's another doozy:
+
+```ruby
+require 'jimmy'
+```
+
+Wasn't that a shock. Let's move on.
+
+## The DSL
+
+Jimmy replaces `.json` JSON schemas files with `.rb` files. Here's a simple example:
+
+```ruby
+# city.rb
+object do
+  string :name, min_length: 2
+  string :postcode, /^\d{4}$/
+
+  require all
+end
+```
+
+This compiles to:
+
+```json
+{
+  "$schema": "https://my.domain.kom/city#",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "minLength": 2
+    },
+    "postcode": {
+      "type": "string",
+      "pattern": "^\\d{4}$"
+    },
+    "required": ["name", "zipcode"],
+    "additionalProperties": false
+  }
+}
+```
+
+Crikey! That's a bit of a difference. Let's take a look at a more complex (and contrived) example:
+
+```ruby
+# types/country_code.rb
+string /^[A-Z]{2}$/
+
+# types/geopoint.rb
+object do
+  number :latitude, -90..90
+  number :longitude, -180..180
+end
+
+# city.rb
+object do
+  string :name, min_length: 2
+  string :postcode, /^\d{4}$/
+  integer :population
+  geopoint :location
+  country_code :country
+  array :points_of_interest do
+    object do
+      string :title, 3..150
+      integer :popularity, [1, 3, 5, 7]
+      geopoint :location
+      boolean :featured
+      require :title
+    end
+  end
+  require all - :location
+end
+```
+
+Here's the full result (though we expect you get the gist of it by now):
+
+```json
+{
+  "$schema": "https://my.domain.kom/city#",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "minLength": 2
+    },
+    "postcode": {
+      "type": "string",
+      "pattern": "^\\d{4}$"
+    },
+    "population": {
+      "type": "integer"
+    },
+    "location": {
+      "$ref": "/types/geopoint#"
+    },
+    "country": {
+      "$ref": "/types/country_code#"
+    },
+    "points_of_interest": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "title": {
+            "type": "string",
+            "minLength": 3,
+            "maxLength": 150
+          },
+          "popularity": {
+            "type": "integer",
+            "enum": [1, 3, 5, 7]
+          },
+          "location": {
+            "$ref": "/types/geopoint#"
+          },
+          "featured": {
+            "type": "boolean"
+          }
+        },
+        "required": [
+          "title"
+        ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required": [
+    "name",
+    "postcode",
+    "population",
+    "country",
+    "points_of_interest"
+  ],
+  "additionalProperties": false
+}
+```

data/Rakefile

@@ -0,0 +1,4 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :spec

data/circle.yml

@@ -0,0 +1,11 @@
+machine:
+  ruby:
+    version: '2.1.5'
+
+dependencies:
+  pre:
+    - gem install bundler -v '~>1.9'
+
+test:
+  override:
+    - bundle exec rake spec

data/jimmy.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jimmy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jimmy'
+  spec.version       = Jimmy::VERSION
+  spec.authors       = ['Neil E. Pearson']
+  spec.email         = ['neil.pearson@orionvm.com']
+
+  spec.summary       = 'Jimmy the JSON Schema DSL'
+  spec.description   = 'Jimmy makes it a snap to compose detailed JSON schema documents.'
+  spec.homepage      = 'https://github.com/hx/jimmy'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.license       = 'Apache License, Version 2.0'
+
+  spec.add_dependency 'json-schema', '~> 2.5'
+
+  spec.add_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+  spec.add_development_dependency 'diff_matcher', '~> 2.7'
+end

data/lib/jimmy.rb

@@ -0,0 +1,20 @@
+require 'pathname'
+require 'jimmy/version'
+
+module Jimmy
+    ROOT = Pathname(__FILE__).parent.parent
+end
+
+require_relative 'jimmy/symbol_array'
+
+require_relative 'jimmy/domain'
+require_relative 'jimmy/schema'
+require_relative 'jimmy/reference'
+require_relative 'jimmy/type_reference'
+require_relative 'jimmy/schema_creation'
+require_relative 'jimmy/schema_types'
+require_relative 'jimmy/schema_type'
+require_relative 'jimmy/combination'
+require_relative 'jimmy/link'
+require_relative 'jimmy/validation_error'
+require_relative 'jimmy/definitions'

data/lib/jimmy/combination.rb

@@ -0,0 +1,34 @@
+require_relative 'schema_types'
+
+module Jimmy
+  class Combination < Array
+    include SchemaCreation::Referencing
+
+    attr_reader :condition, :schema
+
+    # @param [Symbol] condition One of :one, :all, or :any
+    def initialize(condition, schema)
+      @condition = condition
+      @schema = schema
+    end
+
+    def domain
+      schema.domain
+    end
+
+    def evaluate(types_proc)
+      instance_exec &types_proc
+    end
+
+    def compile
+      data.merge "#{condition}Of" => map(&:compile)
+    end
+
+    def data
+      @data ||= {}
+    end
+
+    SchemaCreation.apply_to(self) { |schema| push schema }
+
+  end
+end

data/lib/jimmy/definitions.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+
+module Jimmy
+  class Definitions
+    include SchemaCreation::Referencing
+    extend Forwardable
+    delegate %i[empty? key? map] => :@values
+    
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = schema
+      @values = {}
+    end
+
+    def evaluate(&block)
+      instance_exec &block
+    end
+
+    def domain
+      schema.domain
+    end
+
+    def compile
+      map { |k, v| [k.to_s, v.compile] }.to_h
+    end
+
+    def data
+      schema.data
+    end
+
+    def [](key)
+      @values[key] || (schema.parent && schema.parent.definitions[key])
+    end
+
+    SchemaCreation.apply_to(self) { |schema, name| @values[name] = schema }
+  end
+end

data/lib/jimmy/domain.rb

@@ -0,0 +1,111 @@
+require 'uri'
+require 'pathname'
+require 'json'
+require 'json-schema'
+
+require_relative 'schema_creation'
+
+module Jimmy
+  class Domain
+    DEFAULT_OPTIONS = {
+        transform_keys: nil
+    }
+
+    attr_reader :root, :types, :partials, :options, :schemas
+
+    def initialize(root, **options)
+      @root     = URI(root)
+      @schemas  = {}
+      @types    = {}
+      @partials = {}
+      @import_paths = []
+      @uri_formatter = -> _, name { @root + "#{name}.json#" }
+      @options  = DEFAULT_OPTIONS.merge(options)
+    end
+
+    def domain
+      self
+    end
+
+    def import(path)
+      path = Pathname(path) unless path.is_a? Pathname
+      @import_paths << path unless @import_paths.include? path
+
+      glob path, only: 'types' do |name, schema|
+        @types[name.to_sym] = schema
+      end
+
+      glob path, only: 'partials' do |name|
+        partial_path = path + 'partials' + "#{name}.rb"
+        @partials[name] = [partial_path.read, partial_path.to_s]
+      end
+
+      glob path, ignore: %r`^(types|partials)/` do |name, schema|
+        @schemas[name] = schema
+      end
+    end
+
+    def autoload_type(name)
+      # TODO: protect from circular dependency
+      return if types.key? name
+      @import_paths.each do |import_path|
+        path = import_path + "types/#{name}.rb"
+        if path.file?
+          @types[name] = load_schema_from_path(path, name)
+          return true
+        end
+      end
+      false
+    end
+
+    def [](schema_name)
+      @schemas[schema_name.to_s]
+    end
+
+    def export(path = nil, &serializer)
+      path = Pathname(path) if path.is_a? String
+      raise 'Please specify an export directory' unless path.is_a?(Pathname) && (path.directory? || !path.exist?)
+      path.mkpath
+      @schemas.each { |name, schema| export_schema schema, path +           "#{name.to_s}.json", &serializer }
+      @types.each   { |name, schema| export_schema schema, path + 'types' + "#{name.to_s}.json", &serializer }
+    end
+
+    def uri_for(name)
+      @uri_formatter.call root, name
+    end
+
+    def uri_format(&block)
+      @uri_formatter = block
+    end
+
+    private
+
+    def glob(base_path, only: '.', ignore: nil, &block)
+      lookup_path = base_path + only
+      Dir[lookup_path + '**/*.rb'].each do |full_path|
+        full_path = Pathname(full_path)
+        relative_path = full_path.relative_path_from(lookup_path)
+        next if ignore === relative_path.to_s
+        args = [relative_path.to_s[0..-4]]
+        args << load_schema_from_path(full_path, full_path.relative_path_from(base_path).to_s[0..-4]) if block.arity == 2
+        yield *args
+      end
+    end
+
+    def load_schema_from_path(path, name)
+      @schema_name = name
+      instance_eval(path.read, path.to_s).schema.tap do |schema|
+        schema.name = name.to_s
+        JSON::Validator.add_schema JSON::Schema.new(schema.to_h, nil)
+      end
+    end
+
+    def export_schema(schema, target_path)
+      target_path.parent.mkpath
+      target_path.write block_given? ? yield(schema.to_h) : JSON.pretty_generate(schema.to_h)
+    end
+
+    SchemaCreation.apply_to self
+
+  end
+end