joker 0.0.1 → 1.0.0

data/HISTORY.markdown

@@ -1,3 +1,8 @@
+# 1.0.0 #
+
+*   Re-release as C extension
+
+
 # 0.0.1 #
 
 *   Initial release

data/README.markdown

@@ -9,14 +9,19 @@ for Ruby.
 
 *   Behaves much like Regexp
 *   ` * ` and ` ? ` as wildcard characters
-*   ` \ ` for escaping
-*   `\a` matches `\a`, but not `a`
+*   ` \ ` for escaping:
+    ` \? ` matches ` ? `,
+    ` \* ` matches ` * `,
+    ` \[ ` matches ` [ `,
+    ` \] ` matches ` ] `,
+*   But for all other characters:
+    ` \a ` matches ` \a `, but not ` a `
 *   Wildcards must always match whole string
+    (thus ` uiae ` will only match the string ` uiae `)
 *   Wildcards can be case insensitive
 
 ## Installation ##
 
-    gem install karottenreibe-joker --source http://gems.github.com
     gem install joker
 
 ## Usage ##

data/Rakefile

@@ -1,20 +1,7 @@
-require 'jeweler'
 
-task :build => :gemspec
-
-Jeweler::Tasks.new do |gem|
-    gem.name = 'joker'
-    gem.summary = gem.description =
-        'Joker is a simple wildcard implementation that works much like Regexps'
-    gem.email = 'karottenreibe@gmail.com'
-    gem.homepage = 'http://karottenreibe.github.com/joker'
-    gem.authors = ['Fabian Streitel']
-    gem.rubyforge_project = 'k-gems'
-end
-
-Jeweler::RubyforgeTasks.new
-
-task :test do
-    sh 'bacon -Ilib test/test_*.rb'
-end
+load "tasks/jeweler.rake"
+load "tasks/rdoc.rake"
+load "tasks/c_extensions.rake"
+load "tasks/test.rake"
+load "tasks/shortcuts.rake"
 

data/VERSION

@@ -1 +1 @@
-0.0.1
+1.0.0

data/ext/joker_native/Joker.c

@@ -0,0 +1,72 @@
+#include <malloc.h>
+#include "Joker.h"
+#include "Wildcard.h"
+#include "compile.h"
+#include "match.h"
+
+
+void Init_joker_native(void)  // {{{1
+{
+    class_Wildcard = rb_define_class("Wildcard", rb_cObject);
+    rb_define_singleton_method(class_Wildcard, "new", class_method_new, -1);
+    rb_define_method(class_Wildcard, "=~",  instance_operator_match, 1);
+    rb_define_method(class_Wildcard, "===", instance_operator_match, 1);
+}
+
+
+VALUE instance_operator_match(self, object)  // {{{1
+    VALUE  self;
+    VALUE  object;
+{
+    Wildcard *    wildcard;
+    const char *  cstring;
+    long int      length;
+    int           casefold;
+
+    // check types and get the C representation of stuff
+    Check_Type(object, T_STRING);
+    Data_Get_Struct(self, Wildcard, wildcard);
+    cstring  = rb_str2cstr(object, &length);
+    casefold  = RTEST(rb_iv_get(self, "@casefold"));
+
+    // match and return the result
+    if (Wildcard_match(wildcard, cstring, length, casefold)) {
+        return Qtrue;
+    } else {
+        return Qfalse;
+    }
+}
+
+
+VALUE class_method_new(argc, argv, klass)  // {{{1
+    int      argc;
+    VALUE *  argv;
+    VALUE    klass;
+{
+    VALUE         wildcard_string;
+    VALUE         casefold;
+    VALUE         new_object;
+    Wildcard *    new_wildcard;
+    const char *  wildcard_cstring;
+    long int      string_length;
+
+    // check arity and fill in defaults
+    rb_scan_args(argc, argv, "11", &wildcard_string, &casefold);
+    if (NIL_P(casefold)) {
+        casefold = Qfalse;
+    }
+
+    // get C representation of stuff and create Wildcard
+    wildcard_cstring = rb_str2cstr(wildcard_string, &string_length);
+    new_wildcard     = Wildcard_compile(wildcard_cstring, string_length);
+    // wrap wildcard
+    new_object       = Data_Wrap_Struct(klass, NULL, Wildcard_free, new_wildcard); 
+
+    // set instance variables
+    rb_iv_set(new_object, "@casefold", casefold);
+    rb_iv_set(new_object, "@source",   wildcard_string);
+
+    return new_object;
+}
+
+

