honey 0.0.6

data/lib/honey/command/help.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Honey
+  module Command
+    # Display help
+    class Help
+
+      def self.execute(options)
+        banner
+        commands
+      end
+
+      def self.banner
+        puts "\nUsage: apiary command [options]"
+        puts "Try 'apiary help' for more information."
+      end
+
+      def self.commands
+        puts "\nCurrently available apiary commands are:\n\n"
+        puts "\tpreview                                     Show API documentation in default browser"
+        puts "\tpreview --browser [chrome|safari|firefox]   Show API documentation in specified browser"
+        puts "\tpreview --path [PATH]                       Specify path to blueprint file"
+        puts "\tpreview --api_host [HOST]                   Specify apiary host"
+        puts "\tpreview --server                            Start standalone web server on port 8080"
+        puts "\tpreview --server --port [PORT]              Start standalone web server on specified port"
+        puts "\tpublish --api-name [API_NAME]               Publish apiary.apib on docs.API_NAME.apiary.io"
+        puts "\tokapi help                                  Show okapi testing tool help"
+        puts "\n"
+        puts "\thelp                                        Show this help"
+        puts "\n"
+        puts "\tversion                                     Show version"
+        puts "\n"
+      end
+
+    end
+  end
+end

data/lib/honey/command/preview.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+require 'rest_client'
+require 'rack'
+require 'ostruct'
+
+module Honey
+  module Command
+    # Display preview of local blueprint file
+    class Preview
+
+      BROWSERS = {
+        :safari => "Safari",
+        :chrome => "Google Chrome",
+        :firefox => "Firefox"
+      }
+
+      attr_reader :options
+
+      # TODO: use OpenStruct to store @options
+      def initialize(opts)
+        @options = OpenStruct.new(opts)
+        @options.path         ||= "apiary.apib"
+        @options.api_host     ||= "api.apiary.io"
+        @options.headers      ||= {:accept => "text/html", :content_type => "text/plain"}
+        @options.port         ||= 8080
+      end
+
+      def self.execute(args)
+        args[:server] ? new(args).server : new(args).show
+      end
+
+      def server
+        run_server
+      end
+
+      def show
+        generate_static(path)
+      end
+
+      def validate_apib_file(apib_file)
+        unless File.exist?(apib_file)
+          abort "Apiary definition file hasn't been found: #{apib_file.inspect}"
+        end
+      end
+
+      def path
+        @options.path || "#{File.basename(Dir.pwd)}.apib"
+      end
+
+      def browser
+        BROWSERS[@options.browser]  || nil
+      end
+
+      def rack_app(&block)
+        Rack::Builder.new do
+          run lambda { |env| [200, Hash.new, [block.call]] }
+        end
+      end
+
+      def run_server
+        app = self.rack_app do
+          self.query_apiary(@options.api_host, @options.path)
+        end
+
+        Rack::Server.start(:Port => @options.port, :app => app)
+      end
+
+      def preview_path(path)
+        basename = File.basename(@options.path)
+        "/tmp/#{basename}-preview.html"
+      end
+
+      def query_apiary(host, path)
+        url  = "https://#{host}/blueprint/generate"
+        data = File.read(path)
+        RestClient.post(url, data, @options.headers)
+      end
+
+      # TODO: add linux and windows systems
+      def open_generated_page(path)
+        exec "open #{browser_options} #{path}"
+      end
+
+      def write_generated_path(path, outfile)
+        File.open(outfile, 'w') do |file|
+          file.write(File.open(path, 'r').read)
+        end
+      end
+
+      def generate_static(path)
+        File.open(preview_path(path), "w") do |file|
+          file.write(query_apiary(@options.api_host, path))
+          @options.output ? write_generated_path(file.path, @options.output) : open_generated_page(file.path)
+        end
+      end
+
+      private
+        def browser_options
+          "-a #{BROWSERS[@options.browser.to_sym]}" if @options.browser
+        end
+    end
+  end
+end

