yard-contracts 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a252e7a360f2df858df3b4e3d43c2d163f73abc
+  data.tar.gz: a77c9eb8b9dce8d9c4e797074f79458892665074
+SHA512:
+  metadata.gz: 33c4cbc331e304b7b59590169d4a6f99f09ae8ed3fd3754567676942a653d8cedcc1b769f11fe9cefb5939462749d118a9c3c7fc39f855a69bfe78b3ddfb140b
+  data.tar.gz: 612f609be55f7ef6dfc8f39a47de8ee710e13ba76dcd042e7f3a4b97db5b08d1d9f9aeef664ba9e90f03d59d705da94aadde2261981a0d216e3122df2508bd80

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+yard-contracts-*.gem
+.ruby-version

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.2.1
+  - 2.1
+  - 2.0
+  - jruby-19mode
+script: bundle exec rspec

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in yard-contracts.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Simon George
+
+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,133 @@
+# yard-contracts
+
+[![Build Status](https://travis-ci.org/sfcgeorge/yard-contracts.svg?branch=master)](https://travis-ci.org/sfcgeorge/yard-contracts)
+
+yard-contracts is a YARD plugin that works with the fantastic Contracts gem to automatically document types and descriptions of parameters in your method signatures, saving time, making your code concise and keeping your documentation consistent.
+
+Have you ever got fed up of coding validations, writing error messages and then documenting those things? All this duplication and boilerplate code has always bugged me. Contracts solves the validations and error messages part already, turning many lines of repetitive code into 1 terse readable one. This extension now solves the documentation part making documentation automatically say the same as your validations.
+
+* Types gleaned from Contract and automatically linked with the method signature then added to param documentation.
+* to_s is called on the types and where it is useful, added to the param documentation as the description.
+* If any params are already documented manually, the extra information from the Contract is merged in rather than overriding or duplicating; allowing full flexibility.
+
+I've used this plugin gem on an existing project and documented 69 methods; it seems to be working great! Note I haven't used all corners of YARD, so there may be advanced features or scenarios that this doesn't work for, please open an issue if you find one. For straightforward projects, however, it's fantastic.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'yard-contracts'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install yard-contracts
+
+## Examples
+
+See these two equivalent(ish) examples and be blown away.
+
+Before Contracts and yard-contracts:
+
+```ruby
+# Find the root of a number, like `Math.sqrt` for arbitrary roots.
+# @param root [Numeric] Root must be greater than zero.
+# @param num [Numeric] Can't take root of a negative number.
+# @return [Numeric] Result will be greater than zero.
+def root(root, num) 
+  unless root.is_a?(Numeric) && root > 0
+    raise "root must be Numeric and > 0."
+  end
+  unless num.is_a?(Numeric) && num >= 0
+    raise "num must be Numeric and >= 0."
+  end
+
+  result = num**(1.0/root)
+
+  unless result.is_a?(Numeric) && result >= 0
+    raise "return wasn't Numeric or >= 0."
+  end
+
+  return result
+end
+```
+
+After:
+
+```ruby
+# Find the root of a number, like `Math.sqrt` for arbitrary roots.
+# @param num Can't take root of a negative number.
+Contract Pos, Nat => Nat
+def root(root, num) 
+  num**(1.0/root)
+end
+```
+
+Isn't that nicer? In the above after example, `@param root ...` and `@return ...` are automatically added to the documentation with their type and no description was deemed necessary. The `num` param has a manual documentation description, that automatically has it's type merged in. This gives you the flexibility to document parameters as explicitly as you like with the minimum of duplication.
+
+There is another option for adding more detailed parameter descriptions without duplication of the parameter name or the problem of keeping documentation in sync across methods... and it's already built into Contracts: custom type classes with `to_s`! The above example would be a bad place to do this as there's only one method, but imagine your project had lots of methods that calculate roots on numbers or pass those numbers around---you'd end up duplicating the documentation for the `num` parameter. Instead add a custom type class `Rootable` or more explicitly `RootableNum` if you prefer:
+
+```ruby
+class Rootable
+  def self.valid? val
+    Nat.valid? val
+  end
+
+  def self.to_s
+    "(Nat) Can't take root of a negative number."
+  end
+end
+
+# Find the root of a number, like `Math.sqrt` for arbitrary roots.
+Contract Pos, Rootable => Rootable
+def root(root, num) 
+  num**(1.0/root)
+end
+```
+
+Wow, the code and docstring is now as terse as possible with no duplication at all. Documentation generated will include the type and custom description as before, and now `Rootable` can be used all throughout the project making everything concise and clear. Plus, run time errors will have the same description from `Rootable` making it easier to debug as your documentation matches your errors. Perfect.
+
+For yard-contracts to pick up these custom type classes they you need to supply the path to the file they are defined in to YARD with the -e flag, and they must be defined directly under the Contracts namespace or the global namespace.
+
+See Contracts for more information on creating custom type classes.
+
+## Usage
+
+YARD needs to be made aware of this plugin. Simply give it to YARD with the --plugin flag:
+
+```
+bundle exec yardoc --plugin contracts
+```
+
+If you have defined custom type classes, they need to be given to YARD as well. First they must be specified in the global namespace or directly under the Contracts namespace. Give YARD the path to your custom contracts with the -e flag:
+
+```
+bundle exec yardoc --plugin contracts -e lib/my_project/custom_contracts.rb
+```
+
+If using a local fork of yard-contracts you can specify your path to `yard_extensions.rb` with the -e flag instead.
+
+```
+bundle exec yardoc -e path/to/lib/yard_extensions.rb
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Open issues, and if you can please send pull requests:
+
+1. Fork it ( https://github.com/sfcgeorge/yard-contracts/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "yard-contracts"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/yard-contracts/contract_handler.rb

@@ -0,0 +1,84 @@
+# FIXME: YARD is broken for named arguments in Ruby 2.2, the problem is with
+# a Ripper regression in the standard library! Very annoying.
+# To use YARD you must downgrade to 2.1 temporarily until 2.2 is patched.
+# https://github.com/lsegal/yard/issues/825
+require 'yard'
+
+#require 'contracts/formatters'
+require 'contracts/builtin_contracts'
+require 'yard-contracts/formatters'
+
+# Run the plugin handler by supplying it to yard with the --plugin flag, e.g.
+#
+# bundle exec yardoc --plugin contracts
+class ContractHandler < YARD::Handlers::Ruby::Base
+  handles method_call(:Contract)
+  namespace_only #only match method calls inside a namespace not inside a method
+
+  def process
+    # statement is a YARD attribute, subclassing YARD::Parser::Ruby::AstNode
+    # Here it's class will be YARD::Parser::Ruby::MethodCallNode
+    # MethodCallNode#line_range returns the lines the method call was over
+    # AstNode#line gives the first line of the node
+    # AstNode#traverse takes a block and yields child nodes
+    # AstNode#jump returns the first node matching type, otherwise returns self
+
+    # Go up the tree to namespace level, then jump to next def statement
+    # Note: this won't document dynamicly defined methods.
+    parent = statement.parent
+    contract_last_line = statement.line_range.last
+    #YARD::Parser::Ruby::MethodDefinitionNode
+    def_method_ast = parent.traverse do |node|
+      # Find the first def statement that comes after the contract we're on
+      break node if node.line > contract_last_line && node.def?
+    end
+
+    ## Hacky way to test for class methods
+    ## TODO: What about module methods? Probably broken.
+    scope = def_method_ast.source.match(/ self\./) ? :class : :instance
+    name = def_method_ast.method_name true
+    params = def_method_ast.parameters #YARD::Parser::Ruby::ParameterNode
+    contracts = statement.parameters #YARD::Parser::Ruby::AstNode
+
+    ret = Contracts::Formatters::ParamContracts.new(params, contracts).return
+    params = Contracts::Formatters::ParamContracts.new(params, contracts).params
+    docstring = YARD::DocstringParser.new.parse(statement.docstring).to_docstring
+
+    # Merge params into provided docstring otherwise there can be duplicates
+    docstring.tags(:param).each do |tag|
+      param = params.find{ |t| t[0].to_s == tag.name.to_s }
+      if param
+        params.delete(param)
+        tag.types ||= []
+        tag.types << param[1].inspect
+        tag.text = "#{param[2].empty? ? '' : "#{param[2]}. "}#{tag.text}"
+      end
+    end
+    # If the docstring didn't contain all of the params already add the rest
+    params.each do |param|
+      docstring.add_tag(
+        YARD::Tags::Tag.new(:param, param[2].to_s, param[1].inspect, param[0])
+      )
+    end
+
+    # Merge return into provided docstring otherwise there can be a duplicate
+    # NOTE: Think about what to do with multiple returns
+    if (tag = docstring.tag(:return))
+      tag.types ||= []
+      tag.types << ret[0].inspect
+      tag.text = "#{ret[1].empty? ? '' : "#{ret[1]}. "}#{tag.text}"
+    else
+      # If the docstring didn't contain a return already add it
+      docstring.add_tag(
+        YARD::Tags::Tag.new(:return, ret[1].to_s, ret[0].inspect)
+      )
+    end
+
+    # YARD hasn't got to the def method yet, so we create a stub of it with
+    # our docstring, when YARD gets to it properly it will fill in the rest.
+    YARD::CodeObjects::MethodObject.new(namespace, name, scope) do |o|
+      o.docstring = docstring
+    end
+    # No `register()` it breaks stuff! Above implicit return value is enough.
+  end
+end

data/lib/yard-contracts/formatters.rb

@@ -0,0 +1,260 @@
+require 'contracts/builtin_contracts'
+
+module Contracts
+  # A namespace for classes related to formatting.
+  module Formatters
+    # Used to format contracts for the `Expected:` field of error output.
+    class Expected
+      def initialize(contract, full=true)
+        @contract, @full = contract, full
+      end
+
+      # Formats any type of Contract.
+      def contract(contract = @contract)
+        if contract.is_a?(Hash)
+          hash_contract(contract)
+        elsif contract.is_a?(Array)
+          array_contract(contract)
+        else
+          InspectWrapper.new(contract, @full)
+        end
+      end
+
+      # Formats Hash contracts.
+      def hash_contract(hash)
+        @full = true
+        hash.inject({}) { |repr, (k, v)|
+          repr.merge(k => InspectWrapper.new(contract(v), @full))
+        }.inspect
+      end
+
+      # Formats Array contracts.
+      def array_contract(array)
+        @full = true
+        array.map{ |v| InspectWrapper.new(contract(v), @full) }.inspect
+      end
+    end
+
+    # A wrapper class to produce correct inspect behaviour for different
+    # contract values - constants, Class contracts, instance contracts etc.
+    class InspectWrapper
+      def initialize(value, full=true)
+        @value, @full = value, full
+      end
+
+      # Inspect different types of contract values.
+      # Contracts module prefix will be removed from classes.
+      # Custom to_s messages will be wrapped in round brackets to differentiate
+      # from standard Strings.
+      # Primitive values e.g. 42, true, nil will be left alone.
+      def inspect
+        return '' unless full?
+        return @value.inspect if empty_val?
+        return @value.to_s if plain?
+        return delim(@value.to_s) if has_useful_to_s?
+        @value.inspect.gsub(/^Contracts::/, '')
+      end
+
+      def delim(value)
+        @full ? "(#{value})" : "#{value}"
+      end
+
+      # Eliminates eronious quotes in output that plain inspect includes.
+      def to_s
+        inspect
+      end
+
+      private
+      def empty_val?
+        @value.nil? || @value == ""
+      end
+
+      def full?
+        @full ||
+        @value.is_a?(Hash) || @value.is_a?(Array) ||
+        (!plain? && has_useful_to_s?)
+      end
+
+      def plain?
+        # Not a type of contract that can have a custom to_s defined
+        !@value.is_a?(CallableClass) && @value.class != Class
+      end
+
+      def has_useful_to_s?
+        # Useless to_s value or no custom to_s behavious defined
+        # Ruby < 2.0 makes inspect call to_s so this won't work
+        @value.to_s != "" && @value.to_s != @value.inspect
+      end
+    end
+
+    class TypesAST
+      def initialize(types)
+        @types = types[0..-2]
+      end
+
+      def to_a
+        types = []
+        @types.each_with_index do |type, i|
+          if i == @types.length-1
+            # Get the param out of the `param => result` part
+            types << [type.first.first.source, type.first.first]
+          else
+            types << [type.source, type]
+          end
+        end
+        types
+      end
+
+      def result
+        # Get the result out of the `param => result` part
+        [@types.last.last.last.source, @types.last.last.last]
+      end
+    end
+
+    class ParamsAST
+      def initialize(params)
+        @params = params
+      end
+
+      def to_a
+        params = []
+        @params.each_with_index do |param, i|
+          #YARD::Parser::Ruby::AstNode
+          next if param.nil?
+          if param.type == :list
+            param.each do |p|
+              next if p.nil?
+              params << build_param_element(p)
+            end
+          else
+            params << build_param_element(param)
+          end
+        end
+        params
+      end
+
+      private
+      def build_param_element(param)
+        type = param.type
+        ident = param.jump(:ident, :label).last.to_sym
+        [type, ident]
+      end
+    end
+
+    class TypeAST
+      def initialize(type)
+        @type = type
+      end
+
+      # Formats any type of type.
+      def type(type = @type)
+        if type.type == :hash
+          hash_type(type)
+        elsif type.type == :array
+          array_type(type)
+        else
+          type.source
+        end
+      end
+
+      # Formats Hash type.
+      def hash_type(hash)
+        # Ast inherits from Array not Hash so we have to enumerate :assoc nodes
+        # which are key value pairs of the Hash and build from that.
+        result = {}
+        hash.each do |h|
+          result[h[0].jump(:label).last.to_sym] = Contracts::Formatters::InspectWrapper.new(type(h[1]))
+        end
+        result
+      end
+
+      # Formats Array type.
+      def array_type(array)
+        # This works because Ast inherits from Array.
+        array.map{ |v| Contracts::Formatters::InspectWrapper.new(type(v)) }.inspect
+      end
+    end
+
+    class ParamContracts
+      def initialize(param_string, types_string)
+        @params = ParamsAST.new(param_string).to_a
+        types = TypesAST.new(types_string)
+        @types = types.to_a
+        @result = types.result
+      end
+
+      def params
+        s = []
+        i = named_count = 0
+        @params.each do |param|
+          param_type, param = param
+
+          on_named = param_type == :named_arg ||
+                    (named_count > 0 && param_type == :ident)
+          i -= named_count if on_named
+
+          type, type_ast = @types[i]
+          con = get_contract_value(type)
+          type = TypeAST.new(type_ast).type
+
+          # Ripper has :rest_param (splat) but nothing for doublesplat,
+          # it's just called :ident the same as required positional params.
+          # This is really annoying. So we have to figure it out.
+          if on_named
+            @named_con ||= con
+            @named_type ||= type
+            if @named_con.is_a? Hash
+              if param_type == :named_arg
+                con = @named_con.delete(param)
+                type = @named_type.delete(param)
+              else
+                con = @named_con
+                type = @named_type
+              end
+            else
+              @named_con = con = '?'
+              @named_type = type = []
+            end
+            named_count = 1
+          end
+
+          type = Contracts::Formatters::InspectWrapper.new(type)
+          desc = Contracts::Formatters::Expected.new(con, false).contract
+          # The pluses are to escape things like curly brackets
+          desc = "#{desc}".empty? ? '' : "+#{desc}+"
+          s << [param, type, desc]
+          i += 1
+        end
+        s
+      end
+
+      def return
+        type, type_ast = @result
+        con = get_contract_value(type)
+        type = Contracts::Formatters::InspectWrapper.new(
+          TypeAST.new(type_ast).type
+        )
+        desc = Contracts::Formatters::Expected.new(con, false).contract
+        desc = "#{desc}".empty? ? '' : "+#{desc}+"
+        [type, desc]
+      end
+
+      private
+      # The contract starts as a string, but we need to get it's real value
+      # so that we can call to_s on it.
+      def get_contract_value(type)
+        con = type
+        begin
+          con = Contracts.const_get(type)
+        rescue Exception #NameError
+          begin
+            con = eval(type)
+          rescue Exception
+            con
+          end
+        end
+        con
+      end
+    end
+  end
+end

data/lib/yard-contracts/version.rb

@@ -0,0 +1,3 @@
+module YARDContracts
+  VERSION = "0.1.0"
+end

data/lib/yard-contracts.rb

@@ -0,0 +1,5 @@
+require "yard-contracts/version"
+require File.join(File.dirname(__FILE__), 'yard-contracts', 'contract_handler')
+
+module YARDContracts
+end

data/yard-contracts.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'yard-contracts/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "yard-contracts"
+  spec.version       = YARDContracts::VERSION
+  spec.authors       = ["Simon George"]
+  spec.email         = ["simon@sfcgeorge.co.uk"]
+
+  spec.summary       = %q{YARD Plugin for Automatic Param Docs from Contracts}
+  spec.description   = %q{This YARD plugin uses Contracts and method signatures,
+    merged with your optional docstring to automatically generate parameter
+    documentation with type and description. It does the same for return.
+  }
+  spec.homepage      = "https://github.com/sfcgeorge/yard-contracts"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  #if spec.respond_to?(:metadata)
+    #spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com' to prevent pushes to rubygems.org, or delete to allow pushes to any server."
+  #end
+
+  spec.add_dependency "yard", "~> 0.8"
+  spec.add_dependency "contracts", "~> 0.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "nokogiri", "~> 1.6"
+  spec.add_development_dependency "kramdown", "~> 1.6"
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: yard-contracts
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Simon George
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: contracts
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+description: "This YARD plugin uses Contracts and method signatures,\n    merged with
+  your optional docstring to automatically generate parameter\n    documentation with
+  type and description. It does the same for return.\n  "
+email:
+- simon@sfcgeorge.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/yard-contracts.rb
+- lib/yard-contracts/contract_handler.rb
+- lib/yard-contracts/formatters.rb
+- lib/yard-contracts/version.rb
+- yard-contracts.gemspec
+homepage: https://github.com/sfcgeorge/yard-contracts
+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.4.5
+signing_key: 
+specification_version: 4
+summary: YARD Plugin for Automatic Param Docs from Contracts
+test_files: []
+has_rdoc: