matter_compiler 0.1.1

data/lib/matter_compiler/cli.rb

@@ -0,0 +1,82 @@
+require 'optparse'
+require 'matter_compiler/composer'
+require 'matter_compiler/version'
+
+module MatterCompiler
+  
+  class CLI
+    
+    attr_reader :command
+
+    def self.start
+      cli = CLI.new
+      options = cli.parse_options!(ARGV)
+      cli.runCommand(ARGV, options)
+    end
+
+    def runCommand(args, options)
+      command = :compose if args.first.nil? || @command.nil?
+      command = @command if @command
+
+      if command == :compose && args.first.nil? && (options[:format].nil? || options[:format] == :unknown_ast)
+
+        print options[:format] ? "invalid value of" : "missing"
+        print " '--format option'\n\n"
+
+        CLI.help
+        exit 1
+        end
+
+      case command
+      when :compose
+        Composer.compose(args.first, options[:format])
+      when :version
+        puts MatterCompiler::VERSION
+      else
+        CLI.help
+      end
+          
+    end
+
+    def parse_options!(args)
+      @command = nil
+      options = {}
+      options_parser = OptionParser.new do |opts|
+        opts.on('-f', '--format (yaml|json)') do |format|
+          options[:format] = Composer.parse_format(format)
+          @command = :compose
+        end
+
+        opts.on('-v', '--version') do
+          @command = :version
+        end
+
+        opts.on( '-h', '--help') do
+          @command = :help
+        end
+      end
+
+      options_parser.parse!
+      options
+
+    rescue OptionParser::InvalidOption => e
+      puts e
+      CLI.help
+      exit 1
+    end
+
+    def self.help
+        puts "Usage: matter_compiler [options] [<ast file>]"
+        puts "\nCompose an API blueprint from its AST."
+        puts "If no <ast file> is specified 'matter_compiler' will listen on stdin."
+        
+        puts "\nOptions:\n\n"
+        puts "\t-f, --format (yaml|json)        Set the AST media-type format of the input"
+        puts "\t-h, --help                      Show this help"
+        puts "\t-v, --version                   Show version"
+        puts "\n"
+    end
+
+  end
+
+end

data/lib/matter_compiler/composer.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'json'
+require 'matter_compiler/blueprint'
+require 'object'
+
+module MatterCompiler
+
+  class Composer
+  
+    # Read AST file 
+    def self.read_file(file)
+      unless File.readable?(file)
+        abort "Unable to read input ast file: #{file.inspect}"
+      end      
+      input = File.read(file)
+    end
+
+    # Read AST from stdin.
+    def self.read_stdin
+      input = $stdin.read
+    end
+
+    # Parse format from string
+    def self.parse_format(format)
+      format.downcase!
+      case format
+      when "json"
+        return :json_ast
+      when "yml"
+      when "yaml"
+        return :yaml_ast
+      else
+        return :unknown_ast
+      end      
+    end
+
+    # Guess format from filename extension.
+    def self.guess_format(file)
+      extension = File.extname(file)
+      if extension.length < 1
+        return :unknown_ast
+      end
+
+      self.parse_format(extension[1..-1])
+    end
+
+    # Compose API Blueprint from an AST file.
+    # Returns a string with composed API Blueprint.
+    def self.compose(file = nil, format = nil)
+      # Read input
+      input = nil
+      if file.nil?
+        input = self.read_stdin
+      else 
+        input = self.read_file(file)
+      end
+
+      if input.blank?
+        puts "Empty input"
+        exit
+      end
+
+      # Parse input
+      input_format = format ? format : self.guess_format(file)
+      ast_hash = nil;
+      case input_format
+      when :json_ast
+        ast_hash = JSON.parse(input).deep_symbolize_keys
+      when :yaml_ast
+        ast_hash = YAML.load(input).deep_symbolize_keys
+      else
+        abort "Undefined input format"
+      end
+
+      # Check version of the AST
+      unless Blueprint::SUPPORTED_VERSIONS.include?(ast_hash[Blueprint::VERSION_KEY].to_s)
+        abort("unsupported AST version: '#{ast_hash[Blueprint::VERSION_KEY]}'\n")
+      end
+
+      # Process the AST hash
+      blueprint = Blueprint.new(ast_hash)
+
+      # TODO: use $stdout for now, add serialization options later
+      puts blueprint.serialize
+    end
+  
+  end
+
+end

data/lib/matter_compiler/version.rb

@@ -0,0 +1,3 @@
+module MatterCompiler
+  VERSION = "0.1.1"
+end

data/lib/matter_compiler.rb