data/lib/honey/command/publish.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require 'rest_client'
+require 'rack'
+require 'ostruct'
+
+module Honey
+  module Command
+    # Display preview of local blueprint file
+    class Publish
+
+      attr_reader :options
+
+      # TODO: use OpenStruct to store @options
+      def initialize(opts)
+        @options = OpenStruct.new(opts)
+        @options.path         ||= "apiary.apib"
+        @options.api_host     ||= "api.apiary.io"
+        @options.port         ||= 8080
+        @options.api_name     ||= false
+        @options.api_key      ||= ENV['APIARY_API_KEY']
+        @options.headers      ||= {
+          :accept => "text/html",
+          :content_type => "text/plain",
+          :authentication => "Token #{@options.api_key}"
+        }
+      end
+
+      def self.execute(args)
+        new(args).publish_on_apiary
+      end
+
+      def publish_on_apiary
+        unless @options.api_name
+          abort "Please provide an api-name option (subdomain part from your http://docs.<api-name>.apiary.io/)"
+        end
+
+        unless @options.api_key
+          abort "API key must be provided through environment variable APIARY_API_KEY. Please go to https://login.apiary.io/tokens to obtain it."
+        end
+
+        self.query_apiary(@options.api_host, @options.path)
+
+      end
+
+      def validate_apib_file(apib_file)
+        unless File.exist?(apib_file)
+          abort "Apiary definition file hasn't been found: #{apib_file.inspect}"
+        end
+      end
+
+      def path
+        @options.path || "#{File.basename(Dir.pwd)}.apib"
+      end
+
+      def query_apiary(host, path)
+        url  = "https://#{host}/blueprint/publish/#{@options.api_name}"
+        data = {
+          :code => File.read(path)
+        }
+        response = RestClient.post url, data, @options.headers
+
+        unless response.code == 201
+          abort "Request failed with code #{response.code}"
+        end
+      end
+
+      private
+        def api_name
+          "-a"
+        end
+
+    end
+  end
+end

data/lib/honey/command/runner.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Honey
+  module Command
+    # Run commands
+    class Runner
+
+      def self.run(cmd, options)
+        Honey::Command.const_get(cmd.to_s.capitalize).send(:execute, options)
+      end
+
+    end
+  end
+end

data/lib/honey/command/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Honey
+  module Command
+    # Display version
+    class Version
+
+      def self.execute(options)
+        puts Honey::VERSION
+      end
+
+    end
+ end
+end

data/lib/honey/version.rb

@@ -0,0 +1,3 @@
+module Honey
+  VERSION = "0.0.6"
+end

data/lib/okapi.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+require 'rubygems'
+require "okapi/config"
+require "okapi/output"
+require "okapi/apiary_connector"
+require "okapi/resources"
+require "okapi/spec_parser"
+require "okapi/test"
+require "okapi/cli"
+require "okapi/help"
+
+module Okapi
+end

data/lib/okapi/apiary_connector.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+require 'rest_client'
+require 'json'
+
+module Honey
+  module Okapi
+    class ApiaryConnector
+      attr_reader :apiary_url, :blueprint
+
+      def initialize(apiary_url, req_path, res_path)
+        @apiary_url = apiary_url
+        @req_path = req_path
+        @res_path  = res_path
+      end
+
+      def get_response(raw_resp, json_data, error, code)
+        { :resp => raw_resp,
+          :data => json_data ? json_data['requests'] : nil,
+          :status => json_data ? json_data['status'] : nil ,
+          :error => json_data ? json_data['error'] || error : error,
+          :code => code
+          }
+      end
+
+      def get_requests(resources, blueprint, all_resources = false, global_vars = {})
+        resources_list = []
+
+        resources.each() do |res|
+          resources_list << {
+            :resource =>  res['resource'],
+            :method =>  res['method'],
+            :params =>  res['params']
+          }
+        end
+
+        data = {
+          :resources => resources_list,
+          :blueprint => blueprint,
+          :all_resources => all_resources,
+          :global_vars => global_vars
+        }.to_json()
+        
+        begin
+          response = RestClient.post @apiary_url + @req_path, data, :content_type => :json, :accept => :json
+          get_response(response, JSON.parse(response.to_str), nil, response.code.to_i)
+        rescue RestClient::BadRequest, RestClient::InternalServerError  => e
+          begin
+            data = JSON.parse(e.http_body)
+            get_response(nil, JSON.parse(e.http_body), data['error'], e.http_code.to_i)
+          rescue
+            get_response(nil, nil, e.to_s, e.http_code.to_i)
+          end
+        rescue Exception => e
+          get_response(nil, nil, e.to_s, nil)
+        end
+
+      end
+
+      def get_results(resources, blueprint)
+        resources_list = []
+        resources.each() do |res|
+          resources_list << {
+            :request => {
+              :uri =>  res.uri,
+              :expandedUri => res.expanded_uri,
+              :method =>  res.method,
+              :headers =>  res.headers,
+              :body =>  res.body,
+            },
+            :response => {
+              :status =>  res.response.status,
+              :headers => res.response.headers ,
+              :body =>  res.response.body
+            }
+          }
+        end
+
+        data = {
+          :resources => resources_list,
+          :blueprint => blueprint
+        }.to_json()
+
+        begin
+          response = RestClient.post @apiary_url + @res_path, data, :content_type => :json, :accept => :json
+          get_response(response, JSON.parse(response.to_str), nil, response.code.to_i)
+        rescue RestClient::BadRequest, RestClient::InternalServerError  => e
+          begin
+            get_response(nil, JSON.parse(e.http_body), data['error'], e.http_code.to_i)
+          rescue
+            get_response(nil, nil, e.to_s, e.http_code.to_i)
+          end
+        rescue Exception => e
+          get_response(nil, nil, e.to_s, nil)
+        end
+      end
+    end
+  end
+end