data/ext/joker_native/Joker.h

@@ -0,0 +1,53 @@
+#ifndef JOKER_H_GUARD
+#define JOKER_H_GUARD
+
+#include "ruby.h"
+
+
+VALUE class_Wildcard;
+void Init_joker(void);
+
+
+/*
+ * call-seq:
+ *   Wildcard.new(wildcard_string, casefold = false) -> Wildcard
+ *
+ * Creates a new Wildcard from the given string.
+ * If casefold is true, the Wildcard will ignore case.
+ *
+ * Raisess a SyntaxError if the given string could not
+ * be interpreted as a Wildcard.
+ *
+ * Issues warnings to the console if the given Wildcard
+ * was malformed.
+ *
+ */
+VALUE class_method_new(int argc, VALUE * argv, VALUE klass);
+
+
+/*
+ * call-seq:
+ *   wildcard =~  'string' -> true or false
+ *   'string' =~  wildcard -> true or false
+ *   wildcard === 'string' -> true or false
+ *
+ * Matches the Wildcard against the given string.
+ *
+ * NOTE: Since a wildcard has to match the whole string,
+ * this method only returns true or false, not the position
+ * of the match.
+ *
+ *   Wildcard['*fairy*'] =~  'I love fairycake'    #=> true
+ *   'I love fairycake'  =~  Wildcard['*dairy*']   #=> false
+ *
+ *   case 'I love fairycake'
+ *   when Wildcard['*fairy*'] then puts 'fairy!'
+ *   else puts 'no fairy...'
+ *   end
+ *
+ */
+VALUE instance_operator_match(VALUE self, VALUE string);
+
+
+#endif
+

data/ext/joker_native/Wildcard.c

@@ -0,0 +1,22 @@
+#include <malloc.h>
+#include <stddef.h>
+#include <Wildcard.h>
+
+
+
+void Wildcard_free(wildcard) // {{{1
+    Wildcard *  wildcard;
+{
+    free(wildcard->first);
+    free(wildcard);
+}
+
+
+void Wildcard_enlarge(wildcard) // {{{1
+    Wildcard *  wildcard;
+{
+    wildcard->length += 2;
+    wildcard->first   = realloc(wildcard->first, wildcard->length * sizeof(char));
+    wildcard->last    = wildcard->first + wildcard->length - 2;
+}
+

data/ext/joker_native/Wildcard.h

@@ -0,0 +1,40 @@
+#ifndef WILDCARD_H_GUARD
+#define WILDCARD_H_GUARD
+
+
+/*
+ * The different kinds of Wildcard components.
+ *
+ */
+typedef enum {
+    Kleene  = 0,
+    Fixed   = 1,
+    Group   = 2,
+    Wild    = 3,
+    EOW     = 4,   // only used in matching
+} WildcardType;
+
+/*
+ * Represents a Wildcard internally.
+ *
+ */
+typedef struct {
+    char *   first;     // The first Wildcard part (points to the first of the 2 chars)
+    char *   last;      // The last Wildcard part (points to the first of the 2 chars)
+    long int length;    // How many chars there are (not parts!)
+} Wildcard;
+
+
+void Wildcard_free(Wildcard * wildcard);
+
+
+/*
+ * Adds two additional characters at the end
+ * and adjusts all the pointers.
+ *
+ */
+void Wildcard_enlarge(Wildcard * wildcard);
+
+
+#endif
+

data/ext/joker_native/compile.c

