jimmy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8467dcce9891fc3ea4098a9e89ec2591c58cf1df
+  data.tar.gz: 76ce29801be14c4d29e640d1820e5ea23eda0bb5
+SHA512:
+  metadata.gz: bd47a8d315ea3d3cea8f6faf37441ebb684f0fccb04d8819887bf727dfdefe7d89b810a3d3c09a37d4e2cb0cad50677476220368908da17ec690c29ac00e5d27
+  data.tar.gz: 3b66e4dde7fafab70cb5d52941a4e1d0342509634da90fc9a3f736bbe4b17e5b8d7d2678120c115f9a58dc8a68e178be91c8b382f7188f59760086fb62cd8ae6

data/.gitignore

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

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,152 @@
+# 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..5
+      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",
+            "minimum": 1,
+            "maximum": 5
+          },
+          "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,25 @@
+# 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/orionvm/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_development_dependency 'bundler', '~> 1.9'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.2'
+end

data/lib/jimmy/combination.rb

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

data/lib/jimmy/domain.rb

@@ -0,0 +1,50 @@
+require 'uri'
+require 'pathname'
+
+require_relative 'schema_creation'
+
+module Jimmy
+  class Domain
+
+    attr_reader :root, :types
+
+    def initialize(root)
+      @root = URI(root)
+      @schemas = {}
+      @types = {}
+    end
+
+    def domain
+      self
+    end
+
+    def import_path(path)
+      path = Pathname(path) unless path.is_a? Pathname
+      @types = import_schemas(path + 'types', path).map { |k, v| [k.to_sym, v] }.to_h
+      @schemas = import_schemas(path, path, 'types/')
+    end
+
+    def [](schema_name)
+      @schemas[schema_name.to_s]
+    end
+
+    private
+
+    def import_schemas(path, base_path, reject_prefix = nil)
+      result = {}
+      Dir[path + '**/*.rb'].each do |full_path|
+        full_path = Pathname(full_path)
+        relative_path = full_path.relative_path_from(path)
+        next if reject_prefix && relative_path.to_s.start_with?(reject_prefix)
+        base_name = relative_path.to_s[0..-4]
+        schema = instance_eval(full_path.read, full_path.to_s).schema
+        schema.name = full_path.relative_path_from(base_path).to_s[0..-4]
+        result[base_name] = schema
+      end
+      result
+    end
+
+    SchemaCreation.apply_to self
+
+  end
+end

data/lib/jimmy/schema.rb

@@ -0,0 +1,70 @@
+module Jimmy
+  class Schema
+
+    attr_reader :dsl, :attrs, :domain, :type
+    attr_accessor :name
+
+    @argument_handlers = Hash.new { |hash, key| hash[key] = {} }
+
+    def self.create(*args, &block)
+      new(*args).tap do |schema|
+        schema.dsl.evaluate block if block
+      end
+    end
+
+    def self.set_argument_handler(schema_class, arg_class, handler)
+      @argument_handlers[schema_class][arg_class] = handler
+    end
+
+    def self.argument_hander(schema_class, argument)
+      handlers = {}
+      until schema_class == SchemaType do
+        handlers = (@argument_handlers[schema_class] || {}).merge(handlers)
+        schema_class = schema_class.superclass
+      end
+      result = handlers.find { |k, _| argument.is_a? k }
+      result && result.last
+    end
+
+    def serialize
+      serializer = nil
+      schema_class = SchemaTypes[type]
+      until schema_class == SchemaType do
+        serializer ||= SchemaTypes.serializers[schema_class]
+        schema_class = schema_class.superclass
+      end
+      {'type' => type.to_s}.tap do |hash|
+        dsl.evaluate serializer, hash if serializer
+      end
+    end
+
+    def to_h
+      {}.tap do |hash|
+        hash['$schema'] = "#{domain.root}/#{name}#" if name
+        hash.merge! serialize
+      end
+    end
+
+    private
+
+    def initialize(type, domain, *args)
+      @attrs  = {}
+      @type   = type
+      @domain = domain
+      @dsl    = SchemaTypes.dsls[type].new(self)
+      args.each do |arg|
+        case arg
+          when Symbol
+            dsl.__send__ arg
+          when Hash
+            arg.each { |k, v| dsl.__send__ k, v }
+          else
+            handler = Schema.argument_hander(SchemaTypes[type], arg)
+            raise "`#{type}` cannot handle arguments of type #{arg.class.name}" unless handler
+            dsl.evaluate handler, arg
+        end
+      end
+    end
+
+  end
+end

