json_schema_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9995f6fcf61ca7baf31825818a209be42acc8e9e
+  data.tar.gz: 5a00820d204b5034efbd8fbbf55ae08f87cbd70f
+SHA512:
+  metadata.gz: 5c75a0b8c7285302b9b567b9a687ec73bcef6d9679a06ff2995d93a8fc3455ce1c6f2ea0b43d7d15a7069f78515c4bfdfefe7f9d50cbee59a5a0a0ff53457b06
+  data.tar.gz: 77289c86271e435e5cec7fecdb31a9342e2da82f852362190a2134a8f9407359604f6810fc5f407ee178593301559a2615b3af4f3245a0365fc463528a4afa5a

data/.editorconfig

@@ -0,0 +1,16 @@
+# EditorConfig file
+# http://editorconfig.org/
+
+root = true
+
+[*]
+end_of_line = lf
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+indent_size = 4
+trim_trailing_whitespace = false

data/.gitignore

@@ -0,0 +1,11 @@
+.bundle/
+log/*.log
+rdoc/
+pkg/
+spec/dummy_apps/*/db/*.sqlite3
+spec/dummy_apps/*/db/*.sqlite3-journal
+spec/dummy_apps/*/log/*.log
+spec/dummy_apps/*/tmp/
+spec/dummy_apps/*/.sass-cache
+vendor/
+Gemfile.lock

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Declare your gem's dependencies in json_schema_rails.gemspec.
+# Bundler will treat runtime dependencies like base dependencies, and
+# development dependencies will be added by default to the :development group.
+gemspec
+
+# Declare any dependencies that are still in development here instead of in
+# your gemspec. These might include edge Rails or gems from your path or
+# Git. Remember to move these dependencies to your gemspec before releasing
+# your gem to rubygems.org.
+
+# To use debugger
+# gem 'debugger'

data/Guardfile

@@ -0,0 +1,7 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  watch(%r{^spec/dummy/app/controllers/(.+_controller)\.rb$}) { |m| "spec/dummy/spec/controllers/#{m[1]}_spec.rb" }
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# json_schema_rails
+
+[JSON Schema v4](http://json-schema.org/) validator and generator for Rails 3+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'json_schema_rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install json_schema_rails
+
+## Usage
+
+### Generate schema file
+
+You can use generators to generate schema files for your controller.
+
+    $ rails g schema:controller posts create update
+
+It creates schema files at:
+
+* app/schemas/posts/create.yml
+* app/schemas/posts/update.yml
+
+You can also generate a schema for specific action with some parameters.
+
+    $ rails g schema:action posts::create title body:required published:boolean:required
+
+It creates a schema file at:
+
+* app/schemas/posts/create.yml
+
+And it has title, body and published as parameters.
+
+### Validate request parameters
+
+You can validate request parameters with helper method `validate_schema` (which is before_filter):
+
+```ruby
+class PostsController < ApplicationController
+  # Validate requests for all actions in this controller
+  validate_schema
+
+  def create
+  end
+
+  def update
+  end
+end
+```
+
+You can use options for `before_filter` if you want stop validation for specific actions:
+
+```ruby
+validate_schema excpet: :get
+validate_schema only: [:create, :update]
+```
+
+If you want to specify a schema file to use, you can use `validate_schema` or `validate_schema!` in action methods:
+
+```ruby
+class PostsController < ApplicationController
+  def create
+    validate_schema! "my_schema"   # uses "app/schemas/my_schema.{yml,yaml,json}"
+  end
+end
+```
+
+`validate_schema!` raises `JsonSchemaRails::ValidationError` when the validation failed.
+
+`validate_schema` just returns `true` or `false` as the validation result.
+
+### Error handling
+
+When validation fails, it raises `JsonSchemaRails::ValidationError` which is handled by `schema_validation_failed` method of controllers.
+
+The default handler re-raises the error in development, and renders 400 response (Bad Request) in any other env.
+
+If you want to handle errors by yourself, just define `schema_validation_failed` method to your ApplicationController:
+
+```ruby
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+
+  def schema_validation_failed(exception)
+    # Do It Yourself
+  end
+end
+```
+
+### Validate schema files
+
+json_schema_rails provides a rake task `schema:check` to validate your schema files.
+
+    $ bundle exec rake schema:check
+
+By default, it uses the strict schema which does not allow you to define unknown properties so that misspelling is checked.
+
+If you want to use official schemas which is more loose, pass `LOOSE=1` to rake command.
+
+    $ LOOSE=1 bundle exec rake schema:check
+
+## TODO
+
+* Hook generators like controller or resource to generate schema files as well
+* Write about hyper schema support
+
+## Contributing
+
+1. Fork it ( https://github.com/kotas/json_schema_rails/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'JsonSchemaRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/json_schema_rails.gemspec

@@ -0,0 +1,29 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "json_schema_rails/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "json_schema_rails"
+  s.version     = JsonSchemaRails::VERSION
+  s.authors     = ["Kota Saito"]
+  s.email       = ["kotas@kotas.jp"]
+  s.homepage    = "https://github.com/kotas/json_schema_rails"
+  s.summary     = "JSON schema validation for Rails"
+  s.license     = "MIT"
+
+  s.files       = `git ls-files`.split($\)
+  s.test_files  = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_runtime_dependency "activesupport", [">= 3.0", "< 4.2"]
+  s.add_runtime_dependency "actionpack",    [">= 3.0", "< 4.2"]
+  s.add_runtime_dependency "railties",      [">= 3.0", "< 4.2"]
+  s.add_runtime_dependency "json_schema",   "~> 0.1.4"
+
+  s.add_development_dependency "rails",     [">= 3.0", "< 4.2"]
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "guard-rspec"
+end

data/lib/generators/schema/action/USAGE

@@ -0,0 +1,22 @@
+Description:
+  Generates a new JSON Schema file for signle action.
+
+  See http://json-schema.org/ for JSON Schema syntax.
+
+Example:
+
+  rails generate schema:action posts::create title body:required published:boolean:required
+
+  This will create:
+    app/schemas/posts/create.yml
+      (with title, body and published properties)
+
+  Valid types are:
+    - array
+    - boolean
+    - integer
+    - number
+    - null
+    - object
+    - string (default)
+

data/lib/generators/schema/action/action_generator.rb

@@ -0,0 +1,52 @@
+module Schema
+  module Generators
+    class ActionGenerator < Rails::Generators::NamedBase
+      argument :parameters, type: :array, default: [], banner: "param[:type][:required] param[:type][:required]"
+      source_root File.expand_path("../templates", __FILE__)
+
+      def initialize(args, *options)
+        super
+        parse_parameters!
+      end
+
+      def create_schema_file
+        template "schema.yml.erb", File.join("app/schemas", class_path, "#{file_name}.yml")
+      end
+
+      protected
+
+      def schema_title
+        "#{human_name} #{class_path.map(&:singularize).join(' ').titleize}"
+      end
+
+      def parse_parameters!
+        self.parameters = parameters.map do |param|
+          name, *options = param.split(':')
+          options = options.map(&:to_sym) if options
+          Parameter.new(name, options)
+        end
+      end
+
+      def required_parameters
+        parameters.select(&:required?)
+      end
+
+      class Parameter
+        attr_reader :name, :type
+        alias_method :to_s, :name
+
+        def initialize(name, options)
+          @name = name
+
+          options ||= []
+          @required = !!options.delete(:required)
+          @type     = options.shift || :string
+        end
+
+        def required?
+          @required
+        end
+      end
+    end
+  end
+end

data/lib/generators/schema/action/templates/schema.yml.erb

@@ -0,0 +1,31 @@
+---
+"$schema": "http://json-schema.org/draft-04/schema#"
+title: <%= schema_title %>
+type: object
+properties:
+  <%= file_name %>:
+    type: object
+  <%- if parameters.empty? -%>
+    required:
+      # - param1
+      # - param2
+    properties:
+      # param1:
+      #   type: string
+      # param2:
+      #   type: string
+  <%- else -%>
+    required:
+    <%- parameters.each do |param| -%>
+      <%- if param.required? -%>
+      - <%= param %>
+      <%- else -%>
+      # - <%= param %>
+      <%- end -%>
+    <%- end -%>
+    properties:
+    <%- parameters.each do |param| -%>
+      <%= param %>:
+        type: <%= param.type %>
+    <%- end -%>
+  <%- end -%>

data/lib/generators/schema/controller/USAGE

@@ -0,0 +1,13 @@
+Description:
+  Generates new JSON Schema files for controller.
+
+  See http://json-schema.org/ for JSON Schema syntax.
+
+Example:
+
+  rails generate schema:controller posts create update
+
+  This will create:
+    app/schemas/posts/create.yml
+    app/schemas/posts/update.yml
+

data/lib/generators/schema/controller/controller_generator.rb

@@ -0,0 +1,27 @@
+module Schema
+  module Generators
+    class ControllerGenerator < Rails::Generators::NamedBase
+      argument :actions, type: :array, banner: "action action"
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_schema_files
+        actions.each do |act|
+          self.action_name = act.to_s.underscore
+          template "schema.yml.erb", File.join("app/schemas", class_path, file_name, "#{action_name}.yml")
+        end
+      end
+
+      protected
+
+      attr_accessor :action_name
+
+      def model_name
+        file_name.singularize
+      end
+
+      def schema_title
+        "#{action_name.to_s.humanize} #{model_name.titleize}"
+      end
+    end
+  end
+end

data/lib/generators/schema/controller/templates/schema.yml.erb

@@ -0,0 +1,7 @@
+---
+"$schema": "http://json-schema.org/draft-04/schema#"
+title: <%= schema_title %>
+type: object
+properties:
+  <%= model_name %>:
+    type: object

data/lib/json_schema_rails/errors.rb

@@ -0,0 +1,44 @@
+module JsonSchemaRails
+  class Error < StandardError; end
+
+  class SchemaNotFound < Error
+    def initialize(message = nil)
+      super(message || 'No such schema')
+    end
+  end
+
+  class SchemaParseError < Error
+    attr_reader :schema
+
+    def initialize(message, schema = nil)
+      super(message)
+      @schema = schema
+    end
+  end
+
+  class ValidationError < Error
+    attr_reader :schema
+    attr_reader :errors
+
+    def initialize(message, schema = nil, errors = nil)
+      super(message)
+      @schema = schema
+      @errors = errors
+    end
+
+    def self.from_errors(errors, schema = nil, schema_name = nil)
+      message = "Validation error"
+      message << " for schema #{schema_name}" if schema_name
+
+      errors.each do |err|
+        if err.is_a?(JsonSchema::ValidationError)
+          message << "\n- #{err.pointer}: failed schema #{err.schema.pointer}: #{err.message}"
+        else
+          message << "\n- #{err.schema.pointer}: #{err.message}"
+        end
+      end
+
+      new(message, schema, errors)
+    end
+  end
+end

data/lib/json_schema_rails/helpers.rb

@@ -0,0 +1,38 @@
+module JsonSchemaRails
+  module Helpers
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from JsonSchemaRails::ValidationError, with: :schema_validation_failed
+    end
+
+    module ClassMethods
+      def validate_schema(options = {})
+        before_filter :validate_schema!, options
+      end
+    end
+
+    def validate_schema(schema_name = nil)
+      validate_schema!(schema_name)
+    rescue JsonSchemaRails::ValidationError
+      false
+    end
+
+    def validate_schema!(schema_name = nil)
+      schema_name ||= [
+        "#{controller_path}/#{action_name}",
+        "#{request.method}#{request.path}"
+      ]
+      ::JsonSchemaRails.validate!(schema_name, params)
+      true
+    end
+
+    def schema_validation_failed(exception = nil)
+      if exception
+        raise exception if Rails.env.development?
+        logger.debug exception.message
+      end
+      render nothing: true, status: 400
+    end
+  end
+end

data/lib/json_schema_rails/loaders/base.rb

@@ -0,0 +1,72 @@
+require "erb"
+require "json"
+require "yaml"
+require "json_schema"
+
+module JsonSchemaRails
+  module Loaders
+    class Base
+      attr_writer :cache
+
+      def initialize(options = {})
+        @cache = options.fetch(:cache) { true }
+      end
+
+      def cache?
+        !!@cache
+      end
+
+      def clear
+        cache_data.clear
+      end
+
+      def load_schema(schema_path)
+        load_schema!(schema_path)
+      rescue SchemaNotFound
+        nil
+      end
+
+      def load_schema!(schema_path)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def with_cache(name)
+        if cache?
+          cache_data.fetch(name) { cache_data[name] = yield }
+        else
+          yield
+        end
+      end
+
+      def cache_data
+        @cache_data ||= {}
+      end
+
+      def load_schema_file(file_path)
+        JsonSchema.parse!(load_schema_content(file_path))
+      rescue JsonSchema::SchemaError => e
+        raise SchemaParseError.new(e.mssage, e.schema)
+      end
+
+      def load_schema_content(file_path)
+        contents = ERB.new(IO.read(file_path)).result
+        case File.extname(file_path)
+        when '.json'
+          JSON.load(contents)
+        when '.yaml', '.yml'
+          YAML.load(contents)
+        else
+          raise ArgumentError, "Unknown schema file type"
+        end
+      rescue Errno::ENOENT
+        raise SchemaNotFound
+      rescue JSON::ParserError => e
+        raise SchemaParseError, "Failed to parse schema: #{e.message}"
+      rescue YAML::SyntaxError => e
+        raise SchemaParseError, "Failed to parse schema: #{e.message}"
+      end
+    end
+  end
+end

data/lib/json_schema_rails/loaders/directory.rb

@@ -0,0 +1,39 @@
+module JsonSchemaRails
+  module Loaders
+    class Directory < Base
+      attr_accessor :path, :extnames
+
+      def initialize(path, options = {})
+        @path     = path
+        @extnames = options.delete(:extnames) { %w(.yml .yaml .json) }
+        super(options)
+      end
+
+      def load_schema!(schema_path)
+        with_cache(schema_path) do
+          file_path = lookup_schema_file(schema_path) or raise SchemaNotFound
+          load_schema_file(file_path)
+        end
+      end
+
+      protected
+
+      def lookup_schema_file(schema_path)
+        # Protection from directory traversal attack
+        raise ArgumentError, "Invalid schema path" unless schema_path =~ /\A[\/a-zA-Z0-9_-]+\z/
+
+        base_path = File.join(@path, schema_path)
+        Dir.glob("#{base_path}#{extnames_glob}", File::FNM_NOESCAPE).first
+      end
+
+      def extnames_glob
+        if @extnames.respond_to?(:join)
+          glob = @extnames.join(',')
+          @extnames.size > 1 ? "{#{glob}}" : glob
+        else
+          @extnames.to_s
+        end
+      end
+    end
+  end
+end

data/lib/json_schema_rails/loaders/hyper_schema.rb

@@ -0,0 +1,68 @@
+module JsonSchemaRails
+  module Loaders
+    class HyperSchema < Base
+      attr_accessor :path
+
+      def initialize(path, options = {})
+        @path = path
+        super(options)
+      end
+
+      def load_schema!(schema_path)
+        with_cache(schema_path) do
+          schema_index.find(schema_path) or raise SchemaNotFound
+        end
+      end
+
+      protected
+
+      def schema_index
+        with_cache(:_schema_index) do
+          schema = load_schema_file(@path).tap(&:expand_references!)
+          SchemaIndex.new(schema)
+        end
+      end
+
+      class SchemaIndex
+        def initialize(schema)
+          @index = { _schema: schema }
+          build(schema)
+        end
+
+        def build(schema)
+          schema.links.each do |link|
+            if link.href
+              keys = index_keys("#{link.method || 'GET'}/#{link.href}", true)
+              tail = keys.reduce(@index) { |hash, key| hash[key] ||= {} }
+              tail[:_schema] = schema
+            end
+          end
+          schema.properties.each do |key, subschema|
+            build(subschema)
+          end
+        end
+
+        def find(schema_path)
+          keys = index_keys(schema_path, false)
+          tail = keys.reduce(@index) do |hash, key|
+            if hash.key?(key)
+              hash[key]
+            else
+              next_key = hash.keys.find { |k| k === key } or break
+              hash[next_key]
+            end
+          end
+          tail[:_schema] if tail
+        end
+
+        private
+
+        def index_keys(path, for_build)
+          keys = path.to_s.downcase.split('/').reject(&:empty?)
+          keys.map! { |k| k.gsub!(/\{(.*?)\}/, '[^/]+') ? %r/^#{k}$/ : k } if for_build
+          keys
+        end
+      end
+    end
+  end
+end

data/lib/json_schema_rails/loaders.rb

@@ -0,0 +1,7 @@
+module JsonSchemaRails
+  module Loaders
+    autoload :Base,        'json_schema_rails/loaders/base'
+    autoload :Directory,   'json_schema_rails/loaders/directory'
+    autoload :HyperSchema, 'json_schema_rails/loaders/hyper_schema'
+  end
+end