fluent-json-schema 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a122c3fe665ecb302dcd67b23de5d242ce770250
+  data.tar.gz: ed099de46423b3ba3863b8c51d8a8f1aeb239a1e
+SHA512:
+  metadata.gz: aada2447b24bf48763e98d789b0fe032084f91e582e51acc62a735cfbe25b9ced88a4737d9a350bcb034df1e47c72465f9912c7383229fe3f79adc26432a2813
+  data.tar.gz: 24a37bf30e536f2f2e25319059a17a9762b4d1ff084f2eb2f8da7f196322641064fd7619547700b22c1b9a4137da14d76930947f017a826bb8be02baac68d1b7

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fluent-json-schema.gemspec
+gemspec
+
+gem 'activesupport'
+gem 'activerecord'
+gem 'sqlite3'
+
+gem 'flexcon'
+gem 'fluent-api'
+
+

data/README.md

@@ -0,0 +1,178 @@
+# Fluent::Json::Schema
+
+Build [json schemas](https://json-schema.org/) fluently.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fluent-json-schema', git: 'https://github.com/rcpedro/fluent-json-schema.git'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fluent-json-schema
+
+## Usage
+
+### Basic Usage
+
+Given:
+
+```ruby
+basic = Fluent::Json::Schema::Terms::Obj.new(:user)
+basic
+  .req
+    .strs(:first_name, :last_name, :username, :contact_no, :email, status: { enum: ["active", "inactive"]})
+    .bools(:super)
+    .dates(:created_at, :updated_at)
+  .opt
+    .strs(:created_by, :updated_by)
+```
+
+Calling `as_json` would give the following result:
+
+```ruby
+{
+  type: :object,
+  additionalProperties: false,
+  required: [
+    :first_name, :last_name, :username, :contact_no, :email, 
+    :status, :super, :created_at, :updated_at
+  ],
+  properties: {
+    first_name: { type: :string },
+    last_name:  { type: :string },
+    email:      { type: :string },
+    username:   { type: :string },
+    contact_no: { type: :string },
+    status:     { type: :string, enum: ["active", "inactive"] },
+    super:      { type: :boolean },
+    created_at: { type: :string, format: 'date-time' },
+    updated_at: { type: :string, format: 'date-time' },
+    created_by: { type: :string },
+    updated_by: { type: :string }
+  }
+}
+```
+
+### Nested Objects
+
+Given:
+
+```ruby
+home = Fluent::Json::Schema::Terms::Obj.new(:home)
+
+home
+  .req
+    .obj(:address) { |address|
+      address
+        .req.strs(:city, :country)
+        .opt.strs(:name, :street)
+    }
+    .obj(:owner) { |owner|
+      owner
+        .req.str(:first_name, :last_name, email: { fmt: :email }) 
+        .opt.strs(:title, :contact_no)
+    }
+  .opt
+    .date(:date_built)
+```
+
+Calling `as_json` would give the following result:
+
+```ruby
+{
+  type: :object,
+  additionalProperties: false,
+  required: [
+    :address, :owner
+  ],
+  properties: {
+    address: {
+      type: :object,
+      additionalProperties: false,
+      required: [:city, :country],
+      properties: {
+        city:    { type: :string },
+        country: { type: :string },
+        name:    { type: :string },
+        street:  { type: :string }
+      }
+    },
+    owner: {
+      type: :object,
+      additionalProperties: false,
+      required: [:first_name, :last_name, :email],
+      properties: {
+        email:      { type: :string, format: :email },
+        title:      { type: :string },
+        first_name: { type: :string },
+        last_name:  { type: :string },
+        contact_no: { type: :string }
+      }
+    },
+    date_built: {
+      type: :string,
+      format: :'date-time'
+    }
+  }
+}
+```
+
+### With Active Record
+
+Given:
+
+```ruby
+user = Fluent::Json::Schema::Terms::Obj.new(:user)
+user.lookup(User)
+    .reflect(
+      :first_name, :last_name, :email, :username, :contact_no,
+      :super, :status, :created_by, :updated_by, :created_at,
+      :updated_at
+    )
+```
+
+Calling `as_json` would give the following result:
+
+```ruby
+{
+  type: :object,
+  additionalProperties: false,
+  required: [
+    :first_name, :last_name, :email, :username, :super, :status, 
+    :created_by, :updated_by, :created_at, :updated_at
+  ],
+
+  properties: {
+    first_name: { type: :string },
+    last_name:  { type: :string },
+    email:      { type: :string },
+    username:   { type: :string },
+    contact_no: { type: :string },
+    super:      { type: :boolean },
+    status:     { type: :string, enum: ["active", "inactive"] },
+    created_by: { type: :string },
+    updated_by: { type: :string },
+    created_at: { type: :string, format: 'date-time' },
+    updated_at: { type: :string, format: 'date-time' }
+  }
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/fluent-json-schema.
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fluent/json/schema"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fluent-json-schema.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fluent/json/schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fluent-json-schema"
+  spec.version       = Fluent::Json::Schema::VERSION
+  spec.authors       = ["Rodette Pedro"]
+  spec.email         = ["rodettecpedro@gmail.com"]
+
+  spec.summary       = 'Build JSON Schemas Fluently'
+  spec.description   = 'Build JSON Schemas using a fluent API.'
+  spec.homepage      = 'https://github.com/rcpedro/fluent-json-schema'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/fluent/json/schema.rb

@@ -0,0 +1,18 @@
+require 'fluent'
+require 'fluent/json/schema/version'
+require 'fluent/json/schema/terms/bool'
+require 'fluent/json/schema/terms/date'
+require 'fluent/json/schema/terms/field'
+require 'fluent/json/schema/terms/fk'
+require 'fluent/json/schema/terms/int'
+require 'fluent/json/schema/terms/num'
+require 'fluent/json/schema/terms/reflect'
+require 'fluent/json/schema/terms/obj'
+
+module Fluent
+  module Json
+    module Schema
+      # Your code goes here...
+    end
+  end
+end

data/lib/fluent/json/schema/lexicon.rb

@@ -0,0 +1,47 @@
+require 'singleton'
+
+
+module Fluent
+  module Json
+    module Schema
+      class Lexicon
+        include Singleton
+
+        def dictionary
+          Fluent::Lexicon.reflect(Fluent::Json::Schema::Terms)
+        end
+
+        def translator
+          lambda do |term|
+            term.to_s.singularize.to_sym
+          end
+        end
+
+        def combiner
+          named = lambda do |definition, name| 
+            definition.new(name) 
+          end
+
+          optioned = lambda do |definition, name, options| 
+            definition.new(name, options) 
+          end
+
+          lambda do |api, term, definition, args, block|
+            if definition.class.name.demodulize.downcase.to_sym == term
+              return api.add(definition.new(*args))
+            end
+
+            results = Fluent::Lexicon.collect(
+              named.curry.(definition), 
+              optioned.curry.(definition)
+            ).call(*args)
+
+            block.call(*results) if block.present?
+            return api.add(*results)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/fluent/json/schema/terms.rb

@@ -0,0 +1,9 @@
+module Fluent
+  module Json
+    module Schema
+      module Terms
+      end
+    end
+  end
+end
+

data/lib/fluent/json/schema/terms/bool.rb

@@ -0,0 +1,9 @@
+require 'fluent/json/schema/terms/field'
+
+
+class Fluent::Json::Schema::Terms::Bool < Fluent::Json::Schema::Terms::Field
+  
+  def as_json
+    super({ type: :boolean })
+  end
+end

data/lib/fluent/json/schema/terms/date.rb

@@ -0,0 +1,14 @@
+require 'fluent/json/schema/terms/str'
+
+
+class Fluent::Json::Schema::Terms::Date < Fluent::Json::Schema::Terms::Str
+  
+  def initialize(name)
+    super(name)
+    self.datetime
+  end
+
+  def format
+    return :'date-time'
+  end
+end

data/lib/fluent/json/schema/terms/field.rb

@@ -0,0 +1,46 @@
+require 'fluent/json/schema/terms'
+
+
+class Fluent::Json::Schema::Terms::Field
+  
+  attr_reader :version, :name, :required, :enum, :default, :constraints
+
+  def initialize(name, options={})
+    @name = name
+    @required = options[:required]
+    @constraints = []
+
+    self.set(options)
+  end
+
+  def mandate
+    @required = true
+    return self
+  end
+
+  def optionalise
+    @required = false
+    return self
+  end
+
+  def set(options={})
+    @enum = options[:enum]
+    @default = options[:default]
+  end
+
+  def as_json(options={})
+    return options.merge(self.as_json_fragment(:default, :enum))
+  end
+
+  protected
+    def as_json_fragment(*names)
+      result = {}
+
+      names.each do |name|
+        value = self.send(name)
+        result[name] = value if value.present?
+      end
+
+      return result
+    end
+end

data/lib/fluent/json/schema/terms/fk.rb

@@ -0,0 +1,9 @@
+require 'fluent/json/schema/terms/field'
+
+
+class Fluent::Json::Schema::Terms::Fk < Fluent::Json::Schema::Terms::Field
+
+  def as_json
+    super({ type: :int })
+  end
+end

data/lib/fluent/json/schema/terms/int.rb

@@ -0,0 +1,9 @@
+require 'fluent/json/schema/terms/num'
+
+
+class Fluent::Json::Schema::Terms::Int < Fluent::Json::Schema::Terms::Num
+  
+  def initialize(name)
+    super(name, :integer)
+  end
+end

data/lib/fluent/json/schema/terms/num.rb

@@ -0,0 +1,35 @@
+require 'fluent/json/schema/terms/field'
+
+
+class Fluent::Json::Schema::Terms::Num < Fluent::Json::Schema::Terms::Field
+
+  attr_reader :type, :minimum, :maximum, :exclusive_minimum, :exclusive_maximum, :multiple_of
+
+  def initialize(name, type=:number)
+    super(name)
+    @type = type
+  end
+
+  def set(options={})
+    super(options)
+    @minimum ||= options[:min]
+    @maximum ||= options[:max]
+    
+    if not options[:exclusive].nil?
+      @exclusive_minimum = options[:exclusive].include?(:min)
+      @exclusive_maximum = options[:exclusive].include?(:max)
+    end
+
+    @multiple_of ||= options[:mult]
+    return self
+  end
+
+  def as_json
+    super({ type: @type }).merge!(
+      self.as_json_fragment(
+        :minimum, :minimum, :maximum, :exclusive_minimum, 
+        :exclusive_maximum, :multiple_of
+      )
+    )
+  end
+end

data/lib/fluent/json/schema/terms/obj.rb

@@ -0,0 +1,95 @@
+require 'fluent/json/schema/terms'
+require 'fluent/json/schema/lexicon'
+require 'fluent/json/schema/terms/field'
+
+
+class Fluent::Json::Schema::Terms::Obj < Fluent::Json::Schema::Terms::Field
+  include Fluent
+
+  lexicon Fluent::Json::Schema::Lexicon.instance
+
+  attr_reader :name, :fields, :klass, :additional
+
+  def initialize(name, options={})
+    super(name, options)
+    @fields = {}
+    @additional ||= false
+    @mode = :optional
+  end
+
+  def req
+    @mode = :req 
+    return self
+  end
+
+  def opt
+    @mode = :opt 
+    return self
+  end
+
+  def add(*fields)
+    fields.each do |field|
+      @fields[field.name] = self.prepare(field)
+    end
+    return self
+  end
+
+  def [](prop)
+    return @fields[prop]
+  end
+
+  def open(allowed=nil)
+    @additional = allowed if allowed.present?
+    @additional ||= true
+    return self
+  end
+
+  def strict
+    @additional = false
+    return self
+  end
+
+  def lookup(klass)
+    @name ||= klass.table_name.to_sym
+    @klass = klass
+    return self
+  end
+
+  def reflect(*props)
+    raise 'No lookup defined' if @klass.nil?
+    
+    @mode = nil
+    props.each { |prop| @fields[prop] = Fluent::Json::Schema::Terms::Reflect.new(prop, @klass) }
+    return self
+  end
+
+  def requirements
+    return @fields.map { |k, field| field if field.required }.compact
+    return []
+  end
+
+  def as_json
+    fragment = super.merge!({
+      type: :object,
+      additionalProperties: @additional,
+      required: self.requirements.map { |r| r.name },
+      properties: {}
+    })
+
+    @fields.map { |k, v| fragment[:properties][k] = v.as_json }
+
+    return fragment
+  end
+
+  protected
+    def prepare(field)
+      case @mode
+      when :req
+        return field.mandate
+      when :opt
+        return field.optionalise
+      end
+      
+      return field
+    end
+end

data/lib/fluent/json/schema/terms/reflect.rb

@@ -0,0 +1,37 @@
+require 'fluent/json/schema/terms'
+
+
+class Fluent::Json::Schema::Terms::Reflect < SimpleDelegator
+
+  MAPPINGS = {
+    string:   Fluent::Json::Schema::Terms::Str,
+    datetime: Fluent::Json::Schema::Terms::Date,
+    date:     Fluent::Json::Schema::Terms::Date,
+    time:     Fluent::Json::Schema::Terms::Date,
+    integer:  Fluent::Json::Schema::Terms::Int,
+    decimal:  Fluent::Json::Schema::Terms::Num,
+    boolean:  Fluent::Json::Schema::Terms::Bool
+  }
+
+  attr_reader :klass, :instance
+
+  def initialize(name, klass)
+    @klass = klass
+    # TODO, fk
+    
+    column = klass.columns_hash[name.to_s]
+    raise "Column with name '#{name}' not found in '#{klass.name}'" if column.nil?
+
+    enum = klass.defined_enums[name.to_s]
+    instance_klass = MAPPINGS[column.type.to_sym]
+    instance_klass = MAPPINGS[:string] if enum.present? and enum.keys[0].is_a?(String)
+
+    raise "Unsupported type '#{column.type}' for '#{name}'" if instance_klass.nil?
+    
+    @instance = instance_klass.new(name)
+    @instance.set(enum: enum.keys) if enum.present?
+    @instance.mandate if not column.null
+
+    super(@instance)
+  end
+end

data/lib/fluent/json/schema/terms/str.rb

@@ -0,0 +1,37 @@
+require 'fluent/json/schema/terms/field'
+
+
+class Fluent::Json::Schema::Terms::Str < Fluent::Json::Schema::Terms::Field
+  attr_reader :format, :pattern, :min_length, :max_length
+
+  def initialize(name, options={})
+    super(name, options)
+  end
+
+  def set(options={})
+    super(options)
+    @min_length ||= options[:min]
+    @max_length ||= options[:max]
+    @format ||= options[:fmt]
+    @pattern ||= options[:pattern]
+    return self
+  end
+
+  def datetime
+    @format = :'date-time'
+  end
+
+  def email
+    @format = :email
+  end
+
+  def uri
+    @format = :uri
+  end
+
+  def as_json
+    super({ type: :string }).merge!(
+      self.as_json_fragment(:min_length, :max_length, :format, :pattern)
+    )
+  end
+end

data/lib/fluent/json/schema/version.rb

@@ -0,0 +1,7 @@
+module Fluent
+  module Json
+    module Schema
+      VERSION = "0.1.1"
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: fluent-json-schema
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Rodette Pedro
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-09-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Build JSON Schemas using a fluent API.
+email:
+- rodettecpedro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- fluent-json-schema.gemspec
+- lib/fluent/json/schema.rb
+- lib/fluent/json/schema/lexicon.rb
+- lib/fluent/json/schema/terms.rb
+- lib/fluent/json/schema/terms/bool.rb
+- lib/fluent/json/schema/terms/date.rb
+- lib/fluent/json/schema/terms/field.rb
+- lib/fluent/json/schema/terms/fk.rb
+- lib/fluent/json/schema/terms/int.rb
+- lib/fluent/json/schema/terms/num.rb
+- lib/fluent/json/schema/terms/obj.rb
+- lib/fluent/json/schema/terms/reflect.rb
+- lib/fluent/json/schema/terms/str.rb
+- lib/fluent/json/schema/version.rb
+homepage: https://github.com/rcpedro/fluent-json-schema
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+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.5
+signing_key: 
+specification_version: 4
+summary: Build JSON Schemas Fluently
+test_files: []