tmail 1.1.1

data/bat/stats

@@ -0,0 +1,138 @@
+#!/usr/bin/env ratch
+
+# Simple code count analysis.
+#
+# This ratchet scan source code counting files,
+# lines of code and comments and  presents a
+# report of it's findings.
+
+main :stats do
+  statistics
+end
+
+DEFAULT_STATS_FILES = [ 'lib/**/*', 'ext/**/*', 'bin/**/*' ]
+
+# Basic statics on line count.
+#
+# This task counts the file and lines of code in your
+# project and provided some statistical figures.
+#
+#   files      Files to include and/or exclude in
+#              analysis. '+' and '-' files patterns
+#              are accepted. The default includes all
+#              files in the lib/ and ext/ directories.
+#
+# TODO Support - and + augmentations for configuration.
+
+def statistics
+  config  = configuration['stats'] || {}
+  scripts = config['files'] || DEFAULT_STATS_FILES
+  files   = scripts.inject([]){ |memo, find| memo.concat(glob(find)); memo }
+  #Dir.multiglob_with_default(DEFAULT_STATS_FILES)
+
+  fc, l, c, r, t, s = *line_count(*files)
+
+  fct, lt, ct, rt, tt, st = *([0]*6)
+  if File.directory?('test')
+    fct, lt, ct, rt, tt, st = *line_count('test/**/*')
+    t = lt if lt > 0
+  end
+
+  rat = lambda do |d,n|
+    if d > n and n != 0
+      "%.1f" % [ d.to_f / n ]
+    elsif n > d and d != 0
+      "-" #"%.1f:1" % [ n.to_f / d ]
+    elsif d == 0 or n == 0
+      "-"
+    else
+      "1.0"
+    end
+  end
+
+  per = lambda do |n,d|
+    if d != 0
+      (((n.to_f / d)*100).to_i).to_s + "%"
+    else
+      "-"
+    end
+  end
+
+  max = l.to_s.size + 4
+
+  puts
+  #puts "FILES:"
+  #puts "  source: #{fc}"
+  #puts "  test  : #{fct}"
+  #puts "  total : #{fc+fct}"
+  #puts
+  #puts "LINES:"
+  #puts "  code  : %#{max}s   %4s" % [ c.to_s, per[c,l] ]
+  #puts "  docs  : %#{max}s   %4s" % [ r.to_s, per[r,l] ]
+  #puts "  space : %#{max}s   %4s" % [ s.to_s, per[s,l] ]
+  #puts "  test  : %#{max}s   %4s" % [ t.to_s, per[t,l] ]
+  #puts "  total : %#{max}s   %4s" % [ l.to_s, per[l,l] ]
+  #puts
+  #puts "Ratio to 1 :"
+  #puts "  code to test : #{rat[c,t]} #{per[c,t]}"
+
+  head = ["Total", "Code", "-%-", "Docs", "-%-", "Blank", "-%-", "Files"]
+  prod = [l.to_s, c.to_s, per[c,l], r.to_s, per[r,l], s.to_s, per[s,l], fc]
+  test = [lt.to_s, ct.to_s, per[ct,l], rt.to_s, per[rt,l], st.to_s, per[st,l], fct]
+  totl = [(l+lt), (c+ct), per[c+ct,l+lt], (r+rt), per[r+rt,l+lt], (s+st), per[s+st,l+lt], (fc+fct)]
+
+  puts "TYPE    %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % head
+  puts "Source  %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % prod
+  puts "Test    %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % test
+  puts "Total   %#{max}s %#{max}s %4s %#{max}s %4s %#{max}s %4s %#{max}s" % totl
+  puts
+  puts "RATIO     Code    Docs    Blank   Test   Total"
+  puts "Code   %7s %7s %7s %7s %7s" % [ rat[c,c], rat[c,r], rat[c,s], rat[c,t], rat[c,l] ]
+  puts "Docs   %7s %7s %7s %7s %7s" % [ rat[r,c], rat[r,r], rat[r,s], rat[r,t], rat[r,l] ]
+  puts "Blank  %7s %7s %7s %7s %7s" % [ rat[s,c], rat[s,r], rat[s,s], rat[s,t], rat[s,l] ]
+  puts "Test   %7s %7s %7s %7s %7s" % [ rat[t,c], rat[t,r], rat[t,s], rat[t,t], rat[t,l] ]
+  puts "Total  %7s %7s %7s %7s %7s" % [ rat[l,c], rat[l,r], rat[l,s], rat[l,t], rat[l,l] ]
+  puts
+end
+
+private
+
+# Return line counts for files.
+
+def line_count( *files )
+  files = files.inject([]) do |memo, find|
+    memo.concat(Dir.glob(find)); memo
+  end
+
+  fc, l, c, t, r = 0, 0, 0, 0, 0
+  bt, rb = false, false
+
+  files.each do |fname|
+    next unless fname =~ /.*rb/      # TODO should this be done?
+    fc += 1
+    File.open( fname ) do |f|
+      while line = f.gets
+        l += 1
+        next if line =~ /^\s*$/
+        case line
+        when /^=begin\s+test/
+          tb = true; t+=1
+        when /^=begin/
+          rb = true; r+=1
+        when /^=end/
+          t+=1 if tb
+          r+=1 if rb
+          rb, tb = false, false
+        when /^\s*#/
+          r += 1
+        else
+          c+=1 if !(rb or tb)
+          r+=1 if rb
+          t+=1 if tb
+        end
+      end
+    end
+  end
+  s = l - c - r - t
+  return fc, l, c, r, t, s
+end

