rspec_api_documentation 0.3.1

data/lib/rspec_api_documentation.rb

@@ -0,0 +1,36 @@
+require 'active_support'
+
+module RspecApiDocumentation
+  extend ActiveSupport::Autoload
+
+  require 'rspec_api_documentation/railtie' if defined?(Rails)
+  include ActiveSupport::JSON
+
+  eager_autoload do
+    autoload :Configuration
+    autoload :ApiDocumentation
+    autoload :ApiFormatter
+    autoload :Example
+    autoload :ExampleGroup
+    autoload :Index
+    autoload :TestClient
+  end
+
+  autoload :DSL
+  autoload :TestServer
+  autoload :HtmlWriter
+  autoload :JsonWriter
+  autoload :IndexWriter
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.documentations
+    @documentations ||= configuration.map { |config| ApiDocumentation.new(config) }
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
+end

data/lib/rspec_api_documentation/api_documentation.rb

@@ -0,0 +1,38 @@
+module RspecApiDocumentation
+  class ApiDocumentation
+    attr_reader :configuration, :index
+
+    delegate :docs_dir, :format, :to => :configuration
+
+    def initialize(configuration)
+      @configuration = configuration
+      @index = Index.new
+    end
+
+    def clear_docs
+      if File.exists?(docs_dir)
+        FileUtils.rm_rf(docs_dir, :secure => true)
+      end
+      FileUtils.mkdir_p(docs_dir)
+    end
+
+    def document_example(rspec_example)
+      example = Example.new(rspec_example, configuration)
+      if example.should_document?
+        index.examples << example
+      end
+    end
+
+    def write
+      writers.each do |writer|
+        writer.write(index, configuration)
+      end
+    end
+
+    def writers
+      [*configuration.format].map do |format|
+        RspecApiDocumentation.const_get("#{format}_writer".classify)
+      end
+    end
+  end
+end

data/lib/rspec_api_documentation/api_formatter.rb

@@ -0,0 +1,45 @@
+require 'rspec/core/formatters/base_formatter'
+
+module RspecApiDocumentation
+  class ApiFormatter < RSpec::Core::Formatters::BaseFormatter
+    def initialize(output)
+      super
+
+      output.puts "Generating API Docs"
+    end
+
+    def start(example_count)
+      super
+
+      RspecApiDocumentation.documentations.each(&:clear_docs)
+    end
+
+    def example_group_started(example_group)
+      super
+
+      output.puts "  #{example_group.description}"
+    end
+
+    def example_passed(example)
+      super
+
+      output.puts "    * #{example.description}"
+
+      RspecApiDocumentation.documentations.each do |documentation|
+        documentation.document_example(example)
+      end
+    end
+
+    def example_failed(example)
+      super
+
+      output.puts "    ! #{example.description} (FAILED)"
+    end
+
+    def stop
+      super
+
+      RspecApiDocumentation.documentations.each(&:write)
+    end
+  end
+end

data/lib/rspec_api_documentation/configuration.rb

@@ -0,0 +1,66 @@
+module RspecApiDocumentation
+  class Configuration
+    include Enumerable
+
+    attr_reader :parent
+
+    def initialize(parent = nil)
+      @parent = parent
+      @settings = parent.settings.clone if parent
+    end
+
+    def groups
+      @groups ||= []
+    end
+
+    def define_group(name, &block)
+      subconfig = self.class.new(self)
+      subconfig.filter = name
+      subconfig.docs_dir = self.docs_dir.join(name.to_s)
+      yield subconfig
+      groups << subconfig
+    end
+
+    def self.add_setting(name, opts = {})
+      define_method("#{name}=") { |value| settings[name] = value }
+      define_method("#{name}") do
+        if settings.has_key?(name)
+          settings[name]
+        elsif opts[:default].respond_to?(:call)
+          opts[:default].call(self)
+        else
+          opts[:default]
+        end
+      end
+    end
+
+    add_setting :docs_dir, :default => lambda { |config|
+      if defined?(Rails)
+        Rails.root.join("docs")
+      else
+        Pathname.new("docs")
+      end
+    }
+
+    add_setting :format, :default => :html
+    add_setting :template_path, :default => File.expand_path("../../../templates", __FILE__)
+    add_setting :filter, :default => :all
+    add_setting :exclusion_filter, :default => nil
+    add_setting :app, :default => lambda { |config|
+      if defined?(Rails)
+        Rails.application
+      else
+        nil
+      end
+    }
+
+    def settings
+      @settings ||= {}
+    end
+
+    def each(&block)
+      yield self
+      groups.map { |g| g.each &block }
+    end
+  end
+end