data/lib/jimmy/schema_creation.rb

@@ -0,0 +1,52 @@
+module Jimmy
+  class SchemaCreation
+
+    @handlers = {}
+
+    class << self
+
+      attr_reader :handlers
+
+      def apply_to(klass, &handler)
+        @handlers[klass] = handler
+        %i(one all any).each do |condition|
+          klass.__send__ :define_method, :"#{condition}_of" do |*args, &inner_block|
+            Combination.new(condition, domain).tap do |combo|
+              combo.evaluate inner_block
+              instance_exec combo, *args, &handler
+            end
+          end
+        end
+        klass.include ResolveMissingToCustomType
+      end
+    end
+
+    module ResolveMissingToCustomType
+
+      def respond_to_missing?(method, *)
+        SchemaTypes.key?(method) || domain.types.key?(method) || super
+      end
+
+      def method_missing(method, *args, &block)
+        if SchemaTypes.key? method
+          handler = SchemaCreation.handlers[self.class]
+          self.class.__send__ :define_method, method do |*inner_args, &inner_block|
+            handler_args = handler && inner_args.shift(handler.arity - 1)
+            schema = Schema.create(method, domain, *inner_args, &inner_block)
+            instance_exec schema, *handler_args, &handler if handler
+            schema.dsl
+          end
+          return __send__ method, *args, &block
+        end
+
+        if domain.types.key? method
+          return instance_exec method, *args, &SchemaCreation.handlers[self.class]
+        end
+
+        super method, *args, &block
+      end
+
+    end
+
+  end
+end

data/lib/jimmy/schema_type.rb

@@ -0,0 +1,63 @@
+require 'forwardable'
+
+require_relative 'schema'
+
+module Jimmy
+  class SchemaType
+
+    class << self
+
+      def register!
+        SchemaTypes.register self
+      end
+
+      def trait(name_or_type, &handler)
+        case name_or_type
+          when Symbol
+            handler ||= proc { |value| attrs[name_or_type] = value }
+            self::DSL.__send__ :define_method, name_or_type, handler
+          when Class
+            Schema.set_argument_handler self, name_or_type, handler
+          else
+            raise 'Trait must be a Symbol or a Class'
+        end
+      end
+
+      def nested(&handler)
+        SchemaTypes.nested_handlers[self] = handler
+      end
+
+      def serialize(&handler)
+        SchemaTypes.serializers[self] = handler
+      end
+
+    end
+
+    class DSL
+      extend Forwardable
+
+      attr_reader :schema
+
+      delegate %i(attrs domain) => :schema
+
+      def initialize(schema)
+        @schema = schema
+      end
+
+      def evaluate(proc, *args)
+        instance_exec *args, &proc
+      end
+
+      def camelize_attrs(*args)
+        included_args = args.flatten.reject { |arg| attrs[arg].nil? }
+        included_args.map { |arg| [arg.to_s.gsub(/_([a-z])/) { $1.upcase }, attrs[arg]] }.to_h
+      end
+
+      def serialize_schema(schema)
+        schema.is_a?(Symbol) ? {'$ref' => "/types/#{schema}#"} : schema.serialize
+      end
+
+    end
+
+  end
+end

data/lib/jimmy/schema_types/array.rb