data/bat/tag

@@ -0,0 +1,25 @@
+#!/usr/bin/env ratch
+
+# tag current version
+
+main :tag do
+  rubyforge_username = ENV['RUBYFORGE_USERNAME']
+
+  abort "Need RUBYFORGE_USERNAME evironment setting." unless rubyforge_username
+
+  name, version = *File.basename(glob("meta/*.roll").first).chomp('.roll').split('-')
+
+  changes = /^===\s*#{version}(.*?)\n===/m.match(File.read('History.txt'))[0]
+  changes = changes.chomp('===').strip.sub(/^===\s+/, 'TAG ')
+
+  #puts "#{name}-#{version}"
+  puts changes
+  puts
+
+  case ask("Continue? [yN]").strip.downcase
+  when 'y', 'yes'
+    svn "copy", "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{name}/trunk",
+                "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{name}/tags/REL-#{version}"
+  end
+
+end

data/bat/test

@@ -0,0 +1,25 @@
+#!/usr/bin/env ratch
+
+# Run unit tests
+
+live = ARGV.delete('--live')
+
+unless live
+  $LOAD_PATH.unshift(File.expand_path('lib'))
+end
+
+main :test do
+  if find = argv[0]
+    unless file?(find)
+      find = File.join(find, '**', 'test_*.rb')
+    end
+  else
+    find = 'test/**/test_*.rb'
+  end
+
+  Dir.glob(find).each do |file|
+    next if dir?(file)
+    load file
+  end
+end
+

data/ext/tmail/Makefile

@@ -0,0 +1,25 @@
+#
+# ext/tmail/Makefile
+#
+
+.PHONY: scanner_c base64 clean distclean
+
+all: scanner_c base64
+
+scanner_c: scanner_c/Makefile
+	cd scanner_c; $(MAKE)
+scanner_c/Makefile: scanner_c/extconf.rb
+	cd scanner_c; ruby extconf.rb
+
+base64: base64/Makefile
+	cd base64; $(MAKE)
+base64/Makefile: base64/extconf.rb
+	cd base64; ruby extconf.rb
+
+clean:
+	cd base64; $(MAKE) clean
+	cd scanner_c; $(MAKE) clean
+
+distclean:
+	cd base64; $(MAKE) distclean
+	cd scanner_c; $(MAKE) distclean

data/ext/tmail/base64/MANIFEST

@@ -0,0 +1,4 @@
+MANIFEST
+tmbase64.c
+extconf.rb
+depend

data/ext/tmail/base64/base64.c