@@ -0,0 +1,158 @@
+#include <malloc.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include <string.h>
+#include <ruby.h>
+#include "compile.h"
+
+
+static int hash(cchar)  // {{{1
+    const char  cchar;
+{
+    switch (cchar) {
+        case '\\':
+            return 0;
+        case '[':
+            return 1;
+        case ']':
+            return 2;
+        case '*':
+            return 3;
+        case '?':
+            return 4;
+        default:
+            return 5;
+    }
+}
+
+
+static void push(type, cchar, wildcard)  // {{{1
+    const WildcardType  type;
+    const char          cchar;
+    Wildcard *          wildcard;
+{
+    Wildcard_enlarge(wildcard);
+    *wildcard->last        = (char) type;
+    *(wildcard->last + 1)  = cchar;
+}
+
+
+static void do_transition(transition, input, state, wildcard)  // {{{1
+    const char  transition;
+    const char  input;
+    int *       state;
+    Wildcard *  wildcard;
+{
+    switch (transition) {
+        case 0:
+            *state = 1;
+            break;
+        case 1:
+            *state = 2;
+            break;
+        case 2:
+            push(Fixed, input, wildcard);
+            rb_warning("wildcard has `]' without escape");
+            break;
+        case 3:
+            // refactor ** --> *
+            if (wildcard->last == NULL || *wildcard->last != (char) Kleene) {
+                push(Kleene, '*', wildcard);
+            }
+            break;
+        case 4:
+            push(Wild, '?', wildcard);
+            break;
+        case 5:
+            push(Fixed, input, wildcard);
+            break;
+        case 6:
+            *state = -1;
+            break;
+        case 7:
+            *state = 0;
+            push(Fixed, input, wildcard);
+            break;
+        case 8:
+            *state = 0;
+            push(Fixed, '\\', wildcard);
+            push(Fixed, input, wildcard);
+            break;
+        case 9:
+            *state = -1;
+            push(Fixed, '\\', wildcard);
+            break;
+        case 10:
+            *state = 3;
+            break;
+        case 11:
+            push(Group, input, wildcard);
+            rb_warning("character class has `[' without escape");
+            break;
+        case 12:
+            *state = 0;
+            break;
+        case 13:
+            push(Group, input, wildcard);
+            break;
+        case 14:
+            *state = -1;
+            rb_raise(rb_eSyntaxError, "premature end of wildcard");
+            break;
+        case 15:
+            *state = 2;
+            push(Group, input, wildcard);
+            break;
+        case 16:
+            *state = 2;
+            push(Group, '\\', wildcard);
+            push(Group, input, wildcard);
+            break;
+        default:
+            rb_fatal("Wildcard compilation state machine failure. This is a bug in Joker!");
+    }
+}
+
+
+Wildcard * Wildcard_compile(cstring, len)  // {{{1
+    const char *    cstring;
+    const long int  len;
+{
+    // the table that maps (state x input) -> transition
+    const char transition_table[4][7] = {
+    //    \   [   ]   *   ? any EOS
+        { 0,  1,  2,  3,  4,  5,  6},
+        { 7,  7,  7,  7,  7,  8,  9},
+        {10, 11, 12, 13, 13, 13, 14},
+        {15, 15, 15, 16, 16, 16, 14}
+    };
+    int state = 0;
+
+    Wildcard * wildcard;
+    long int   p;
+    char       input;
+    int        hashed;
+    char       transition;
+
+    wildcard = malloc(sizeof(Wildcard));
+    wildcard->length = 0;
+    wildcard->first  = NULL;
+    wildcard->last   = NULL;
+
+    // for each char:
+    for (p = 0; p < len; p++) {
+        // get the input, it's type and what transition to make
+        input = cstring[p];
+        hashed = hash(input);
+        transition = transition_table[state][hashed];
+        // and execute the transition
+        do_transition(transition, input, &state, wildcard);
+    }
+
+    // finally: execute the finishing transition
+    transition = transition_table[state][6];
+    do_transition(transition, '\0', &state, wildcard);
+    return wildcard;
+}
+

data/ext/joker_native/compile.h

