raml_parser 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15632f30b43baa8f09f37bb3f06b10fee158f138
+  data.tar.gz: 87d3a333ef6dbb848da083db0f344e9e0041a404
+SHA512:
+  metadata.gz: 251ac847b813be9b1bea013ded667d10208d377b56f75edae87bce4fe5a352ca3f8d94f3fea44297c9527ce6b227521ad4eeded792eadcf2b96acb8c2d2b770a
+  data.tar.gz: 6fbf700a78e581c13ebf1248621fe7c280215580651f8096c974ee80f9b0e3fbff78fa4feb61bc8017879c3d2a1ce8ef8eb8c5ba567cd623dfa127175efdf0c1

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in my_ruby_gem.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Christian Hoffmeister
+
+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,39 @@
+# RamlParser
+
+[![build](https://img.shields.io/travis/ePages-de/raml_parser/develop.svg)](https://travis-ci.org/ePages-de/raml_parser)
+[![license](http://img.shields.io/badge/license-MIT-lightgrey.svg)](http://opensource.org/licenses/MIT)
+
+A parser for the [RAML](http://raml.org/) API modeling language.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'raml_parser', :git => 'https://github.com/ePages-de/raml_parser.git', :branch => 'master'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+TODO: Write usage instructions here
+
+## What parts of RAML are not supported
+
+These are features of the RAML 0.8 specification that are not fully handled yet. This list should be complete, i.e. everything not listed here should work.
+
+* [Base URI Parameters](http://raml.org/spec.html#base-uri-parameters)
+* [Schemas](http://raml.org/spec.html#schemas)
+* [Protocols](http://raml.org/spec.html#protocols)
+* [Named parameters with multiple types](http://raml.org/spec.html#named-parameters-with-multiple-types)
+
+## Contributing
+
+1. Fork it ( https://github.com/ePages-de/raml_parser/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,7 @@
+require "bundler/gem_tasks"
+
+multitask :default => [:test]
+task :spec => :test
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:test)

data/lib/raml_parser.rb

@@ -0,0 +1,270 @@
+require 'raml_parser/yaml_helper'
+require 'raml_parser/model'
+
+module RamlParser
+  class Parser
+    attr_reader :path, :root
+
+    def self.parse_file(path)
+      node = YamlNode.new(nil, 'root', YamlHelper.read_yaml(path))
+      parse_root(node)
+    end
+
+    def self.parse_file_with_marks(path)
+      node = YamlNode.new(nil, 'root', YamlHelper.read_yaml(path))
+      node.mark_all(:unused)
+      node.mark(:used)
+      root = parse_root(node)
+      { :root => root, :marks => node.marks }
+    end
+
+    private
+
+    def self.parse_root(node)
+      node.hash('schemas').mark_all(:unsupported) if node.value.has_key? 'schemas'
+
+      root = Model::Root.new
+      root.title = node.hash('title').or_default('').value
+      root.base_uri = node.hash('baseUri').or_default('').value
+      root.version = node.hash('version').value
+      root.media_type = node.hash('mediaType').value
+      root.secured_by = node.hash('securedBy').or_default([]).array_map { |n| n.value }
+      root.documentation = node.hash('documentation').array_map { |n| parse_documenation(n) }
+      root.security_schemes = node.hash('securitySchemes').arrayhash_map { |n| parse_security_scheme(n) }
+      root.resource_types = node.hash('resourceTypes').mark_all(:used).arrayhash_map { |n| n }
+      root.traits = node.hash('traits').mark_all(:used).arrayhash_map { |n| n }
+
+      root.resources = traverse_resources(node, nil) do |n,parent|
+        parent_absolute_uri = parent != nil ? parent.absolute_uri : root.base_uri || ''
+        parent_relative_uri = parent != nil ? parent.relative_uri : ''
+        parent_uri_parameters = parent != nil ? parent.uri_parameters.clone : {}
+        parse_resource(n, root, parent_absolute_uri, parent_relative_uri, parent_uri_parameters, false)
+      end
+
+      root
+    end
+
+    def self.parse_resource(node, root, parent_absolute_uri, parent_relative_uri, parent_uri_parameters, as_resource_type)
+      def self.extract_uri_parameters(relative_uri)
+        names = relative_uri.scan(/\{([a-zA-Z\_\-]+)\}/).map { |m| m.first }
+        Hash[names.map { |name| [name, Model::NamedParameter.new(name, 'string', name)] }]
+      end
+
+      node = node.or_default({})
+      resource = Model::Resource.new(parent_absolute_uri + node.key, parent_relative_uri + node.key)
+      resource.display_name = node.hash('displayName').value
+      resource.description = node.hash('description').value
+      resource.uri_parameters = extract_uri_parameters(node.key).merge(parent_uri_parameters.merge(node.hash('uriParameters').hash_map { |n| parse_named_parameter(n) }))
+      resource.type = parse_type(node.hash('type'))
+      resource.is = parse_is(node.hash('is'))
+      resource.secured_by = (root.secured_by + node.hash('securedBy').or_default([]).array_map { |n| n.value }).uniq
+
+      for m in %w(get post put delete head patch options trace connect) do
+        if node.value.has_key? m
+          resource.methods[m] = parse_method(node.hash(m), root, resource, as_resource_type)
+        end
+      end
+
+      unless as_resource_type
+        resource = mixin_resource_types(node, root, resource)
+        resource.display_name = resource.relative_uri unless resource.display_name
+      end
+
+      resource
+    end
+
+    def self.parse_method(node, root, resource, as_trait)
+      node = node.or_default({})
+      method = Model::Method.new(node.key.upcase)
+      method.display_name = node.hash('displayName').value
+      method.description = node.hash('description').value
+      method.query_parameters = node.hash('queryParameters').hash_map { |n| parse_named_parameter(n) }
+      method.bodies = node.hash('body').hash_map { |n| parse_body(n) }
+      method.responses = node.hash('responses').hash_map { |n| parse_response(n) }
+      method.headers = node.hash('headers').hash_map { |n| parse_named_parameter(n) }
+      method.secured_by = (resource.secured_by + node.hash('securedBy').or_default([]).array_map { |n| n.value }).uniq if resource
+      method.is = parse_is(node.hash('is'))
+
+      unless as_trait
+        method = mixin_traits(node, root, method, resource)
+        method.display_name = method.method + ' ' + resource.relative_uri unless method.display_name
+      end
+
+      method
+    end
+
+    def self.parse_response(node)
+      node = node.or_default({})
+      response = Model::Response.new(node.key)
+      response.display_name = node.hash('displayName').value
+      response.description = node.hash('description').value
+      response.bodies = node.hash('body').hash_map { |n| parse_body(n) }
+      response.headers = node.hash('headers').hash_map { |n| parse_named_parameter(n) }
+      response
+    end
+
+    def self.parse_named_parameter(node)
+      if node.value.is_a? Array
+        node.mark_all(:unsupported)
+        # TODO: Not yet supported named parameters with multiple types
+        return Model::NamedParameter.new(node.key)
+      end
+
+      node = node.or_default({})
+      named_parameter = Model::NamedParameter.new(node.key)
+      named_parameter.type = node.hash('type').or_default('string').value
+      named_parameter.display_name = node.hash('displayName').or_default(named_parameter.name).value
+      named_parameter.description = node.hash('description').value
+      named_parameter.required = node.hash('required').or_default(true).value
+      named_parameter.default = node.hash('default').value
+      named_parameter.example = node.hash('example').value
+      named_parameter.min_length = node.hash('minLength').value
+      named_parameter.max_length = node.hash('maxLength').value
+      named_parameter.minimum = node.hash('minimum').value
+      named_parameter.maximum = node.hash('maximum').value
+      named_parameter.repeat = node.hash('repeat').value
+      named_parameter.enum = node.hash('enum').or_default([]).array_map { |n| n.value }
+      named_parameter.pattern = node.hash('pattern').value
+      named_parameter
+    end
+
+    def self.parse_body(node)
+      node = node.or_default({})
+      body = Model::Body.new(node.key)
+      body.example = node.hash('example').value
+      body.schema = node.hash('schema').value
+      body.form_parameters = node.hash('formParameters').hash_map { |n| parse_named_parameter(n) }
+      # TODO: Form parameters are only allowed for media type application/x-www-form-urlencoded or multipart/form-data
+      body
+    end
+
+    def self.parse_security_scheme(node)
+      node.hash('describedBy').mark_all(:unsupported) if node.value.has_key? 'describedBy'
+
+      node = node.or_default({})
+      security_scheme = Model::SecurityScheme.new(node.key)
+      security_scheme.type = node.hash('type').value
+      security_scheme.description = node.hash('description').value
+      security_scheme.described_by = node.hash('describedBy').value
+      security_scheme.settings = node.hash('settings').mark_all(:used).value
+      security_scheme
+    end
+
+    def self.parse_documenation(node)
+      node = node.or_default({})
+      documentation = Model::Documentation.new
+      documentation.title = node.hash('title').value
+      documentation.content = node.hash('content').value
+      documentation
+    end
+
+    def self.parse_type(node)
+      node = node.or_default({}).mark_all(:used)
+      result = {}
+      if node.value.is_a? String
+        result = { node.value => nil }
+      elsif node.value.is_a? Hash
+        result = node.value
+      else
+        raise "Invalid syntax for 'type' property at #{node.path}"
+      end
+      result
+    end
+
+    def self.parse_is(node)
+      node = node.or_default({}).mark_all(:used)
+      result = {}
+      node.value.each { |n|
+        if n.is_a? String
+          result = result.merge({ n => nil })
+        elsif n.is_a? Hash
+          result = result.merge(n)
+        else
+          raise "Invalid syntax for 'is' property at #{node.path}"
+        end
+      }
+      result
+    end
+
+    def self.mixin_resource_types(node, root, resource)
+      result = Model::Resource.new(nil, nil)
+      resource.type.each do |name,value|
+        params = (value || {}).merge({
+            'resourcePath' => resource.relative_uri,
+            'resourcePathName' => resource.relative_uri.match(/[^\/]*$/).to_s
+        })
+        resource_type = root.resource_types.has_key?(name) ? parse_resource(resolve_parametrization(root.resource_types[name], params), root, '', '', {}, true) : nil
+        if resource_type != nil
+          result = Model::Resource.merge(result, resource_type)
+        else
+          raise "Referencing unknown resource type #{name} at #{node.path}"
+        end
+      end
+
+      Model::Resource.merge(result, resource)
+    end
+
+    def self.mixin_traits(node, root, method, resource)
+      result = Model::Method.new(nil)
+      (resource.is.merge(method.is)).each do |name,value|
+        params = (value || {}).merge({
+            'resourcePath' => resource.relative_uri,
+            'resourcePathName' => resource.relative_uri.match(/[^\/]*$/).to_s,
+            'methodName' => method.method.downcase
+        })
+        trait = root.traits.has_key?(name) ? parse_method(resolve_parametrization(root.traits[name], params), root, nil, true) : nil
+        if trait != nil
+          result = Model::Method.merge(result, trait)
+        else
+          raise "Referencing unknown trait #{name} at #{node.path}"
+        end
+      end
+
+      Model::Method.merge(result, method)
+    end
+
+    def self.resolve_parametrization(node, params)
+      require 'active_support/core_ext/string/inflections'
+
+      def self.alter_string(str, params, node)
+        str.gsub(/<<([a-zA-Z]+)(\s*\|\s*!([a-zA-Z_\-]+))?>>/) do |a,b|
+          case $3
+            when nil
+              params[$1].to_s
+            when 'singularize'
+              params[$1].to_s.singularize
+            when 'pluralize'
+              params[$1].to_s.pluralize
+            else
+              raise "Using unknown parametrization function #{$3} at #{node.path}"
+          end
+        end
+      end
+
+      def self.traverse(raw, params, node)
+        if raw.is_a? Hash
+          Hash[raw.map { |k,v| [traverse(k, params, node), traverse(v, params, node)] }]
+        elsif raw.is_a? Array
+          raw.map { |i| traverse(i, params, node) }
+        elsif raw.is_a? String
+          alter_string(raw, params, node)
+        else
+          raw
+        end
+      end
+
+      YamlNode.new(node.parent, node.key, traverse(node.value, params, node))
+    end
+
+    def self.traverse_resources(node, parent_resource, &code)
+      node.hash_map { |n|
+        if n.key =~ /^\//
+          resource = code.call(n, parent_resource)
+          [resource] + traverse_resources(n, resource, &code)
+        else
+          []
+        end
+      }.values.flatten
+    end
+  end
+end

data/lib/raml_parser/model.rb

@@ -0,0 +1,146 @@
+module RamlParser
+  module Model
+    class Root
+      attr_accessor :title, :base_uri, :version, :media_type, :security_schemes, :resource_types, :traits, :secured_by, :documentation, :resources
+
+      def initialize(title = nil, base_uri = nil, version = nil, media_type = nil, security_schemes = {}, resource_types = {}, traits = {}, secured_by = [], documentation = [], resources = [])
+        @title = title
+        @base_uri = base_uri
+        @version = version
+        @media_type = media_type
+        @security_schemes = security_schemes
+        @resource_types = resource_types
+        @traits = traits
+        @secured_by = secured_by
+        @documentation = documentation
+        @resources = resources
+      end
+    end
+
+    class Resource
+      attr_accessor :absolute_uri, :relative_uri, :display_name, :description, :uri_parameters, :methods, :type, :is, :secured_by
+
+      def initialize(absolute_uri, relative_uri, display_name = nil, description = nil, uri_parameters = {}, methods = {}, type = {}, is = {}, secured_by = [])
+        @absolute_uri = absolute_uri
+        @relative_uri = relative_uri
+        @display_name = display_name
+        @description = description
+        @uri_parameters = uri_parameters
+        @methods = methods
+        @type = type
+        @is = is
+        @secured_by = secured_by
+      end
+
+      def self.merge(a, b)
+        resource = Resource.new(b.absolute_uri, b.relative_uri)
+
+        resource.display_name = if b.display_name then b.display_name else a.display_name end
+        resource.description = if b.description then b.description else a.description end
+        resource.uri_parameters = a.uri_parameters.merge(b.uri_parameters)
+        resource.methods = a.methods.merge(b.methods)
+        resource.type = a.type.merge(b.type)
+        resource.is = a.is.merge(b.is)
+        resource.secured_by = (a.secured_by + b.secured_by).uniq
+
+        resource
+      end
+    end
+
+    class Method
+      attr_accessor :method, :display_name, :description, :query_parameters, :responses, :bodies, :headers, :is, :secured_by
+
+      def initialize(method, display_name = nil, description = nil, query_parameters = {}, responses = {}, bodies = {}, headers = {}, is = {}, secured_by = [])
+        @method = method
+        @display_name = display_name
+        @description = description
+        @query_parameters = query_parameters
+        @responses = responses
+        @bodies = bodies
+        @headers = headers
+        @is = is
+        @secured_by = secured_by
+      end
+
+      def self.merge(a, b)
+        method = Method.new(b.method)
+
+        method.display_name = if b.display_name then b.display_name else a.display_name end
+        method.description = if b.description then b.description else a.description end
+        method.query_parameters = a.query_parameters.merge(b.query_parameters)
+        method.responses = a.responses.merge(b.responses)
+        method.bodies = a.bodies.merge(b.bodies)
+        method.headers = a.headers.merge(b.headers)
+        method.is = a.is.merge(b.is)
+        method.secured_by = (a.secured_by + b.secured_by).uniq
+
+        method
+      end
+    end
+
+    class Response
+      attr_accessor :status_code, :display_name, :description, :bodies, :headers
+
+      def initialize(status_code, display_name = nil, description = nil, bodies = {}, headers = {})
+        @status_code = status_code
+        @display_name = display_name
+        @description = description
+        @bodies = bodies
+        @headers = headers
+      end
+    end
+
+    class Body
+      attr_accessor :media_type, :example, :schema, :form_parameters
+
+      def initialize(media_type, example = nil, schema = nil, form_parameters = {})
+        @media_type = media_type
+        @example = example
+        @schema = schema
+        @form_parameters = form_parameters
+      end
+    end
+
+    class NamedParameter
+      attr_accessor :name, :type, :display_name, :description, :required, :default, :example, :min_length, :max_length, :minimum, :maximum, :repeat, :enum, :pattern
+
+      def initialize(name, type = nil, display_name = nil, description = nil, required = false, default = nil, example = nil, min_length = nil, max_length = nil, minimum = nil, maximum = nil, repeat = nil, enum = nil, pattern = nil)
+        @name = name
+        @type = type
+        @display_name = display_name
+        @description = description
+        @required = required
+        @default = default
+        @example = example
+        @min_length = min_length
+        @max_length = max_length
+        @minimum = minimum
+        @maximum = maximum
+        @repeat = repeat
+        @enum = enum
+        @pattern = pattern
+      end
+    end
+
+    class Documentation
+      attr_accessor :title, :content
+
+      def initialize(title = nil, content = nil)
+        @title = title
+        @content = content
+      end
+    end
+
+    class SecurityScheme
+      attr_accessor :name, :type, :description, :described_by, :settings
+
+      def initialize(name, type = nil, description = nil, described_by = nil, settings = {})
+        @name = name
+        @type = type
+        @description = description
+        @described_by = described_by
+        @settings = settings
+      end
+    end
+  end
+end