gumiho 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 421a54bca859b8958330490d21fb78d2827f4b3f
+  data.tar.gz: 1b48177a716cf8aee17805ffe010d4dee80cc619
+SHA512:
+  metadata.gz: 5316f7fb5e2a5b346a1314302540374567f50b1b6fc353c8b1936576bf346caf6fc2ee5903d50b006b5df5d5302f2e46d3b6b566328e26396d3b5a1091a86227
+  data.tar.gz: a7e2d82593e1142821d0ce71894ed85152ad929e17d0235255c8e028a074b6be0062f2364b0e846e831a31f8b9493c1070b0a184df3f923126dd5ff54b3a99bc

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    gumiho (0.0.1)
+      choice (~> 0.1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    awesome_print (1.2.0)
+    choice (0.1.6)
+    rake (10.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print
+  bundler (~> 1.3)
+  gumiho!
+  rake

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 IvaDobreva
+
+MIT License
+
+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,19 @@
+# Gumiho
+
+ Easily create RESTful API documentation
+
+##Table of contents
+- [Installation] (#instalattion)
+- [Usage](#usage)
+	-[Settings](#settings)	
+		
+## Installation
+
+ $ gem install gumiho
+
+## Usage
+
+ After installing gumiho you need to have running API.
+
+##Settings
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/gumiho-export

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'generate_doc'
+require_relative '../lib/gumiho/command_line_params'
+
+module Gumiho
+
+  command_line = get_cl_params
+  export_dir = command_line[:export]
+  document = Gumiho::generate_documentation(command_line, export_dir) 
+end

data/gumiho.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gumiho/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gumiho"
+  spec.version       = '0.0.2'
+  spec.authors       = ["IvaDobreva"]
+  spec.email         = ["iva95dobreva@gmail.com"]
+  spec.description   = %q{Ruby gem for creating online RESTful API documentation with possibility to test different HTTP requests}
+  spec.summary       = %q{Create API documentation}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = 'gumiho-export'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  
+  spec.add_runtime_dependency "choice", "~> 0.1.6"
+end

data/lib/config.yml

@@ -0,0 +1,20 @@
+# http | list
+generate_strategy: 'http'
+
+methods: [ 'GET', 'POST', 'DELETE', 'PUT' ]
+
+http:
+  hostname: '0.0.0.0'
+  port: '4000'
+  path: '/v1/routes'
+
+#
+# http://0.0.0.0:3000/v1
+
+report:
+  document_headers: false
+  document_status: true
+
+template:
+  '/home/iva/GEM/lib/generate_doc/template.html.erb'
+

data/lib/generate_doc.rb

@@ -0,0 +1,80 @@
+$:.unshift File.dirname(__FILE__)
+require 'gumiho/route_methods'
+require 'gumiho/path_config'
+require 'gumiho/generate_response.rb'
+require 'yaml'
+ 
+module Gumiho
+  
+  extend self
+
+    def generate_documentation(params, export_dir)
+      #Checks for command line parameters and load them
+      
+      #Check for config file
+      if params[:config]
+
+        if File.file?(params[:config])
+          #parses yaml config file and creates PathConfig 
+          yaml = YAML.load_file(params[:config])
+           
+          path_conf = PathConfig.new(yaml['generate_strategy'], 
+                                    yaml['http']['hostname'], 
+                                    yaml['http']['port'],
+                                    yaml['http']['path'])
+          template_file = yaml['template']
+        else
+
+          abort('Wrong file')
+
+        end
+
+      else  
+        
+        #Creates new PathConfig object with following params
+        path_conf = PathConfig.new(params[:protocol], params[:hostname],
+                                   params[:port], params[:route])
+
+        template_file = params[:template]
+      end
+
+      routes_hash = routes_get(path_conf.build_path)
+      response = []
+      
+      routes_hash.each do |route|
+        
+        if route_filter(route['path'])==false
+          path = path_conf.build_path(route['path']) 
+         
+          params[:methods].each do |method|
+            case method
+            when 'GET' 
+              response << { :method => 'GET', 
+                            :url => path, 
+                            :response => get_method(path) 
+                          } if route['method'].downcase == 'get'
+            when 'POST'
+              response << { :method => 'POST', 
+                            :url => path, 
+                            :response => post_method(path) 
+                          } if route['method'].downcase == 'post'
+            when 'PUT' 
+              response << { :method => 'PUT', 
+                            :url => path, 
+                            :response => put_method(path) 
+                          } if route['method'].downcase == 'put'
+            when 'DELETE'
+              response << { :method => 'DELETE', 
+                            :url => path, 
+                            :response => delete_method(path) 
+                          } if route['method'].downcase == 'delete'
+            end
+          end
+        end
+
+      end
+      
+      generate_response(response, template_file, export_dir)
+  
+    end
+end

data/lib/gumiho/command_line_params.rb

@@ -0,0 +1,76 @@
+require 'choice'
+
+module Gumiho
+ 
+  def get_cl_params
+ 
+    spec = Gem::Specification.find_by_name("gumiho")
+    gem_root = spec.gem_dir
+    template = gem_root + "/lib/gumiho/template/template.html.erb"
+   
+    Choice.options do 
+      header ''
+      header 'Specific options:'
+
+      option :config do
+        short '-c'
+        long '--config'
+        desc 'Add config file'
+        default nil
+      end
+
+      option :methods do
+        short '-m'
+        long '--method'
+        desc 'Add GET, POST, PUT, DELETE methods'
+        default ['GET', 'POST', 'PUT', 'DELETE']
+      end
+
+      option :protocol do
+        short '-pr'
+        long '--protocol'
+        desc 'Change current protocol'
+        default 'http'
+      end
+        
+      option :hostname do
+        short '-h'
+        long '--host'
+        desc 'Change current hostname'
+        default '0.0.0.0'
+      end
+
+      option :port do
+        short '-p'
+        long '--port'
+        desc 'Change current port'
+        default '4000'
+      end      
+
+      option :route do
+        short '-r'
+        long '--route'
+        desc 'Change current route'
+        default '/v1/routes'
+      end  
+
+      option :template do
+        short '-t'
+        long '--template'
+        desc 'Add report template file'
+        default template
+      end 
+
+      option :export do
+        short '-e'
+        long '--export'
+        desc 'Export path'
+        default './report.html'
+      end
+    end
+        
+    Choice.choices
+  end
+
+  
+end

data/lib/gumiho/generate_response.rb

@@ -0,0 +1,54 @@
+require 'awesome_print'
+require 'erb'
+require 'json'
+
+module Gumiho
+
+  def generate_response(response, template_file, export_dir)
+    template = File.open(template_file, 'r').read
+    erb = ERB.new(template)
+    File.open(File.join(File.dirname(export_dir), File.basename(export_dir)), 'w+') { 
+      |file| file.write(erb.result(binding)) 
+    }
+  end
+
+###Methods used in the template file
+  def parse_response(response, template_param)
+    params = template_param.split('.')
+    result = response
+    params.each do |param|
+      result = result[param] if result.class == Hash
+    end
+
+    result
+  end
+
+######CHECK HTTTP REQUEST STATUS !!!!!
+  def check_status(response, template_param)
+    status = parse_response(response, template_param)
+  end
+######
+
+  def map_array(response, template_param)
+    result = Array.new
+    data = parse_response(response, template_param)
+
+    #Checks for wrong or empty array
+    if data.class == Array and data.empty? == false
+      result.push(data)
+    end
+    
+    result.each do |param|
+     # ap param
+      param.each do |one_param|
+        yield one_param
+      end
+    end
+
+  end
+
+  def map_string(response, template_param)
+    data = parse_response(response, template_param)
+  end
+
+end

data/lib/gumiho/path_config.rb

@@ -0,0 +1,23 @@
+
+module Gumiho
+
+  class PathConfig
+  
+    attr_reader  :hostname, :port, :protocol
+
+    def initialize(protocol, hostname, port, path)
+      @protocol = protocol
+      @hostname = hostname
+      @port = port
+      @path = path
+    end
+
+    #Builds path from given params
+    def build_path(other=nil)
+      return @route = "#{@protocol}://#{@hostname}:#{@port}#{@path}" if other==nil
+      return @route = "#{@protocol}://#{@hostname}:#{@port}#{other}"
+    end       
+ 
+  end
+
+end

data/lib/gumiho/route_methods.rb

@@ -0,0 +1,107 @@
+require 'net/http'
+require 'json'
+require 'awesome_print'
+
+module JSON
+  def self.is_json?(foo)
+    begin
+      return false unless foo.is_a?(String)
+      JSON.parse(foo).all?
+    rescue JSON::ParserError
+      false
+    end 
+  end
+end
+
+
+module Gumiho
+  
+  def print_processing_url_method(url, method)
+    puts "Processing URL: #{url} via method #{method}"
+  end
+
+  def check_if_json(response_body)
+    if JSON.is_json?(response_body)
+      json_data = JSON.parse(response_body)
+    end
+  end
+
+  #Without doc true
+  def routes_get(path)
+    uri = URI(path)
+
+   # uri.query = URI.encode_www_form()
+    http = Net::HTTP.new(uri.host, uri.port)  
+
+    print_processing_url_method(uri, 'GET')
+
+    response = http.get(uri)
+  
+    #Checks if JSON response is right
+    check_if_json(response.body)
+  end
+
+  # GET request
+  def get_method(path)
+    uri = URI(path)
+
+    uri.query = URI.encode_www_form({ :doc => true })
+    http = Net::HTTP.new(uri.host, uri.port)  
+
+    print_processing_url_method(uri, 'GET')
+
+    response = http.get(uri)
+  
+    #Checks if JSON response is right
+    check_if_json(response.body)
+   
+  end
+
+  #POST request
+  def post_method(path)
+    
+    uri = URI(path)
+
+    request = Net::HTTP::Post.new(uri.path)
+
+    request.set_form_data({:doc=>true})
+  
+    response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+      http.request(request)
+    end
+    print_processing_url_method(uri, 'POST')
+    check_if_json(response.body)
+  end
+
+  #PUT request
+  def put_method(path)
+    uri = URI(path)
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    print_processing_url_method(uri, 'PUT')
+
+    request = Net::HTTP::Put.new(path)
+    request.set_form_data({:doc=>true })
+    response = http.request(request)
+    
+    check_if_json(response.body)
+  end
+  
+  #DELETE request
+  def delete_method(path)
+    uri = URI(path)
+    http = Net::HTTP.new(uri.host, uri.port)
+
+    print_processing_url_method(uri, 'DELETE')
+
+    response = http.delete(path)
+    
+    check_if_json(response.body)
+  end
+
+  #Example filter for routes containing given substring used in generate_doc
+  def route_filter(path)
+    path.include? 'time'
+  end
+
+end

data/lib/gumiho/template/javascript/template_script.js

@@ -0,0 +1,68 @@
+ 
+toggleResult = function(button) {
+  form.find('.result').toggle('slow')
+  
+  if($(button).html() == 'Hide') {
+    $(button).html('Show')
+  } else {
+    $(button).html('Hide')
+  }
+}
+
+tryMe = function(method, url, button){
+  form = $(button).parent()
+  inputs = form.find('input')
+  data = {}
+  param_url = url
+  inputs.each(function(index) {
+    
+    if(url.indexOf(':' + $(this).attr('name')) >= 0) {
+      url=url.replace(':' + $(this).attr('name'), $(this).val()) 
+    } else {
+      data[$(this).attr('name')] = $(this).val()
+    }
+    
+  })
+ 
+
+  $.ajax({ 
+    type: method,
+    url: url,
+    data: data,
+    dataType: 'json',
+    crossDomain: true,
+    
+    success: function( data, textStatus, jqXHR ){
+      console.log(data);
+      str = JSON.stringify(data, undefined, 4)
+      form.find('.result').show()
+      form.find('.requested_url').html(url)
+      form.find('.response_box').html(str)
+      form.find('.response_headers').html(jqXHR.getAllResponseHeaders())
+      form.find('.response_code').html(jqXHR.status)
+      
+      if(form.find('button[onclick="toggleResult(this)"]').length==0) {
+        form.append('<button onclick="toggleResult(this)" type="button">Hide</button>')
+      }
+    },
+    error: function(data) {
+      inputs.each(function(index){
+        if(param_url.indexOf(':' + $(this).attr('name'))>=0) {
+          input_name = 'input[name='+$(this).attr('name')+']'
+          form.find(input_name).val('required').css('color', 'red')
+        }
+      })
+      
+      inputs.focus(function() {
+        if($(this).val()=='required') {
+          $(this).animate({color:'red'}, 100, function() {
+            $(this).val('').css('color', 'black')
+          })
+        }
+      })
+      
+    }
+  })
+  
+}
+   

data/lib/gumiho/template/style/template_style.css

@@ -0,0 +1,84 @@
+
+div.main {
+width: 1000px;
+margin: auto;}
+
+.box {
+display: block;
+padding: 10px 10px;
+font-size: 14px;
+color: #1a2f43;
+margin: 25px;
+background-color:#dddddd;
+border-color: black;
+border-radius: 5px;}
+        
+.method {
+background-color:#6fc717;
+padding: 10px 10px;
+border-radius: 5px;
+padding: 10px 10px;
+color: #fff;
+font-weight:bold;}
+              
+.response_box {
+display: block;
+padding: 10px;
+background-color: white;
+height: 250px;
+overflow: auto;
+border-radius: 5px;}
+
+.params {
+border-collapse: collapse; 
+width: 100%;
+border-bottom: 1px solid #889098;}
+
+.params td, th {border-top: 1px solid #889098;}
+  
+.failed {
+font-weight:bold;
+color: #bb132a;
+font-size: 16px;}
+
+.method_failed {
+background-color:#bb132a;
+padding: 10px 10px;
+border-radius: 5px;
+padding: 10px 10px;
+color: #fff;
+font-weight:bold;}
+
+.requested_url {
+background-color: white;
+height: 20px;
+border-radius: 5px;
+padding: 10px;
+overflow: auto;
+display: block;}
+
+.description {
+display: block;
+padding: 12px 0px;}
+
+.response_headers {
+background-color: white;
+padding: 10px;
+height: 100px;
+overflow: auto;
+border-radius: 5px;
+display: block;}
+
+.result {
+display: none;}
+
+.response_h {
+font-weight: bold;}
+
+.response_code {
+display: block;
+background-color: white;
+padding: 10px;
+height: 20px;
+overflow: auto;
+border-radius: 5px;}

data/lib/gumiho/template/template.html.erb

@@ -0,0 +1,64 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Generated Documentation</title>
+
+    <link rel="stylesheet" type="text/css" href=<%=Gem::Specification.find_by_name("gumiho").gem_dir + "/lib/generate_doc/style/template_style.css" %>>
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+    <script type="text/javascript" src=<%=Gem::Specification.find_by_name("gumiho").gem_dir + "/lib/generate_doc/javascript/template_script.js" %>> </script>
+  </head>
+  
+  <body>
+    <br>
+      <div class="main">
+        <ul class="items">
+          <% response.each do |res| %>
+            <% if check_status(res[:response], 'metadata.status') == 'ok' %>
+              <li class="box">
+                <span class="method"><%= res[:method]  %></span> 
+                <span class="url"><b><%= res[:url]  %> </b></span>
+                <span class="description"><b>Description:</b> <%=  map_string(res[:response], 'data.description') %> </span>
+                <form>
+                  <table class ="params">
+                    <tr>
+                      <th><b>Name</b></th>
+                      <th><b>Value</b></th>
+                      <th><b>Require</b></th>
+                      <th><b>Type</b></th>
+                      <th><b>Description</b></th>
+                    </tr> 
+                    <% map_array(res[:response], 'data.params') do |param_data| %>
+                      <tr>
+                        <td><%= name = map_string(param_data,'name') %></td>
+                        <td><input type="text" name=<%= name %> ></td>
+                        <td><%= map_string(param_data,'required') %></td>
+                        <td><%= map_string(param_data,'type') %></td>
+                        <td><%= map_string(param_data,'desc') %></td>
+                      </tr>
+                    <% end %>
+                  </table>
+                  <div class="result">
+                    <span class="response_h">Requested url</span>
+                    <pre class="requested_url"></pre>
+                    <span class="response_h">Response body</span>
+                    <pre class="response_box" ></pre>
+                    <span class="response_h">Response headers</span>
+                    <pre class="response_headers"></pre>
+                    <span class="response_h">Response status</span>
+                    <pre class='response_code'></pre>
+                  </div>
+                  <button onclick="tryMe('<%= res[:method] %>', '<%= res[:url] %>', this)" type="button">Try it out</button>
+                </form>
+              </li>
+            <% else %>
+              <li class="box">
+                <span class="method_failed"><%= res[:method] %></span> 
+                <span class="url"><b><%= res[:url] %> </b></span>
+                <p class="failed">Request FAILED.</p>
+              </li>
+            <% end %>
+        <% end %>
+      </ul>
+    </div>
+  </body>
+</html>

data/lib/gumiho/version.rb

@@ -0,0 +1,3 @@
+module Gumiho
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: gumiho
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- IvaDobreva
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: choice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+description: Ruby gem for creating online RESTful API documentation with possibility
+  to test different HTTP requests
+email:
+- iva95dobreva@gmail.com
+executables:
+- gumiho-export
+extensions: []
+extra_rdoc_files: []
+files:
+- ".README.md.swp"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/gumiho-export
+- gumiho.gemspec
+- lib/config.yml
+- lib/generate_doc.rb
+- lib/gumiho/command_line_params.rb
+- lib/gumiho/generate_response.rb
+- lib/gumiho/path_config.rb
+- lib/gumiho/route_methods.rb
+- lib/gumiho/template/javascript/template_script.js
+- lib/gumiho/template/style/template_style.css
+- lib/gumiho/template/template.html.erb
+- lib/gumiho/version.rb
+- pkg/generate_doc-0.0.1.gem
+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.2
+signing_key: 
+specification_version: 4
+summary: Create API documentation
+test_files: []