matter_compiler 0.1.1

data/test/parameters_test.rb

@@ -0,0 +1,84 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+
+class ParametersTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :id => {
+      :description => "Lorem\nIpsum\n",
+      :type => "number",
+      :required => false,
+      :default => "42",
+      :example => "1000",
+      :values => [ "42", "1000", "1AM4646" ]
+    }
+  }
+
+  AST_HASH_MANY = {
+    :id => {
+      :description => "Lorem",
+      :type => nil,
+      :required => true,
+      :default => nil,
+      :example => nil,
+      :values => nil
+    },
+    :search => {
+      :description => "Ipsum",
+      :type => nil,
+      :required => true,
+      :default => nil,
+      :example => nil,
+      :values => nil
+    }    
+  }
+
+  BLUEPRINT = \
+%Q{+ Parameters
+    + id = `42` (number, optional, `1000`)
+
+        Lorem
+        Ipsum
+
+        + Values
+            + `42`
+            + `1000`
+            + `1AM4646`
+
+}
+
+  BLUEPRINT_MANY = \
+%Q{+ Parameters
+    + id ... Lorem
+    + search ... Ipsum
+
+}
+
+  def test_from_ast_hash
+    parameters = MatterCompiler::Parameters.new(ParametersTest::AST_HASH)
+    assert_instance_of Array, parameters.collection
+    assert_equal 1, parameters.collection.length
+    assert_instance_of MatterCompiler::Parameter, parameters.collection[0]
+
+    parameter = parameters.collection[0]
+    assert_equal :id.to_s, parameter.name
+    assert_equal ParametersTest::AST_HASH[:id][:description], parameter.description
+    assert_equal ParametersTest::AST_HASH[:id][:type], parameter.type
+    assert_equal :optional, parameter.use
+    assert_equal ParametersTest::AST_HASH[:id][:default], parameter.default_value
+    assert_equal ParametersTest::AST_HASH[:id][:example], parameter.example_value
+
+    assert_instance_of Array, parameter.values
+    assert_equal ParametersTest::AST_HASH[:id][:values].length, parameter.values.length
+    assert_equal ParametersTest::AST_HASH[:id][:values][0], parameter.values[0]
+    assert_equal ParametersTest::AST_HASH[:id][:values][1], parameter.values[1]
+    assert_equal ParametersTest::AST_HASH[:id][:values][2], parameter.values[2]
+  end
+
+  def test_serialize
+    parameters = MatterCompiler::Parameters.new(ParametersTest::AST_HASH)
+    assert_equal ParametersTest::BLUEPRINT, parameters.serialize
+
+    parameters = MatterCompiler::Parameters.new(ParametersTest::AST_HASH_MANY)
+    assert_equal ParametersTest::BLUEPRINT_MANY, parameters.serialize    
+  end
+end

data/test/payload_test.rb

