jadtfmt 0.0.2

data/ext/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+
+if have_header('unicode/calendar.h') and have_header('unicode/smpdtfmt.h') and ( have_library('icuin') or have_library('icui18n') ) and have_library('icuuc')
+  create_makefile('jadtfmt')
+end

data/ext/jadtfmt.c

@@ -0,0 +1,198 @@
+/* */
+#ifdef _WIN32
+__declspec(dllexport) void Init_jadtfmt();
+#endif
+
+#include <string.h>
+
+#ifndef _WIN32
+#include <alloca.h>
+#else
+#include <malloc.h>
+#endif
+
+#include "ruby.h"
+#include "jadtfmt.h"
+#include "jadtfmt_icu.h"
+
+#define VERSION "0.0.2"
+
+#define DEFAULT_INT(n) (NIL_P(n) ? 0 : NUM2INT(n))
+
+static VALUE JapaneseDateFormat;
+static VALUE pph_E, pph_N, pph_n, pph_E_pattern, pph_N_pattern, pph_n_pattern;
+
+/* */
+static VALUE jadtfmt_initialize(int argc, VALUE *argv, VALUE self) {
+  struct jadtfmt *p;
+  VALUE pattern, kcode;
+  char *s_pattern = NULL;
+  int i_pattern_len = 0;
+  const char *s_kcode;
+  char *s_codepage;
+
+  rb_scan_args(argc, argv, "02", &pattern, &kcode);
+
+  if (!NIL_P(pattern)) {
+    Check_Type(pattern, T_STRING);
+    s_pattern = StringValuePtr(pattern);
+    i_pattern_len = RSTRING(pattern)->len;
+  }
+
+  if (!NIL_P(kcode)) {
+    Check_Type(kcode, T_STRING);
+    s_kcode = (RSTRING(kcode)->len > 0) ? StringValuePtr(kcode) : "UTF8";
+  } else {
+    s_kcode = rb_get_kcode();
+  }
+
+  switch (s_kcode[0]) {
+    case 'S': case 's': s_codepage = "Shift_JIS"; break;
+    case 'E': case 'e': s_codepage = "EUC-JP"; break;
+    case 'U': case 'u': s_codepage = "UTF-8"; break;
+    default: s_codepage = "UTF-8"; break;
+  }
+
+  Data_Get_Struct(self, struct jadtfmt, p);
+  p->fmt = jadtfmt_icu_new(s_pattern, s_codepage);
+  p->pattern_len = i_pattern_len;
+  p->codepage = s_codepage;
+
+  return Qnil;
+}
+
+/* */
+static VALUE jadtfmt_format(VALUE self, VALUE src) {
+  struct jadtfmt *p;
+  VALUE year, month, day, hour, min, sec;
+  char *buf;
+
+  if (!rb_obj_is_instance_of(src, rb_cTime)) {
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected Time)", rb_class2name(CLASS_OF(src)));
+  }
+
+  year = rb_funcall(src, rb_intern("year"), 0);
+  month = rb_funcall(src, rb_intern("month"), 0);
+  day = rb_funcall(src, rb_intern("day"), 0);
+  hour = rb_funcall(src, rb_intern("hour"), 0);
+  min = rb_funcall(src, rb_intern("min"), 0);
+  sec = rb_funcall(src, rb_intern("sec"), 0);
+
+  Data_Get_Struct(self, struct jadtfmt, p);
+
+  if (p->pattern_len > 0) {
+    int len = p->pattern_len * 3 + 16;
+    buf = alloca(len);
+    memset(buf, 0, len);
+  } else {
+    rb_raise(rb_eRuntimeError, "pattern is not set");
+  }
+
+  jadtfmt_icu_format(p->fmt, NUM2INT(year), NUM2INT(month), NUM2INT(day), NUM2INT(hour), NUM2INT(min), NUM2INT(sec), p->codepage, buf);
+
+  return rb_str_new2(buf);
+}
+
+/* */
+static VALUE jadtfmt_format_attrs(int argc, VALUE *argv, VALUE self) {
+  struct jadtfmt *p;
+  VALUE year, month, day, hour, min, sec;
+  char *buf;
+
+  rb_scan_args(argc, argv, "15", &year, &month, &day, &hour, &min, &sec);
+
+  Data_Get_Struct(self, struct jadtfmt, p);
+
+  if (p->pattern_len > 0) {
+    int len = p->pattern_len * 3 + 16;
+    buf = alloca(len);
+    memset(buf, 0, len);
+  } else {
+    rb_raise(rb_eRuntimeError, "pattern is not set");
+  }
+
+  jadtfmt_icu_format(p->fmt, NUM2INT(year), DEFAULT_INT(month), DEFAULT_INT(day), DEFAULT_INT(hour), DEFAULT_INT(min), DEFAULT_INT(sec), p->codepage, buf);
+
+  return rb_str_new2(buf);
+}
+
+/* */
+static VALUE jadtfmt_apply_pattern(VALUE self, VALUE pattern) {
+  struct jadtfmt *p;
+
+  Check_Type(pattern, T_STRING);
+  Data_Get_Struct(self, struct jadtfmt, p);
+  jadtfmt_icu_apply_pattern(p->fmt, StringValuePtr(pattern), p->codepage);
+  p->pattern_len = RSTRING(pattern)->len;
+
+  return Qnil;
+}
+
+/* */
+static VALUE jadtfmt_Time_jadtfmt(VALUE self, VALUE pattern) {
+  VALUE jadtfmt = rb_funcall(JapaneseDateFormat, rb_intern("new"), 1, pattern);
+  return rb_funcall(jadtfmt, rb_intern("format"), 1, self);
+}
+
+/* */
+static VALUE jadtfmt_Time_jastrftime(VALUE self, VALUE format) {
+  VALUE jadtfmt, replace;
+
+  Check_Type(format, T_STRING);
+  jadtfmt = rb_funcall(JapaneseDateFormat, rb_intern("new"), 0);
+
+  if (rb_funcall(format, rb_intern("include?"), 1, pph_E)) {
+    rb_funcall(jadtfmt, rb_intern("apply_pattern"), 1, pph_E_pattern);
+    replace = rb_funcall(jadtfmt, rb_intern("format"), 1, self);
+    format = rb_funcall(format, rb_intern("gsub"), 2, pph_E, replace);
+  }
+
+  if (rb_funcall(format, rb_intern("include?"), 1, pph_N)) {
+    rb_funcall(jadtfmt, rb_intern("apply_pattern"), 1, pph_N_pattern);
+    replace = rb_funcall(jadtfmt, rb_intern("format"), 1, self);
+    format = rb_funcall(format, rb_intern("gsub"), 2, pph_N, replace);
+  }
+
+  if (rb_funcall(format, rb_intern("include?"), 1, pph_n)) {
+    rb_funcall(jadtfmt, rb_intern("apply_pattern"), 1, pph_n_pattern);
+    replace = rb_funcall(jadtfmt, rb_intern("format"), 1, self);
+    format = rb_funcall(format, rb_intern("gsub"), 2, pph_n, replace);
+  }
+
+  return rb_funcall(self, rb_intern("strftime"), 1, format);
+}
+
+static void jadtfmt_free(struct jadtfmt *p) {
+  jadtfmt_icu_delete(p->fmt);
+  xfree(p);
+}
+
+static VALUE jadtfmt_alloc(VALUE klass) {
+  struct jadtfmt *p = ALLOC(struct jadtfmt);
+
+  p->fmt = NULL;
+  p->pattern_len = 0;
+  p->codepage = NULL;
+
+  return Data_Wrap_Struct(klass, 0, jadtfmt_free, p);
+}
+
+void Init_jadtfmt() {
+  JapaneseDateFormat = rb_define_class("JapaneseDateFormat", rb_cObject);
+  rb_define_const(JapaneseDateFormat, "VERSION", rb_str_new2(VERSION));
+  rb_define_alloc_func(JapaneseDateFormat, jadtfmt_alloc);
+  rb_define_private_method(JapaneseDateFormat, "initialize", jadtfmt_initialize, -1);
+  rb_define_method(JapaneseDateFormat, "format", jadtfmt_format, 1);
+  rb_define_method(JapaneseDateFormat, "format_attrs", jadtfmt_format_attrs, -1);
+  rb_define_method(JapaneseDateFormat, "apply_pattern", jadtfmt_apply_pattern, 1);
+
+  rb_define_method(rb_cTime, "jadtfmt", jadtfmt_Time_jadtfmt, 1);
+  rb_define_method(rb_cTime, "jastrftime", jadtfmt_Time_jastrftime, 1);
+
+  pph_E = rb_str_new2("%E");
+  pph_N = rb_str_new2("%N");
+  pph_n = rb_str_new2("%n");
+  pph_E_pattern = rb_str_new2("G");
+  pph_N_pattern = rb_str_new2("yy");
+  pph_n_pattern = rb_str_new2("y");
+}

