joker 0.0.1 → 1.0.0

data/ext/joker_native/match.h

@@ -0,0 +1,21 @@
+#ifndef MATCH_H_GUARD
+#define MATCH_H_GUARD
+
+#include "Wildcard.h"
+#include "stdbool.h"
+
+
+/*
+ * Matches a given Wildcard against a given string and returns
+ * true on success and false otherwise.
+ *
+ */
+bool Wildcard_match(
+        Wildcard *     wildcard,  // The wildcard to match
+        const char *   cstring,   // The string to match against
+        const long int len,       // The length of the string
+        bool casefold);           // Whether to ignore character case  
+
+
+#endif
+

data/lib/joker.rb

@@ -2,6 +2,8 @@
 # Joker is a simple Wildcard implementation that works much like Regexps.
 #
 
+require File.join( File.dirname( File.expand_path(__FILE__)), 'joker_native')
+
 #
 # Implements wildcards for Ruby. Modeled after the Regexp class.
 #
@@ -54,6 +56,7 @@ class Wildcard
     #
     # Creates a new Wildcard from the given string.
     # If casefold is true, the Wildcard will ignore case.
+    # TODO
     #
     def initialize( wildcard_string, casefold = false )
         @source   = wildcard_string
@@ -71,7 +74,7 @@ class Wildcard
         # special meaning in a Wildcard.
         #
         def quote( string )