data/lib/rspec_api_documentation/dsl.rb

@@ -0,0 +1,204 @@
+require 'rack/test/methods'
+require 'rack'
+require 'webmock'
+
+module RspecApiDocumentation
+  module DSL
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def self.define_action(method)
+        define_method method do |*args, &block|
+          options = if args.last.is_a?(Hash) then args.pop else {} end
+          options[:method] = method
+          options[:path] = args.first
+          args.push(options)
+          args[0] = "#{method.to_s.upcase} #{args[0]}"
+          context(*args, &block)
+        end
+      end
+
+      define_action :get
+      define_action :post
+      define_action :put
+      define_action :delete
+
+      def parameter(name, description, options = {})
+        parameters.push(options.merge(:name => name.to_s, :description => description))
+      end
+
+      def required_parameters(*names)
+        names.each do |name|
+          param = parameters.find { |param| param[:name] == name.to_s }
+          raise "Undefined parameters can not be required." unless param
+          param[:required] = true
+        end
+      end
+
+      def callback(description, &block)
+        self.send(:include, WebMock::API)
+        context(description, &block)
+      end
+
+      def trigger_callback(&block)
+        define_method(:do_callback) do
+          stub_request(:any, callback_url).to_rack(destination)
+          instance_eval &block
+        end
+      end
+
+      def scope_parameters(scope, keys)
+        return unless metadata[:parameters]
+
+        if keys == :all
+          keys = parameter_keys.map(&:to_s)
+        else
+          keys = keys.map(&:to_s)
+        end
+
+        keys.each do |key|
+          param = parameters.detect { |param| param[:name] == key }
+          param[:scope] = scope if param
+        end
+      end
+
+      def example_request(description, params = {}, &block)
+        example(description) do
+          do_request(params)
+          instance_eval &block if block_given?
+        end
+      end
+
+      private
+      def parameters
+        metadata[:parameters] ||= []
+        if superclass_metadata && metadata[:parameters].equal?(superclass_metadata[:parameters])
+          metadata[:parameters] = Marshal.load(Marshal.dump(superclass_metadata[:parameters]))
+        end
+        metadata[:parameters]
+      end
+
+      def parameter_keys
+        parameters.map { |param| param[:name] }
+      end
+    end
+
+    module InstanceMethods
+      def client
+        @client ||= TestClient.new(self)
+      end
+
+      def destination
+        @destination ||= TestServer.new(self)
+      end
+
+      def callback_url
+        raise "You must define callback_url"
+      end
+
+      def do_request(extra_params = {})
+        @extra_params = extra_params
+        params_or_body = nil
+        path_or_query = path
+
+        if method == :get && !query_string.blank?
+          path_or_query = path + "?#{query_string}"
+        else
+          params_or_body = respond_to?(:raw_post) ? raw_post : params
+        end
+
+        client.send(method, path_or_query, params_or_body)
+      end
+
+      def query_string
+        query = params.to_a.map do |param|
+          param.map! { |a| CGI.escape(a.to_s) }
+          param.join("=")
+        end
+        query.join("&")
+      end
+
+      def params
+        return unless example.metadata[:parameters]
+        parameters = example.metadata[:parameters].inject({}) do |hash, param|
+          set_param(hash, param)
+        end
+        parameters.merge!(extra_params)
+        parameters
+      end
+
+      def method
+        example.metadata[:method]
+      end
+
+      def in_path?(param)
+        path_params.include?(param)
+      end
+
+      def path_params
+        example.metadata[:path].scan(/:(\w+)/).flatten
+      end
+
+      def path
+        example.metadata[:path].gsub(/:(\w+)/) do |match|
+          if respond_to?($1)
+            send($1)
+          else
+            match
+          end
+        end
+      end
+
+      def app
+        RspecApiDocumentation.configuration.app
+      end
+
+      def explanation(text)
+        example.metadata[:explanation] = text
+      end
+
+      def status
+        last_response.status
+      end
+
+      def response_body
+        last_response.body
+      end
+
+      private
+      def extra_params
+        return {} if @extra_params.nil?
+        @extra_params.inject({}) do |h, (k, v)|
+          h[k.to_s] = v
+          h
+        end
+      end
+
+      def set_param(hash, param)
+        key = param[:name]
+        return hash if !respond_to?(key) || in_path?(key)
+
+        if param[:scope]
+          hash[param[:scope].to_s] ||= {}
+          hash[param[:scope].to_s][key] = send(key)
+        else
+          hash[key] = send(key)
+        end
+
+        hash
+      end
+    end
+  end
+end
+
+def self.resource(*args, &block)
+  options = if args.last.is_a?(Hash) then args.pop else {} end
+  options[:api_docs_dsl] = true
+  options[:resource_name] = args.first
+  options[:document] = true
+  args.push(options)
+  describe(*args, &block)
+end
+
+RSpec.configuration.include RspecApiDocumentation::DSL, :api_docs_dsl => true
+RSpec.configuration.include Rack::Test::Methods, :api_docs_dsl => true

