smpdtfmt 0.0.1

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('smpdtfmt')
+end

data/ext/smpdtfmt.c

@@ -0,0 +1,212 @@
+/* */
+#ifdef _WIN32
+__declspec(dllexport) void Init_smpdtfmt();
+#endif
+
+#include <string.h>
+
+#ifndef _WIN32
+#include <alloca.h>
+#else
+#include <malloc.h>
+#endif
+
+#include "ruby.h"
+#include "smpdtfmt.h"
+#include "smpdtfmt_icu.h"
+
+#define VERSION "0.0.1"
+
+#define DEFAULT_INT(n) (NIL_P(n) ? 0 : NUM2INT(n))
+
+static VALUE rb_cSimpleDateFormat;
+
+/* */
+static VALUE smpdtfmt_initialize(int argc, VALUE *argv, VALUE self) {
+  struct smpdtfmt *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 smpdtfmt, p);
+  p->fmt = smpdtfmt_icu_new(s_pattern, s_codepage);
+  p->pattern_len = i_pattern_len;
+  p->codepage = s_codepage;
+
+  return Qnil;
+}
+
+/* */
+static VALUE smpdtfmt_format(VALUE self, VALUE src) {
+  struct smpdtfmt *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 smpdtfmt, 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");
+  }
+
+  smpdtfmt_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 smpdtfmt_format_attrs(int argc, VALUE *argv, VALUE self) {
+  struct smpdtfmt *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 smpdtfmt, 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");
+  }
+
+  smpdtfmt_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 smpdtfmt_parse(VALUE self, VALUE text) {
+  struct smpdtfmt *p;
+  int year, month, day, hour, min, sec;
+
+  Check_Type(text, T_STRING);
+  Data_Get_Struct(self, struct smpdtfmt, p);
+  smpdtfmt_icu_parse(p->fmt, StringValuePtr(text), p->codepage, &year, &month, &day, &hour, &min, &sec);
+
+  return rb_funcall(rb_cTime, rb_intern("mktime"), 6, INT2NUM(year), INT2NUM(month), INT2NUM(day), INT2NUM(hour), INT2NUM(min), INT2NUM(sec));
+}
+
+/* */
+static VALUE smpdtfmt_apply_pattern(VALUE self, VALUE pattern) {
+  struct smpdtfmt *p;
+
+  Check_Type(pattern, T_STRING);
+  Data_Get_Struct(self, struct smpdtfmt, p);
+  smpdtfmt_icu_apply_pattern(p->fmt, StringValuePtr(pattern), p->codepage);
+  p->pattern_len = RSTRING(pattern)->len;
+
+  return Qnil;
+}
+
+/* */
+static VALUE smpdtfmt_set_lenient(VALUE self, VALUE lenient) {
+  struct smpdtfmt *p;
+  int i_lenient;
+
+  switch (TYPE(lenient)) {
+  case T_TRUE:  i_lenient = 1; break;
+  case T_FALSE: i_lenient = 0; break;
+  default:
+    rb_raise(rb_eTypeError, "wrong argument type %s (expected TrueClass or FalseClass)", CLASS_OF(lenient));
+    break;
+  }
+
+  Data_Get_Struct(self, struct smpdtfmt, p);
+  smpdtfmt_icu_set_lenient(p->fmt, i_lenient);
+
+  return Qnil;
+}
+
+/* */
+static VALUE smpdtfmt_Time_dtfmt(VALUE self, VALUE pattern) {
+  VALUE smpdtfmt = rb_funcall(rb_cSimpleDateFormat, rb_intern("new"), 1, pattern);
+  return rb_funcall(smpdtfmt, rb_intern("format"), 1, self);
+}
+
+/* */
+static VALUE smpdtfmt_Time_icuparse(int argc, VALUE *argv, VALUE self) {
+  VALUE smpdtfmt, pattern, text, lenient;
+
+  rb_scan_args(argc, argv, "21", &pattern, &text, &lenient);
+  Check_Type(pattern, T_STRING);
+
+  if (NIL_P(lenient)) {
+    lenient = Qtrue;
+  }
+
+  smpdtfmt = rb_funcall(rb_cSimpleDateFormat, rb_intern("new"), 1, pattern);
+  rb_funcall(smpdtfmt, rb_intern("lenient="), 1, lenient);
+
+  return rb_funcall(smpdtfmt, rb_intern("parse"), 1, text);
+}
+
+static void smpdtfmt_free(struct smpdtfmt *p) {
+  smpdtfmt_icu_delete(p->fmt);
+  xfree(p);
+}
+
+static VALUE smpdtfmt_alloc(VALUE klass) {
+  struct smpdtfmt *p = ALLOC(struct smpdtfmt);
+
+  p->fmt = NULL;
+  p->pattern_len = 0;
+  p->codepage = NULL;
+
+  return Data_Wrap_Struct(klass, 0, smpdtfmt_free, p);
+}
+
+void Init_smpdtfmt() {
+  rb_cSimpleDateFormat = rb_define_class("SimpleDateFormat", rb_cObject);
+  rb_define_const(rb_cSimpleDateFormat, "VERSION", rb_str_new2(VERSION));
+  rb_define_alloc_func(rb_cSimpleDateFormat, smpdtfmt_alloc);
+  rb_define_private_method(rb_cSimpleDateFormat, "initialize", smpdtfmt_initialize, -1);
+  rb_define_method(rb_cSimpleDateFormat, "format", smpdtfmt_format, 1);
+  rb_define_method(rb_cSimpleDateFormat, "format_attrs", smpdtfmt_format_attrs, -1);
+  rb_define_method(rb_cSimpleDateFormat, "parse", smpdtfmt_parse, 1);
+  rb_define_method(rb_cSimpleDateFormat, "apply_pattern", smpdtfmt_apply_pattern, 1);
+  rb_define_method(rb_cSimpleDateFormat, "lenient=", smpdtfmt_set_lenient, 1);
+
+  rb_define_method(rb_cTime, "dtfmt", smpdtfmt_Time_dtfmt, 1);
+  rb_define_singleton_method(rb_cTime, "icuparse", smpdtfmt_Time_icuparse, -1);
+}

