/**
* 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, "%s", 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;
}
/**
* 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;
}
/**
* 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, "%s", "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, "%s", "No block given. How to correct?");
}
return result;
}
/**
* 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, "%s", aspell_config_error_message(config));
}
return result;
}
/**
* 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, "%s", aspell_speller_error_message(speller));
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;
}
/**
* 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;
}
/**
* 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, StringValuePtr(word), -1);
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;
}
/**
* 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;
}
/**
* 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));
}
/**
* 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;
}
/**
* 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;
}
/**
* @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;
}
/**
* 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;
}
/**
* 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));
}
/**
* 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, StringValuePtr(word), -1));
}