-            string.gsub(%r{[\\?*\[]}) { |char| "\\#{char}" }
+            string.gsub(%r{[\\?*\[\]]}) { |char| "\\#{char}" }
         end
 
         alias_method :[], :new
@@ -81,7 +84,7 @@ class Wildcard
     end
 
     def inspect
-        %{Wildcard[#{@source.inspect}]#{@casefold ? 'i' : ''}}
+        %{Wildcard[#{self.source.inspect}]#{self.casefold ? 'i' : ''}}
     end
 
     #
@@ -94,33 +97,6 @@ class Wildcard
         self =~ $_
     end
 
-    #
-    # 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
-    #
-    def =~( string )
-        !!(@regexp =~ string)
-    end
-
-    #
-    # The case operator. Allows you to use Wildcards in case
-    # expressions:
-    #
-    #   case 'I love fairycake'
-    #   when Wildcard['*fairy*'] then puts 'fairy!'
-    #   else puts 'no fairy...'
-    #   end
-    #
-    def ===( object )
-        !!(@regexp =~ object)
-    end
-
     #
     # Compares to Wildcards for equality.
     #
@@ -129,51 +105,11 @@ class Wildcard
     #
     def eql?( that )
         return false unless that.is_a?(Wildcard)
-        @source == that.source && @casefold == that.casefold
+        self.source == that.source && self.casefold == that.casefold
     end
 
     alias_method :==, :eql?
     alias_method :casefold?, :casefold
 
-    private
-
-    #
-    # Converts the wildcard string into a Regexp.
-    # A simple parser, I just threw it in there, no
-    # optimizations.
-    #
-    def compile
-        ptr = 0
-        compiled = '^'
-        while ptr < @source.length
-            snip = @source[ptr..-1]
-            if snip.scan(%r{^\\\\}).first
-                compiled << '\\\\'
-                ptr += 2
-            elsif snip.scan(%r{^\\\?}).first
-                compiled << '\\?'
-                ptr += 2
-            elsif snip.scan(%r{^\\\*}).first
-                compiled << '\\*'
-                ptr += 2
-            elsif snip.scan(%r{^\?}).first
-                compiled << '.'
-                ptr += 1
-            elsif snip.scan(%r{^\*}).first
-                compiled << '.*'
-                ptr += 1
-            elsif group = snip.scan(%r{^\[(?:\\\]|[^\]])+\]}).first
-                ptr += group.length
-                group = group[1..-2]  # remove []
-                group = group.gsub(%r{\\\]}) { ']' }
-                compiled << '[' << Regexp.quote(group) << ']'
-            else
-                compiled << Regexp.quote(@source[ptr..ptr])
-                ptr += 1
-            end
-        end
-        compiled + '$'
-    end
-
 end
 

data/tasks/c_extensions.rake

@@ -0,0 +1,29 @@
+require 'rake/extensiontask'
+require 'rake/extensiontesttask'
+
+extension_task =
+Rake::ExtensionTask.new('joker_native', $gemspec) do |ext|
+    ext.cross_compile   = true
+    ext.cross_platform  = 'x86-mswin32'
+    ext.test_files      = FileList['test/c/*']
+end
+
+CLEAN.include 'lib/**/*.so'
+
+
+# workaround for rake-compiler which needs the gemspec to have a
+# version and yaml-dump-loads the
+# gemspec which leads to errors since procs can't be loaded
+Rake::Task.tasks.each do |task_name|
+    case task_name.to_s
+    when /^native/
+        task_name.prerequisites.unshift("gemspec", "fix_rake_compiler_gemspec_dump")
+    end
+end
+
+task :fix_rake_compiler_gemspec_dump do
+    %w{files extra_rdoc_files test_files}.each do |accessor|
+        $gemspec.send(accessor).instance_eval { @exclude_procs = Array.new }
+    end
+end
+

data/tasks/jeweler.rake

@@ -0,0 +1,28 @@
+
+task :release do
+    sh "vim HISTORY.markdown"
+    sh "vim README.markdown"
+    sh "git commit -a -m 'prerelease adjustments'; true"
+end
+
+task :build => :gemspec
+
+require 'jeweler'
+jeweler_tasks = Jeweler::Tasks.new do |gem|
+    gem.name                = 'joker'
+    gem.summary             = 'Joker is a simple wildcard implementation that works much like Regexps'
+    gem.description         = gem.summary
+    gem.email               = 'karottenreibe@gmail.com'
+    gem.homepage            = 'http://karottenreibe.github.com/joker'
+    gem.authors             = ['Fabian Streitel']
+    gem.rubyforge_project   = 'k-gems'
+    gem.extensions          = FileList['ext/**/extconf.rb']
+
+    gem.files.include('lib/joker_native.*') # add native stuff
+end
+
+$gemspec = jeweler_tasks.gemspec
+
+Jeweler::RubyforgeTasks.new
+Jeweler::GemcutterTasks.new
+

data/tasks/rdoc.rake

@@ -0,0 +1,9 @@
+require 'rake/rdoctask'
+
+Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_dir = 'rdoc'
+    rdoc.title = 'Joker'
+    rdoc.rdoc_files.include('lib/**/*.rb')
+    rdoc.rdoc_files.include('ext/**/*.rb')
+end
+

data/tasks/shortcuts.rake

@@ -0,0 +1,22 @@
+
+desc("Build linux and windows specific gems")
+task :gems do
+    sh "rake clean build:native"
+    sh "rake clean build:cross"
+    sh "rake clean build"
+end
+
+task "build:native" => [:no_extconf, :native, :build] do
+    file = "pkg/joker-#{`cat VERSION`.chomp}.gem"
+    mv file, "#{file.ext}-i686-linux.gem"
+end
+
+task "build:cross" => [:no_extconf, :cross, :native, :build] do
+    file = "pkg/joker-#{`cat VERSION`.chomp}.gem"
+    mv file, "#{file.ext}-x86-mingw32.gem"
+end
+
+task :no_extconf do
+    $gemspec.extensions = []
+end
+

data/tasks/test.rake

@@ -0,0 +1,6 @@
+
+desc('Test the ruby part of Joker')
+task :test => 'build:native' do
+    sh 'bacon -Ilib test/ruby/test_*.rb'
+end
+

data/test/c/test_compile.c

@@ -0,0 +1,215 @@
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <setjmp.h>
+#include <cmockery.h>
+#include <stdio.h>
+#include <string.h>
+#include <ruby.h>
+#include "compile.h"
+#include "Wildcard.h"
+
+//
+// Possible scenarios:
+// *    string empty
+//      string not empty
+// *    contains group
+//      contains fixed
+//      contains wildcard
+//      contains kleene
+// *    contains "**"
+// *    contains escape at EOS
+//      contains escape at Fixed
+//      contains escape at Group
+//
+
+
+static void generic_test(cstring, length, expected) // {{{1
+    const char *  cstring;
+    const int     length;
+    const char *  expected;
+{
+    Wildcard *    wildcard;
+    int           i;
+
+    wildcard = Wildcard_compile(cstring, strlen(cstring));
+    assert_int_not_equal( (int)NULL, (int)wildcard        );
+    assert_int_not_equal( (int)NULL, (int)wildcard->first );
+    assert_int_not_equal( (int)NULL, (int)wildcard->last  );
+    assert_int_equal(     length,    wildcard->length     );
+
+    for (i = 0; i < length; i += 2) {
+        assert_int_equal((int)*(expected + i), (int)*(wildcard->first + i));
+    }
+
+    Wildcard_free(wildcard);
+}
+
+
+static void test_empty(state) // {{{1
+    void ** state;
+{
+    Wildcard *    wildcard;
+    int           i;
+
+    wildcard = Wildcard_compile("", 0);
+    assert_int_not_equal( (int)NULL, (int)wildcard        );
+    assert_int_equal(     (int)NULL, (int)wildcard->first );
+    assert_int_equal(     (int)NULL, (int)wildcard->last  );
+    assert_int_equal(     0,         wildcard->length     );
+
+    Wildcard_free(wildcard);
+}
+
+
+static void test_fixed(state) // {{{1
+    void ** state;
+{
+    const char expected[8] = {
+        Fixed, 'u',
+        Fixed, 'i',
+        Fixed, 'a',
+        Fixed, 'e',
+    };
+
+    generic_test("uiae", 8, expected);
+}
+
+
+static void test_group(state) // {{{1
+    void ** state;
+{
+    const char expected[4] = {
+        Group, 'i',
+        Group, 'a',
+    };
+
+    generic_test("[ia]", 4, expected);
+}
+
+
+static void test_wild(state) // {{{1
+    void ** state;
+{
+    const char expected[2] = {
+        Wild, '?',
+    };
+
+    generic_test("?", 2, expected);
+}
+
+
+static void test_kleene(state) // {{{1
+    void ** state;
+{
+    const char expected[2] = {
+        Kleene, '*',
+    };
+
+    generic_test("*",    2, expected);
+    generic_test("**",   2, expected);
+    generic_test("****", 2, expected);
+}
+
+
+static void test_mixed(state) // {{{1
+    void ** state;
+{
+    const char expected[10] = {
+        Fixed,  'u',
+        Wild,   '?',
+        Kleene, '*',
+        Group,  'e',
+        Group,  '?',
+    };
+
+    generic_test("u?*[e?]", 10, expected);
+}
+
+
+static void test_escaping(state) // {{{1
+    void ** state;
+{
+    ruby_init(); // since we will be calling rb_warning
+
+    // escaping in fixed parts
+    {
+        char expected[4] = {
+            Fixed,  '?',
+            Fixed,  'a',
+        };
+
+        // escaping of escapable characters
+        generic_test("\\?", 2, expected);
+
+        expected[1] = '*';
+        generic_test("\\*", 2, expected);
+
+        expected[1] = '[';
+        generic_test("\\[", 2, expected);
+
+        expected[1] = ']';
+        generic_test("\\]", 2, expected);
+
+        expected[1] = '\\';
+        generic_test("\\\\", 2, expected);
+
+        // special warning-generating escaping mechanism
+        expected[1] = ']';
+        generic_test("]", 2, expected);
+
+        // escaping of non-escapable characters
+        expected[1] = '\\';
+        generic_test("\\a", 4, expected);
+    }
+    // escaping in group parts
+    {
+        char expected[4] = {
+            Group,  '[',
+            Group,  'a',
+        };
+
+        // escaping of escapable characters
+        generic_test("[\\[]", 2, expected);
+
+        expected[1] = ']';
+        generic_test("[\\]]", 2, expected);
+
+        expected[1] = '\\';
+        generic_test("[\\\\]", 2, expected);
+
+        // special warning-generating escaping mechanism
+        expected[1] = '[';
+        generic_test("[[]", 2, expected);
+
+        // escaping of non-escapable characters
+        expected[1] = '\\';
+        generic_test("[\\a]", 4, expected);
+
+        expected[3] = '?';
+        generic_test("[\\?]", 4, expected);
+    }
+    // escaping at EOS
+    {
+        char expected[4] = {
+            Fixed,  '\\',
+        };
+
+        generic_test("\\", 2, expected);
+    }
+}
+
+
+int main() { // {{{1
+    const UnitTest tests[] = {
+        unit_test(test_empty),
+        unit_test(test_fixed),
+        unit_test(test_group),
+        unit_test(test_wild),
+        unit_test(test_kleene),
+        unit_test(test_mixed),
+        unit_test(test_escaping),
+    };
+    return run_tests(tests);
+}
+