@@ -0,0 +1,166 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'headers_test'
+
+#
+# Payload test consists of testing Model, Request and Response
+# with model test used as an archetype for payload.
+#
+
+class ModelTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "My Resource",
+    :description => "Lorem ipsum dolor sit amet.\n",
+    :parameters => nil,
+    :headers => nil,
+    :body => "{ \"message\": \"Hello World\" }\n",
+    :schema => "{ \"$schema\": \"http://json-schema.org/draft-03/schema\" }\n"
+  }
+
+  BLUEPRINT = \
+%Q{+ Model
+
+    Lorem ipsum dolor sit amet.
+
+    + Body
+
+            { \"message\": \"Hello World\" }
+
+    + Schema
+
+            { \"$schema\": \"http://json-schema.org/draft-03/schema\" }
+
+}
+
+  def test_from_ast_hash
+    model = MatterCompiler::Model.new(ModelTest::AST_HASH)
+    assert_equal ModelTest::AST_HASH[:name], model.name
+    assert_equal ModelTest::AST_HASH[:description], model.description
+    assert_equal nil, model.parameters
+    assert_equal nil, model.headers
+    assert_equal ModelTest::AST_HASH[:body], model.body
+    assert_equal ModelTest::AST_HASH[:schema], model.schema
+  end
+
+  def test_serialize
+    model = MatterCompiler::Model.new(ModelTest::AST_HASH)
+    assert_equal ModelTest::BLUEPRINT, model.serialize
+  end
+end
+
+class RequestTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "Name",
+    :description => "Lorem\nIpsum\n",
+    :parameters => nil,
+    :headers => nil,
+    :body => "Hello World!\n",
+    :schema => nil
+  }
+
+  BLUEPRINT = \
+%Q{+ Request Name
+
+    Lorem
+    Ipsum
+
+    + Body
+
+            Hello World!
+
+}
+
+  def test_from_ast_hash
+    request = MatterCompiler::Request.new(RequestTest::AST_HASH)
+    assert_equal RequestTest::AST_HASH[:name], request.name
+    assert_equal RequestTest::AST_HASH[:description], request.description
+    assert_equal nil, request.parameters
+    assert_equal nil, request.headers
+    assert_equal RequestTest::AST_HASH[:body], request.body
+    assert_equal RequestTest::AST_HASH[:schema], request.schema
+  end
+
+  def test_serialize
+    request = MatterCompiler::Request.new(RequestTest::AST_HASH)
+    assert_equal RequestTest::BLUEPRINT, request.serialize
+  end
+end
+
+class ResponseTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "200",
+    :description => nil,
+    :parameters => nil,
+    :headers => HeadersTest::AST_HASH,
+    :body => "Hello\nWorld!\n",
+    :schema => nil
+  }
+
+  AST_HASH_ABBREV = {
+    :name => "200",
+    :description => nil,
+    :parameters => nil,
+    :headers => HeadersTest::AST_HASH_CONTENT_ONLY,
+    :body => "Hello\nWorld!\n",
+    :schema => nil
+  }
+
+  AST_HASH_EMPTY = {
+    :name => "204",
+    :description => nil,
+    :parameters => nil,
+    :headers => nil,
+    :body => nil,
+    :schema => nil  
+  }
+
+  BLUEPRINT = \
+%Q{+ Response 200 (text/plain)
+#{HeadersTest::BLUEPRINT_NESTED_IGNORE_CONTENT}    + Body
+
+            Hello
+            World!
+
+}
+
+  BLUEPRINT_ABBREV = \
+%Q{+ Response 200 (text/plain)
+
+        Hello
+        World!
+
+}
+
+  BLUEPRINT_EMPTY = \
+%Q{+ Response 204
+
+}
+
+  def test_from_ast_hash
+    response = MatterCompiler::Response.new(ResponseTest::AST_HASH)
+    assert_equal ResponseTest::AST_HASH[:name], response.name
+    assert_equal ResponseTest::AST_HASH[:description], response.description
+    assert_equal nil, response.parameters
+
+    assert_instance_of MatterCompiler::Headers, response.headers
+    assert_instance_of Array, response.headers.collection
+    assert_equal HeadersTest::AST_HASH.keys.length, response.headers.collection.length
+
+    assert_equal ResponseTest::AST_HASH[:body], response.body
+    assert_equal ResponseTest::AST_HASH[:schema], response.schema
+  end
+
+  def test_serialize
+    # Full syntax
+    response = MatterCompiler::Response.new(ResponseTest::AST_HASH)
+    assert_equal ResponseTest::BLUEPRINT, response.serialize
+
+    # Abbreviated syntax
+    response = MatterCompiler::Response.new(ResponseTest::AST_HASH_ABBREV)
+    assert_equal ResponseTest::BLUEPRINT_ABBREV, response.serialize
+
+    # Empty response
+    response = MatterCompiler::Response.new(ResponseTest::AST_HASH_EMPTY)
+    assert_equal ResponseTest::BLUEPRINT_EMPTY, response.serialize
+  end
+end