data/lib/rspec_api_documentation/example.rb

@@ -0,0 +1,49 @@
+module RspecApiDocumentation
+  class Example
+    attr_reader :example, :configuration
+
+    def initialize(example, configuration)
+      @example = example
+      @configuration = configuration
+    end
+
+    def method_missing(method_sym, *args, &block)
+      if example.metadata.has_key?(method_sym)
+        example.metadata[method_sym]
+      else
+        example.send(method_sym, *args, &block)
+      end
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      super || example.metadata.has_key?(method_sym) || example.respond_to?(method_sym, include_private)
+    end
+
+    def method
+      metadata[:method]
+    end
+
+    def should_document?
+      return false if pending? || !metadata[:resource_name] || !metadata[:document]
+      return true if configuration.filter == :all
+      return false if (Array(metadata[:document]) & Array(configuration.exclusion_filter)).length > 0
+      return true if (Array(metadata[:document]) & Array(configuration.filter)).length > 0
+    end
+
+    def public?
+      metadata[:public]
+    end
+
+    def has_parameters?
+      respond_to?(:parameters) && parameters.present?
+    end
+
+    def explanation
+      metadata[:explanation] || nil
+    end
+
+    def requests
+      metadata[:requests] || []
+    end
+  end
+end

data/lib/rspec_api_documentation/html_writer.rb

@@ -0,0 +1,72 @@
+require 'mustache'
+
+module RspecApiDocumentation
+  class HtmlWriter
+    attr_accessor :index, :configuration
+
+    def initialize(index, configuration)
+      self.index = index
+      self.configuration = configuration
+    end
+
+    def self.write(index, configuration)
+      writer = new(index, configuration)
+      writer.write
+    end
+
+    def write
+      File.open(configuration.docs_dir.join("index.html"), "w+") do |f|
+        f.write HtmlIndex.new(index, configuration).render
+      end
+      index.examples.each do |example|
+        html_example = HtmlExample.new(example, configuration)
+        FileUtils.mkdir_p(configuration.docs_dir.join(html_example.dirname))
+        File.open(configuration.docs_dir.join(html_example.dirname, html_example.filename), "w+") do |f|
+          f.write html_example.render
+        end
+      end
+    end
+  end
+
+  class HtmlIndex < Mustache
+    def initialize(index, configuration)
+      @index = index
+      @configuration = configuration
+      self.template_path = configuration.template_path
+    end
+
+    def sections
+      IndexWriter.sections(examples)
+    end
+
+    def examples
+      @index.examples.map { |example| HtmlExample.new(example, @configuration) }
+    end
+  end
+
+  class HtmlExample < Mustache
+    delegate :method, :to => :@example
+
+    def initialize(example, configuration)
+      @example = example
+      self.template_path = configuration.template_path
+    end
+
+    def method_missing(method, *args, &block)
+      @example.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @example.respond_to?(method, include_private)
+    end
+
+    def dirname
+      resource_name.downcase.gsub(/\s+/, '_')
+    end
+
+    def filename
+      basename = description.downcase.gsub(/\s+/, '_').gsub(/[^a-z_]/, '')
+      "#{basename}.html"
+    end
+  end
+end

data/lib/rspec_api_documentation/index.rb

@@ -0,0 +1,7 @@
+module RspecApiDocumentation
+  class Index
+    def examples
+      @examples ||= []
+    end
+  end
+end

data/lib/rspec_api_documentation/index_writer.rb

@@ -0,0 +1,11 @@
+module RspecApiDocumentation
+  module IndexWriter
+    def sections(examples)
+      resources = examples.group_by(&:resource_name).inject([]) do |arr, (resource_name, examples)|
+        arr << { :resource_name => resource_name, :examples => examples.sort_by(&:description) }
+      end
+      resources.sort_by { |resource| resource[:resource_name] }
+    end
+    module_function :sections
+  end
+end