@@ -0,0 +1,264 @@
+/*
+
+    base64.c
+
+    Copyright (c) 2001-2007 Minero Aoki
+
+    This program is free software.
+    You can distribute/modify this program under the terms of
+    the GNU Lesser General Public License version 2.1.
+
+*/
+
+#include "ruby.h"
+#include "version.h"
+#include <stdio.h>
+
+#ifdef DEBUG
+#  define D(code) code
+#else
+#  define D(code)
+#endif
+
+static char *CONVTAB =
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+static int REVTAB[256];
+#define INIT    (-1)
+#define SKIP    (-2)
+#define ILLEGAL (-3)
+
+#if RUBY_VERSION_CODE < 170   /* Ruby 1.6 */
+# define StringValue(s) tmail_rb_string_value(&(s))
+static void
+tmail_rb_string_value(s)
+    VALUE *s;
+{
+    if (TYPE(*s) != T_STRING) {
+        *s = rb_str_to_str(*s);
+    }
+}
+#endif
+
+static void
+get_ptrlen(s, ptr, len)
+    VALUE *s;
+    char **ptr;
+    long *len;
+{
+    StringValue(*s);
+    *ptr = RSTRING(*s)->ptr;
+    if (!*ptr) *ptr = "";
+    *len = RSTRING(*s)->len;
+}
+
+static long
+calculate_buflen(len, eollen, limit)
+    long len, eollen;
+{
+    long result;
+
+    result = (len/3 + 1) * 4;
+    if (eollen) {
+        result += (result/limit + 1) * eollen;
+    }
+    return result;
+}
+
+static VALUE
+do_base64(str, eolv, limit)
+    VALUE str, eolv;
+    long limit;
+{
+    char *buf, *b;
+    char *p, *pend;
+    long len;
+    char *eol;
+    long eollen;
+    VALUE s;
+    char *linehead;
+
+    get_ptrlen(&str, &p, &len);
+    pend = p + len;
+    if (NIL_P(eolv)) {
+        eol = "";
+        eollen = 0;
+    }
+    else {
+        get_ptrlen(&eolv, &eol, &eollen);
+    }
+    b = buf = ALLOC_N(char, calculate_buflen(len, eollen, limit));
+    linehead = b;
+
+    while (pend - p >= 3) {
+        if (eollen) {
+            if (b - linehead + 4 > limit) {
+                memcpy(b, eol, eollen); b += eollen;
+                linehead = b;
+            }
+        }
+        *b++ = CONVTAB[0x3f & (p[0] >> 2)];
+        *b++ = CONVTAB[0x3f & (((p[0] << 4) & 0x30) | ((p[1] >> 4) & 0xf))];
+        *b++ = CONVTAB[0x3f & (((p[1] << 2) & 0x3c) | ((p[2] >> 6) & 0x3))];
+        *b++ = CONVTAB[0x3f & p[2]];
+        p += 3;
+    }
+    if ((b - linehead) + (pend - p) > limit) {
+        if (eollen) {
+            memcpy(b, eol, eollen); b += eollen;
+        }
+    }
+    if (pend - p == 2) {
+        *b++ = CONVTAB[0x3f & (p[0] >> 2)];
+        *b++ = CONVTAB[0x3f & (((p[0] << 4) & 0x30) | ((p[1] >> 4) &0xf))];
+        *b++ = CONVTAB[0x3f & (((p[1] << 2) & 0x3c) | 0)];
+        *b++ = '=';
+    }
+    else if (pend - p == 1) {
+        *b++ = CONVTAB[0x3f & (p[0] >> 2)];
+        *b++ = CONVTAB[0x3f & (((p[0] << 4) & 0x30) | 0)];
+        *b++ = '=';
+        *b++ = '=';
+    }
+    if (eollen) {
+        memcpy(b, eol, eollen); b += eollen;
+    }
+
+    s = rb_str_new("", 0);
+    rb_str_cat(s, buf, b - buf);
+    free(buf);
+
+    return s;
+}
+
+#define DEFAULT_LINE_LIMIT 72
+
+/* def folding_encode( str, eol, limit ) */
+static VALUE
+b64_fold_encode(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE str, eol, limit_v;
+    long limit = DEFAULT_LINE_LIMIT;
+
+    switch (rb_scan_args(argc, argv, "12", &str, &eol, &limit_v)) {
+    case 1:
+        eol = rb_str_new("\n", 1);
+        break;
+    case 2:
+        break;
+    case 3:
+        limit = NUM2LONG(limit_v);
+        if (limit < 4) {
+            rb_raise(rb_eArgError, "too small line length limit");
+        }
+        break;
+    default:
+        break;
+    }
+    return do_base64(str, eol, limit);
+}
+
+static VALUE
+b64_encode(self, str)
+    VALUE self, str;
+{
+    return do_base64(str, Qnil, 0);
+}
+
+static VALUE
+b64_decode(argc, argv, self)
+    int argc;
+    VALUE *argv;
+    VALUE self;
+{
+    VALUE str, strict;
+    char *buf, *bp;
+    char *p, *pend;
+    long len;
+    int a, b, c, d;
+    VALUE s;
+
+    if (rb_scan_args(argc, argv, "11", &str, &strict) == 1) {
+        strict = Qfalse;
+    }
+
+    get_ptrlen(&str, &p, &len);
+    pend = p + len;
+    bp = buf = ALLOC_N(char, (len/4 + 1) * 3);
+
+#define FETCH(ch) \
+while (1) {                                                \
+    if (p >= pend) goto brk;                               \
+    ch = REVTAB[(int)(*p++)];                              \
+    if (ch == ILLEGAL) {                                   \
+        rb_raise(rb_eArgError, "corrupted base64 string"); \
+    }                                                      \
+    else if (ch == SKIP) {                                 \
+        ;                                                  \
+    }                                                      \
+    else {                                                 \
+        break;                                             \
+    }                                                      \
+    ch = INIT;                                             \
+}
+    a = b = c = d = INIT;
+    while (p < pend) {
+        FETCH(a); D(printf("fetch a: %d\n", (int)a));
+        FETCH(b); D(printf("fetch b: %d\n", (int)b));
+        FETCH(c); D(printf("fetch c: %d\n", (int)c));
+        FETCH(d); D(printf("fetch d: %d\n", (int)d));
+
+        *bp++ = (a << 2) | (b >> 4);
+        *bp++ = (b << 4) | (c >> 2);
+        *bp++ = (c << 6) | d;
+        a = b = c = d = INIT;
+    }
+brk:
+    if (a != INIT && b != INIT && c != INIT) {
+        D(puts("3bytes"));
+        *bp++ = (a << 2) | (b >> 4);
+        *bp++ = (b << 4) | (c >> 2);
+    }
+    else if (a != INIT && b != INIT) {
+        D(puts("2bytes"));
+        *bp++ = (a << 2) | (b >> 4);
+    }
+    /* ignore if only 'a' */
+
+    D(printf("decoded len=%d\n", (int)(bp - buf)));
+    s = rb_str_new("", 0);
+    rb_str_cat(s, buf, bp - buf);
+    free(buf);
+        
+    return s;
+}
+
+static void
+initialize_reverse_table()
+{
+    int i;
+
+    for (i = 0; i < 256; i++) {
+        REVTAB[i] = ILLEGAL;
+    }
+    REVTAB[(int)'='] = SKIP;
+    REVTAB[(int)'\r'] = SKIP;
+    REVTAB[(int)'\n'] = SKIP;
+    for (i = 0; i < 64; i++) {
+        REVTAB[(int)CONVTAB[i]] = (char)i;
+    }
+}
+
+void
+Init_base64()
+{
+    VALUE Base64;
+
+    Base64 = rb_eval_string("module TMail; module Base64; end end; ::TMail::Base64");
+    rb_define_module_function(Base64, "c_folding_encode", b64_fold_encode, -1);
+    rb_define_module_function(Base64, "c_encode", b64_encode, 1);
+    rb_define_module_function(Base64, "c_decode", b64_decode, -1);
+    initialize_reverse_table();
+}