RubyGems - rubybreaker - Versions diffs - 0.0.1 - Mend

rubybreaker 0.0.1

Files changed (53) hide show

data/AUTHORS +7 -0
data/LICENSE +26 -0
data/README.md +403 -0
data/Rakefile +90 -0
data/TODO +30 -0
data/bin/gen_stub_rubylib +64 -0
data/bin/rubybreaker +67 -0
data/lib/rubybreaker/context.rb +122 -0
data/lib/rubybreaker/debug.rb +48 -0
data/lib/rubybreaker/error.rb +59 -0
data/lib/rubybreaker/rubylib/core.rb +2316 -0
data/lib/rubybreaker/rubylib.rb +3 -0
data/lib/rubybreaker/runtime/inspector.rb +57 -0
data/lib/rubybreaker/runtime/monitor.rb +235 -0
data/lib/rubybreaker/runtime/object_wrapper.rb +77 -0
data/lib/rubybreaker/runtime/overrides.rb +42 -0
data/lib/rubybreaker/runtime/pluggable.rb +57 -0
data/lib/rubybreaker/runtime/type_placeholder.rb +27 -0
data/lib/rubybreaker/runtime/type_system.rb +228 -0
data/lib/rubybreaker/runtime/typesig_parser.rb +45 -0
data/lib/rubybreaker/runtime.rb +103 -0
data/lib/rubybreaker/test/testcase.rb +39 -0
data/lib/rubybreaker/test.rb +1 -0
data/lib/rubybreaker/type/type.rb +241 -0
data/lib/rubybreaker/type/type_comparer.rb +143 -0
data/lib/rubybreaker/type/type_grammar.treetop +285 -0
data/lib/rubybreaker/type/type_unparser.rb +142 -0
data/lib/rubybreaker/type.rb +2 -0
data/lib/rubybreaker/typing/rubytype.rb +47 -0
data/lib/rubybreaker/typing/subtyping.rb +480 -0
data/lib/rubybreaker/typing.rb +3 -0
data/lib/rubybreaker/util.rb +31 -0
data/lib/rubybreaker.rb +193 -0
data/test/integrated/tc_method_missing.rb +30 -0
data/test/integrated/tc_simple1.rb +77 -0
data/test/runtime/tc_obj_wrapper.rb +73 -0
data/test/runtime/tc_typesig_parser.rb +33 -0
data/test/ts_integrated.rb +4 -0
data/test/ts_runtime.rb +5 -0
data/test/ts_type.rb +5 -0
data/test/ts_typing.rb +4 -0
data/test/type/tc_comparer.rb +211 -0
data/test/type/tc_parser.rb +219 -0
data/test/type/tc_unparser.rb +276 -0
data/test/typing/tc_rubytype.rb +63 -0
data/test/typing/tc_typing.rb +219 -0
data/webpage/footer.html +5 -0
data/webpage/generated_toc.js +319 -0
data/webpage/header.html +14 -0
data/webpage/images/logo.png +0 -0
data/webpage/index.html +439 -0
data/webpage/rubybreaker.css +53 -0
metadata +119 -0

data/webpage/index.html ADDED Viewed