@@ -0,0 +1,29 @@
+module Jimmy
+  class SchemaTypes::Array < SchemaType
+    register!
+
+    trait :min_items
+    trait :max_items
+    trait Range do |range|
+      min, max = [range.first, range.last].sort
+      min_items min
+      max_items max
+    end
+    trait(Fixnum) { |value| min_items value; max_items value }
+
+    nested do |schema|
+      (attrs[:items] ||= []) << schema
+    end
+
+    serialize do |hash|
+      hash.merge! camelize_attrs(%i[min_items max_items])
+      items = attrs[:items] || []
+      if items.length > 1
+        hash['items'] = {'anyOf' => items.map { |i| serialize_schema i }}
+      elsif items.length == 1
+        hash['items'] = serialize_schema(items.first)
+      end
+    end
+
+  end
+end

data/lib/jimmy/schema_types/boolean.rb

@@ -0,0 +1,6 @@
+module Jimmy
+  class SchemaTypes::Boolean < SchemaType
+    register!
+
+  end
+end

data/lib/jimmy/schema_types/integer.rb

@@ -0,0 +1,8 @@
+require_relative 'number'
+
+module Jimmy
+  class SchemaTypes::Integer < SchemaTypes::Number
+    register!
+
+  end
+end

data/lib/jimmy/schema_types/null.rb

@@ -0,0 +1,6 @@
+module Jimmy
+  class SchemaTypes::Null < SchemaType
+    register!
+
+  end
+end

data/lib/jimmy/schema_types/number.rb

@@ -0,0 +1,30 @@
+module Jimmy
+  class SchemaTypes::Number < SchemaType
+    register!
+
+    trait :multiple_of
+    trait :minimum
+    trait :maximum
+    trait(:<) { |value| maximum value; attrs[:exclusive_maximum] = true; self }
+    trait(:<=) { |value| maximum value; attrs[:exclusive_maximum] = nil; self }
+    trait(:>) { |value| minimum value; attrs[:exclusive_minimum] = true; self }
+    trait(:>=) { |value| minimum value; attrs[:exclusive_minimum] = nil; self }
+    trait(Numeric) { |value| minimum value; maximum value }
+    trait(Range) do |range|
+      if range.first <= range.last
+        minimum range.first
+        maximum range.last
+        attrs[:exclusive_maximum] ||= range.exclude_end? || nil
+      else
+        minimum range.last
+        maximum range.first
+        attrs[:exclusive_minimum] ||= range.exclude_end? || nil
+      end
+    end
+
+    serialize do |hash|
+      hash.merge! camelize_attrs(%i[minimum maximum exclusive_minimum exclusive_maximum multiple_of])
+    end
+
+  end
+end

data/lib/jimmy/schema_types/object.rb

@@ -0,0 +1,42 @@
+module Jimmy
+  class SchemaTypes::Object < SchemaType
+    register!
+
+    trait :require do |*required_keys|
+      if required_keys == [0]
+        attrs[:required] = SymbolArray.new
+      else
+        attrs[:required] ||= SymbolArray.new
+        attrs[:required] |= required_keys.flatten.map(&:to_s).uniq
+      end
+    end
+
+    trait :all do
+      SymbolArray.new(attrs[:properties].keys.select { |x| x.is_a? Symbol })
+    end
+
+    trait(:none) { 0 }
+
+    trait(:allow_additional) { attrs[:additional_properties] = true }
+
+    nested do |schema, property_name|
+      (attrs[:properties] ||= {})[property_name] = schema
+    end
+
+    serialize do |hash|
+      (attrs[:properties] || {}).each do |key, value|
+        collection, key =
+            if key.is_a? Regexp
+              ['patternProperties', key.inspect.gsub(%r`^/|/[a-z]*$`, '')]
+            else
+              ['properties', key.to_s]
+            end
+        hash[collection] ||= {}
+        hash[collection][key] = serialize_schema(value)
+      end
+      hash['required'] = (attrs[:required] || []).to_a
+      hash['additionalProperties'] = !!attrs[:additional_properties]
+    end
+
+  end
+end

