prmd 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZGFhZTI3Yjc0OTA3ZWI5Mzc4NzBlNWQzMWY4YmQ5ZmRmNjAzZGIwMg==
+    ZTIwZDk1MjQwNDczNDkxOTkyZWE4NjVhNjgyZGI5MDBhOWY4ODNlZA==
   data.tar.gz: !binary |-
-    MTZlMzFjMDhjMWYyYmRlM2YxZjIyNjNkZjRjOWI0NmZkNDk4ZmU1MQ==
+    NGQxYTRlZjE5NmQ5YzcwZGM4OWZmMzFiYTU5OGU3N2FjYzkyYTMxOA==
 SHA512:
   metadata.gz: !binary |-
-    MDM1ZTE1MTI1YWNiMDMzZmQ4YmRhYzQ0MDI4Nzc4ZmI1ODM3NTUyODEzYjZm
-    YTY5NGU3Mjk1ZmVhZDQ3Mjg2OTMwZjA2NmRlYzc3OTNkNWEyOWZjYTM4NzI2
-    OWU5OTZjMTU4ZmNiYzUyMTg5NmE4NGM0MTgyN2QxMzFiNzEyMDY=
+    MmUwNWIxYjEwMDExY2FkYTM5MDliNDM0MGNlYjY2NzFhYzhhNzhlNWNhY2M2
+    YmFiOTFiOGFkMzdhZGFlMWU5ODk2OTY4ZWVkMDE3MjA5YzAyOTIyZDFlZjdi
+    MjEwNzVlZjUzMWUyNzI5NDc0NDk2OTgzMmZiZTc2NjNkYmI0N2E=
   data.tar.gz: !binary |-
-    NjI0ZWJjOTRjNTA5YTM4MzI4NzI0ZDc2ZTYyZDQyNzRlYmM2MzIwOWQ2MDMy
-    NWVlYmExZDNhNTJiMDkxYmU5ZmRiNzRiZGNhYjA1NDUwZjcwOGQ0NDhhZmY0
-    Yjg4MDMwYmFlOWJkMDY0ZDljOTdiMWRhY2Q0NzA4ZmQ3YWFkMDU=
+    ZDAxNWM4ZWJmZDJhN2YwZjIyMDNkZmJlY2E2ZGMzYzllOTI2Y2UxYzI5M2Nm
+    ZDU0YzYzNTI1YTI5NGM0NjA3NmRhZjI3MWFjZGY0OGNmMzliNThkNzg0NjBj
+    MjEzYWUwZDhlMDc3ZWU3MWZhMmVjMWRmNTNmZDk1ODQwNDk5YzI=

data/README.md

@@ -44,6 +44,7 @@ Prmd provides four main commands:
 * `combine`: Combine schemata and metadata into single schema
 * `verify`: Verify a schema
 * `doc`: Generate documentation from a schema
+* `render`: Render views from schema
 
 Here's an example of using these commands in a typical workflow:
 
@@ -77,6 +78,9 @@ $ prmd verify schema.json
 $ prmd doc schema.json > schema.md
 ```
 
+# Render from schema
+$ prmd render --template schemata.erb schema.json > schema.md
+
 Typically you'll want to prepend header and overview information to
 your API documentation. You can do this with the `--prepend` flag:
 

data/bin/prmd

@@ -23,6 +23,15 @@ commands = {
       options[:yaml] = y
     end
   end,
+  render: OptionParser.new do |opts|
+    opts.banner = "prmd doc [options] <combined schema>"
+    opts.on("-p", "--prepend header,overview", Array, "Prepend files to output") do |p|
+      options[:prepend] = p
+    end
+    opts.on("-t", "--template schemata.erb", String, "Use alternate template") do |t|
+      options[:template] = t
+    end
+  end,
   verify: OptionParser.new do |opts|
     opts.banner = "prmd verify [options] <combined schema>"
   end
@@ -66,17 +75,26 @@ case command
   when :combine
     puts Prmd.combine(ARGV[0], options).to_s
   when :doc
-    unless $stdin.tty?
-      data = JSON.parse($stdin.read)
-      schema = Prmd::Schema.new(data)
-      puts Prmd.doc(schema, options)
+    data = unless $stdin.tty?
+      $stdin.read
     else
-      data = JSON.parse(File.read(ARGV[0]))
-      schema = Prmd::Schema.new(data)
-      puts Prmd.doc(schema, options)
+      File.read(ARGV[0])
     end
+    schema = Prmd::Schema.new(JSON.parse(data))
+
+    options[:template] = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'prmd', 'templates', 'schema.erb'))
+
+    puts Prmd.render(schema, options)
   when :init
     puts Prmd.init(ARGV[0], options)
+  when :render
+    data = unless $stdin.tty?
+      $stdin.read
+    else
+      File.read(ARGV[0])
+    end
+    schema = Prmd::Schema.new(JSON.parse(data))
+    puts Prmd.render(schema, options)
   when :verify
     data, errors = '', []
     unless $stdin.tty?

data/docs/schemata.md

@@ -20,7 +20,7 @@ Each schema MUST include some meta-data, which we cluster at the top of the file
 * `description` - a description of the resource described by the schema
 * `id` - an id for this schema, it MUST be in the form `"schema/#{lower_case_singular_resource}"`
 * `$schema` - defines what meta-schema is in use, it MUST be `http://json-schema.org/draft-04/hyper-schema`