@@ -0,0 +1,439 @@
+<html>
+<head>
+  <title>RubyBreaker</title>
+  <LINK REL=StyleSheet HREF="rubybreaker.css" TYPE="text/css">
+	<script type="text/javascript" src="generated_toc.js">  </script>
+</head>
+<body onLoad="createTOC()">
+  <center>
+	<div id="content">
+		<div id="logo">
+			<img src="images/logo.png" border="0">
+		</div>
+		<hr />
+		<div id="generated-toc"></div>
+<hr />
+<h1>Introduction</h1>
+<p>RubyBreaker is a dynamic type documentation tool written purely in Ruby. It
+provides the framework for dynamically instrumenting a Ruby program to
+monitor objects during executions and document the observed type
+information. The type documentation generated by RubyBreaker is also an
+executable Ruby code. It contains type signatures that can be interpreted by
+RubyBreaker Runtime Library and can be used in future documentation of the
+program.</p>
+<p>The primary goal of RubyBreaker is to assign a type signature to every
+method in designated modules and classes.  A type signature is written in
+the RubyBreaker Type Annotation Language which resembles the documentation
+style used in RubyDoc. Overall, this tool should help Ruby programmers
+document their code more rigorously and effectively.  Currently, manual
+modification of the user program is required to run RubyBreaker, but this is
+kept minimal.</p>
+<h2>Limitations</h2>
+<ul>
+<li>It only works on toy Ruby programs so far :)</li>
+<li>Block argument cannot be auto-documented. (Inherent)</li>
+<li>Manual modification (minimal) of code is required.</li>
+<li>No parametric polymorphic types are supported.</li>
+</ul>
+<h2>Requirements</h2>
+<p>Ruby 1.9.x and TreeTop 1.x</p>
+<p>If the most recent Ruby 1.9 is installed on the computer, it will probably
+work. If TreeTop is not installed, use RubyGems or download from the
+following URL: <a href="http://treetop.rubyforge.org/">TreeTop</a></p>
+<h2>Installation</h2>
+<p>It is as simple as running the following:</p>
+<pre><code>$ gem install rubybreaker
+</code></pre>
+<p>You probably want to test out your installation by running
+<code>rake test</code> in your RubyBreaker directory:</p>
+<pre><code>$ rake test
+</code></pre>
+<hr />
+<h1>Tutorial</h1>
+<p>This tutorial will describe the basic usage of the tool, the RubyBreaker
+Type Annotation Language, and the RubyBreaker Type System.</p>
+<h2>Usage</h2>
+<p>There are two ways to use RubyBreaker:</p>
+<pre><code>$ rubybreaker prog.rb
+</code></pre>
+<p>Or, use it as a Ruby library and just run the program on Ruby.</p>
+<pre><code>$ ruby prog.rb
+</code></pre>
+<p>Both methods require manual modification of the code, but the former will
+generate the output into a separate <code>.rubybreaker</code> file whereas the latter
+will display the output on the screen. The former will also automatically
+import the <code>.rubybreaker</code> file for the user program of which the output is
+appended at the end. Consequently, this output/input file will grow as more
+analysis is done on the program.</p>
+<p>For example, let us assume <code>prog.rb</code> as the following:</p>
+<pre><code>require "rubybreaker"
+class A
+  include RubyBreaker::Breakable
+  def foo(x)
+    x.to_s
+  end
+end
+class B
+  # include RubyBreaker::Breakable
+  def bar(y,z)
+    y.foo(z)
+  end
+end
+RubyBreaker.monitor()
+A.new.foo(1)
+</code></pre>
+<p>Do not worry about other parts of the code for now. This example is to show
+how <code>foo</code> method is <em>typed</em> by RubyBreaker.  After running <code>rubybreaker
+prog.rb</code>, the following output will be generated and saved into
+<code>prog.rubybreaker</code>.</p>
+<pre><code>require "rubybreaker"
+class A
+  include RubyBreaker::Broken
+  typesig("foo(fixnum[to_s]) -&gt; string")
+end
+</code></pre>
+<p>Now, assume that the last line of <code>prog.rb</code> is changed to
+<code>B.new.bar(A.new,1)</code> and the <code>include</code> command in class <code>B</code> is uncommented.
+The subsequent analysis will generate the following result:</p>
+<pre><code># This is auto-generated by RubyBreaker
+require "rubybreaker"
+class A
+  include RubyBreaker::Broken
+  typesig("foo(fixnum[to_s]) -&gt; string")
+end
+class B
+  include RubyBreaker::Broken
+  typesig("bar(a[foo], fixnum[to_s]) -&gt; string")
+end
+</code></pre>
+<p>RubyBreaker is designed to gather type information based on the actual
+execution of a program. This means the program should be equipped with
+test suites that cover a reasonable number of program paths for accurate
+results. Additionally, RubyBreaker assumes that test runs are correct
+and the program behaves correctly (for the test runs) as intended by
+the programmer. This assumption is not a strong requirement, but is
+necessary to obtain precise type information.</p>
+<p>In order to use RubyBreaker, there needs two kinds of manual code changes.
+First, the user must indicate which modules are subject to analysis and
+which modules can be used for the analysis. Next, the user has to indicate
+where the entry point of the program is. Alternatively, he has to make a
+small change to the test cases to use RubyBreaker's testing framework.</p>
+<h3>Breakable and Broken</h3>
+<p>In order to indicate modules and classes that already have type information
+or to designate those that need to be auto-documented, the user must be
+familiar with the two most important modules of RubyBreaker--<code>Breakable</code> and
+<code>Broken</code>. The former refers to a module (or a class) that needs dynamic
+instrumentation and monitoring for getting type information. The latter
+refers to a module that have type information already documented in type
+signature form.</p>
+<p>For example, consider the following Ruby code:</p>
+<pre><code>require "rubybreaker"
+class A
+  include RubyBreaker::Breakable
+  def foo(x)
+    x.to_s
+  end
+end
+</code></pre>
+<p>By including <code>Breakable</code>, class <code>A</code> is subject to dynamic instrumentation
+and monitoring. On the other hand, the following class is a <code>Broken</code> module.
+(Yes, like a crazy wild horse that has been <em>broken</em>!)</p>
+<pre><code>require "rubybreaker"
+class B
+  include RubyBreaker::Broken
+  typesig("bar(fixnum[to_s]) -&gt; string")
+  def foo(x)
+    x.to_s
+  end
+end
+</code></pre>
+<p>This tells RubyBreaker that class <code>B</code> has type information in place, and
+therefore, it will use the information for analyzing <code>Breakable</code> modules
+elsewhere (if applicable). In this example, a method <code>foo</code> has a type
+signature <code>bar(fixnum[to_s]) -&gt; string</code>, which means it takes an object that
+has <code>Fixnum</code>'s <code>to_s</code> method and returns a string. More detail on the type
+annotation language will be explained in later section.</p>
+<p>Currently, both <code>Breakable</code> and <code>Broken</code> only support instance methods.
+Furthermore, class and module methods can neither be monitored nor used for
+analysis. It is important to keep in mind that <code>Broken</code> module always wins.
+In other words, if a module is declared as both <code>Broken</code> and <code>Breakable</code>, it
+is treated as <code>Broken</code>.</p>
+<h3>Program Entry Point</h3>
+<p>In Ruby, as soon as a file is <code>require</code>d, the execution of that file begins.
+For RubyBreaker, however, it is not trivial to find the actual starting
+point of the program because there <em>has</em> to be a clear point in time at
+which monitoring of <code>Breakable</code> modules begins. <em>This is necessary as
+attempting to instrument and monitor at the same time will cause an infinite
+loop!</em></p>
+<p>Indicating the program entry point is simply done by inserting the following
+line at the code (assuming "<code>require 'rubybreaker'</code>" is already placed at
+the top of the file):</p>
+<pre><code>RubyBreaker.monitor()
+</code></pre>
+<p>It basically tells RubyBreaker to start monitoring. What really happens at
+this point is that all <code>Breakable</code> modules are dynamically instrumented so
+that they are ready to be monitored. Any execution after this point will
+run the instrumented code (for <code>Breakable</code> modules) which will gather type
+information for methods.</p>
+<p>Although this seems simple and easy, this is not the recommended way for
+analyzing a program. Why? Because RubyBreaker has a built-in testing
+framework that (supposedly :)) works seemlessly with the existing tests of
+the program.</p>
+<h3>Using RubyBreaker Testing Framework</h3>
+<p>Instead of manually inserting the entry point indicator into the program,
+the user can take advantage of the Ruby Unit Test framework. This is the
+recommended way of using RubyBreaker, especially for a long term program
+maintainability. But no worries! This method is as simple as the previous
+one.</p>
+<pre><code>require "rubybreaker"
+require "test/unit"
+class TestClassA &lt; Test::Unit::TestCase
+  include RubyBreaker::TestCase
+  # ...tests!...
+end
+</code></pre>
+<p>That's it!</p>
+<p>Currently, RubyBreaker only supports the standard unit test framework.
+Other testing frameworks such as RSpec and Cucumber are not supported at the
+moment (but will be in future/hopefully).</p>
+<h2>Type Annotation</h2>
+<p>The annotation language used in RubyBreaker resembles the method
+documentation used by Ruby Standard Library Doc. Each type signature
+defines a method type using the name, argument types, block type, and return
+type. But, let us consider a simple case where there is one argument type
+and a return type.</p>
+<pre><code>class A
+  ...
+  typesig("foo(fixnum) -&gt; string")
+end
+</code></pre>
+<p>In RubyBreaker, a type signature is recognized by the meta-class level
+method <code>typesig</code> which takes a string as an argument. This string is the
+actual type signature written in the Ruby Type Annotation Language. This
+language is designed to reflect the common documentation practice used by
+RubyDoc. It starts with the name of the method. In the above example, <code>foo</code>
+is currently being given a type. The rest of the signature takes a typical
+method type symbol, <code>(x) -&gt; y</code> where <code>x</code> is the argument type and <code>y</code> is the
+return type. In the example shown above, the method takes a <code>Fixnum</code> object
+and returns a <code>String</code> object. Note that these types are in lowercase,
+indicating they are objects and not modules or classes themselves.</p>
+<p>There are several types that represent an object: nominal, duck, fusion,
+nil, 'any', and block. Each type signature itself represents a method type
+or a method list type (explained below).</p>
+<h3>Nominal Type</h3>
+<p>This is the simplest and most intuitive way to represent an object. For
+instance, <code>fixnum</code> is an object of type <code>Fixnum</code>. Use lower-case letters and
+underscores instead of <em>camelized</em> name. <code>MyClass</code>, for example would be
+<code>my_class</code> in RubyBreaker type signatures. There is no particular
+reason for this convention other than it is the common practice used in
+RubyDoc.</p>
+<h3>Self Type</h3>
+<p>This type is similar to the nominal type but is referring to the current
+object--that is, the receiver of the method being typed. RubyBreaker will
+auto-document the return type as a self type if the return value is the same
+as the receiver of that call. It is also recommended to use this type over
+a nominal type (if the return value is <code>self</code>) since it depicts more
+precise return type.</p>
+<h3>Duck Type</h3>
+<p>This type is inspired by the Ruby Language's duck typing, <em>"if it
+walks like a duck and quacks like a duck, it must be a duck."</em> Using this
+type, an object can be represented simply by a list of method names. For
+example <code>[walks, quacks]</code> is an object that has <code>walks</code> and <code>quacks</code>
+methods. Note that these method names do <em>not</em> reveal any type
+information for themselves.</p>
+<h3>Fusion Type</h3>
+<p>Duck type is very flexible but can be too lenient when trying to restrict
+the type of an object. RubyBreaker provides a type called <em>the fusion type</em>
+which lists method names but with respect to a nominal type. For
+example, <code>fixnum[to_f, to_s]</code> represents an object that has methods <code>to_f</code>
+and <code>to_s</code> whose types are same as those of <code>Fixnum</code>. This is more
+restrictive (precise) than <code>[to_f, to_s]</code> because the two methods must have
+the same types as <code>to_f</code> and <code>to_s</code> methods, respectively, in <code>Fixnum</code>.</p>
+<h3>Nil Type</h3>
+<p>A nil type represents a value of nil and is denoted by <code>nil</code>.</p>
+<h3>Any Type</h3>
+<p>RubyBreaker also provides a way to represent an object that is compatible with
+any type. This type is denoted by <code>?</code>. Use caution with this type because
+it should be only used for an object that requires an arbitrary yet most
+specific type--that is, <code>?</code> is a subtype of any other type, but any
+other type is not a subtype of <code>?</code>. This becomes a bit complicated for
+method or block argument types because of their contra-variance
+characteristic. Please kefer to the section <em>Subtyping</em>.</p>
+<h3>Block Type</h3>
+<p>One of the Ruby's prominent features is the block argument. It allows
+the caller to pass in a piece of code to be executed inside the callee. This
+code block can be executed by the Ruby construct, <code>yield</code>, or by directly
+calling the <code>call</code> method of the block object. In RubyBreaker, this type can
+be respresented by curly brackets. For instance, <code>{|fixnum,string| -&gt;
+string}</code> represents a block that takes two arguments--one <code>Fixnum</code> and one
+<code>String</code>--and returns a <code>String</code>.</p>
+<p>RubyBreaker does supports nested blocks as Ruby 1.9 finally allows them.
+However, <em>keep in mind</em> that RubyBreaker <em>cannot</em> automatically document the
+block types due to <code>yield</code> being a language construct rather than a method,
+which means it cannot be captured by meta-programming!</p>
+<h3>Optional Argument Type and Variable-Length Argument Type</h3>
+<p>Another useful features of Ruby are the optional argument type and the
+variable-length argument type. The former represents an argument that has a
+default value (and therefore does not have to be provided). The latter
+represents zero or more arguments of the same type. These are denoted by
+suffices, <code>?</code> and <code>*</code>, respectively.</p>
+<h3>Method Type and Method List Types</h3>
+<p>Method type is similar to the block type, but it represents an actual method
+and not a block object. It is the "root" type that the type annotation
+language supports, along with method list types. Method <em>list</em> type is a
+collection of method types to represent more than one type information for
+the given method. Why would this type be needed? Consider the following Ruby
+code:</p>
+<pre><code>def foo(x)
+  case x
+  when Fixnum
+    1
+  when String
+    "1"
+  end
+end
+</code></pre>
+<p>There is no way to document the type of <code>foo</code> without using a method list
+type. Let's try to give a method type to <code>foo</code> without a method list. The
+closest we can come up with would be <code>foo(fixnum or string) -&gt; fixnum and
+string</code>. But RubyBreaker does not have the "and" type in the type annotation
+language because it gives me an headache! (By the way, it needs to be an
+"and" type because the caller must handle both <code>Fixnum</code> and <code>String</code> return
+values.)</p>
+<p>It is a dilemma because Ruby programmers actually enjoy using this kind of
+dynamic type checks in their code. To alleviate this headache, RubyBreaker
+supports the method list type to represent different scenarios depending on
+the argument types. Thus, the <code>foo</code> method shown above can be given the
+following method list type:</p>
+<pre><code>typesig("foo(fixnum) -&gt; fixnum")
+typesig("foo(string) -&gt; string")
+</code></pre>
+<p>These two type signatures simply tell RubyBreaker that <code>foo</code> has two method
+types--one for a <code>Fixnum</code> argument and another for a <code>String</code> argument.
+Depending on the argument type, the return type is determined. In this
+example, a <code>Fixnum</code> is returned when the argument is also a <code>Fixnum</code> and a
+<code>String</code> is returned when the argument is also a <code>String</code>. When
+automatically documenting such a type, RubyBreaker looks for the (subtyping)
+compatibility between the return types and "promote" the method type to a
+method list type by spliting the type signature into two (or more in
+subsequent "promotions").</p>
+<h2>Type System</h2>
+<p>RubyBreaker comes with its own type system that is used to document type
+information. This section describes how RubyBreaker determines which type(s)
+to document. <em>More documentation coming soon...</em></p>
+<h3>Subtyping</h3>
+<p><em>Documentation coming soon...</em></p>
+<h3>Subtyping vs. Subclassing</h3>
+<p><em>Documentation coming soon...</em></p>
+<h3>Pluggable Type System (Advanced)</h3>
+<p>Yes, RubyBreaker was designed with the replaceable type system in mind. In
+other words, anyone can write his own type system and plug it into
+RubyBreaker.</p>
+<p><em>Documentation coming soon...</em></p>
+<hr />
+<h1>Acknowledgment</h1>
+<p>The term, "Fusion Type," is first coined by Professor Michael W. Hicks at
+University of Maryland and represents an object using a structural type with
+respect to a nominal type.</p>
+<hr />
+<h1>Copyright</h1>
+<p>Copyright (c) 2012 Jong-hoon (David) An. All Rights Reserved.</p>
+	</div>
+  </center>
+</body>
+</html>