data/ext/smpdtfmt.h

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

data/ext/smpdtfmt_icu.cpp

@@ -0,0 +1,99 @@
+#include <string>
+#include <iostream>
+#include "unicode/calendar.h"
+#include "unicode/smpdtfmt.h"
+
+#include "ruby.h"
+
+#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 *smpdtfmt_icu_new(const char *pattern, const char *codepage);
+  void smpdtfmt_icu_delete(void *p);
+  void smpdtfmt_icu_format(void *p, int year, int month, int date, int hour, int minute, int second, const char *codepage, char *dst);
+  void smpdtfmt_icu_parse(void *p, const char *text, const char *codepage, int *year, int *month, int *date, int *hour, int *minute, int *second);
+  void smpdtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage);
+  void smpdtfmt_icu_set_lenient(void *p, int lenient);
+}
+
+void *smpdtfmt_icu_new(const char *pattern, const char *codepage) {
+  UErrorCode status = U_ZERO_ERROR;
+  SimpleDateFormat *fmt;
+
+  if (pattern) {
+    fmt = new SimpleDateFormat(UnicodeString(pattern), status);
+  } else {
+    fmt = new SimpleDateFormat(status);
+  }
+
+  if (U_FAILURE(status)) {
+    delete fmt;
+    RAISE_ICU_ERRER(status);
+  }
+
+  return fmt;
+}
+
+void smpdtfmt_icu_delete(void *p) {
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  delete fmt;
+}
+
+void smpdtfmt_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(status);
+  Chack_ICU_ERROR(status);
+
+  cal->set(year, 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 smpdtfmt_icu_parse(void *p, const char *text, const char *codepage, int *year, int *month, int *date, int *hour, int *minute, int *second) {
+  UErrorCode status = U_ZERO_ERROR;
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  Calendar *cal = Calendar::createInstance(status);
+  Chack_ICU_ERROR(status);
+
+  UDate parsed = fmt->parse(UnicodeString(text, codepage), status);
+  Chack_ICU_ERROR(status);
+
+  cal->setTime(parsed, status);
+  Chack_ICU_ERROR(status);
+
+  *year = cal->get(UCAL_YEAR, status);
+  Chack_ICU_ERROR(status);
+  *month = cal->get(UCAL_MONTH, status) + 1;
+  Chack_ICU_ERROR(status);
+  *date = cal->get(UCAL_DATE, status);
+  Chack_ICU_ERROR(status);
+  *hour = cal->get(UCAL_HOUR_OF_DAY, status);
+  Chack_ICU_ERROR(status);
+  *minute = cal->get(UCAL_MINUTE, status);
+  Chack_ICU_ERROR(status);
+  *second = cal->get(UCAL_SECOND, status);
+  Chack_ICU_ERROR(status);
+
+  delete cal;
+}
+
+void smpdtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage) {
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  fmt->applyPattern(UnicodeString(pattern, codepage));
+}
+
+void smpdtfmt_icu_set_lenient(void *p, int lenient) {
+  SimpleDateFormat *fmt = static_cast<SimpleDateFormat *>(p);
+  fmt->setLenient(static_cast<UBool>(lenient));
+}

data/ext/smpdtfmt_icu.h

@@ -0,0 +1,11 @@
+#ifndef __JADTFMT_ICU_H__
+#define __JADTFMT_ICU_H__
+
+void *smpdtfmt_icu_new(const char *pattern, const char *codepage);
+void smpdtfmt_icu_delete(void *p);
+void smpdtfmt_icu_format(void *p, int year, int month, int date, int hour, int minute, int second, const char *codepage, char *dst);
+void smpdtfmt_icu_parse(void *p, const char *text, const char *codepage, int *year, int *month, int *date, int *hour, int *minute, int *second);
+void smpdtfmt_icu_apply_pattern(void *p, const char *pattern, const char *codepage);
+void smpdtfmt_icu_set_lenient(void *p, int lenient);
+
+#endif

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+name: smpdtfmt
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- winebarrel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-04-19 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: 
+email: sgwr_dts@yahoo.co.jp
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- ext/smpdtfmt.c
+files: 
+- ext/smpdtfmt.c
+- ext/smpdtfmt.h
+- ext/smpdtfmt_icu.cpp
+- ext/smpdtfmt_icu.h
+- ext/extconf.rb
+has_rdoc: true
+homepage: http://smpdtfmt.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: smpdtfmt
+rubygems_version: 1.1.1
+signing_key: 
+specification_version: 2
+summary: formatting a Time to the japanese time string using ICU.
+test_files: []
+