yard 0.6.1 → 0.6.2

data/spec/handlers/class_condition_handler_spec.rb

@@ -8,6 +8,10 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassConditionHandler
     names.each {|name| Registry.at("A##{name}not").should be_nil }
   end
   
+  def no_undoc_error(code)
+    lambda { StubbedSourceParser.parse_string(code) }.should_not raise_error
+  end
+  
   it "should parse all unless blocks for complex conditions" do
     verify_method :g
   end
@@ -45,13 +49,14 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassConditionHandler
   end
   
   it "should not fail on complex conditions" do
-    lambda { YARD.parse_string("if defined?(A) && defined?(B); puts 'hi' end") }.should_not raise_error
-    lambda do 
-      YARD.parse_string(<<-eof)
-        (<<-TEST) unless defined?(ABCD_MODEL_TEST)
-          'String'
-        TEST
-      eof
-    end.should_not raise_error
+    log.should_not_receive(:warn)
+    log.should_not_receive(:error)
+    no_undoc_error "if defined?(A) && defined?(B); puts 'hi' end"
+    no_undoc_error(<<-eof)
+      (<<-TEST) unless defined?(ABCD_MODEL_TEST)
+        'String'
+      TEST
+    eof
+    no_undoc_error "if caller.none? { |l| l =~ %r{lib/rails/generators\\.rb:(\\d+):in `lookup!'$} }; end"
   end
 end

data/spec/handlers/class_handler_spec.rb

@@ -21,7 +21,7 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassHandler" do
   end
   
   it "should interpret class << ClassName as a class level block in ClassName's namespace" do
-    P("A::B::C::Hello").should be_instance_of(CodeObjects::MethodObject)
+    P("A::B::C.Hello").should be_instance_of(CodeObjects::MethodObject)
   end
   
   it "should make visibility public when parsing a block" do
@@ -174,64 +174,72 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ClassHandler" do
     obj.tag(:param).types.should == ["IO"]
   end
   
-  it "defines both readers and writers when @attr is used on Structs" do
-    obj = Registry.at("SemiDoccedStruct")
-    attrs = obj.attributes[:instance]
-    attrs[:first][:read].should_not be_nil
-    attrs[:first][:write].should_not be_nil
-  end
+  ["SemiDoccedStruct", "NotAStruct"].each do |struct|
+    describe("Attributes on a " + (struct == "NotAStruct" ? "class" : "struct")) do
+      it "defines both readers and writers when @attr is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:first][:read].should_not be_nil
+        attrs[:first][:write].should_not be_nil
+      end
   
-  it "defines only a reader when only @attr_reader is used on Structs" do
-    obj = Registry.at("SemiDoccedStruct")
-    attrs = obj.attributes[:instance]
-    attrs[:second][:read].should_not be_nil
-    attrs[:second][:write].should be_nil
-  end
+      it "defines only a reader when only @attr_reader is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:second][:read].should_not be_nil
+        attrs[:second][:write].should be_nil
+      end
   
-  it "defines only a writer when only @attr_writer is used on Structs" do
-    obj = Registry.at("SemiDoccedStruct")
-    attrs = obj.attributes[:instance]
-    attrs[:third][:read].should be_nil
-    attrs[:third][:write].should_not be_nil
-  end
+      it "defines only a writer when only @attr_writer is used on Structs" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:third][:read].should be_nil
+        attrs[:third][:write].should_not be_nil
+      end
   
-  it "defines a reader with correct return types when @attr_reader is used on Structs" do
-    obj = Registry.at("SemiDoccedStruct#second")
-    obj.tag(:return).types.should == ["Fixnum"]
-  end
+      it "defines a reader with correct return types when @attr_reader is used on Structs" do
+        obj = Registry.at("#{struct}#second")
+        obj.tag(:return).types.should == ["Fixnum"]
+      end
   
-  it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
-    obj = Registry.at("SemiDoccedStruct#third=")
-    obj.tag(:param).types.should == ["Array"]
-  end
+      it "defines a writer with correct parameter types when @attr_writer is used on Structs" do
+        obj = Registry.at("#{struct}#third=")
+        obj.tag(:param).types.should == ["Array"]
+      end
   