data/webpage/rubybreaker.css ADDED Viewed

@@ -0,0 +1,53 @@
+body {
+	background-color: #aa0000;
+	/* font-family: Verdana, Arial, "sans-serif"; */
+	font-family: "Lucida Grande", "Lucida Sans Unicode", Helvetica, Arial, Verdana, sans-serif;
+	width: 100%;
+	text-align: center;
+	padding:0px;
+	margin: 0px;
+	font-size:0.9em;
+	line-height:150%;
+	color: #2f2f2f;
+}
+/* Gradient transparent - color - transparent */
+hr {
+	border: 0;
+	height: 2px;
+	background-image: -webkit-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0));
+	background-image:	-moz-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0));
+	background-image:	 -ms-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0));
+	background-image:	  -o-linear-gradient(left, rgba(0,0,0,0), rgba(0,0,0,0.75), rgba(0,0,0,0));
+	margin: 40px 0px 40px 0px;
+}
+h1,
+h2,
+h3,
+h4 {
+	margin: 40px 0px 20px 0px;
+	color: #990000;
+}
+code {
+	/* color: #5c5c5c; */
+	font-family: "Lucida Console", "Courier New", Monospace;
+	font-weight: bold;
+}
+div#content {
+	background-color: white;
+	width: 660px;
+	text-align: left;
+	padding: 20px 80px 40px 80px;
+	margin: 0px;
+	-moz-box-shadow: 0 0 30px 5px #333;
+	-webkit-box-shadow: 0 0 30px 5px #333;
+}
+div#logo {
+	padding-bottom: 20px;
+	text-align:center;
+}