@@ -0,0 +1,16 @@
+#ifndef COMPILE_H_GUARD
+#define COMPILE_H_GUARD
+
+#include "Wildcard.h"
+
+
+/*
+ * Compiles an input string to the internal Wildcard
+ * represenation.
+ *
+ */
+Wildcard * Wildcard_compile(const char * cstring, const long int len);
+
+
+#endif
+

data/ext/joker_native/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+extension_name = 'joker_native'
+dir_config(extension_name)
+create_makefile(extension_name)
+

data/ext/joker_native/match.c

@@ -0,0 +1,272 @@
+#include <malloc.h>
+#include <stdio.h>
+#include <stddef.h>
+#include <string.h>
+#include <ruby.h>
+#include <ctype.h>
+#include "match.h"
+
+#define SUCCESS_STATE 42
+#define FAILURE_STATE 23
+
+
+typedef struct {
+    const char *  input;
+    const char *  wildcard;
+    const char *  pushed_input;
+    const char *  pushed_wildcard;
+    int           state;
+    void (*inc)(const char **, int);
+} StateMachine;
+
+
+typedef struct {
+    StateMachine *  left;
+    StateMachine *  right;
+    StateMachine *  active;
+} MatchData;
+
+
+static void left_inc(pointer, offset) // {{{1
+    const char **  pointer;
+    int            offset;
+{
+    (*pointer) += offset;
+}
+
+
+static void right_inc(pointer, offset) // {{{1
+    const char **  pointer;
+    int            offset;
+{
+    (*pointer) -= offset;
+}
+
+static int matches(type, data, input, eos, casefold)  // {{{1
+    WildcardType type;
+    const char   data;
+    const char   input;
+    bool         eos;
+    bool         casefold;
+{
+    switch(type) {
+        case Fixed:
+        case Group:
+            if (casefold) {
+                return !eos && tolower(input) == tolower(data);
+            } else {
+                return !eos && input == data;
+            }
+        case Wild:
+            return !eos && input != '\0';
+        case Kleene:
+            return 1;
+        case EOW:
+            return eos;
+        default:
+            rb_raise(rb_eSyntaxError, "corrupted wildcard");
+            return 0;
+    }
+}
+
+
+static bool eow(match_data) // {{{1
+    MatchData * match_data;
+{
+    return match_data->left->wildcard == NULL || match_data->left->wildcard > match_data->right->wildcard;
+}
+
+
+static bool eos(match_data) // {{{1
+    MatchData * match_data;
+{
+    return match_data->left->input > match_data->right->input;
+}
+
+
+static void push(match_data) // {{{1
+    MatchData * match_data;
+{
+    StateMachine * sm;
+    
+    if (!eos(match_data)) {
+        sm                  = match_data->active;
+        sm->pushed_input    = sm->input;
+        sm->pushed_wildcard = sm->wildcard;
+    }
+}
+
+
+static void pull(match_data) // {{{1
+    MatchData * match_data;
+{
+    StateMachine * sm;
+
+    sm = match_data->active;
+    if (sm->pushed_input == NULL) {
+        sm->state            = FAILURE_STATE;
+    } else {
+        sm->input            = sm->pushed_input;
+        sm->wildcard         = sm->pushed_wildcard;
+        sm->pushed_input     = NULL;
+        sm->pushed_wildcard  = NULL;
+        (*sm->inc)(&sm->input, 1); 
+
+        if (sm == match_data->left) {
+            match_data->active = match_data->right;
+        } else {
+            match_data->active = match_data->left;
+        }
+    }                              
+}                                  
+                                   
+
+static void do_transition(transition, match_data)  // {{{1
+    const char   transition;
+    MatchData *  match_data;
+{
+    StateMachine * sm;
+
+    sm = match_data->active;
+    switch (transition) {
+        case 0:
+            push(match_data);
+            (*sm->inc)(&sm->wildcard, 2);
+            break;
+        case 1:
+            sm->state = 1;
+            break;
+        case 2:
+            sm->state = 2;
+            break;
+        case 3:
+            sm->state = 4;
+            break;
+        case 4:
+            // does no exist
+            break;
+        case 5:
+            sm->state = SUCCESS_STATE;
+            break;
+        case 6:
+            sm->state = 0;
+            (*sm->inc)(&sm->wildcard, 2);
+            (*sm->inc)(&sm->input,    1);
+            break;
+        case 7:
+            sm->state = 0;
+            pull(match_data);
+            break;
+        case 8:
+            (*sm->inc)(&sm->wildcard, 2);
+            break;
+        case 9:
+            sm->state = 3;
+            (*sm->inc)(&sm->wildcard, 2);
+            (*sm->inc)(&sm->input,    1);
+            break;
+        case 10:
+            sm->state = 0;
+            break;
+        case 11:
+            (*sm->inc)(&sm->wildcard, 2);
+            break;
+        case 12:
+            sm->state = 0;
+            (*sm->inc)(&sm->wildcard, 2);
+            (*sm->inc)(&sm->input,    1);
+            break;
+        default:
+            rb_fatal("Wildcard matching state machine failure. This is a bug in Joker!");
+    }
+}
+
+
+bool Wildcard_match(wildcard, cstring, len, casefold)  // {{{1
+    Wildcard *      wildcard;
+    const char *    cstring;
+    const long int  len;
+    bool casefold;
+{
+    // the table that maps (match x state x type) -> transition
+    const char transition_table[2][5][5] = {
+        // fail
+        {
+        //   kleene, fixed, group, wild, EOW
+            {     0,     1,     2,    3,   7}, // basic
+            {     7,     7,     7,    7,   7}, // fixed
+            {     7,     7,     8,    7,   7}, // group
+            {    10,    10,    11,   10,  10}, // group_finish
+            {     7,     7,     7,    7,   7}, // wild
+        },
+
+        // match
+        {
+        //   kleene, fixed, group, wild, EOW
+            {     0,     1,     2,    3,   5}, // basic
+            {     6,     6,     6,    6,   6}, // fixed
+            {     7,     7,     9,    7,   7}, // group
+            {    10,    10,    11,   10,  10}, // group_finish
+            {    12,    12,    12,   12,  12}, // wild
+        },
+    };
+
+    MatchData *   match_data;
+    WildcardType  type;
+    char          data;
+    char          input;
+    int           match;
+    char          transition;
+
+    match_data                          = malloc(sizeof(MatchData));
+    match_data->left                    = malloc(sizeof(StateMachine));
+    match_data->right                   = malloc(sizeof(StateMachine));
+    match_data->active                  = match_data->left;
+
+    match_data->left->input             = cstring;
+    match_data->left->wildcard          = wildcard->first;
+    match_data->left->pushed_input      = NULL;
+    match_data->left->pushed_wildcard   = NULL;
+    match_data->left->state             = 0;
+    match_data->left->inc               = left_inc;
+
+    match_data->right->input            = cstring + len - 1;
+    match_data->right->wildcard         = wildcard->last;
+    match_data->right->pushed_input     = NULL;
+    match_data->right->pushed_wildcard  = NULL;
+    match_data->right->state            = 0;
+    match_data->right->inc              = right_inc;
+
+    while (true) {
+        // get the data and it's type
+        if (eow(match_data)) {
+            type   = EOW;
+            data   = '\0';
+        } else {
+            type   = (WildcardType) *match_data->active->wildcard;
+            data   = *(match_data->active->wildcard + 1);
+        }
+
+        // get input, whether it matches the data and the transition to make
+        input      = *match_data->active->input;
+        match      = matches(type, data, input, eos(match_data), casefold);
+        transition = transition_table[match][(int)match_data->active->state][type];
+        // and execute the tansition
+        do_transition(transition, match_data);
+
+        // if the transition resulted in failure or success:
+        // clean up and terminate
+        if (match_data->active->state == SUCCESS_STATE) {
+            free(match_data->right);
+            free(match_data->left);
+            free(match_data);
+            return true;
+        } else if (match_data->active->state == FAILURE_STATE) {
+            free(match_data->right);
+            free(match_data->left);
+            free(match_data);
+            return false;
+        }
+    }
+}
+