-  it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
-    obj = Registry.at("SemiDoccedStruct")
-    attrs = obj.attributes[:instance]
-    attrs[:fourth][:read].should_not be_nil
-    attrs[:fourth][:write].should_not be_nil
-  end
+      it "defines a reader and a writer when both @attr_reader and @attr_writer are used" do
+        obj = Registry.at(struct)
+        attrs = obj.attributes[:instance]
+        attrs[:fourth][:read].should_not be_nil
+        attrs[:fourth][:write].should_not be_nil
+      end
   
-  it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
-    obj = Registry.at("SemiDoccedStruct#fourth")
-    obj.tag(:return).types.should == ["#read"]
-  end
+      it "uses @attr_reader for the getter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth")
+        obj.tag(:return).types.should == ["#read"]
+      end
   
-  it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
-    obj = Registry.at("SemiDoccedStruct#fourth=")
-    obj.tag(:param).types.should == ["IO"]
-  end
+      it "uses @attr_writer for the setter when both @attr_reader and @attr_writer are given" do
+        obj = Registry.at("#{struct}#fourth=")
+        obj.tag(:param).types.should == ["IO"]
+      end
   
-  it "extracts text from @attr_reader" do
-    Registry.at("SemiDoccedStruct#fourth").docstring.should == "returns a proc that reads"
-  end
+      it "extracts text from @attr_reader" do
+        Registry.at("#{struct}#fourth").docstring.should == "returns a proc that reads"
+      end
   
-  it "extracts text from @attr_writer" do
-    Registry.at("SemiDoccedStruct#fourth=").docstring.should == "sets the proc that writes stuff"
+      it "extracts text from @attr_writer" do
+        Registry.at("#{struct}#fourth=").docstring.should == "sets the proc that writes stuff"
+      end
+    end
   end
     
   it "should inherit from a regular struct" do
     Registry.at('RegularStruct').superclass.should == P(:Struct)
     Registry.at('RegularStruct2').superclass.should == P(:Struct)
   end
+  
+  it "should handle inheritance from 'self'" do
+    Registry.at('Outer1::Inner1').superclass.should == Registry.at('Outer1')
+  end
 end

data/spec/handlers/constant_handler_spec.rb

@@ -45,6 +45,19 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ConstantHandler" do
     obj.attributes[:instance].should be_empty
   end
   
+  it "should maintain docstrings on structs defined via constants" do
+    obj = Registry.at("DocstringStruct")
+    obj.should_not be_nil
+    obj.docstring.should == "A crazy struct."
+    obj.attributes[:instance].should_not be_empty
+    a1 = Registry.at("DocstringStruct#bar")
+    a2 = Registry.at("DocstringStruct#baz")
+    a1.docstring.should == "An attr"
+    a1.tag(:return).types.should == ["String"]
+    a2.docstring.should == "Another attr"
+    a2.tag(:return).types.should == ["Number"]
+  end
+  
   it "should raise undocumentable error in 1.9 parser for Struct.new assignment to non-const" do
     undoc_error "nonconst = Struct.new"
   end if RUBY19

data/spec/handlers/examples/alias_handler_001.rb.txt

@@ -25,4 +25,6 @@ class B < C
   alias_method :t, :inspect if 500 == 3 * CONSTANT
   alias_method :<<, :a
   alias_method :for, :a
+  alias do x
+  alias x2 do
 end

data/spec/handlers/examples/class_handler_001.rb.txt

@@ -105,4 +105,15 @@ end
 # @attr_reader [#read] fourth returns a proc that reads
 # @attr_writer [IO] fourth sets the proc that writes stuff
 class SemiDoccedStruct < Struct.new(:first, :second, :third, :fourth)
-end
+end
+
+# @attr [String] first the first entry
+# @attr_reader [Fixnum] second this only has a reader
+# @attr_writer [Array] third this only has a writer
+# @attr_reader [#read] fourth returns a proc that reads
+# @attr_writer [IO] fourth sets the proc that writes stuff
+class NotAStruct; end
+
+class Outer1
+  class Inner1 < self; end
+end

data/spec/handlers/examples/constant_handler_001.rb.txt

@@ -17,3 +17,9 @@ end
 MyClass = Struct.new(:a, :b, :c)
 NotMyClass = Struct.new("NotMyClass2", :b, :c)
 MyEmptyStruct = Struct.new
+
+# A crazy struct.
+#
+# @attr [String] bar An attr
+# @attr [Number] baz Another attr
+DocstringStruct = Struct.new(:bar, :baz)

data/spec/handlers/examples/exception_handler_001.rb.txt