data/lib/rspec_api_documentation/json_writer.rb

@@ -0,0 +1,93 @@
+module RspecApiDocumentation
+  class JsonWriter
+    attr_accessor :index, :configuration
+    delegate :docs_dir, :to => :configuration
+
+    def initialize(index, configuration)
+      self.index = index
+      self.configuration = configuration
+    end
+
+    def self.write(index, configuration)
+      writer = new(index, configuration)
+      writer.write
+    end
+
+    def write
+      File.open(docs_dir.join("index.json"), "w+") do |f|
+        f.write JsonIndex.new(index).to_json
+      end
+      index.examples.each do |example|
+        json_example = JsonExample.new(example)
+        FileUtils.mkdir_p(docs_dir.join(json_example.dirname))
+        File.open(docs_dir.join(json_example.dirname, json_example.filename), "w+") do |f|
+          f.write json_example.to_json
+        end
+      end
+    end
+  end
+
+  class JsonIndex
+    def initialize(index)
+      @index = index
+    end
+
+    def sections
+      IndexWriter.sections(examples)
+    end
+
+    def examples
+      @index.examples.map { |example| JsonExample.new(example) }
+    end
+
+    def to_json
+      sections.inject({:resources => []}) do |h, section|
+        h[:resources].push(
+          :name => section[:resource_name],
+          :examples => section[:examples].map { |example|
+            {
+              :description => example.description,
+              :link => "#{example.dirname}/#{example.filename}"
+            }
+          }
+        )
+        h
+      end.to_json
+    end
+  end
+
+  class JsonExample
+    delegate :method, :to => :@example
+
+    def initialize(example)
+      @example = example
+    end
+
+    def method_missing(method, *args, &block)
+      @example.send(method, *args, &block)
+    end
+
+    def respond_to?(method, include_private = false)
+      super || @example.respond_to?(method, include_private)
+    end
+
+    def dirname
+      resource_name.downcase.gsub(/\s+/, '_')
+    end
+
+    def filename
+      basename = description.downcase.gsub(/\s+/, '_').gsub(/[^a-z_]/, '')
+      "#{basename}.json"
+    end
+
+    def to_json
+      {
+        :resource => resource_name,
+        :description => description,
+        :explanation => explanation,
+        :parameters => respond_to?(:parameters) ? parameters : [],
+        :requests => requests
+      }.to_json
+    end
+  end
+end

data/lib/rspec_api_documentation/railtie.rb

@@ -0,0 +1,7 @@
+module RspecApiDocumentation
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/docs.rake"
+    end
+  end
+end

data/lib/rspec_api_documentation/test_client.rb

@@ -0,0 +1,124 @@
+module RspecApiDocumentation
+  class TestClient < Struct.new(:session, :options)
+    attr_accessor :user
+
+    delegate :example, :last_response, :last_request, :to => :session
+    delegate :metadata, :to => :example
+
+    def get(*args)
+      process :get, *args
+    end
+
+    def post(*args)
+      process :post, *args
+    end
+
+    def put(*args)
+      process :put, *args
+    end
+
+    def delete(*args)
+      process :delete, *args
+    end
+
+    def sign_in(user)
+      @user = user
+    end
+
+    def last_headers
+      session.last_request.env.select do |k, v|
+        k =~ /^(HTTP_|CONTENT_TYPE)/
+      end
+    end
+
+    def last_query_string
+      session.last_request.env["QUERY_STRING"]
+    end
+
+    def last_query_hash
+      strings = last_query_string.split("&")
+      arrays = strings.map do |segment|
+        segment.split("=")
+      end
+      Hash[arrays]
+    end
+
+    def headers(method, action, params)
+      if options && options[:headers]
+        options[:headers]
+      else
+        {}
+      end
+    end
+
+    private
+    def process(method, action, params = {})
+      session.send(method, action, params, headers(method, action, params))
+
+      document_example(method, action, params)
+    end
+
+    def document_example(method, action, params)
+      return unless metadata[:document]
+
+      input = last_request.env["rack.input"]
+      input.rewind
+      request_body = input.read
+
+      request_metadata = {}
+
+      request_metadata[:method] = method.to_s.upcase
+      request_metadata[:route] = action
+      if is_json?(request_body)
+        request_metadata[:request_body] = prettify_json(request_body)
+      else
+        request_metadata[:request_body] = prettify_request_body(request_body)
+      end
+      request_metadata[:request_headers] = format_headers(last_headers)
+      request_metadata[:request_query_parameters] = format_query_hash(last_query_hash)
+      request_metadata[:response_status] = last_response.status
+      request_metadata[:response_status_text] = Rack::Utils::HTTP_STATUS_CODES[last_response.status]
+      request_metadata[:response_body] = prettify_json(last_response.body)
+      request_metadata[:response_headers] = format_headers(last_response.headers)
+
+      metadata[:requests] ||= []
+      metadata[:requests] << request_metadata
+    end
+
+    def format_headers(headers)
+      headers.map do |key, value|
+        # HTTP_ACCEPT_CHARSET => Accept-Charset
+        formatted_key = key.gsub(/^HTTP_/, '').titleize.split.join("-")
+        "#{formatted_key}: #{value}"
+      end.join("\n")
+    end
+
+    def format_query_hash(query_hash)
+      return if query_hash.blank?
+      query_hash.map do |key, value|
+        "#{key}: #{CGI.unescape(value)}"
+      end.join("\n")
+    end
+
+    def prettify_json(json)
+      begin
+        JSON.pretty_generate(JSON.parse(json))
+      rescue
+        nil
+      end
+    end
+
+    def prettify_request_body(string)
+      return if string.blank?
+      CGI.unescape(string.split("&").join("\n"))
+    end
+
+    def is_json?(string)
+      begin
+        JSON.parse(string)
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/rspec_api_documentation/test_server.rb