-* `title` - title for this resource, it MUST be in the form `"Heroku Platform API - #{title_case_plural_resource}"`
+* `title` - title for this resource, it MUST be in the form `"#{title_case_API_name} - #{title_case_plural_resource}"`
 * `type` - the type(s) of this schema, it MUST be `["object"]`
 
 ### `definitions`
@@ -41,7 +41,7 @@ Each attribute MUST include the following properties:
 
 Each attribute MAY include the following properties:
 
-* `pattern` - a regex encoded in a string that the valid values MUST match
+* `pattern` - a javascript regex encoded in a string that the valid values MUST match
 * `format` - format of the value. MUST be one of spec defined `["date-time", "email", "hostname", "ipv4", "ipv6", "uri"]` or defined by us `["uuid"]`
 
 Examples:

data/lib/prmd.rb

@@ -5,9 +5,9 @@ require "yaml"
 
 dir = File.dirname(__FILE__)
 require File.join(dir, 'prmd', 'commands', 'combine')
-require File.join(dir, 'prmd', 'commands', 'doc')
 require File.join(dir, 'prmd', 'commands', 'expand')
 require File.join(dir, 'prmd', 'commands', 'init')
+require File.join(dir, 'prmd', 'commands', 'render')
 require File.join(dir, 'prmd', 'commands', 'verify')
 require File.join(dir, 'prmd', 'schema')
 require File.join(dir, 'prmd', 'version')

data/lib/prmd/commands/combine.rb

@@ -8,7 +8,7 @@ module Prmd
       [path]
     end
     # sort for stable loading on any platform
-    schemas = files.sort.map { |file| [file, YAML.load(File.read(file))] }
+    schemata = files.sort.map { |file| [file, YAML.load(File.read(file))] }
 
     data = {
       '$schema'     => 'http://json-schema.org/draft-04/hyper-schema',
@@ -18,51 +18,41 @@ module Prmd
     }
 
     # tracks which entities where defined in which file
-    definitions_map = {}
+    schemata_map = {}
 
     if options[:meta] && File.exists?(options[:meta])
       data.merge!(YAML.load(File.read(options[:meta])))
     end
 
-    schemas.each do |schema_file, schema_data|
-      id = if schema_data['id']
-        schema_data['id'].split('/').last
-      end
-      next if id.nil? || id[0..0] == '_' # FIXME: remove this exception?
+    schemata.each do |schema_file, schema_data|
+      id_prefix, id = schema_data['id'].split('/')
 
-      if file = definitions_map[id]
-        $stderr.puts "`#{id}` (from #{schema_file}) was already defined in `#{file}` and will overwrite the first definition"
+      if file = schemata_map[schema_data['id']]
+        $stderr.puts "`#{schema_data['id']}` (from #{schema_file}) was already defined in `#{file}` and will overwrite the first definition"
       end
-      definitions_map[id] = schema_file
+      schemata_map[schema_data['id']] = schema_file
 
-      data['definitions'][id] = schema_data
+      data['definitions'][id_prefix] ||= {}
+      data['definitions'][id_prefix][id] = schema_data
       reference_localizer = lambda do |datum|
         case datum
         when Array
           datum.map {|element| reference_localizer.call(element)}
         when Hash
           if datum.has_key?('$ref')