@@ -44,4 +44,12 @@ class Testing
     obj.raise IgnoreMe
 	obj.raise(IgnoreMe)
   end
+  
+  def mymethod10
+    raise ArgumentError 'Message' # actually a method call
+  end
+  
+  def mymethod11
+    raise foo('bar')
+  end
 end

data/spec/handlers/examples/method_handler_001.rb.txt

@@ -79,3 +79,9 @@ end
   def auto_opts(opts)
   end
 end
+
+CONST = Foo
+def CONST.meth_on_const; end
+CONST2 = CONST
+def CONST2.meth2_on_const; end
+

data/spec/handlers/examples/visibility_handler_001.rb.txt

@@ -21,4 +21,7 @@ class Testing
   private name
   private *argument
   private *(method_call)
+  
+  def Foo; end
+  private :Foo
 end

data/spec/handlers/exception_handler_spec.rb

@@ -36,4 +36,9 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ExceptionHandler" do
   it "should ignore any raise calls on a receiver" do
     P('Testing#mymethod9').tag(:raise).should be_nil
   end
+  
+  it "should handle raise expressions that are method calls" do
+    P('Testing#mymethod10').tag(:raise).should be_nil
+    P('Testing#mymethod11').tag(:raise).should be_nil
+  end
 end

data/spec/handlers/extend_handler_spec.rb

@@ -16,4 +16,8 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}ExtendHandler" do
   it "should extend module with correct namespace" do
     Registry.at('Q::R::S').class_mixins.first.path.should == 'A'
   end
+  
+  it "should not allow extending self if object is a class" do
+    undoc_error "class Foo; extend self; end"
+  end
 end

data/spec/handlers/method_handler_spec.rb

@@ -127,4 +127,9 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MethodHandler" do
     undoc_error "error = Foo; def error.at(foo) end"
     Registry.at('error').should be_nil
   end
+  
+  it "should allow class method to be defined on constant reference object" do
+    Registry.at('Foo.meth_on_const').should_not be_nil
+    Registry.at('Foo.meth2_on_const').should_not be_nil
+  end
 end

data/spec/handlers/mixin_handler_spec.rb

@@ -37,4 +37,14 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}MixinHandler" do
     P("ABC::DEF::FOO").mixins.should == [P("ABC::FOO")]
     P("ABC::DEF::BAR").mixins.should == [P("ABC::BAR")]
   end
+  
+  it "should raise undocumentable error if argument is variable" do
+    undoc_error "module X; include invalid; end"
+    Registry.at('X').mixins.should == []
+  end
+  
+  it "should parse all other arguments before erroring out on undocumentable error" do
+    undoc_error "module X; include invalid, Y; end"
+    Registry.at('X').mixins.should == [P('Y')]
+  end
 end

data/spec/handlers/visibility_handler_spec.rb

@@ -27,4 +27,8 @@ describe "YARD::Handlers::Ruby::#{RUBY18 ? "Legacy::" : ""}VisibilityHandler" do
     Registry.at('Testing#argument').should be_nil
     Registry.at('Testing#method_call').should be_nil
   end
+  
+  it "should handle constants passed in as symbols" do
+    Registry.at('Testing#Foo').visibility.should == :private
+  end
 end

data/spec/parser/base_spec.rb

@@ -7,7 +7,7 @@ describe YARD::Parser::Base do
     end
     
     it "should take 2 arguments" do