data/ext/jadtfmt.h

@@ -0,0 +1,10 @@
+#ifndef __JADTFMT_H__
+#define __JADTFMT_H__
+
+struct jadtfmt {
+  void *fmt;
+  int pattern_len;
+  char *codepage;
+};
+
+#endif

data/ext/jadtfmt_icu.cpp

@@ -0,0 +1,76 @@
+#include <string>
+#include <iostream>
+#include "unicode/calendar.h"
+#include "unicode/smpdtfmt.h"
+
+#include "ruby.h"
+
+#define JADTFMT_LOCALE "ja_JP_TRADITIONAL"
+#define RAISE_ICU_ERRER(s) do { rb_raise(rb_eRuntimeError, u_errorName(s)); } while(0)
+#define Chack_ICU_ERROR(s) do { if (U_FAILURE(s)) { RAISE_ICU_ERRER(s); } } while(0)
+
+extern "C" {
+  void *jadtfmt_icu_new(const char *pattern, const char *codepage);
+  void jadtfmt_icu_delete(void *p);
+  void jadtfmt_icu_format(void *p, int year, int month, int date, int hour, int minute, int second, const char *codepage, char *dst);
+  void jadtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage);
+}
+
+void *jadtfmt_icu_new(const char *pattern, const char *codepage) {
+  UErrorCode status = U_ZERO_ERROR;
+  SimpleDateFormat *fmt;
+  Calendar *cal;
+
+  if (pattern) {
+    fmt = new SimpleDateFormat(UnicodeString(pattern), status);
+  } else {
+    fmt = new SimpleDateFormat(status);
+  }
+
+  if (U_FAILURE(status)) {
+    delete fmt;
+    RAISE_ICU_ERRER(status);
+  }
+
+  cal = Calendar::createInstance(JADTFMT_LOCALE, status);
+
+  if (U_FAILURE(status)) {
+    delete cal;
+    delete fmt;
+    RAISE_ICU_ERRER(status);
+  }
+
+  fmt->adoptCalendar(cal);
+
+  return fmt;
+}
+
+void jadtfmt_icu_delete(void *p) {
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  delete fmt;
+}
+
+void jadtfmt_icu_format(void *p, int year, int month, int date, int hour, int minute, int second, const char *codepage, char *dst) {
+  UErrorCode status = U_ZERO_ERROR;
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  Calendar *cal = Calendar::createInstance(JADTFMT_LOCALE, status);
+  Chack_ICU_ERROR(status);
+
+  cal->set(year - 1988, month - 1, date, hour, minute, second);
+  UDate now = cal->getTime(status);
+  Chack_ICU_ERROR(status);
+
+  UnicodeString buf;
+  fmt->format(now, buf);
+
+  std::string conv(buf.extract(0, buf.length(), 0, codepage), '\0');
+  buf.extract(0, buf.length(), &conv[0], codepage);
+  memcpy(dst, conv.c_str(), conv.size());
+
+  delete cal;
+}
+
+void jadtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage) {
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  fmt->applyPattern(UnicodeString(pattern, codepage));
+}

data/ext/jadtfmt_icu.h

@@ -0,0 +1,9 @@
+#ifndef __JADTFMT_ICU_H__
+#define __JADTFMT_ICU_H__
+
+void *jadtfmt_icu_new(const char *pattern, const char *codepage);
+void jadtfmt_icu_delete(void *p);
+void jadtfmt_icu_format(void *p, int year, int month, int date, int hour, int minute, int second, const char *codepage, char *dst);
+void jadtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage);
+
+#endif

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: jadtfmt
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-17 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- ext/jadtfmt.c
+files: 
+- ext/jadtfmt.c
+- ext/jadtfmt.h
+- ext/jadtfmt_icu.cpp
+- ext/jadtfmt_icu.h
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://rua.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --title
+- JapaneseDateFormat - formatting a Time to the japanese time string using ICU.
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jadtfmt
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: formatting a Time to the japanese time string using ICU.
+test_files: []
+