data/test/resource_group_test.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'resource_test'
+
+class ResourceGroupTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "My Resource Group",
+    :description => "Lorem Ipsum at [Apiary](http://apiary.io)\n\n",
+    :resources => [ ResourceTest::AST_HASH ]
+  }
+
+  BLUEPRINT = \
+%Q{# Group My Resource Group
+Lorem Ipsum at [Apiary](http://apiary.io)
+
+#{ResourceTest::BLUEPRINT}}
+
+  def test_from_ast_hash
+    resource_group = MatterCompiler::ResourceGroup.new(ResourceGroupTest::AST_HASH)
+    assert_equal ResourceGroupTest::AST_HASH[:name], resource_group.name
+    assert_equal ResourceGroupTest::AST_HASH[:description], resource_group.description
+    
+    assert_instance_of Array, resource_group.resources
+    assert_equal ResourceGroupTest::AST_HASH[:resources].length, resource_group.resources.length
+    assert_equal ResourceTest::AST_HASH[:name], resource_group.resources[0].name
+  end
+
+  def test_serialize
+    resource_group = MatterCompiler::ResourceGroup.new(ResourceGroupTest::AST_HASH)
+    assert_equal BLUEPRINT, resource_group.serialize
+  end
+end

data/test/resource_test.rb

@@ -0,0 +1,53 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'action_test'
+require_relative 'payload_test'
+require_relative 'parameters_test'
+require_relative 'headers_test'
+
+class ResourceTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "My Resource",
+    :description => "Lorem ipsum dolor sit amet, consectetur adipiscing elit.\n\n",
+    :uriTemplate => "/my-resource/{id}",
+    :model => ModelTest::AST_HASH,
+    :parameters => ParametersTest::AST_HASH,
+    :headers => HeadersTest::AST_HASH,
+    :actions => [ActionTest::AST_HASH]
+  }
+
+  BLUEPRINT = \
+%Q{## My Resource [/my-resource/{id}]
+Lorem ipsum dolor sit amet, consectetur adipiscing elit.
+
+#{ModelTest::BLUEPRINT}#{ParametersTest::BLUEPRINT}#{HeadersTest::BLUEPRINT}#{ActionTest::BLUEPRINT}}
+
+  def test_from_ast_hash
+    resource = MatterCompiler::Resource.new(ResourceTest::AST_HASH)
+    assert_equal ResourceTest::AST_HASH[:name], resource.name
+    assert_equal ResourceTest::AST_HASH[:description], resource.description
+    assert_equal ResourceTest::AST_HASH[:uriTemplate], resource.uri_template
+    
+    assert_instance_of MatterCompiler::Model, resource.model
+    assert_equal ModelTest::AST_HASH[:name], resource.model.name
+
+    assert_instance_of MatterCompiler::Parameters, resource.parameters
+    assert_instance_of Array, resource.parameters.collection
+    assert_equal ParametersTest::AST_HASH.keys.length, resource.parameters.collection.length
+
+    assert_instance_of MatterCompiler::Headers, resource.headers
+    assert_instance_of Array, resource.headers.collection
+    assert_equal HeadersTest::AST_HASH.keys.length, resource.headers.collection.length
+
+    assert_instance_of Array, resource.actions
+    assert_equal ResourceTest::AST_HASH[:actions].length, resource.actions.length
+    assert ResourceTest::AST_HASH[:actions].length > 0
+    assert_instance_of MatterCompiler::Action, resource.actions[0]
+    assert_equal ActionTest::AST_HASH[:name], resource.actions[0].name
+  end
+
+  def test_serialize
+    resource = MatterCompiler::Resource.new(ResourceTest::AST_HASH)
+    assert_equal ResourceTest::BLUEPRINT, resource.serialize
+  end
+end

data/test/transaction_example_test.rb

@@ -0,0 +1,38 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'payload_test'
+
+class TransactionExampleTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "",
+    :description => "",
+    :requests => [RequestTest::AST_HASH],
+    :responses => [ResponseTest::AST_HASH]
+  }
+
+  BLUEPRINT = \
+%Q{#{RequestTest::BLUEPRINT}#{ResponseTest::BLUEPRINT}}
+
+  def test_from_ast_hash
+    transaction_example = MatterCompiler::TransactionExample.new(TransactionExampleTest::AST_HASH)
+    assert_equal TransactionExampleTest::AST_HASH[:name], transaction_example.name
+    assert_equal TransactionExampleTest::AST_HASH[:description], transaction_example.description
+    
+    assert_instance_of Array, transaction_example.requests
+    assert_equal TransactionExampleTest::AST_HASH[:requests].length, transaction_example.requests.length
+    assert transaction_example.requests.length > 0
+    assert_instance_of MatterCompiler::Request, transaction_example.requests[0]
+    assert_equal RequestTest::AST_HASH[:name], transaction_example.requests[0].name
+
+    assert_instance_of Array, transaction_example.responses
+    assert_equal TransactionExampleTest::AST_HASH[:responses].length, transaction_example.responses.length
+    assert transaction_example.responses.length > 0
+    assert_instance_of MatterCompiler::Response, transaction_example.responses[0]
+    assert_equal ResponseTest::AST_HASH[:name], transaction_example.responses[0].name
+  end
+
+  def test_serialize
+    action = MatterCompiler::TransactionExample.new(TransactionExampleTest::AST_HASH)
+    assert_equal TransactionExampleTest::BLUEPRINT, action.serialize
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: matter_compiler
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Zdenek Nemec
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Matter Compiler is a API Blueprint AST Media Types to API Blueprint conversion
+  tool. It composes an API blueprint from its serialzed AST media-type.
+email:
+- z@apiary.io
+executables:
+- matter_compiler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/matter_compiler
+- features/compose.feature
+- features/step_definitions/file_content_step.rb
+- features/support/setup.rb
+- lib/matter_compiler.rb
+- lib/matter_compiler/blueprint.rb
+- lib/matter_compiler/cli.rb
+- lib/matter_compiler/composer.rb
+- lib/matter_compiler/version.rb
+- lib/object.rb
+- matter_compiler.gemspec
+- test/action_test.rb
+- test/blueprint_test.rb
+- test/composer_test.rb
+- test/headers_test.rb
+- test/metadata_test.rb
+- test/parameters_test.rb
+- test/payload_test.rb
+- test/resource_group_test.rb
+- test/resource_test.rb
+- test/transaction_example_test.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: API Blueprint AST to API Blueprint convertor
+test_files:
+- features/compose.feature
+- features/step_definitions/file_content_step.rb
+- features/support/setup.rb
+- test/action_test.rb
+- test/blueprint_test.rb
+- test/composer_test.rb
+- test/headers_test.rb
+- test/metadata_test.rb
+- test/parameters_test.rb
+- test/payload_test.rb
+- test/resource_group_test.rb
+- test/resource_test.rb
+- test/transaction_example_test.rb