data/lib/okapi/cli.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+require 'optparse'
+require 'yaml'
+
+module Honey
+  module Okapi
+    class CLI
+
+      def initialize(args)
+        case args.first
+          when 'help'
+            Honey::Okapi::Help.show
+            exit 0
+          when 'okapi'
+            Honey::Okapi::Help.okapi
+            exit 0
+          else
+            parse_options!(args)
+            parse_config
+            @options[:blueprint]   ||= BLUEPRINT_PATH
+            @options[:test_spec]   ||= TEST_SPEC_PATHS
+            @options[:output]      ||= OUTPUT
+            @options[:test_url]    ||= TEST_URL
+            @options[:apiary_url]  ||= APIARY_URL
+
+            @options[:test_spec] ||= TEST_SPEC_PATHS.gsub(' ','').split(',')
+
+            if @options[:params]
+              puts "running with :"
+              p @options
+              puts "\n"
+            end
+
+            exit run
+        end    
+      end
+
+      def run
+        pass = true
+        @options[:test_spec].each { |spec|
+          pass = Honey::Okapi::Test.new(@options[:blueprint], spec, @options[:test_url], @options[:output], @options[:apiary_url]).run()
+          }
+        if pass
+          0
+        else
+          1
+        end
+      end
+
+      def parse_config
+        begin
+          if tests = YAML.load_file(@options[:config_path])['tests']
+            @options[:test_url] ||= tests['host'] if tests['host']
+            @options[:test_spec] ||= tests['specs'] if tests['specs']
+          end
+        rescue Errno::ENOENT  => e          
+          puts "Config file (#{@options[:config_path]}) not accessible ... skiping"
+          puts "\n"
+        rescue Exception => e
+          puts "Config file (#{@options[:config_path]}) loading problem :#{e}"
+          puts "\n"
+          exit 1
+        end
+      end
+
+      def parse_options!(args)
+        @options = {}
+        options_parser = OptionParser.new do |opts|
+          opts.on("-c", "--config CONFIG",
+                  "path config file (default: " + CONFIG_PATH + " )") do |config|
+            @options[:config_path] = config
+          end
+
+          opts.on("-b", "--blueprint BLUEPRINT",
+                  "path to the blueprint (default: " + BLUEPRINT_PATH + " )") do |blueprint|            
+            @options[:blueprint] = blueprint
+          end
+
+          opts.on("-t","--test_spec TEST_SPEC",
+                  "comma separated paths to the test specifications (default: " + TEST_SPEC_PATHS + " )") do |test_spec|
+            @options[:test_spec] = test_spec
+          end
+
+          opts.on("-o","--output OUTPUT",
+                  "output format (default" + OUTPUT + ")") do |output|
+            @options[:output] = output
+          end
+
+          opts.on("-u","--test_url TEST_URL",
+                  "url to test (default" + TEST_URL + ")") do |test_url|
+            @options[:test_url] = test_url
+          end
+
+          opts.on("-a","--apiary APIARY",
+                  "apiary url  (default" + APIARY_URL + ")") do |apiary|
+            @options[:apiary_url] = apiary
+          end
+
+          opts.on("-p","--params [PARAMS]",
+                  "show parameters" ) do |params|
+            @options[:params] = true
+          end          
+        end
+
+        options_parser.parse!
+
+        @options[:config_path]  ||= CONFIG_PATH
+        @options[:test_spec] = @options[:test_spec].gsub(' ','').split(',') if @options[:test_spec]
+
+        @options
+
+      rescue OptionParser::InvalidOption => e
+        puts "\n"
+        puts e
+        Honey::Okapi::Help.banner
+        puts "\n"
+        exit 1
+      end
+
+    end
+  end
+end