@@ -0,0 +1,44 @@
+module RspecApiDocumentation
+  class TestServer < Struct.new(:session)
+    delegate :example, :last_request, :last_response, :to => :session
+    delegate :metadata, :to => :example
+
+    def call(env)
+      env["rack.input"].rewind
+
+      request_metadata = {}
+
+      request_metadata[:method] = env["REQUEST_METHOD"]
+      request_metadata[:route] = env["PATH_INFO"]
+      request_metadata[:request_body] = prettify_json(env["rack.input"].read)
+      request_metadata[:request_headers] = headers(env)
+
+      metadata[:requests] ||= []
+      metadata[:requests] << request_metadata
+
+      return [200, {}, [""]]
+    end
+
+    private
+
+    def headers(env)
+      env.
+        select do |k, v|
+          k =~ /^(HTTP_|CONTENT_TYPE)/
+        end.
+        map do |key, value|
+          # HTTP_ACCEPT_CHARSET => Accept-Charset
+          formatted_key = key.gsub(/^HTTP_/, '').titleize.split.join("-")
+          "#{formatted_key}: #{value}"
+        end.join("\n")
+    end
+
+    def prettify_json(json)
+      begin
+        JSON.pretty_generate(JSON.parse(json))
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/tasks/docs.rake

@@ -0,0 +1,9 @@
+require 'rspec/core/rake_task'
+
+if Rails.env.test? || Rails.env.development?
+  desc 'Generate API request documentation from API specs'
+  RSpec::Core::RakeTask.new('docs:generate') do |t|
+    t.pattern = 'spec/acceptance/**/*_spec.rb'
+    t.rspec_opts = ["--format RspecApiDocumentation::ApiFormatter"]
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: rspec_api_documentation
+version: !ruby/object:Gem::Version
+  version: 0.3.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Cahoon
+- Sam Goldman
+- Eric Oestrich
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70151618292380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618292380
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70151618291040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618291040
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: &70151618289580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618289580
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70151618288780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618288780
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: &70151618287740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618287740
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70151618286920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70151618286920
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: &70151618285800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151618285800
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &70151618283740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70151618283740
+description: Generate API docs from your test suite
+email:
+- chris@smartlogicsolutions.com
+- sam@smartlogicsolutions.com
+- eric@smartlogicsolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rspec_api_documentation/api_documentation.rb
+- lib/rspec_api_documentation/api_formatter.rb
+- lib/rspec_api_documentation/configuration.rb
+- lib/rspec_api_documentation/dsl.rb
+- lib/rspec_api_documentation/example.rb
+- lib/rspec_api_documentation/html_writer.rb
+- lib/rspec_api_documentation/index.rb
+- lib/rspec_api_documentation/index_writer.rb
+- lib/rspec_api_documentation/json_writer.rb
+- lib/rspec_api_documentation/railtie.rb
+- lib/rspec_api_documentation/test_client.rb
+- lib/rspec_api_documentation/test_server.rb
+- lib/rspec_api_documentation.rb
+- lib/tasks/docs.rake
+homepage: http://smartlogicsolutions.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A double black belt for your docs
+test_files: []