-      lambda { Parser::Base.new }.should raise_error(ArgumentError, /wrong number of arguments/)
+      lambda { Parser::Base.new }.should raise_error(ArgumentError, /wrong (number|#) of arguments/)
     end
     
     it "should raise NotImplementedError on #initialize" do

data/spec/parser/c_parser_spec.rb

@@ -5,6 +5,9 @@ describe YARD::Parser::CParser do
   before(:all) do
     file = File.join(File.dirname(__FILE__), 'examples', 'array.c.txt')
     @parser = Parser::CParser.new(IO.read(file)).parse
+
+    override_file = File.join(File.dirname(__FILE__), 'examples', 'override.c.txt')
+    @override_parser = Parser::CParser.new(IO.read(override_file)).parse
   end
   
   describe '#parse' do
@@ -20,4 +23,39 @@ describe YARD::Parser::CParser do
       obj.tags(:overload).size.should > 1
     end
   end
-end
+
+  describe '#find_override_comment' do
+    it "should parse GMP::Z class" do
+      z = YARD::Registry.at('GMP::Z')
+      z.should_not be_nil
+      z.docstring.should_not be_blank
+    end
+
+    it "should parse GMP::Z methods w/ bodies" do
+      add = YARD::Registry.at('GMP::Z#+')
+      add.docstring.should_not be_blank
+      add.source.should_not be_nil
+      add.source.should_not be_empty
+
+      add_self = YARD::Registry.at('GMP::Z#+')
+      add_self.docstring.should_not be_blank
+      add_self.source.should_not be_nil
+      add_self.source.should_not be_empty
+
+      sqrtrem = YARD::Registry.at('GMP::Z#+')
+      sqrtrem.docstring.should_not be_blank
+      sqrtrem.source.should_not be_nil
+      sqrtrem.source.should_not be_empty
+    end
+
+    it "should parse GMP::Z methods w/o bodies" do
+      neg = YARD::Registry.at('GMP::Z#neg')
+      neg.docstring.should_not be_blank
+      neg.source.should be_nil
+
+      neg_self = YARD::Registry.at('GMP::Z#neg')
+      neg_self.docstring.should_not be_blank
+      neg_self.source.should be_nil
+    end
+  end
+end if CONTINUATIONS_SUPPORTED

data/spec/parser/examples/override.c.txt

@@ -0,0 +1,424 @@
+#include <gmpz.h>
+#include <gmpq.h>
+#include <gmpf.h>
+
+/*
+ * Document-class: GMP::Z
+ *
+ * GMP Multiple Precision Integer.
+ *
+ * Instances of this class can store variables of the type mpz_t. This class
+ * also contains many methods that act as the functions for mpz_t variables,
+ * as well as a few methods that attempt to make this library more Ruby-ish.
+ */
+
+/**********************************************************************
+ *    Macros                                                          *
+ **********************************************************************/
+
+/*
+ * DEFUN_INT2INT defines two functions. The first takes a GMP::Z as
+ * self, calls mpz_fname on the contained mpz_t, whose arguments are
+ * exactly (0) the return argument and (1) self. The second is the same
+ * destructive method.
+ */
+#define DEFUN_INT2INT(fname,mpz_fname)         \
+static VALUE r_gmpz_##fname(VALUE self)        \
+{                                              \
+  MP_INT *self_val, *res_val;                  \
+  VALUE res;                                   \
+  mpz_get_struct(self, self_val);              \
+  mpz_make_struct_init(res, res_val);          \
+  mpz_fname(res_val, self_val);                \
+  return res;                                  \
+}                                              \
+                                               \
+static VALUE r_gmpz_##fname##_self(VALUE self) \
+{                                              \
+  MP_INT *self_val;                            \
+  mpz_get_struct(self, self_val);              \
+  mpz_fname(self_val, self_val);               \
+  return self;                                 \
+}
+
+
+/**********************************************************************
+ *    Integer Arithmetic                                              *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   a + b
+ *
+ * Adds _a_ to _b_. _b_ must be an instance of one of:
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpz_add(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_get_struct(arg,arg_val);
+    mpz_make_struct_init(res, res_val);
+    mpz_add(res_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    if (FIX2NUM(arg) > 0)
+      mpz_add_ui(res_val, self_val, FIX2NUM(arg));
+    else
+      mpz_sub_ui(res_val, self_val, -FIX2NUM(arg));
+  } else if (GMPQ_P(arg)) {
+    return r_gmpq_add(arg, self);
+  } else if (GMPF_P(arg)) {
+#ifndef MPFR
+    return r_gmpf_add(arg, self);
+#else
+    return rb_funcall(arg, rb_intern("+"), 1, self);
+#endif
+  } else if (BIGNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_init(res_val);
+    mpz_set_bignum(res_val, arg);
+    mpz_add(res_val, res_val, self_val);
+  } else {
+    typeerror(ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   a.add!(_b_)
+ *
+ * Adds _a_ to _b_ in-place, setting _a_ to the sum. _b_ must be an instance of one of:
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpz_add_self(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_get_struct(arg,arg_val);
+    mpz_add(self_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    if (FIX2NUM(arg) > 0)
+      mpz_add_ui(self_val, self_val, FIX2NUM(arg));
+    else
+      mpz_sub_ui(self_val, self_val, -FIX2NUM(arg));
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val, arg);
+    mpz_add(self_val, self_val, arg_val);
+    mpz_temp_free(arg_val);
+  } else {
+    typeerror(ZXB);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   a - b
+ *
+ * Subtracts _b_ from _a_. _b_ must be an instance of one of:
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpz_sub(VALUE self, VALUE arg)
+{
+  MP_RAT *res_val_q, *arg_val_q;
+  MP_INT *self_val, *arg_val, *res_val;
+  MP_FLOAT *arg_val_f, *res_val_f;
+  VALUE res;
+  unsigned long prec;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_get_struct(arg,arg_val);
+    mpz_sub (res_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    if (FIX2NUM(arg) > 0)
+      mpz_sub_ui (res_val, self_val, FIX2NUM(arg));
+    else
+      mpz_add_ui (res_val, self_val, -FIX2NUM(arg));
+  } else if (GMPQ_P(arg)) {
+    mpq_make_struct_init(res, res_val_q);
+    mpq_get_struct(arg,arg_val_q);
+    mpz_set (mpq_denref(res_val_q), mpq_denref(arg_val_q));
+    mpz_mul (mpq_numref(res_val_q), mpq_denref(arg_val_q), self_val);
+    mpz_sub (mpq_numref(res_val_q), mpq_numref(res_val_q), mpq_numref(arg_val_q));
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct_prec (arg, arg_val_f, prec);
+    mpf_make_struct_init(res, res_val_f, prec);
+    mpf_set_z (res_val_f, self_val);
+    mpf_sub (res_val_f, res_val_f, arg_val_f);
+  } else if (BIGNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_sub (res_val, self_val, res_val);
+  } else {
+    typeerror (ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   a.sub!(b)
+ *
+ * Subtracts _b_ from _a_ in-place, setting _a_ to the difference. _b_ must be an
+ * instance of one of:
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpz_sub_self(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val);
+    mpz_sub (self_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    if (FIX2NUM(arg) > 0)
+      mpz_sub_ui (self_val, self_val, FIX2NUM(arg));
+    else
+      mpz_add_ui (self_val, self_val, -FIX2NUM(arg));
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val, arg);
+    mpz_sub (self_val, self_val, arg_val);
+    mpz_temp_free (arg_val);
+  } else {
+    typeerror (ZXB);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *   a * b
+ *
+ * Multiplies _a_ with _b_. _a_ must be an instance of one of
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpz_mul(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_get_struct(arg,arg_val);
+    mpz_mul(res_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_mul_si(res_val, self_val, FIX2NUM(arg));
+  } else if (GMPQ_P(arg)) {
+    return r_gmpq_mul(arg, self);
+  } else if (GMPF_P(arg)) {
+#ifndef MPFR
+    return r_gmpf_mul(arg, self);
+#else
+    return rb_funcall(arg, rb_intern("*"), 1, self);
+#endif
+  } else if (BIGNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_set_bignum(res_val, arg);
+    mpz_mul(res_val, res_val, self_val);
+  } else {
+    typeerror(ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   a.addmul!(b, c)
+ *
+ * @since 0.4.17
+ *
+ * Sets _a_ to _a_ plus _b_ times _c_. _b_ and _c_ must each be an instance of one of
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
+ */
+VALUE r_gmpz_addmul_self(VALUE self, VALUE b, VALUE c)
+{
+  MP_INT *self_val, *b_val, *c_val;
+  int free_b_val = 0;
+
+  if (GMPZ_P(b)) {
+    mpz_get_struct(b, b_val);
+  } else if (FIXNUM_P(b)) {
+    mpz_temp_alloc(b_val);
+    mpz_init_set_si(b_val, FIX2NUM(b));
+    free_b_val = 1;
+  } else if (BIGNUM_P(b)) {
+    mpz_temp_from_bignum(b_val, b);
+    free_b_val = 1;
+  } else {
+    typeerror_as(ZXB, "addend");
+  }
+  mpz_get_struct(self, self_val);
+
+  if (GMPZ_P(c)) {
+    mpz_get_struct(c, c_val);
+    mpz_addmul(self_val, b_val, c_val);
+  } else if (FIXNUM_P(c)) {
+    if (FIX2NUM(c) < 0)
+    {
+      if (free_b_val) { mpz_temp_free(b_val); }
+      rb_raise(rb_eRangeError, "multiplicand (Fixnum) must be nonnegative");
+    }
+    mpz_addmul_ui(self_val, b_val, FIX2NUM(c));
+  } else if (BIGNUM_P(c)) {
+    mpz_temp_from_bignum(c_val, c);
+    mpz_addmul(self_val, b_val, c_val);
+    mpz_temp_free(c_val);
+  } else {
+    if (free_b_val)
+      mpz_temp_free(b_val);
+    typeerror_as(ZXB, "multiplicand");
+  }
+  if (free_b_val)
+    mpz_temp_free(b_val);
+  return self;
+}
+
+/*
+ * Document-method: neg
+ *
+ * call-seq:
+ *   a.neg
+ *   -a
+ *
+ * Returns -_a_.
+ */
+/*
+ * Document-method: neg!
+ *
+ * call-seq:
+ *   a.neg!
+ *
+ * Sets _a_ to -_a_.
+ */
+DEFUN_INT2INT(neg, mpz_neg)
+/*
+ * Document-method: abs
+ *
+ * call-seq:
+ *   a.abs
+ *
+ * Returns the absolute value of _a_.
+ */
+/*
+ * Document-method: abs!
+ *
+ * call-seq:
+ *   a.abs!
+ *
+ * Sets _a_ to its absolute value.
+ */
+DEFUN_INT2INT(abs, mpz_abs)
+
+
+/**********************************************************************
+ *    Integer Roots                                                   *
+ **********************************************************************/
+
+/*
+ * Document-method: sqrt
+ *
+ * call-seq:
+ *   a.sqrt
+ *
+ * Returns the truncated integer part of the square root of _a_.
+ */
+/*
+ * Document-method: sqrt!
+ *
+ * call-seq:
+ *   a.sqrt!
+ *
+ * Sets _a_ to the truncated integer part of its square root.
+ */
+DEFUN_INT2INT(sqrt, mpz_sqrt)
+
+/*
+ * call-seq:
+ *   a.sqrtrem #=> s, r
+ *
+ * Returns the truncated integer part of the square root of _a_ as _s_ and the remainder
+ * <i>a - s * s</i> as _r_, which will be zero if _a_ is a perfect square.
+ */
+static VALUE r_gmpz_sqrtrem(VALUE self)
+{
+  MP_INT *self_val, *sqrt_val, *rem_val;
+  VALUE sqrt, rem;
+
+  mpz_get_struct(self, self_val);
+  mpz_make_struct_init(sqrt, sqrt_val);
+  mpz_make_struct_init(rem, rem_val);
+  mpz_sqrtrem(sqrt_val, rem_val, self_val);
+  return rb_assoc_new(sqrt, rem);
+}
+
+
+/**********************************************************************
+ *    Init function                                                   *
+ **********************************************************************/
+
+void init_gmpz()
+{
+  mGMP = rb_define_module("GMP");
+  rb_define_module_function(mGMP, "Z", r_gmpmod_z, -1);
+
+  cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
+
+  // Integer Arithmetic
+  rb_define_method(cGMP_Z, "+",       r_gmpz_add, 1);
+  rb_define_method(cGMP_Z, "add!",    r_gmpz_add_self, 1);
+  rb_define_method(cGMP_Z, "-",       r_gmpz_sub, 1);  
+  rb_define_method(cGMP_Z, "sub!",    r_gmpz_sub_self, 1);
+  rb_define_method(cGMP_Z, "*",       r_gmpz_mul, 1);
+  rb_define_method(cGMP_Z, "addmul!", r_gmpz_addmul_self, 2);
+  rb_define_method(cGMP_Z, "neg",     r_gmpz_neg, 0);
+  rb_define_method(cGMP_Z, "neg!",    r_gmpz_neg_self, 0);
+  rb_define_method(cGMP_Z, "-@",      r_gmpz_neg, 0);
+  rb_define_method(cGMP_Z, "abs",     r_gmpz_abs, 0);
+  rb_define_method(cGMP_Z, "abs!",    r_gmpz_abs_self, 0);
+
+  // Integer Roots
+  rb_define_method(cGMP_Z, "root",    r_gmpz_root, 1);
+  rb_define_method(cGMP_Z, "sqrt",    r_gmpz_sqrt, 0);
+  rb_define_method(cGMP_Z, "sqrt!",   r_gmpz_sqrt_self, 0);
+  rb_define_method(cGMP_Z, "sqrtrem", r_gmpz_sqrtrem, 0);
+}