data/lib/jimmy/schema_types/string.rb

@@ -0,0 +1,18 @@
+module Jimmy
+  class SchemaTypes::String < SchemaType
+    register!
+
+    trait :min_length
+    trait :max_length
+    trait(:pattern) { |regex| attrs[:pattern] = regex.is_a?(Regexp) ? regex.inspect.gsub(%r`^/|/[a-z]*$`, '') : regex }
+    trait(Regexp) { |regex| pattern regex }
+    trait(Range) { |value| attrs[:min_length], attrs[:max_length] = [value.first, value.last].sort }
+    trait(Fixnum) { |value| min_length value; max_length value }
+    trait(Array) { |value| attrs[:enum] = value.map(&:to_s) }
+
+    serialize do |hash|
+      hash.merge! camelize_attrs(%i[min_length max_length pattern enum])
+    end
+
+  end
+end

data/lib/jimmy/schema_types.rb

@@ -0,0 +1,42 @@
+require 'forwardable'
+
+require_relative 'schema_type'
+require_relative 'schema_creation'
+
+module Jimmy
+  module SchemaTypes
+
+    @types = {}
+    @dsls = {}
+    @nested_handlers = {}
+    @serializers = {}
+
+    class << self
+      extend Forwardable
+
+      delegate %i[each keys values key?] => :@types
+
+      attr_reader :dsls, :nested_handlers, :serializers
+
+      def [](type_name)
+        @types[type_name]
+      end
+
+      def register(type_class)
+        type_name = type_class.name[/\w+$/].downcase.to_sym
+        dsl_class = Class.new(type_class.superclass::DSL)
+        type_class.const_set :DSL, dsl_class
+        @dsls[type_name] = dsl_class
+        @types[type_name] = type_class
+      end
+
+    end
+
+    Dir[ROOT + 'lib/jimmy/schema_types/*.rb'].each do |path|
+      require path
+    end
+
+    nested_handlers.each { |klass, handler| SchemaCreation.apply_to klass::DSL, &handler }
+
+  end
+end

data/lib/jimmy/symbol_array.rb

@@ -0,0 +1,17 @@
+module Jimmy
+  class SymbolArray < Array
+
+    def initialize(*args)
+      super args.flatten.map(&:to_s)
+    end
+
+    %i(<< push unshift).each do |method|
+      define_method(method) { |*args| super *args.map(&:to_s) }
+    end
+
+    %i(+ - | &).each do |method|
+      define_method(method) { |*args| SymbolArray.new(super args.flatten.map(&:to_s)) }
+    end
+
+  end
+end

data/lib/jimmy/version.rb

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

data/lib/jimmy.rb

@@ -0,0 +1,15 @@
+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/schema_creation'
+require_relative 'jimmy/schema_types'
+require_relative 'jimmy/schema_type'
+require_relative 'jimmy/combination'

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: jimmy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Neil E. Pearson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Jimmy makes it a snap to compose detailed JSON schema documents.
+email:
+- neil.pearson@orionvm.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- circle.yml
+- jimmy.gemspec
+- lib/jimmy.rb
+- lib/jimmy/combination.rb
+- lib/jimmy/domain.rb
+- lib/jimmy/schema.rb
+- lib/jimmy/schema_creation.rb
+- lib/jimmy/schema_type.rb
+- lib/jimmy/schema_types.rb
+- lib/jimmy/schema_types/array.rb
+- lib/jimmy/schema_types/boolean.rb
+- lib/jimmy/schema_types/integer.rb
+- lib/jimmy/schema_types/null.rb
+- lib/jimmy/schema_types/number.rb
+- lib/jimmy/schema_types/object.rb
+- lib/jimmy/schema_types/string.rb
+- lib/jimmy/symbol_array.rb
+- lib/jimmy/version.rb
+homepage: https://github.com/orionvm/jimmy
+licenses:
+- Apache License, Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Jimmy the JSON Schema DSL
+test_files: []