@@ -0,0 +1,5 @@
+require "matter_compiler/version"
+
+module MatterCompiler
+  # Your code goes here...
+end

data/lib/object.rb

@@ -0,0 +1,17 @@
+# Essential extensions to base object class
+# used throughout MatterCompiler
+
+class Object
+
+  # Symbolizes keys of a hash
+  def deep_symbolize_keys
+    return self.inject({}){|memo, (k,v)| memo[k.to_sym] = v.deep_symbolize_keys; memo} if self.is_a? Hash
+    return self.inject([]){|memo, v | memo << v.deep_symbolize_keys; memo} if self.is_a? Array
+    return self
+  end
+
+  # Returns true if object is nil or empty, false otherwise
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end

data/matter_compiler.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'matter_compiler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "matter_compiler"
+  spec.version       = MatterCompiler::VERSION
+  spec.authors       = ["Zdenek Nemec"]
+  spec.email         = ["z@apiary.io"]
+  spec.summary       = %q{API Blueprint AST to API Blueprint convertor}
+  spec.description   = %q{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.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "minitest"
+  
+  # Use latest aruba for STDIN capabilities, see the Gemfile
+  # spec.add_development_dependency "aruba"
+end

data/test/action_test.rb

@@ -0,0 +1,48 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'parameters_test'
+require_relative 'headers_test'
+require_relative 'transaction_example_test'
+
+class ActionTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :name => "Into Action",
+    :description => "Dolor sit amet\n\n",
+    :method => "GET",
+    :parameters => ParametersTest::AST_HASH,
+    :headers => HeadersTest::AST_HASH,
+    :examples => [TransactionExampleTest::AST_HASH]
+  }
+
+  BLUEPRINT = \
+%Q{### Into Action [GET]
+Dolor sit amet
+
+#{ParametersTest::BLUEPRINT}#{HeadersTest::BLUEPRINT}#{TransactionExampleTest::BLUEPRINT}}
+
+  def test_from_ast_hash
+    action = MatterCompiler::Action.new(ActionTest::AST_HASH)
+    assert_equal ActionTest::AST_HASH[:name], action.name
+    assert_equal ActionTest::AST_HASH[:description], action.description
+    assert_equal ActionTest::AST_HASH[:method], action.method
+    
+    assert_instance_of MatterCompiler::Parameters, action.parameters
+    assert_instance_of Array, action.parameters.collection
+    assert_equal ParametersTest::AST_HASH.keys.length, action.parameters.collection.length
+
+    assert_instance_of MatterCompiler::Headers, action.headers
+    assert_instance_of Array, action.headers.collection
+    assert_equal HeadersTest::AST_HASH.keys.length, action.headers.collection.length
+
+    assert_instance_of Array, action.examples
+    assert_equal ActionTest::AST_HASH[:examples].length, action.examples.length
+    assert action.examples.length > 0
+    assert_instance_of MatterCompiler::TransactionExample, action.examples[0]
+    assert_equal TransactionExampleTest::AST_HASH[:name], action.examples[0].name
+  end
+
+  def test_serialize
+    action = MatterCompiler::Action.new(ActionTest::AST_HASH)
+    assert_equal ActionTest::BLUEPRINT, action.serialize
+  end
+end

data/test/blueprint_test.rb

@@ -0,0 +1,43 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+require_relative 'resource_group_test'
+require_relative 'metadata_test'
+
+class BlueprintTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :_version => 1.0,
+    :metadata => MetadataTest::AST_HASH,
+    :name => "My API",
+    :description => "Lorem Ipsum\n\n",
+    :resourceGroups => [ ResourceGroupTest::AST_HASH ]
+  }
+
+  BLUEPRINT = \
+%Q{#{MetadataTest::BLUEPRINT}# My API
+Lorem Ipsum
+
+#{ResourceGroupTest::BLUEPRINT}}
+
+  def test_from_ast_hash
+    blueprint = MatterCompiler::Blueprint.new(BlueprintTest::AST_HASH)
+
+    assert_equal BlueprintTest::AST_HASH[:name], blueprint.name
+    assert_equal BlueprintTest::AST_HASH[:description], blueprint.description
+    
+    assert_instance_of Array, blueprint.resource_groups
+    assert_equal BlueprintTest::AST_HASH[:resourceGroups].length, blueprint.resource_groups.length
+    assert_equal ResourceGroupTest::AST_HASH[:name], blueprint.resource_groups[0].name
+
+    assert_instance_of MatterCompiler::Metadata, blueprint.metadata
+    assert_instance_of Array, blueprint.metadata.collection
+    assert_equal BlueprintTest::AST_HASH[:metadata].keys.length, blueprint.metadata.collection.length
+    assert_equal BlueprintTest::AST_HASH[:metadata].keys[0], blueprint.metadata.collection[0].keys[0]
+  end
+
+  def test_serialize
+    blueprint = MatterCompiler::Blueprint.new(BlueprintTest::AST_HASH)
+    assert_equal BlueprintTest::BLUEPRINT, blueprint.serialize
+    
+    #puts "\n\n>>>\n#{blueprint.serialize}"
+  end
+end

data/test/composer_test.rb

@@ -0,0 +1,10 @@
+require 'minitest/autorun'
+require 'matter_compiler/composer'
+
+class ComposerTest < Minitest::Unit::TestCase
+  def test_guess_format
+    assert_equal :yaml_ast, MatterCompiler::Composer.guess_format('test.yaml')
+    assert_equal :json_ast, MatterCompiler::Composer.guess_format('test.json')
+    assert_equal :unknown_ast, MatterCompiler::Composer.guess_format('test.txt')
+  end
+end

data/test/headers_test.rb

@@ -0,0 +1,75 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+
+class HeadersTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :'X-Header' => {
+      :value => "1"      
+    },
+    :'Content-Type' => {
+      :value => "text/plain"
+    }
+  }
+
+  AST_HASH_CONTENT_ONLY = {
+    :'Content-Type' => {
+      :value => "text/plain"
+    }
+  }  
+
+  BLUEPRINT = \
+%Q{+ Headers
+
+        X-Header: 1
+        Content-Type: text/plain
+
+}
+
+  BLUEPRINT_IGNORE_CONTENT = \
+%Q{+ Headers
+
+        X-Header: 1
+
+}
+
+  BLUEPRINT_CONTENT_ONLY = \
+%Q{+ Headers
+
+        Content-Type: text/plain
+
+}
+
+  BLUEPRINT_IGNORE_CONTENT_CONTENT_ONLY = %Q{}
+
+  BLUEPRINT_NESTED_IGNORE_CONTENT = \
+%Q{    + Headers
+
+            X-Header: 1
+
+}
+
+  def test_from_ast_hash
+    headers = MatterCompiler::Headers.new(HeadersTest::AST_HASH)
+    assert_equal 2, headers.collection.length
+
+    assert_instance_of Hash, headers.collection[0]
+    assert_equal :'X-Header', headers.collection[0].keys[0]
+    assert_equal "1", headers.collection[0][:'X-Header']
+
+    assert_instance_of Hash, headers.collection[1]
+    assert_equal :'Content-Type', headers.collection[1].keys[0]
+    assert_equal "text/plain", headers.collection[1][:'Content-Type']
+
+    assert_equal "text/plain", headers.content_type    
+  end
+
+  def test_serialize
+    headers = MatterCompiler::Headers.new(HeadersTest::AST_HASH)
+    assert_equal HeadersTest::BLUEPRINT, headers.serialize(0)
+    assert_equal HeadersTest::BLUEPRINT_IGNORE_CONTENT, headers.serialize(0, [MatterCompiler::Headers::CONTENT_TYPE_HEADER_KEY])
+
+    headers = MatterCompiler::Headers.new(HeadersTest::AST_HASH_CONTENT_ONLY)
+    assert_equal HeadersTest::BLUEPRINT_CONTENT_ONLY, headers.serialize(0)
+    assert_equal HeadersTest::BLUEPRINT_IGNORE_CONTENT_CONTENT_ONLY, headers.serialize(0, [MatterCompiler::Headers::CONTENT_TYPE_HEADER_KEY])
+  end
+end

data/test/metadata_test.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+require 'matter_compiler/blueprint'
+
+class MetadataTest < Minitest::Unit::TestCase
+  AST_HASH = {
+    :FORMAT => {
+      :value => "1A"      
+    }
+  }
+
+  BLUEPRINT = \
+%Q{FORMAT: 1A
+
+}
+
+  def test_from_ast_hash
+    metadata = MatterCompiler::Metadata.new(MetadataTest::AST_HASH)
+    assert_equal 1, metadata.collection.length
+    assert_instance_of Hash, metadata.collection[0]
+    assert_equal :FORMAT, metadata.collection[0].keys[0]
+    assert_equal "1A", metadata.collection[0][:FORMAT]
+  end
+
+  def test_serialize
+    metadata = MatterCompiler::Metadata.new(MetadataTest::AST_HASH)
+    assert_equal MetadataTest::BLUEPRINT, metadata.serialize
+  end
+end