-            if datum['$ref'].include?('/schema/')
-              $stderr.puts("`#{schema_data['id']}` `/schema/` prefixed refs are deprecated, use `/schemata/` prefixes")
-              datum['$ref'] = datum['$ref'].gsub(%r{/schema/([^#]*)#}, '#/definitions/\1')
-            end
-            datum['$ref'] = datum['$ref'].gsub(%r{/schemata/([^#]*)#}, '#/definitions/\1')
+            datum['$ref'] = '#/definitions' + datum['$ref'].gsub('#', '')
           end
           if datum.has_key?('href')
-            if datum['href'].include?('%2Fschema%2F')
-              $stderr.puts("`#{id}` `%2Fschema%2F` prefixed hrefs are deprecated, use `%2Fschemata%2F` prefixes")
-              datum['href'] = datum['href'].gsub(%r{%2Fschema%2F([^%]*)%23%2F}, '%23%2Fdefinitions%2F\1%2F')
-            end
-            datum['href'] = datum['href'].gsub(%r{%2Fschemata%2F([^%]*)%23%2F}, '%23%2Fdefinitions%2F\1%2F')
+            datum['href'] = datum['href'].gsub('%23', '').gsub(%r{(%2Fschemata%2F[^%]*%2F)}, '%23%2Fdefinitions\1')
           end
           datum.each { |k,v| datum[k] = reference_localizer.call(v) }
         else
           datum
         end
       end
-      reference_localizer.call(data['definitions'][id])
+      reference_localizer.call(data['definitions'][id_prefix][id])
 
-      data['properties'][id] = { '$ref' => "#/definitions/#{id}" }
+      data['properties'][id] = { '$ref' => "#/definitions/#{id_prefix}/#{id}" }
     end
 
     Prmd::Schema.new(data)

data/lib/prmd/commands/render.rb

@@ -0,0 +1,16 @@
+module Prmd
+  def self.render(schema, options={})
+    doc = ''
+
+    if options[:prepend]
+      doc << options[:prepend].map {|path| File.read(path)}.join("\n") << "\n"
+    end
+
+    doc << Erubis::Eruby.new(File.read(options[:template])).result({
+      options:         options,
+      schema:          schema
+    })
+
+    doc
+  end
+end

data/lib/prmd/schema.rb

@@ -24,6 +24,7 @@ module Prmd
         end
       end
       @data = convert_type_to_array.call(new_data)
+      @schemata_examples = {}
     end
 
     def dereference(reference)
@@ -55,6 +56,39 @@ module Prmd
       end
     end
 
+    def schema_example(schema)
+      example = {}
+
+      if schema.has_key?('example')
+        example.merge!(schema['example'])
+      elsif schema.has_key?('properties')
+        schema['properties'].each do |key, value|
+          _, value = dereference(value)
+          if value.has_key?('properties') # nested properties
+            example[key] = {}
+            value['properties'].each do |k,v|
+              example[key][k] = dereference(v).last['example']
+            end
+          else
+            example[key] = value['example']
+          end
+        end
+      end
+
+      example
+    end
+
+    def schemata_example(schemata_id)
+      _, schema = dereference("#/definitions/#{schemata_id}")
+      @schemata_examples[schemata_id] ||= begin
+        schema_example(schema)
+      end
+    end
+
+    def href
+      (@data['links'].detect { |link| link['rel'] == 'self' } || {})['href']
+    end
+
     def to_json
       new_json = JSON.pretty_generate(@data)
       # nuke empty lines

data/lib/prmd/templates/schema.erb

@@ -0,0 +1,12 @@
+<%=
+  schemata_template = File.read(File.join(File.dirname(options[:template]), 'schemata.erb'))
+
+  schema['properties'].map do |_, property|
+    _, schemata = schema.dereference(property)
+    Erubis::Eruby.new(schemata_template).result({
+      options:         options,
+      schema:          schema,
+      schemata:        schemata
+    })
+  end.join("\n") << "\n"
+%>

data/lib/prmd/templates/schemata.erb

@@ -0,0 +1,171 @@
+<%-
+  return unless schemata.has_key?('links') && !schemata['links'].empty?
+
+  link_schema_properties_template = File.read(File.join(File.dirname(options[:template]), 'link_schema_properties.erb'))
+  resource = schemata['id'].split('/').last
+  title = schemata['title'].split(' - ', 2).last
+
+  def extract_attributes(schema, properties)
+    attributes = []
+    properties = properties.sort_by {|k,v| k} # ensure consistent ordering
+
+    properties.each do |key, value|
+      # found a reference to another element:
+      _, value = schema.dereference(value)
+      if value.has_key?('anyOf')
+        descriptions = []
+        examples = []
+
+        # sort anyOf! always show unique identifier first
+        anyof = value['anyOf'].sort_by do |property|
+          property['$ref'].split('/').last.gsub('id', 'a')
+        end
+
+        anyof.each do |ref|
+          _, nested_field = schema.dereference(ref)
+          descriptions << nested_field['description']
+          examples << nested_field['example']
+        end
+
+        # avoid repetition :}
+        if descriptions.size > 1
+          descriptions.first.gsub!(/ of (this )?.*/, "")
+          descriptions[1..-1].map { |d| d.gsub!(/unique /, "") }
+        end
+
+        last = descriptions.pop
+        description = [descriptions.join(", "), last].join(" or ")
+
+        example = [*examples].map { |e| "<code>#{e.to_json}</code>" }.join(" or ")
+        attributes << [key, "string", description, example]
+
+      # found a nested object
+      elsif value['type'] == ['object'] && value['properties']
+        nested = extract_attributes(schema, value['properties'])
+        nested.each do |attribute|
+          attribute[0] = "#{key}:#{attribute[0]}"
+        end
+        attributes.concat(nested)
+      # just a regular attribute
+      else
+        description = value['description']
+        if value['enum']
+          description += '<br/><b>one of:</b>' + [*value['enum']].map { |e| "<code>#{e.to_json}</code>" }.join(" or ")
+        end
+        example = [*value['example']].map { |e| "<code>#{e.to_json}</code>" }.join(" or ")
+        type = if value['type'].include?('null')
+          'nullable '
+        else
+          ''
+        end
+        type += (value['format'] || (value['type'] - ['null']).first)
+        attributes << [key, type, description, example]
+      end
+    end
+    return attributes
+  end
+%>
+## <%= title %>
+<%= schemata['description'] %>
+
+<%- if schemata['properties'] %>
+### Attributes
+<table>
+  <tr>
+    <th>Name</th>
+    <th>Type</th>
+    <th>Description</th>
+    <th>Example</th>
+  </tr>
+  <%- extract_attributes(schema, schemata['properties']).each do |(key, type, description, example)| %>
+  <tr>
+    <td><strong><%= key %></strong></td>
+    <td><em><%= type %></em></td>
+    <td><%= description %></td>
+    <td><%= example %></td>
+  </tr>
+  <%- end %>
+</table>
+
+<%- end %>
+<%- schemata['links'].each do |link, datum| %>
+  <%-
+    path = link['href'].gsub(%r|(\{\([^\)]+\)\})|) do |ref|
+      ref = ref.gsub('%2F', '/').gsub('%23', '#').gsub(%r|[\{\(\)\}]|, '')
+      ref_resource = ref.split('#/definitions/schemata/').last.split('/').first.gsub('-','_')
+      identity_key, identity_value = schema.dereference(ref)
+      if identity_value.has_key?('anyOf')
+        '{' + ref_resource + '_' + identity_value['anyOf'].map {|r| r['$ref'].split('/').last}.join('_or_') + '}'
+      else
+        '{' + ref_resource + '_' + identity_key.split('/').last + '}'
+      end
+    end
+  -%>
+### <%= title %> <%= link['title'] %>
+<%= link['description'] %>
+
+```
+<%= link['method'] %> <%= path %>
+```
+
+  <%- if link.has_key?('schema') && link['schema'].has_key?('properties') %>
+    <%-
+      required, optional = link['schema']['properties'].partition do |k, v|
+        (link['schema']['required'] || []).include?(k)
+      end.map { |partition| Hash[partition] }
+    %>
+    <%- unless required.empty? %>
+#### Required Parameters
+<%= Erubis::Eruby.new(link_schema_properties_template).result(params: required, schema: schema) %>
+
+    <%- end %>
+      <%- unless optional.empty? %>
+#### Optional Parameters
+<%= Erubis::Eruby.new(link_schema_properties_template).result(params: optional, schema: schema) %>
+    <%- end %>
+  <%- end %>
+
+#### Curl Example
+```term
+  <%-
+    data = {}
+    path = path.gsub(/{([^}]*)}/) {|match| '$' + match.gsub(/[{}]/, '').upcase}
+
+    if link.has_key?('schema')
+      data.merge!(schema.schema_example(link['schema']))
+
+      if link['method'].upcase == 'GET' && !data.empty?
+        path << '?'
+        data.sort_by {|k,_| k.to_s }.each do |key, values|
+          [values].flatten.each do |value|
+            path << [key.to_s, CGI.escape(value.to_s)].join('=') << '&'
+          end
+        end
+        path.chop! # remove trailing '&'
+      end
+    end
+  %>
+$ curl -n -X <%= link['method'] %> <%= schema.href %><%= path %>
+  <%- unless data.empty? || link['method'].upcase == 'GET' %>
+-H "Content-Type: application/json" \
+-d '<%= data.to_json %>'
+  <%- end %>
+```
+
+#### Response Example
+```
+HTTP/1.1 <%= case link['rel']
+  when 'create'
+    '201 Created'
+  else
+    '200 OK'
+  end %>
+```
+```javascript```
+  <%- if link['rel'] == 'instances' %>
+<%= JSON.pretty_generate([schema.schemata_example(schemata['id'])]) %>
+  <%- else %>
+<%= JSON.pretty_generate(schema.schemata_example(schemata['id'])) %>
+  <%- end %>
+```
+<%- end -%>

data/lib/prmd/version.rb

@@ -1,3 +1,3 @@
 module Prmd
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/test/schema_test.rb

@@ -1,34 +1,34 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'helpers'))
 
-class SchemaTest < Minitest::Unit::TestCase
+class SchemaTest < Minitest::Test
   def test_dereference_with_ref
     key, value = user_input_schema.dereference({
-      '$ref' => '#/definitions/user/definitions/id'
+      '$ref' => '#/definitions/schemata/user/definitions/id'
     })
-    assert_equal(key,   '#/definitions/user/definitions/id')
-    assert_equal(value, user_input_schema['definitions']['user']['definitions']['id'])
+    assert_equal(key,   '#/definitions/schemata/user/definitions/id')
+    assert_equal(value, user_input_schema['definitions']['schemata']['user']['definitions']['id'])
   end
 
   def test_dereference_without_ref
-    key, value = user_input_schema.dereference('#/definitions/user/definitions/id')
-    assert_equal(key,   '#/definitions/user/definitions/id')
-    assert_equal(value, user_input_schema['definitions']['user']['definitions']['id'])
+    key, value = user_input_schema.dereference('#/definitions/schemata/user/definitions/id')
+    assert_equal(key,   '#/definitions/schemata/user/definitions/id')
+    assert_equal(value, user_input_schema['definitions']['schemata']['user']['definitions']['id'])
   end
 
   def test_dereference_with_nested_ref
     key, value = user_input_schema.dereference({
-      '$ref' => '#/definitions/user/definitions/identity'
+      '$ref' => '#/definitions/schemata/user/definitions/identity'
     })
-    assert_equal(key,   '#/definitions/user/definitions/id')
-    assert_equal(value, user_input_schema['definitions']['user']['definitions']['id'])
+    assert_equal(key,   '#/definitions/schemata/user/definitions/id')
+    assert_equal(value, user_input_schema['definitions']['schemata']['user']['definitions']['id'])
   end
 
   def test_dereference_with_local_context
     key, value = user_input_schema.dereference({
-      '$ref'     => '#/definitions/user/properties/id',
+      '$ref'     => '#/definitions/schemata/user/properties/id',
       'override' => true
     })
-    assert_equal(key,   '#/definitions/user/definitions/id')
-    assert_equal(value, {'override' => true}.merge(user_input_schema['definitions']['user']['definitions']['id']))
+    assert_equal(key,   '#/definitions/schemata/user/definitions/id')
+    assert_equal(value, {'override' => true}.merge(user_input_schema['definitions']['schemata']['user']['definitions']['id']))
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prmd
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - geemus
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-28 00:00:00.000000000 Z
+date: 2014-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubis
@@ -87,14 +87,15 @@ files:
 - docs/schemata.md
 - lib/prmd.rb
 - lib/prmd/commands/combine.rb
-- lib/prmd/commands/doc.rb
 - lib/prmd/commands/expand.rb
 - lib/prmd/commands/init.rb
+- lib/prmd/commands/render.rb
 - lib/prmd/commands/verify.rb
 - lib/prmd/schema.rb
+- lib/prmd/templates/link_schema_properties.erb
+- lib/prmd/templates/schema.erb
+- lib/prmd/templates/schemata.erb
 - lib/prmd/version.rb
-- lib/prmd/views/endpoint.erb
-- lib/prmd/views/parameters.erb
 - prmd.gemspec
 - test/helpers.rb
 - test/schema_test.rb

data/lib/prmd/commands/doc.rb

@@ -1,114 +0,0 @@
-def extract_attributes(schema, properties)
-  attributes = []
-  properties.each do |key, value|
-    # found a reference to another element:
-    _, value = schema.dereference(value)
-    if value.has_key?('anyOf')
-      descriptions = []
-      examples = []
-
-      # sort anyOf! always show unique identifier first
-      anyof = value['anyOf'].sort_by do |property|
-        property['$ref'].split('/').last.gsub('id', 'a')
-      end
-
-      anyof.each do |ref|
-        _, nested_field = schema.dereference(ref)
-        descriptions << nested_field['description']
-        examples << nested_field['example']
-      end
-
-      # avoid repetition :}
-      if descriptions.size > 1
-        descriptions.first.gsub!(/ of (this )?.*/, "")
-        descriptions[1..-1].map { |d| d.gsub!(/unique /, "") }
-      end
-
-      last = descriptions.pop
-      description = [descriptions.join(", "), last].join(" or ")
-
-      example = doc_example(*examples)
-      attributes << [key, "string", description, example]
-
-    # found a nested object
-    elsif value['type'] == ['object'] && value['properties']
-      nested = extract_attributes(schema, value['properties'])
-      nested.each do |attribute|
-        attribute[0] = "#{key}:#{attribute[0]}"
-      end
-      attributes.concat(nested)
-    # just a regular attribute
-    else
-      description = value['description']
-      if value['enum']
-        description += '<br/><b>one of:</b>' + doc_example(*value['enum'])
-      end
-      example = doc_example(value['example'])
-      attributes << [key, doc_type(value), description, example]
-    end
-  end
-  return attributes
-end
-
-def doc_type(property)
-  schema_type = property["type"].dup
-  type = "nullable " if schema_type.delete("null")
-  type.to_s + (property["format"] || schema_type.first)
-end
-
-def doc_example(*examples)
-  examples.map { |e| "<code>#{e.to_json}</code>" }.join(" or ")
-end
-
-module Prmd
-  def self.doc(schema, options={})
-    root_url = schema['links'].find{|l| l['rel'] == 'self'}['href']
-
-    doc = (options[:prepend] || []).map do |path|
-      File.open(path, 'r').read + "\n"
-    end
-
-    doc << schema['definitions'].map do |_, definition|
-      next if (definition['links'] || []).empty?
-      resource = definition['id'].split('/').last
-      serialization = {}
-      if definition['definitions'].has_key?('identity')
-        identifiers = if definition['definitions']['identity'].has_key?('anyOf')
-          definition['definitions']['identity']['anyOf']
-        else
-          [definition['definitions']['identity']]
-        end
-
-        identifiers = identifiers.map {|ref| ref['$ref'].split('/').last }
-      end
-      if definition['properties']
-        definition['properties'].each do |key, value|
-          _, value = schema.dereference(value)
-          if value.has_key?('properties')
-            serialization[key] = {}
-            value['properties'].each do |k,v|
-              serialization[key][k] = schema.dereference(v).last['example']
-            end
-          else
-            serialization[key] = value['example']
-          end
-        end
-      else
-        serialization.merge!(definition['example'])
-      end
-
-      title = definition['title'].split(' - ', 2).last
-
-      Erubis::Eruby.new(File.read(File.dirname(__FILE__) + "/../views/endpoint.erb")).result({
-        definition:      definition,
-        identifiers:     identifiers,
-        resource:        resource,
-        root_url:        root_url,
-        schema:          schema,
-        serialization:   serialization,
-        title:           title,
-        params_template: File.read(File.dirname(__FILE__) + "/../views/parameters.erb"),
-      }) + "\n"
-    end
-  end
-end

data/lib/prmd/views/endpoint.erb

@@ -1,128 +0,0 @@
-## <%= title %>
-<%= definition['description'] %>
-
-<%- if definition['properties'] %>
-### Attributes
-<table>
-  <tr>
-    <th>Name</th>
-    <th>Type</th>
-    <th>Description</th>
-    <th>Example</th>
-  </tr>
-  <%- extract_attributes(schema, definition['properties']).each do |(key, type, description, example)| %>
-  <tr>
-    <td><strong><%= key %></strong></td>
-    <td><em><%= type %></em></td>
-    <td><%= description %></td>
-    <td><%= example %></td>
-  </tr>
-  <%- end %>
-</table>
-
-<%- end %>
-<%- definition['links'].each do |link, datum| %>
-<%- path = link['href'].gsub(%r|(\{\([^\)]+\)\})|) do |ref|
-  ref = ref.gsub('%2F', '/').gsub('%23', '#').gsub(%r|[\{\(\)\}]|, '')
-  resource = ref.match(%r{^#/definitions/([^/]*)}).captures.first
-  identity_key, identity_value = schema.dereference(ref)
-  if identity_value.has_key?('anyOf')
-    '{' + resource + '_' + identity_value['anyOf'].map {|r| r['$ref'].split('/').last}.join('_or_') + '}'
-  else
-    '{' + resource + '_' + identity_key.split('/').last + '}'
-  end
-end -%>
-### <%= title %> <%= link['title'] %>
-<%= link['description'] %>
-
-```
-<%= link['method'] %> <%= path %>
-```
-
-<%- if link.has_key?('schema') && link['schema'].has_key?('properties') %>
-<%-
-  required, optional = link['schema']['properties'].partition do |k, v|
-    (link['schema']['required'] || []).include?(k)
-  end.map { |partition| Hash[partition] }
-%>
-<%- unless required.empty? %>
-#### Required Parameters
-<%= Erubis::Eruby.new(params_template).result(params: required, schema: schema) %>
-
-<%- end %>
-<%- unless optional.empty? %>
-#### Optional Parameters
-<%= Erubis::Eruby.new(params_template).result(params: optional, schema: schema) %>
-<%- end %>
-<%- end %>
-
-#### Curl Example
-```term
-<%- path = path.gsub(/{([^}]*)}/) {|match| '$' + match.gsub(/[{}]/, '')} %>
-<%- if link.has_key?('schema') && (link['schema'].has_key?('properties') || link['schema'].has_key?('example')) %>
-  <%-
-    data = {}
-    if link['schema']['properties']
-      link['schema']['properties'].each do |key, value|
-        _, value = schema.dereference(value)
-        if value.has_key?('anyOf')
-          id_ref = value['anyOf'].detect {|ref| ref['$ref'].split('/').last == 'id'}
-          data[key] = schema.dereference(id_ref).last['example']
-        elsif value.has_key?('properties')
-          data[key] = {}
-          value['properties'].each do |k,v|
-            data[key][k] = schema.dereference(v).last['example']
-          end
-        else
-          data[key] = schema.dereference(value).last['example']
-        end
-      end
-    else
-      data.merge!(link['schema']['example'])
-    end
-  %>
-  <%- if link['method'].upcase == 'GET' %>
-    <%-
-      unless data.empty?
-        path << '?'
-        data.sort_by {|k,_| k.to_s }.each do |key, values|
-          if values.nil?
-            path << key.to_s << '&'
-          else
-            [values].flatten.each do |value|
-              path << key.to_s << '=' << CGI.escape(value.to_s) << '&'
-            end
-          end
-        end
-        path.chop! # remove trailing '&'
-      end
-    %>
-$ curl -n -X <%= link['method'] %> <%= root_url %><%= path %>
-  <%- else %>
-$ curl -n -X <%= link['method'] %> <%= root_url %><%= path %> \
--H "Content-Type: application/json" \
--d '<%= data.to_json %>'
-  <%- end %>
-<%- else %>
-$ curl -n -X <%= link['method'] %> <%= root_url %><%= path %>
-<%- end %>
-```
-
-#### Response Example
-```
-HTTP/1.1 <%= case link['rel']
-when 'create'
-  '201 Created'
-else
-  '200 OK'
-end %>
-```
-```javascript```
-<%- if link['rel'] == 'instances' %>
-<%= JSON.pretty_generate([serialization]) %>
-<%- else %>
-<%= JSON.pretty_generate(serialization) %>
-<%- end %>
-```
-
-<%- end -%>