metadata ADDED Viewed

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: rubybreaker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease:
+platform: ruby
+authors:
+- Jong-hoon (David) An
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2012-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RubyBreaker is a dynamic type documentation tool for Ruby.
+email: rubybreaker@gmail.com
+executables:
+- rubybreaker
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rubybreaker/context.rb
+- lib/rubybreaker/debug.rb
+- lib/rubybreaker/error.rb
+- lib/rubybreaker/rubylib/core.rb
+- lib/rubybreaker/rubylib.rb
+- lib/rubybreaker/runtime/inspector.rb
+- lib/rubybreaker/runtime/monitor.rb
+- lib/rubybreaker/runtime/object_wrapper.rb
+- lib/rubybreaker/runtime/overrides.rb
+- lib/rubybreaker/runtime/pluggable.rb
+- lib/rubybreaker/runtime/type_placeholder.rb
+- lib/rubybreaker/runtime/type_system.rb
+- lib/rubybreaker/runtime/typesig_parser.rb
+- lib/rubybreaker/runtime.rb
+- lib/rubybreaker/test/testcase.rb
+- lib/rubybreaker/test.rb
+- lib/rubybreaker/type/type.rb
+- lib/rubybreaker/type/type_comparer.rb
+- lib/rubybreaker/type/type_grammar.treetop
+- lib/rubybreaker/type/type_unparser.rb
+- lib/rubybreaker/type.rb
+- lib/rubybreaker/typing/rubytype.rb
+- lib/rubybreaker/typing/subtyping.rb
+- lib/rubybreaker/typing.rb
+- lib/rubybreaker/util.rb
+- lib/rubybreaker.rb
+- bin/gen_stub_rubylib
+- bin/rubybreaker
+- AUTHORS
+- LICENSE
+- Rakefile
+- README.md
+- TODO
+- test/integrated/tc_method_missing.rb
+- test/integrated/tc_simple1.rb
+- test/runtime/tc_obj_wrapper.rb
+- test/runtime/tc_typesig_parser.rb
+- test/ts_integrated.rb
+- test/ts_runtime.rb
+- test/ts_type.rb
+- test/ts_typing.rb
+- test/type/tc_comparer.rb
+- test/type/tc_parser.rb
+- test/type/tc_unparser.rb
+- test/typing/tc_rubytype.rb
+- test/typing/tc_typing.rb
+- webpage/footer.html
+- webpage/generated_toc.js
+- webpage/header.html
+- webpage/images/logo.png
+- webpage/index.html
+- webpage/rubybreaker.css
+homepage:
+licenses:
+- BSD
+post_install_message:
+rdoc_options:
+- -x
+- lib/rubybreaker/rubylib/*.rb
+- -x
+- lib/rubybreaker/type/type_grammar.rb
+- lib
+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: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.23
+signing_key:
+specification_version: 3
+summary: Break Ruby types
+test_files: []