dmarkow-raspell 1.2

data/CHANGELOG

@@ -0,0 +1,6 @@
+
+v1.1. Would be nice if it actually compiled again.
+
+v1.0. Documentation.
+
+v0.3. Fix OS X compilation problem; Rubyforge release.

data/LICENSE

@@ -0,0 +1,342 @@
+GNU GENERAL PUBLIC LICENSE
+
+Version 2, June 1991
+
+  Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+== Preamble
+
+The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+The precise terms and conditions for copying, distribution and
+modification follow.
+
+== GNU GENERAL PUBLIC LICENSE
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+a) You must cause the modified files to carry prominent notices
+stating that you changed the files and the date of any change.
+
+b) You must cause any work that you distribute or publish, that in
+whole or in part contains or is derived from the Program or any
+part thereof, to be licensed as a whole at no charge to all third
+parties under the terms of this License.
+
+c) If the modified program normally reads commands interactively
+when run, you must cause it, when started running for such
+interactive use in the most ordinary way, to print or display an
+announcement including an appropriate copyright notice and a
+notice that there is no warranty (or else, saying that you provide
+a warranty) and that users may redistribute the program under
+these conditions, and telling the user how to view a copy of this
+License.  (Exception: if the Program itself is interactive but
+does not normally print such an announcement, your work based on
+the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+a) Accompany it with the complete corresponding machine-readable
+source code, which must be distributed under the terms of Sections
+1 and 2 above on a medium customarily used for software interchange; or,
+
+b) Accompany it with a written offer, valid for at least three
+years, to give any third party, for a charge no more than your
+cost of physically performing source distribution, a complete
+machine-readable copy of the corresponding source code, to be
+distributed under the terms of Sections 1 and 2 above on a medium
+customarily used for software interchange; or,
+
+c) Accompany it with the information you received as to the offer
+to distribute corresponding source code.  (This alternative is
+allowed only for noncommercial distribution and only if you
+received the program in object code or executable form with such
+an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+== NO WARRANTY
+
+11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+== END OF TERMS AND CONDITIONS
+
+How to Apply These Terms to Your New Programs
+
+If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+<one line to give the program's name and a brief idea of what it does.>
+Copyright (C) <year>  <name of author>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+  
+  Gnomovision version 69, Copyright (C) year name of author
+  Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+  This is free software, and you are welcome to redistribute it
+  under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+  
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

data/README

@@ -0,0 +1,78 @@
+
+raspell
+
+An interface binding for the Aspell spelling checker.
+
+== License
+
+Copyright 2007, 2008 Cloudburst, LLC. Licensed under the GPL 2.0. See included LICENSE file. Portions copyright 2005 Matthias Veit, Biro Eszter and used with permission.  
+
+The public certificate for the gem is here[http://rubyforge.org/frs/download.php/25331/evan_weaver-original-public_cert.pem]. 
+
+If you use this software, please {make a donation}[http://blog.evanweaver.com/donate/], or {recommend Evan}[http://www.workingwithrails.com/person/7739-evan-weaver] at Working with Rails.
+
+== Requirements
+
+Raspell requires Aspell version 0.6 (http://www.aspell.net) and at least one Aspell dictionary. 
+
+Mac: 
+  sudo port install aspell aspell-dict-en
+
+Ubuntu: 
+  sudo apt-get install aspell libaspell-dev aspell-en
+  
+== Installation
+
+Mac:
+  sudo gem install raspell -- --with-opt-dir=/opt/local
+  
+Ubuntu:
+  sudo gem install raspell
+  
+== Usage
+
+Aspell lets you <tt>check</tt> words and <tt>suggest</tt> corrections. For example:
+   
+  require 'rubygems'
+  require 'raspell'
+  
+  speller = Aspell.new("en_US")
+  speller.suggestion_mode = Aspell::NORMAL
+  
+  string = "my haert wil go on"
+  
+  string.gsub(/[\w\']+/) do |word| 
+    if !speller.check(word) 
+      # word is wrong
+      puts "Possible correction for #{word}:"
+      puts speller.suggest(word).first
+    end
+  end
+
+This outputs:
+
+  Possible correction for haert:
+  heart
+  Possible correction for wil:
+  Will
+
+Note that <tt>suggest</tt> returns an array of suggestions even for words that are correctly spelled.
+
+== Options
+
+The most useful options are <tt>suggestion_mode</tt>, and the passthrough option <tt>ignore_case</tt>. Passthrough options have to be set as so:
+
+  speller.set_option("ignore-case", "true")
+
+See http://aspell.net/man-html/The-Options.html for a list of the passthrough options. 
+
+== Reporting problems
+
+The support forum is here[http://rubyforge.org/forum/forum.php?forum_id=13988].
+
+Patches and contributions are very welcome. Please note that contributors are required to assign copyright for their additions to Cloudburst, LLC.
+
+== Futher resources
+
+* http://blog.evanweaver.com/articles/2007/03/10/add-gud-spelning-to-ur-railz-app-or-wharever
+

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+have_header("ruby.h")
+have_header("aspell.h")
+have_library("aspell")
+create_makefile("raspell")

data/ext/raspell.c

@@ -0,0 +1,726 @@
+
+#include "raspell.h"
+
+extern void Init_dictinfo();
+extern void Init_aspell();
+
+void Init_raspell() {
+    cAspellError = rb_define_class("AspellError", rb_eStandardError);
+    Init_dictinfo();
+    Init_aspell();
+}
+
+static AspellDictInfo* get_info(VALUE info) {
+    AspellDictInfo *result;
+    Data_Get_Struct(info, AspellDictInfo, result);
+    return result;
+}
+
+static VALUE dictinfo_s_new(int argc, VALUE *argv, VALUE klass) {
+    rb_raise(rb_eException, "not instantiable");
+}
+
+static VALUE dictinfo_name(VALUE self) {
+    return rb_str_new2(get_info(self)->name);
+}
+
+static VALUE dictinfo_code(VALUE self) {
+    return rb_str_new2(get_info(self)->code);
+}
+
+static VALUE dictinfo_jargon(VALUE self) {
+    return rb_str_new2(get_info(self)->jargon);
+}
+
+static VALUE dictinfo_size(VALUE self) {
+    return INT2FIX(get_info(self)->size);
+}
+
+static VALUE dictinfo_size_str(VALUE self) {
+    return rb_str_new2(get_info(self)->size_str);
+}
+
+void Init_dictinfo() {
+    //CLASS DEFINITION=========================================================
+    cDictInfo = rb_define_class("AspellDictInfo", rb_cObject);
+    
+    //CLASS METHODS============================================================
+    rb_define_singleton_method(cDictInfo, "new", dictinfo_s_new, 0);
+
+    //METHODS =================================================================
+    rb_define_method(cDictInfo, "name", dictinfo_name, 0);
+    rb_define_method(cDictInfo, "code", dictinfo_code, 0);
+    rb_define_method(cDictInfo, "jargon", dictinfo_jargon, 0);
+    rb_define_method(cDictInfo, "size", dictinfo_size, 0);
+    rb_define_method(cDictInfo, "size_str", dictinfo_size_str, 0);
+}
+
+extern VALUE rb_cFile;
+
+/**
+ * This method is called from the garbage collector during finalization.
+ * @param p pointer to spellchecker-object.
+ */
+static void aspell_free(void *p) {
+    delete_aspell_speller(p);
+}
+
+/**
+ * Check for an error - raise exception if so.
+ * @param speller the spellchecker-object.
+ * @return void
+ * @exception Exception if there was an error.
+ */
+static void check_for_error(AspellSpeller * speller) {
+    if (aspell_speller_error(speller) != 0) {
+        rb_raise(cAspellError, aspell_speller_error_message(speller));
+    }
+}
+
+/**
+ * Set a specific option, that is known by aspell.
+ * @param config the config object of a specific spellchecker.
+ * @param key the option to set (eg: lang).
+ * @param value the value of the option to set (eg: "us_US").
+ * @exception Exception if key not known, or value undefined.
+ */
+static void set_option(AspellConfig *config, char *key, char *value) {
+    //printf("set option: %s = %s\n", key, value);
+    if (aspell_config_replace(config, key, value) == 0) {
+        rb_raise(cAspellError, aspell_config_error_message(config));
+    }
+    //check config:
+    if (aspell_config_error(config) != 0) {
+        rb_raise(cAspellError, aspell_config_error_message(config));
+    }
+}
+
+static void set_options(AspellConfig *config, VALUE hash) {
+    VALUE options = rb_funcall(hash, rb_intern("keys"), 0);
+    int count=RARRAY_LEN(options);
+    int c = 0;
+    //set all values
+    while(c<count) {
+        //fetch option
+        VALUE option = RARRAY_PTR(options)[c];
+        VALUE value = rb_funcall(hash, rb_intern("fetch"), 1, option);
+        if (TYPE(option)!=T_STRING) rb_raise(cAspellError, "Given key must be a string.");
+        if (TYPE(value )!=T_STRING) rb_raise(cAspellError, "Given value must be a string.");
+        set_option(config, STR2CSTR(option), STR2CSTR(value));
+        c++;
+    }
+}
+
+/**
+ * Extract c-struct speller from ruby object.
+ * @param speller the speller as ruby object.
+ * @return the speller as c-struct.
+ */
+static AspellSpeller* get_speller(VALUE speller) {
+    AspellSpeller *result;
+    Data_Get_Struct(speller, AspellSpeller, result);
+    return result;
+}
+
+/**
+ * Generate a document checker object from a given speller.
+ * @param speller the speller that shall chech a document.
+ * @return a fresh document checker.
+ */
+static AspellDocumentChecker* get_checker(AspellSpeller *speller) {
+    AspellCanHaveError * ret;
+    AspellDocumentChecker * checker;
+    ret = new_aspell_document_checker(speller);
+    if (aspell_error(ret) != 0)
+        rb_raise(cAspellError, aspell_error_message(ret));
+    checker = to_aspell_document_checker(ret);
+    return checker;
+}
+
+/**
+ * Utility function that wraps a list of words as ruby array of ruby strings.
+ * @param list an aspell wordlist.
+ * @return an ruby array, containing all words as ruby strings.
+ */
+static VALUE get_list(const AspellWordList *list) {
+    VALUE result = rb_ary_new2(aspell_word_list_size(list));
+    if (list != 0) {
+        AspellStringEnumeration * els = aspell_word_list_elements(list);
+        const char * word;
+        while ( (word = aspell_string_enumeration_next(els)) != 0) {
+            rb_ary_push(result, rb_str_new2(word));
+        }
+        delete_aspell_string_enumeration(els);
+    }
+    return result;
+}
+
+/**
+ * Generate a regexp from the given word with word boundaries.
+ * @param word the word to match.
+ * @return regular expression, matching exactly the word as whole.
+ */
+static VALUE get_wordregexp(VALUE word) {
+    char *cword = STR2CSTR(word);
+    char *result = malloc((strlen(cword)+5)*sizeof(char));
+    *result='\0';
+    strcat(result, "\\b");
+    strcat(result, cword);
+    strcat(result, "\\b");
+    word = rb_reg_new(result, strlen(result), 0);
+    free(result);
+    return word;
+}
+
+
+/**
+ * Ctor for aspell objects:
+ * Aspell.new(language, jargon, size, encoding)
+ * Please note: All parameters are optional. If a parameter is omitted, a default value is assumed from
+ *              the environment (eg lang from $LANG). To retain default values, you can use nil
+ *              as value: to set only size: Aspell.new(nil, nil, "80")
+ * @param language ISO639 language code plus optional ISO 3166 counry code as string (eg: "de" or "us_US")
+ * @param jargon a special jargon of the selected language
+ * @param size the size of the dictionary to chose (if there are options)
+ * @param encoding the encoding to use
+ * @exception Exception if the specified dictionary is not found.
+ */
+static VALUE aspell_s_new(int argc, VALUE *argv, VALUE klass) {
+    VALUE vlang, vjargon, vsize, vencoding;
+    const char *tmp;
+    //aspell values
+    AspellCanHaveError * ret;
+    AspellSpeller * speller;
+    AspellConfig * config;
+
+    //create new config
+    config = new_aspell_config();
+
+    //extract values
+    rb_scan_args(argc, argv, "04", &vlang, &vjargon, &vsize, &vencoding);
+
+    //language:
+    if (RTEST(vlang)) set_option(config, "lang", STR2CSTR(vlang));
+    //jargon:
+    if (RTEST(vjargon)) set_option(config, "jargon", STR2CSTR(vjargon));
+    //size:
+    if (RTEST(vsize)) set_option(config, "size", STR2CSTR(vsize));
+    //encoding:
+    if (RTEST(vencoding)) set_option(config, "encoding", STR2CSTR(vencoding));
+
+    //create speller:
+    ret = new_aspell_speller(config);
+    delete_aspell_config(config);
+    if (aspell_error(ret) != 0) {
+        tmp = strdup(aspell_error_message(ret));
+        delete_aspell_can_have_error(ret);
+        rb_raise(cAspellError, tmp);
+    }
+
+    speller = to_aspell_speller(ret);
+
+    //wrap pointer
+    return Data_Wrap_Struct(klass, 0, aspell_free, speller);
+}
+
+
+
+/**
+ * Ctor for aspell objects.
+ * This is a custom constructor and takes a hash of config options: key, value pairs.
+ * Common use:
+ *
+ * a = Aspell.new({"lang"=>"de", "jargon"=>"berlin"})
+ *
+ * For a list of config options, see aspell manual.
+ * @param options hash of options
+ */
+static VALUE aspell_s_new1(VALUE klass, VALUE options) {
+    //aspell values
+    AspellCanHaveError * ret;
+    AspellSpeller * speller;
+    AspellConfig * config;
+
+    //create new config
+    config = new_aspell_config();
+
+    //set options
+    set_options(config, options);
+
+    //create speller:
+    ret = new_aspell_speller(config);
+    delete_aspell_config(config);
+    if (aspell_error(ret) != 0) {
+        const char *tmp = strdup(aspell_error_message(ret));
+        delete_aspell_can_have_error(ret);
+        rb_raise(cAspellError, tmp);
+    }
+
+    speller = to_aspell_speller(ret);
+
+    //wrap pointer
+    return Data_Wrap_Struct(klass, 0, aspell_free, speller);
+}
+
+/**
+ * List all available dictionaries.
+ * @param class object
+ * @return array of AspellDictInfo objects.
+ */
+static VALUE aspell_s_list_dicts(VALUE klass) {
+    AspellConfig * config;
+    AspellDictInfoList * dlist;
+    AspellDictInfoEnumeration * dels;
+    const AspellDictInfo * entry;
+    VALUE result = rb_ary_new();
+
+    //get a list of dictionaries
+    config = new_aspell_config();
+    dlist = get_aspell_dict_info_list(config);
+    delete_aspell_config(config);
+
+    //iterate over list - fill ruby array
+    dels = aspell_dict_info_list_elements(dlist);
+    while ( (entry = aspell_dict_info_enumeration_next(dels)) != 0) {
+        rb_ary_push(result, Data_Wrap_Struct(cDictInfo, 0, 0, (AspellDictInfo *)entry));
+    }
+    delete_aspell_dict_info_enumeration(dels);
+    return result;
+}
+
+/**
+ * @see set_option. 
+ */
+static VALUE aspell_set_option(VALUE self, VALUE option, VALUE value) {
+    AspellSpeller *speller = get_speller(self);
+    set_option(aspell_speller_config(speller), STR2CSTR(option), STR2CSTR(value));
+    return self;
+}
+
+
+/**
+ * Delete an option.
+ * @param option optionstring to remove from the options.
+ */
+static VALUE aspell_remove_option(VALUE self, VALUE option) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_config_remove(aspell_speller_config(speller), STR2CSTR(option));
+    return self;
+}
+
+/**
+ * To set the mode, words are suggested.
+ * @param one of Aspell::[ULTRA|FAST|NORMAL|BADSPELLERS]
+ */
+static VALUE aspell_set_suggestion_mode(VALUE self, VALUE value) {
+    AspellSpeller *speller = get_speller(self);
+    set_option(aspell_speller_config(speller), "sug-mode", STR2CSTR(value));
+    return self;
+}
+
+/**
+ * Returns the personal wordlist as array of strings.
+ * @return array of strings
+ */
+static VALUE aspell_personal_wordlist(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    return get_list(aspell_speller_personal_word_list(speller));
+}
+
+/**
+ * Returns the session wordlist as array of strings.
+ * @return array of strings
+ */
+static VALUE aspell_session_wordlist(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    return get_list(aspell_speller_session_word_list(speller));
+}
+
+/**
+ * Returns the main wordlist as array of strings.
+ * @return array of strings
+ */
+static VALUE aspell_main_wordlist(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    return get_list(aspell_speller_main_word_list(speller));
+}
+
+/**
+ * Synchronize all wordlists with the current session.
+ */
+static VALUE aspell_save_all_wordlists(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_speller_save_all_word_lists(speller);
+    check_for_error(speller);
+    return self;
+}
+
+/**
+ * Remove all words inside session.
+ */
+static VALUE aspell_clear_session(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_speller_clear_session(speller);
+    check_for_error(speller);
+    return self;
+}
+
+/**
+ * Suggest words for the given misspelled word.
+ * @param word the misspelled word.
+ * @return array of strings.
+ */
+static VALUE aspell_suggest(VALUE self, VALUE word) {
+    AspellSpeller *speller = get_speller(self);
+    return get_list(aspell_speller_suggest(speller, STR2CSTR(word), -1));
+}
+
+/**
+ * Add a given word to the list of known words inside my private dictionary.
+ * You have to call aspell_save_all_wordlists to make sure the list gets persistent.
+ * @param word the word to add.
+ */
+static VALUE aspell_add_to_personal(VALUE self, VALUE word) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_speller_add_to_personal(speller, STR2CSTR(word), -1);
+    check_for_error(speller);
+    return self;
+}
+
+/**
+ * Add a given word to the list of known words just for the lifetime of this object.
+ * @param word the word to add.
+ */
+static VALUE aspell_add_to_session(VALUE self, VALUE word) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_speller_add_to_session(speller, STR2CSTR(word), -1);
+    check_for_error(speller);
+    return self;
+}
+
+/**
+ * Retrieve the value of a specific option.
+ * The options are listed inside 
+ * Aspell::[DictionaryOptions|CheckerOptions|FilterOptions|RunTogetherOptions|MiscOptions|UtilityOptions]
+ * @param word the option as string.
+ */
+static VALUE aspell_conf_retrieve(VALUE self, VALUE key) {
+    AspellSpeller *speller = get_speller(self);
+    AspellConfig *config = aspell_speller_config(speller);
+    VALUE result = rb_str_new2(aspell_config_retrieve(config, STR2CSTR(key)));
+    if (aspell_config_error(config) != 0) {
+        rb_raise(cAspellError, aspell_config_error_message(config));
+    }
+    return result;
+}
+
+/**
+ * Retrieve the value of a specific option as list.
+ * @param word the option as string.
+ */
+static VALUE aspell_conf_retrieve_list(VALUE self, VALUE key) {
+    AspellSpeller *speller = get_speller(self);
+    AspellConfig *config = aspell_speller_config(speller);
+    AspellStringList * list = new_aspell_string_list();
+    AspellMutableContainer * container  = aspell_string_list_to_mutable_container(list);
+    AspellStringEnumeration * els;
+    VALUE result = rb_ary_new();
+    const char *option_value;
+
+    //retrieve list
+    aspell_config_retrieve_list(config, STR2CSTR(key), container);
+    //check for error
+    if (aspell_config_error(config) != 0) {
+        char *tmp = strdup(aspell_config_error_message(config));
+        delete_aspell_string_list(list);
+        rb_raise( cAspellError, tmp);
+    }
+
+    //iterate over list
+    els = aspell_string_list_elements(list);
+    while ( (option_value = aspell_string_enumeration_next(els)) != 0) {
+        //push the option value to result
+        rb_ary_push(result, rb_str_new2(option_value));
+    }
+    //free list
+    delete_aspell_string_enumeration(els);
+    delete_aspell_string_list(list);
+
+    return result;
+}
+
+/**
+ * Simply dump config.
+ * Not very useful at all.
+ */
+static VALUE aspell_dump_config(VALUE self) {
+    AspellSpeller *speller = get_speller(self);
+    AspellConfig *config = aspell_speller_config(speller);
+    AspellKeyInfoEnumeration * key_list = aspell_config_possible_elements( config, 0 );
+    const AspellKeyInfo * entry;
+
+    while ( (entry = aspell_key_info_enumeration_next(key_list) ) ) {
+        printf("%20s:  %s\n", entry->name, aspell_config_retrieve(config, entry->name) );
+    }
+    delete_aspell_key_info_enumeration(key_list);
+    return self;
+}
+
+/**
+ * Check a given word for correctness.
+ * @param word the word to check
+ * @return true if the word is correct, otherwise false.
+ */
+static VALUE aspell_check(VALUE self, VALUE word) {
+    AspellSpeller *speller = get_speller(self);
+    VALUE result = Qfalse;
+    int code = aspell_speller_check(speller, STR2CSTR(word), -1);
+    if (code == 1)
+        result = Qtrue;
+    else if (code == 0)
+        result = Qfalse;
+    else
+        rb_raise( cAspellError, aspell_speller_error_message(speller));
+    return result;
+}
+
+/**
+ * This method will check an array of strings for misspelled words.
+ * This method needs a block to work proper. Each misspelled word is yielded,
+ * a correct word as result from the block is assumed.
+ * Common use:
+ * 
+ * a = Aspell.new(...)
+ * text = ...
+ * a.correct_lines(text) { |badword|
+ *    puts "Error: #{badword}\n"
+ *    puts a.suggest(badword).join(" | ")
+ *    gets #the input is returned as right word
+ * }
+ * 
+ * @param ary the array of strings to check.
+ * @result an array holding all lines with corrected words.
+ */
+static VALUE aspell_correct_lines(VALUE self, VALUE ary) {
+    VALUE result = ary;
+    if (rb_block_given_p()) {
+        //create checker
+        AspellSpeller *speller = get_speller(self);
+        AspellDocumentChecker * checker = get_checker(speller);
+        AspellToken token;
+        //some tmp values
+        VALUE vline, sline;
+        VALUE word, rword;
+        char *line;
+        int count=RARRAY_LEN(ary);
+        int c=0;
+        //create new result array
+        result = rb_ary_new();
+        //iterate over array
+        while(c<count) {
+            int offset=0;
+            //fetch line
+            vline = RARRAY_PTR(ary)[c];
+            //save line
+            sline = rb_funcall(vline, rb_intern("dup"), 0);
+            //c representation
+            line = STR2CSTR(vline);
+            //process line
+            aspell_document_checker_process(checker, line, -1);
+            //iterate over all misspelled words
+            while (token = aspell_document_checker_next_misspelling(checker), token.len != 0) {
+                //extract word by start/length qualifier
+                word = rb_funcall(vline, rb_intern("[]"), 2, INT2FIX(token.offset), INT2FIX(token.len));
+                //get the right word from the block
+                rword = rb_yield(word);
+                //nil -> do nothing
+                if(rword == Qnil) continue;
+                //check for string
+                if (TYPE(rword) != T_STRING) rb_raise(cAspellError, "Need a String to substitute");
+                //chomp the string
+                rb_funcall(rword, rb_intern("chomp!"), 0);
+                //empty string -> do nothing
+                if(strlen(STR2CSTR(rword)) == 0) continue;
+                //remember word for later suggestion
+                aspell_speller_store_replacement(speller, STR2CSTR(word), -1, STR2CSTR(rword), -1);
+                //substitute the word by replacement
+                rb_funcall(sline, rb_intern("[]="), 3, INT2FIX(token.offset+offset), INT2FIX(token.len), rword);
+                //adjust offset
+                offset += strlen(STR2CSTR(rword))-strlen(STR2CSTR(word));
+                //printf("replace >%s< with >%s< (offset now %d)\n", STR2CSTR(word), STR2CSTR(rword), offset);
+            }
+            //push the substituted line to result
+            rb_ary_push(result, sline);
+            c++;
+        }
+        //free checker
+        delete_aspell_document_checker(checker);
+    } else {
+        rb_raise(cAspellError, "No block given. How to correct?");
+    }
+    return result;
+}
+
+/**
+ * Remember a correction.
+ * This affects the suggestion of other words to fit this correction.
+ * @param badword the bad spelled word as string.
+ * @param badword the correction of the bad spelled word as string.
+ * @result self
+ */
+static VALUE aspell_store_replacement(VALUE self, VALUE badword, VALUE rightword) {
+    AspellSpeller *speller = get_speller(self);
+    aspell_speller_store_replacement(speller, STR2CSTR(badword), -1, STR2CSTR(rightword), -1);
+    return self;
+}
+
+/**
+ * Simple utility function to correct a file.
+ * The file gets read, content will be checked and write back.
+ * Please note: This method will change the file! - no backup and of course: no warranty!
+ * @param filename the name of the file as String.
+ * @exception Exception due to lack of read/write permissions.
+ */
+static VALUE aspell_correct_file(VALUE self, VALUE filename) {
+    if (rb_block_given_p()) {
+        VALUE content = rb_funcall(rb_cFile, rb_intern("readlines"), 1, filename);
+        VALUE newcontent = aspell_correct_lines(self, content);
+        VALUE file = rb_file_open(STR2CSTR(filename), "w+");
+        rb_funcall(file, rb_intern("write"), 1, newcontent);
+        rb_funcall(file, rb_intern("close"), 0);
+    } else {
+        rb_raise(cAspellError, "No block given. How to correct?");
+    }
+    return self;
+
+}
+
+/**
+ * Return a list of all misspelled words inside a given array of strings.
+ * @param ary an array of strings to check for.
+ * @return array of strings: words that are misspelled.
+ */
+static VALUE aspell_list_misspelled(VALUE self, VALUE ary) {
+    VALUE result = rb_hash_new();
+    //create checker
+    AspellSpeller *speller = get_speller(self);
+    AspellDocumentChecker * checker = get_checker(speller);
+    AspellToken token;
+    VALUE word, vline;
+    int count=RARRAY_LEN(ary);
+    int c=0;
+    //iterate over array
+    while(c<count) {
+        //process line
+        vline = RARRAY_PTR(ary)[c];
+        aspell_document_checker_process(checker, STR2CSTR(vline), -1);
+        //iterate over all misspelled words
+        while (token = aspell_document_checker_next_misspelling(checker), token.len != 0) {
+            //extract word by start/length qualifier
+            word = rb_funcall(vline, rb_intern("[]"), 2, INT2FIX(token.offset), INT2FIX(token.len));
+            rb_hash_aset(result, word, Qnil);
+            //yield block, if given
+            if (rb_block_given_p())
+                rb_yield(word);
+        }
+        c++;
+    }
+    //free checker
+    delete_aspell_document_checker(checker);
+    result = rb_funcall(result, rb_intern("keys"), 0);
+    return result;
+}
+
+void Init_aspell() {
+    //CLASS DEFINITION=========================================================
+    cAspell = rb_define_class("Aspell", rb_cObject);
+
+    //CONSTANTS================================================================
+    rb_define_const(cAspell, "ULTRA", rb_str_new2("ultra"));
+    rb_define_const(cAspell, "FAST", rb_str_new2("fast"));
+    rb_define_const(cAspell, "NORMAL", rb_str_new2("normal"));
+    rb_define_const(cAspell, "BADSPELLERS", rb_str_new2("bad-spellers"));
+    rb_define_const(cAspell, "DictionaryOptions", rb_ary_new3(  11,
+                    rb_str_new2("master"),
+                    rb_str_new2("dict-dir"),
+                    rb_str_new2("lang"),
+                    rb_str_new2("size"),
+                    rb_str_new2("jargon"),
+                    rb_str_new2("word-list-path"),
+                    rb_str_new2("module-search-order"),
+                    rb_str_new2("personal"),
+                    rb_str_new2("repl"),
+                    rb_str_new2("extra-dicts"),
+                    rb_str_new2("strip-accents")));
+    rb_define_const(cAspell, "CheckerOptions", rb_ary_new3(  11,
+                    rb_str_new2("ignore"),
+                    rb_str_new2("ignore-case"),
+                    rb_str_new2("ignore-accents"),
+                    rb_str_new2("ignore-repl"),
+                    rb_str_new2("save-repl"),
+                    rb_str_new2("sug-mode"),
+                    rb_str_new2("module-search-order"),
+                    rb_str_new2("personal"),
+                    rb_str_new2("repl"),
+                    rb_str_new2("extra-dicts"),
+                    rb_str_new2("strip-accents")));
+    rb_define_const(cAspell, "FilterOptions", rb_ary_new3(  10,
+                    rb_str_new2("filter"),
+                    rb_str_new2("mode"),
+                    rb_str_new2("encoding"),
+                    rb_str_new2("add-email-quote"),
+                    rb_str_new2("rem-email-quote"),
+                    rb_str_new2("email-margin"),
+                    rb_str_new2("sgml-check"),
+                    rb_str_new2("sgml-extension"),
+                    rb_str_new2("tex-command"),
+                    rb_str_new2("tex-check-command")));
+    rb_define_const(cAspell, "RunTogetherOptions", rb_ary_new3( 3,
+                    rb_str_new2("run-together"),
+                    rb_str_new2("run-together-limit"),
+                    rb_str_new2("run-together-min")));
+    rb_define_const(cAspell, "MiscOptions", rb_ary_new3( 8,
+                    rb_str_new2("conf"),
+                    rb_str_new2("conf-dir"),
+                    rb_str_new2("data-dir"),
+                    rb_str_new2("local-data-dir"),
+                    rb_str_new2("home-dir"),
+                    rb_str_new2("per-conf"),
+                    rb_str_new2("prefix"),
+                    rb_str_new2("set-prefix")));
+
+    rb_define_const(cAspell, "UtilityOptions", rb_ary_new3( 4,
+                    rb_str_new2("backup"),
+                    rb_str_new2("time"),
+                    rb_str_new2("reverse"),
+                    rb_str_new2("keymapping")));
+
+    //CLASS METHODS============================================================
+    rb_define_singleton_method(cAspell, "new", aspell_s_new, -1);
+    rb_define_singleton_method(cAspell, "new1", aspell_s_new1, 1);
+    rb_define_singleton_method(cAspell, "list_dicts", aspell_s_list_dicts, 0);
+
+    //METHODS =================================================================
+    rb_define_method(cAspell, "add_to_personal", aspell_add_to_personal, 1);
+    rb_define_method(cAspell, "add_to_session", aspell_add_to_personal, 1);
+    rb_define_method(cAspell, "check", aspell_check, 1);
+    rb_define_method(cAspell, "correct_lines", aspell_correct_lines, 1);
+    rb_define_method(cAspell, "correct_file", aspell_correct_file, 1);
+    rb_define_method(cAspell, "clear_session", aspell_clear_session, 0);
+    rb_define_method(cAspell, "dump_config", aspell_dump_config, 0);
+    rb_define_method(cAspell, "list_misspelled", aspell_list_misspelled, 1);
+    //This seems not to be very useful ...
+    //rb_define_method(cAspell, "main_wordlist", aspell_main_wordlist, 0);
+    rb_define_method(cAspell, "personal_wordlist", aspell_personal_wordlist, 0);
+    rb_define_method(cAspell, "save_all_word_lists", aspell_save_all_wordlists, 0);
+    rb_define_method(cAspell, "session_wordlist", aspell_session_wordlist, 0);
+    rb_define_method(cAspell, "set_option", aspell_set_option, 2);
+    rb_define_method(cAspell, "store_replacement", aspell_store_replacement, 2);
+    rb_define_method(cAspell, "remove_option", aspell_remove_option, 1);
+    rb_define_method(cAspell, "get_option", aspell_conf_retrieve, 1);
+    rb_define_method(cAspell, "get_option_as_list", aspell_conf_retrieve_list, 1);
+    rb_define_method(cAspell, "suggest", aspell_suggest, 1);
+    rb_define_method(cAspell, "suggestion_mode=", aspell_set_suggestion_mode, 1);
+}
+
+