json_schema_tools 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+.rvmrc
+coverage
+rdoc/*
+pkg/*
+.DS_Store
+Gemfile.lock
+.yardoc
+doc/
+tmp/
+*.*~

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.md

@@ -0,0 +1,73 @@
+# JSON Schema Tools
+
+{<img src="https://secure.travis-ci.org/salesking/json_schema_tools.png?branch=master" alt="Build Status" />}[http://travis-ci.org/salesking/json_schema_tools]
+
+Set of tools to help working with JSON Schemata:
+
+* read schema files into a ruby hash
+* add schema properties to a class
+* convert a model(class instance) into it's schema markup
+* clean parameters according to a schema (e.g. in an api controller)
+
+
+## Usage
+
+Hook the gem into your app
+
+    gem 'json_schema_tools'
+
+### Read Schema
+
+Before the fun begins with any of the tools one or multiple JSON schema files
+must be read(into a hash). So first provide a base path where the .json files
+can be found:
+
+    SchemaTools.schema_path = '/path/to/schema-json-files'
+
+No you can read a single or multiple schemas:
+
+    schema = SchemaTools::Reader.read :client
+    # read all *.json files in schema path
+    schemata = SchemaTools::Reader.read_all
+    # see schema cached in registry
+    SchemaTools::Reader.registry[:client]
+
+Read files from another path?
+
+    schema = SchemaTools::Reader.read :client, 'my/path/to/json-files'
+    schemata = SchemaTools::Reader.read_all 'my/path/to/json-files'
+
+Don't like the global path and registry? Go local:
+
+    reader = SchemaTools::Reader.new
+    reader.read :client, 'from/path'
+    reader.registry
+
+
+## Object to schema markup
+
+A schema provides a (public) contract about an object definition. It is
+therefore a common task to convert an internal object to its schema version.
+Before the object can be represented as a json string, it is converted to a
+hash containing only the properties(keys) from its schema definition:
+
+Following uses client.json schema(same as client.class name) from global
+schema_path and adds properties to the clients_hash simply calling
+client.send('property-name'):
+
+  peter = Client.new name: 'Peter'
+  client_hash = SchemaTools::Hash.from_schema(peter)
+  # to_json is up to you .. or your rails controller
+
+TODO: explain Options for parsing:
+* custom class name
+* fields include/exclude
+* custom schema name
+
+## Test
+
+  bundle install
+  bundle exec rake spec
+
+
+Copyright 2012-1013, Georg Leciejewski, MIT License

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/json_schema_tools.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'schema_tools/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'json_schema_tools'
+  s.version     = SchemaBuilder::VERSION
+  s.authors     = ['Georg Leciejewski']
+  s.email       = ['gl@salesking.eu']
+  s.homepage    = 'http://www.salesking.eu/dev'
+  s.summary     = %q{JSON Schema API tools.}
+  s.description = %q{Want to create a JSON Schema powered API? This toolset provides methods to read schemata, render objects as defined in schema, clean parameters according to schema, ...}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'json'
+  s.add_dependency 'activesupport'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rspec'
+end

data/lib/json_schema_tools.rb

@@ -0,0 +1 @@
+require 'schema_tools'

data/lib/schema_tools/cleaner.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module SchemaTools
+  class Cleaner
+
+    class << self
+
+      # Clean a hash before a new object is created from it. Can be used in
+      # your ruby controllers where new objects are created from a params-hash
+      # Directly CHANGES incoming params-hash!
+      #
+      # @param [String|Symbol] obj_name of the object/schema
+      # @param [Hash{String|Symbol=>Mixed}] params properties for the object
+      # @param [Object] opts
+      # @options opts [Array<String|Symbol>] :keep properties not being kicked
+      # even if defined as readonly
+      def clean_params!(obj_name, params, opts={})
+        schema = SchemaTools::Reader.read(obj_name)
+        setters = []
+        # gather allowed properties
+        schema[:properties].each{ |k,v| setters << k if !v['readonly'] }
+        setters += opts[:keep] if opts[:keep] && opts[:keep].is_a?(Array)
+        # kick readonly
+        params.delete_if { |k,v| !setters.include?("#{k}")  }
+        #convert to type in schema
+        params.each do |k,v|
+          if schema[:properties]["#{k}"]['type'] == 'string' && !v.is_a?(String)
+            params[k] = "#{v}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/schema_tools/hash.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+module SchemaTools
+  class Hash
+    extend SchemaTools::Modules::Hash
+  end
+end

data/lib/schema_tools/modules/hash.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module SchemaTools
+  module Modules
+    module Hash
+
+      # Create a Hash with the available (api)object attributes defined in the
+      # according schema properties. This is the meat of the
+      # object-to-api-markup workflow
+      #
+      # === Example
+      #  obj = Invoice.new(:title =>'hello world', :number=>'4711')
+      #
+      #  obj_hash = SchemaTools::Hash.from_schema(obj, 'v1.0')
+      #   => { 'invoice' =>{'title'=>'hello world', 'number'=>'4711' } }
+      #
+      #  obj_hash = Schema.to_hash_from_schema(obj, 'v1.0', :fields=>['title'])
+      #   => { 'invoice' =>{'title'=>'hello world' } }
+      #
+      #  obj_hash = Schema.to_hash_from_schema(obj, 'v1.0', :class_name=>:document)
+      #   => { 'document' =>{'title'=>'hello world' } }
+      #
+      # === Parameter
+      # obj<Object>:: An ruby object which is returned as hash
+      # version<String>:: the schema version, must be a valid folder name see
+      # #self.read
+      # opts<Hash{Symbol=>Mixed} >:: additional options
+      #
+      # ==== opts Parameter
+      # class_name<String|Symbol>:: Name of the class to use as hash key. Should be
+      # a lowered, underscored name and it MUST have an existing schema file.
+      # Use it to override the default, which is obj.class.name
+      # fields<Array[String]>:: Fields/properties to return. If not set all
+      # schema's properties are used.
+      #
+      # === Return
+      # <Hash{String=>{String=>Mixed}}>:: The object as hash:
+      # { invoice =>{'title'=>'hello world', 'number'=>'4711' } }
+      # @param [Object] obj
+      # @param [Object] opts
+      def from_schema(obj, opts={})
+        fields = opts[:fields]
+        # get objects class name without inheritance
+        real_class_name = obj.class.name.split('::').last.underscore
+        class_name =  opts[:class_name] || real_class_name
+
+        return obj if ['array', 'hash'].include? class_name
+
+        data = {}
+        # get schema
+        schema = SchemaTools::Reader.read(class_name)
+        # iterate over the defined schema fields
+        schema['properties'].each do |field, prop|
+          next if fields && !fields.include?(field)
+          if prop['type'] == 'array'
+            data[field] = [] # always set an empty array
+            if rel_objects = obj.send( field )
+              rel_objects.each do |rel_obj|
+                data[field] << to_hash_from_schema(rel_obj, version)
+              end
+            end
+          elsif prop['type'] == 'object' # a singular related object
+            data[field] = nil # always set empty val
+            if rel_obj = obj.send( field )
+              #dont nest field to prevent => client=>{client=>{data} }
+              data[field] = to_hash_from_schema(rel_obj, version)
+            end
+          else # a simple field is only added if the object knows it
+            data[field] = obj.send(field) if obj.respond_to?(field)
+          end
+        end
+        hsh = { "#{class_name}" => data }
+        #add links if present
+        links = parse_links(obj, schema)
+        links && hsh['links'] = links
+        hsh
+      end
+
+      # Parse the link section of the schema by replacing {id} in urls
+      # === Returns
+      # <Array[Hash{String=>String}]>::
+      # <nil>:: no links present
+      def parse_links(obj, schema)
+        links = []
+        schema['links'] && schema['links'].each do |link|
+          links << { 'rel' => link['rel'], 'href' => link['href'].gsub(/\{id\}/, "#{obj.id}") }
+        end
+        links.uniq
+        # return links only if not empty
+        links.empty? ? nil : links
+      end
+
+    end
+  end
+end

data/lib/schema_tools/modules/read.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/string/inflections'
+
+module SchemaTools
+  module Modules
+    # Read schemas into a hash
+    module Read
+
+      # Variable remembering already read-in schema's
+      # {
+      #   :invoice =>{schema}
+      #   :credit_note =>{schema}
+      #   }
+      # }
+      # @return [Hash{String=>Hash{Symbol=>HashWithIndifferentAccess}}]
+      def registry
+        @registry ||= {}
+      end
+
+      def registry_reset
+        @registry = nil
+      end
+
+      # Read a schema and return it as hash. You can supply a path or the
+      # global path defined in #SchemaTools.schema_path is used.
+      # Schemata returned from cache in #registry to prevent filesystem
+      # round-trips. The cache can be resented with #registry_reset
+      #
+      # @param [String|Symbol] schema name to be read from schema path directory
+      # @param [String] path
+      # @return[HashWithIndifferentAccess] schema as hash
+      def read(schema, path=nil)
+        schema = schema.to_sym
+        return registry[schema] if registry[schema]
+        file_path = File.join(path || SchemaTools.schema_path, "#{schema}.json")
+        plain_data = File.open(file_path, 'r'){|f| f.read}
+        registry[schema] = ActiveSupport::JSON.decode(plain_data).with_indifferent_access
+      end
+
+      # Read all available schemas from a given path(folder) and return
+      # them as array
+      #
+      # @param [String] path to schema files
+      # @return [Array<HashWithIndifferentAccess>] array of schemas as hash
+      def read_all(path=nil)
+        schemas = []
+        file_path = File.join(path || SchemaTools.schema_path, '*.json')
+        Dir.glob( file_path ).each do |file|
+          schema_name = File.basename(file, '.json').to_sym
+          schemas << read(schema_name, path)
+        end
+        schemas
+      end
+    end
+  end
+end

data/lib/schema_tools/reader.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+module SchemaTools
+  # Read schemas into a hash.
+  # Use as instance if you have multiple different schema sources/versions
+  # which may collide. Go for class methods if you have globally unique schemata
+  class Reader
+    include SchemaTools::Modules::Read
+    extend SchemaTools::Modules::Read
+  end
+end

data/lib/schema_tools/version.rb

@@ -0,0 +1,3 @@
+module SchemaBuilder
+  VERSION = '0.0.1'
+end

data/lib/schema_tools.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'schema_tools/version'
+require 'schema_tools/modules/read'
+require 'schema_tools/modules/hash'
+require 'schema_tools/reader'
+require 'schema_tools/hash'
+
+
+module SchemaTools
+  class << self
+
+    # @param [String] path to schema json files
+    def schema_path=(path)
+      @schema_path = path
+    end
+    def schema_path
+      @schema_path
+    end
+  end
+end

data/spec/fixtures/address.json

@@ -0,0 +1,85 @@
+{ "type":"object",
+  "title": "address",
+  "name": "address",
+  "description":"An address in SK is maintained within it's parent object(client, company). The first address(default_address) is used inside the address field of new documents. With multiple addresses sorting(first) is done by date, newest first. So if you add a new adddress it will be the new default one. See order and type property for details about ordering and accessing parcel work or home addresses.",
+  "properties":{
+    "id":{
+      "description":"Unique identifier - UUID",
+      "identity":true,
+      "readonly":true,
+      "type":"string",
+      "maxLength": 22,
+      "minLength":22
+    },
+    "city":{
+      "description": "City for the address. Must at least be present for an address.",
+      "required":true,
+      "type":"string",
+      "maxLength": 100
+    },
+    "address1":{
+      "description": "Should contain the street or otherwise primary address information.",
+      "type":"string",
+      "maxLength": 100
+    },
+    "address2":{
+      "description": "Additional address information, like floor number",
+      "type":"string",
+      "maxLength": 100
+    },
+    "pobox":{
+      "description": "Post office box number",
+      "type":"string",
+      "maxLength": 10
+    },
+    "zip":{
+      "description": "Zip number of the city. Length must be between 4..10",
+      "type":"string",
+      "maxLength": 10
+    },
+    "state":{
+      "description": "Country state of address",
+      "type":"string",
+      "maxLength": 100
+    },
+    "country":{
+      "description": "Country of the address.",
+      "type":"string",
+      "maxLength": 100
+    },
+    "created_at":{
+      "description": "Date the object was created in SK. Never changes afterwards",
+      "format":"date-time",
+      "readonly":true,
+      "type":"string"
+    },
+    "updated_at":{
+      "description": "Date the object was edited in SK.",
+      "format":"date-time",
+      "readonly":true,
+      "type":"string"
+    },
+    "address_type":{
+      "description": "Type of the address, as seen by vCard definition. There can only be one type. Inside of SK you can use placeholders like client.parcel_address.city to access the first parcel adr(Same for work_ / home_). <br/>Besides the placeholder default_address, always returns the first address found. Sorting is done by the order(if set) else by date, newest first.",
+      "enum":["work","home", "parcel"],
+      "type":"string"
+    },
+    "order":{
+      "description": "Addresses are normally sorted by date, newest first. If you need to strongly rely on their sorting e.g. default_address (always first) or have multiple addresses of one type(3 parcel), use this field for all adrs. <br/>Single adrs are used in placeholders like: addresses.2.city, returning the second adr found(not necessarily one with order=2).",
+      "type":"integer"
+    },
+    "lat":{
+      "description": "Geo-Location latitude",
+      "type":"number"
+    },
+    "long":{
+      "description": "Geo-Location longitude",
+      "type":"number"
+    },
+    "_destroy":{
+      "description": "When set an existing address will be deleted. This switch is only used when addresses are passed-in nested inside their parent object(a contact).",
+      "type":"boolean"
+    }
+  },
+  "links":[]
+}

data/spec/fixtures/client.json

@@ -0,0 +1,317 @@
+{"type":"object",
+  "title": "client",
+  "name": "client",
+  "description": "A client as seen by SalesKing",
+  "properties":{
+    "id":{
+      "description":"Unique identifier - UUID",
+      "identity":true,
+      "readonly":true,
+      "type":"string",
+      "maxLength": 22,
+      "minLength":22
+    },
+    "number":{
+      "description": "Unique number, auto-created by SK for new client without number.",
+      "type":"string",
+      "maxLength": 50
+    },
+    "organisation":{
+      "description": "Name of a company. This or lastname must be present",
+      "required" : true,
+      "type":"string",
+      "maxLength": 100
+    },
+    "last_name":{
+      "description": "Last name of a person. At least this or the organisation field must be filled for new records",
+      "type":"string",
+      "maxLength": 50
+    },
+    "first_name":{
+      "description": "First name of a person.",
+      "type":"string",
+      "maxLength": 50
+    },
+    "gender":{
+      "description": "Can be empty for a company. Is used in salutation",
+      "enum":["male", "female"],
+      "type":"string"
+    },
+    "notes":{
+      "description": "Notes for a contact. For day to day information you should use comments instead.",
+      "type":"string",
+      "format": "text"
+    },
+    "position":{
+      "description": "Position of a person in a company.",
+      "type":"string",
+      "maxLength": 50
+    },
+    "title":{
+      "description": "Academical title of a person e.g. Dr., Prof",
+      "type":"string",
+      "maxLength": 50
+    },
+    "tax_number":{
+      "description": "Tax number, normally applies to a private person",
+      "type":"string",
+      "maxLength": 30
+    },
+    "vat_number":{
+      "description": "VAT number, for a company or person paying value added taxes.",
+      "type":"string",
+      "maxLength": 30
+    },
+    "email":{
+      "description": "Email address of the contact.",
+      "type":"string",
+      "maxLength": 100
+    },
+    "url":{
+      "description": "An url associated with the person, e.g its company website.",
+      "type":"string",
+      "maxLength": 255
+    },
+    "birthday":{
+      "format":"date",
+      "type":"string"
+    },
+    "tag_list":{
+      "description": "Space separated list of tags. Are split and saved as Tag objects on create, update.",
+      "type":"string"
+    },
+    "created_at":{
+      "description": "Date the record was created in SK. Never changes afterwards.",
+      "format":"date-time",
+      "readonly":true,
+      "type":"string"
+    },
+    "updated_at":{
+      "description": "Last date when the record was edited.",
+      "format":"date-time",
+      "readonly":true,
+      "type":"string"
+    },
+    "language":{
+      "description": "Should be a valid language short-code: de-DE, fr, en-GB; like defined in your account language menu. When the client is emailed, a localized version of a multi-language template(email, pdf) will be used if available. The language will also be set for new documents.",
+      "type":"string",
+      "maxLength": 10
+    },
+    "currency":{
+      "description": "Currency code as defined by the ISO 4217 standard(3-letter UPCASE: EUR, USD). If set the currency is taken for new documents.",
+      "type":"string",
+      "maxLength": 3,
+      "minLength": 3
+    },
+    "payment_method":{
+      "description": "Default payment method for used for new documemts",
+      "enum":["cash","bank_transfer","credit_card","paypal","direct_debit","cheque", "moneybookers", "premium_sms"],
+      "type":"string"
+    },
+    "bank_name":{
+      "description": "Bank name",
+      "type":"string",
+      "maxLength": 70
+    },
+    "bank_number":{
+      "description": "Bank number",
+      "type":"string",
+      "maxLength": 35
+    },
+    "bank_account_number":{
+      "description": "Bank account number.",
+      "type":"string",
+      "maxLength": 35
+    },
+    "bank_iban":{
+      "description": "IBAN Number of the bank account. Is validated",
+      "type":"string",
+      "maxLength": 35
+    },
+    "bank_swift":{
+      "description": "SWIFT BIC-  Bank Identifier Code",
+      "type":"string",
+      "maxLength": 11
+    },
+    "bank_owner":{
+      "description": "Bank account owner",
+      "type":"string",
+      "maxLength": 70
+    },
+    "phone_fax":{
+      "description": "Fax number",
+      "type":"string",
+      "maxLength": 30
+    },
+    "phone_office":{
+      "description": "Office phone number",
+      "type":"string",
+      "maxLength": 30
+    },
+    "phone_home":{
+      "description": "Private phone number",
+      "type":"string",
+      "maxLength": 30
+    },
+    "phone_mobile":{
+      "description": "Mobile phone number",
+      "type":"string",
+      "maxLength": 30
+    },
+    "lock_version":{
+      "description": "Increased on every edit, so SK can detect/prevent a concurrent edit by another user. First save wins.",
+      "type":"integer"
+    },
+    "cash_discount":{
+      "description": "Default cash discount for new invoices.",
+      "type":"number"
+    },
+    "due_days":{
+      "description": "Default due days for new invoices.",
+      "type":"integer"
+    },
+    "address_field":{
+      "description": "Returns the address field used on new docs. Consist of Organisation name and default(first) address",
+      "readonly":true,
+      "type":"string"
+    },
+    "addresses":{
+      "description": "A client can have many addresses, sorted by date descending(new first). Default address is the most recent one.",
+      "type":"array",
+      "properties" : {"$ref":"./address.json#properties"}
+    },
+    "team_id":{
+      "description": "A team uuid. If set only the team and its parent teams can see the record.",
+      "type":"string",
+      "maxLength": 22,
+      "minLength":22
+    }
+  },
+  "links":[
+    { "rel": "self",
+      "href": "clients/{id}"
+    },
+    { "rel": "instances",
+      "href": "clients",
+      "properties" : {
+        "page":{
+          "title" : "Page",
+          "description": "In paginated results set the page to look for",
+          "type":"number"
+        },
+        "per_page":{
+          "title" : "Per page",
+          "description": "Results per page. Default is 10, max is 100",
+          "type":"number"
+        },
+        "filter[q]":{
+          "title" : "Search",
+          "description": "Wildcard search in first, last_name, organisation, email, number",
+          "type":"string"
+        },
+        "filter[tags]":{
+          "title" : "Tags",
+          "description": "Filter by a space delimited list of tags",
+          "type":"string"
+        },
+        "filter[ids]":{
+          "title" : "Clients",
+          "description": "A single or a list of client uuids, comma separated",
+          "type" : "string"
+        },
+        "filter[created_at_from]":{
+          "title" : "From date",
+          "description": "Objects with a creation date after the date, including given datetime. ISO 8601 format YYY-MM-DDThh:mm:ss+z",
+          "format" : "date-time",
+          "type" : "string"
+        },
+        "filter[created_at_to]":{
+          "title" : "To date",
+          "description": "Objects with a creation date before the date, including given datetime. ISO 8601 format YYY-MM-DDThh:mm:ss+z",
+          "format" : "date-time",
+          "type" : "string"
+        },
+        "filter[birthday_from]":{
+          "title" : "From birthday date",
+          "description": "Contacts with a birthday after and on the date. Leave the birthday-to date blank to only search on this day.",
+          "format" : "date",
+          "type" : "string"
+        },
+        "filter[birthday_to]":{
+          "title" : "To birthday date",
+          "description": "Contacts with a birthday date before and on the date.",
+          "format" : "date",
+          "type" : "string"
+        },
+        "filter[creator_ids]":{
+          "title" : "Creator",
+          "description": "Objects created by the given users uuids, comma separated",
+          "type" : "string"
+        },
+        "filter[number]":{
+          "title" : "By number",
+          "description": "Search by number where the number is matched from the start: number%",
+          "type" : "string"
+        },
+        "filter[languages]":{
+          "title" : "Languages",
+          "description": "A single or a list of language codes, comma separated",
+          "type" : "string"
+        },
+        "sort_by":{
+          "title" : "Sort by",
+          "description": "Sort the results by the given field => number",
+          "enum":["organisation", "number","email","first_name","last_name", "created_at", "updated_at"],
+          "type": "string"
+        },
+        "sort":{
+          "title" : "Sort",
+          "enum":["ASC","DESC"],
+          "description": "Sort the results in ASC or DESC"
+        }
+      }
+    },
+    { "rel": "destroy",
+      "href": "clients/{id}",
+      "method": "DELETE"
+    },
+    { "rel": "update",
+      "href": "clients/{id}",
+      "method": "PUT"
+    },
+    { "rel": "create",
+      "href": "clients",
+      "method": "POST"
+    },
+    { "rel": "documents",
+      "href": "clients/{id}/documents"
+    },
+    { "rel": "attachments",
+      "href": "clients/{id}/attachments"
+    },
+    { "rel": "invoices",
+      "href": "clients/{id}/invoices"
+    },
+    { "rel": "estimates",
+      "href": "clients/{id}/estimates"
+    },
+    { "rel": "orders",
+      "href": "clients/{id}/orders"
+    },
+    { "rel": "credit_notes",
+      "href": "clients/{id}/credit_notes"
+    },
+    { "rel": "recurrings",
+      "href": "clients/{id}/recurrings"
+    },
+    { "rel": "payment_reminders",
+      "href": "clients/{id}/payment_reminders"
+    },
+    { "rel": "comments",
+      "href": "clients/{id}/comments"
+    },
+    { "rel": "emails",
+      "href": "clients/{id}/emails"
+    }
+  ]
+}

data/spec/fixtures/page.json

@@ -0,0 +1,73 @@
+{
+  "type": "object",
+  "title": "Page",
+  "name": "page",
+  "description": "A page of a PDF which can either belong to a PDF template or archived PDF.",
+  "properties": {
+    "id": {
+      "description": "The object identifier.",
+      "identity": true,
+      "readonly": true,
+      "type": "integer"
+    },
+    "number": {
+      "description": "Number of this page inside the document",
+      "readonly": true,
+      "type": "integer"
+    },
+    "related_object_id": {
+      "description": "ID  of the PDF object the page belongs to.",
+      "readonly": true,
+      "type": "integer"
+    },
+    "related_object_type": {
+      "description": "Type of the related object Pdf or Pdt (camelCased class name)",
+      "readonly": true,
+      "type": "string",
+      "maxlength": 20
+    },
+    "width": {
+      "description": "Page width",
+      "type": "number"
+    },
+    "created_at": {
+      "description": "Creation date.",
+      "readonly": true,
+      "type": "string",
+      "format": "date-time"
+    },
+    "updated_at": {
+      "description": "Update date.",
+      "readonly": true,
+      "type": "string",
+      "format": "date-time"
+    },
+    "user_id": {
+      "description": "User who created the object.",
+      "readonly": true,
+      "type": "integer"
+    },
+    "screenshot": {
+      "description": "Screenshot file url png",
+      "type": "string",
+      "maxlength": 128
+    },
+    "account_id": {
+      "description": "Account this objects belongs to.",
+      "type": "integer"
+    },
+    "blocks": {
+      "description": "Placeholder blocks on this page,, if it belongs to a PDF Template",
+      "type": "array",
+      "properties": {"$ref":"./block.json#properties"}
+    }
+
+  },
+  "links": [
+    {
+      "rel": "self",
+      "method": "GET",
+      "href": "/pages/{id}"
+    }
+  ]
+}

data/spec/schema_tools/hash_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+class Client
+  attr_accessor :first_name, :last_name, :addresses, :id
+end
+
+describe SchemaTools::Hash do
+
+  context 'from_schema' do
+    let(:client){Client.new}
+    before :each do
+      client.first_name = 'Peter'
+      client.last_name = 'Paul'
+    end
+    after :each do
+      SchemaTools::Reader.registry_reset
+    end
+
+    it 'should return hash' do
+      hash = SchemaTools::Hash.from_schema(client)
+      hash['client']['last_name'].should == 'Paul'
+    end
+  end
+end
+

data/spec/schema_tools/reader_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe SchemaTools::Reader do
+
+  context 'class methods' do
+    after :each do
+      SchemaTools::Reader.registry_reset
+    end
+    it 'should read a single schema' do
+      schema = SchemaTools::Reader.read(:page)
+      schema[:name].should == 'page'
+      schema[:properties].should_not be_empty
+      SchemaTools::Reader.registry.should_not be_empty
+    end
+  end
+
+  context 'instance methods' do
+
+    let(:reader){ SchemaTools::Reader.new }
+
+    it 'should read a single schema' do
+      schema = reader.read(:client)
+      schema[:name].should == 'client'
+      schema[:properties].should_not be_empty
+      reader.registry[:client].should_not be_empty
+    end
+
+    it 'should populate instance registry' do
+      reader.read(:client)
+      reader.read(:address)
+      keys = reader.registry.keys
+      keys.length.should == 2
+      keys.should include(:client, :address)
+    end
+
+    it 'should not populate class registry' do
+      reader.read(:client)
+      SchemaTools::Reader.registry.should be_empty
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'simplecov'
+require 'active_support'
+
+SimpleCov.start do
+  root File.join(File.dirname(__FILE__), '..')
+  add_filter "/bin/"
+  add_filter "/spec/"
+end
+
+$:.unshift(File.dirname(__FILE__))
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'json_schema_tools'
+
+RSpec.configure do |config|
+  #config.treat_symbols_as_metadata_keys_with_true_values = true
+  #config.run_all_when_everything_filtered = true
+  #config.filter_run :focus
+  #config.after(:all) do
+  #end
+end
+
+# set global json schema path for examples
+SchemaTools.schema_path = File.expand_path('../fixtures', __FILE__)

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: json_schema_tools
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Georg Leciejewski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Want to create a JSON Schema powered API? This toolset provides methods
+  to read schemata, render objects as defined in schema, clean parameters according
+  to schema, ...
+email:
+- gl@salesking.eu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- json_schema_tools.gemspec
+- lib/json_schema_tools.rb
+- lib/schema_tools.rb
+- lib/schema_tools/cleaner.rb
+- lib/schema_tools/hash.rb
+- lib/schema_tools/modules/hash.rb
+- lib/schema_tools/modules/read.rb
+- lib/schema_tools/reader.rb
+- lib/schema_tools/version.rb
+- spec/fixtures/address.json
+- spec/fixtures/client.json
+- spec/fixtures/page.json
+- spec/schema_tools/hash_spec.rb
+- spec/schema_tools/reader_spec.rb
+- spec/spec_helper.rb
+homepage: http://www.salesking.eu/dev
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3313090340920384455
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3313090340920384455
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: JSON Schema API tools.
+test_files: []