icu-calendar 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b86febf5c2e4f2d55a1b67b9e308b20b75e728f
+  data.tar.gz: ceca6826de5dfbe5a4485e6cd7c31872904e5f6a
+SHA512:
+  metadata.gz: 17221530b16d9f8da24c767b7d9a4b4d140c2edbcb4d9f2ffbb85b62f15e42dba1c26d668c84009e71a8f64dac4a5ea14f9f849bc790003a186d232212da8ca5
+  data.tar.gz: 29c51cbe355bb924f707c64d584896d399e3f6ed061c55ebfc4231f35a6e5ef56bae8fa15ebe82365e993f1961e924ca96c069a1c001fbb3e21d2dfd30aa3aef

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 Christopher Bandy
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,51 @@
+# ICU::Calendar
+
+[Ruby-FFI] bindings for the Calendar functionality of [ICU].
+
+[![Build Status](https://travis-ci.org/cbandy/icu-calendar.svg?branch=master)](https://travis-ci.org/cbandy/icu-calendar)
+
+
+## Requirements
+
+* [ICU4C] >= 4.2
+* [Ruby-FFI]
+* Ruby >= 1.9.3
+
+
+## Installation
+
+```sh
+gem install icu-calendar
+```
+
+### Ubuntu
+
+```sh
+sudo apt-get install ^libicu..$
+```
+
+## Usage
+
+```ruby
+require 'icu/calendar'
+
+# Calendar for the default locale at the current time in the current timezone
+ICU::Calendar.new
+
+ICU::Calendar.new(locale: 'de_DE')
+ICU::Calendar.new(time: Time.now - 300)
+ICU::Calendar.new(timezone: 'America/New_York')
+
+# Chinese calendar for the default locale
+ICU::Calendar.new(locale: '@calendar=chinese')
+
+calendar = ICU::Calendar.new
+calendar[:year] # 2014
+calendar.add(:month, 12)
+calendar[:year] # 2015
+```
+
+
+[ICU]: http://icu-project.org "International Components for Unicode"
+[ICU4C]: http://icu-project.org/download
+[Ruby-FFI]: https://github.com/ffi/ffi

data/lib/icu/calendar.rb

@@ -0,0 +1,401 @@
+require 'icu/calendar/library'
+
+module ICU
+  class Calendar
+    RuntimeError = Class.new(::RuntimeError)
+
+    include Comparable
+
+    class << self
+      def available_locales
+        (0...Library.ucal_countAvailable).map(&Library.method(:ucal_getAvailable))
+      end
+
+      def canonical_timezone_identifier(timezone)
+        FFI::MemoryPointer.new(:bool) do |is_system_id|
+          return Library.wchar_buffer_from_string(timezone) do |w_timezone|
+            Library.read_into_wchar_buffer(32) do |buffer, status|
+              Library.ucal_getCanonicalTimeZoneID(
+                w_timezone, -1,
+                buffer, buffer.size / buffer.type_size,
+                is_system_id, status
+              )
+            end
+          end
+        end
+      end
+
+      def country_timezones(country)
+        Library.read_wchar_enumeration(->(status) do
+          Library.ucal_openCountryTimeZones(country, status)
+        end).to_a
+      end
+
+      def default_timezone
+        Library.read_into_wchar_buffer(32) do |buffer, status|
+          Library.ucal_getDefaultTimeZone(buffer, buffer.size / buffer.type_size, status)
+        end
+      end
+
+      def default_timezone=(timezone)
+        Library.wchar_buffer_from_string(timezone) do |w_timezone|
+          Library.assert_success do |status|
+            Library.ucal_setDefaultTimeZone(w_timezone, status)
+          end
+        end
+      end
+
+      def dst_savings(timezone)
+        Library.wchar_buffer_from_string(timezone) do |w_timezone|
+          Library.assert_success do |status|
+            Library.ucal_getDSTSavings(w_timezone, status)
+          end
+        end
+      end
+
+      def timezone_data_version
+        Library.assert_success do |status|
+          Library.ucal_getTZDataVersion(status)
+        end
+      end
+
+      def timezone_identifiers(type, region = nil, offset = nil)
+        offset = FFI::MemoryPointer.new(:int32).write_int32(offset) unless offset.nil?
+
+        Library.read_wchar_enumeration(->(status) do
+          Library.ucal_openTimeZoneIDEnumeration(type, region, offset, status)
+        end).to_a
+      ensure
+        offset.free unless offset.nil?
+      end
+
+      def timezones
+        Library.read_wchar_enumeration(->(status) do
+          Library.ucal_openTimeZones(status)
+        end).to_a
+      end
+    end
+
+    def [](field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_get(@calendar, field, status)
+      end)
+    end
+
+    def []=(field, value)
+      if value.nil?
+        Library.ucal_clearField(@calendar, field)
+      else
+        Library.ucal_set(@calendar, field, value)
+      end
+    end
+
+    def <=>(other)
+      time <=> coerce_to_milliseconds(other)
+    end
+
+    def actual_maximum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :actual_maximum, status)
+      end)
+    end
+
+    def actual_minimum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :actual_minimum, status)
+      end)
+    end
+
+    def add(field, amount)
+      Library.assert_success do |status|
+        Library.ucal_add(@calendar, field, amount, status)
+      end
+
+      self
+    end
+
+    def clear
+      Library.ucal_clear(@calendar)
+    end
+
+    def daylight_time?
+      Library.assert_success do |status|
+        Library.ucal_inDaylightTime(@calendar, status)
+      end
+    end
+
+    def difference(from, field)
+      from = coerce_to_milliseconds(from)
+      Library.assert_success do |status|
+        Library.ucal_getFieldDifference(@calendar, from, field, status)
+      end
+    end
+
+    def eql?(other)
+      equivalent?(other) && time == other.time
+    end
+
+    def equivalent?(other)
+      Calendar === other && Library.ucal_equivalentTo(@calendar, other.calendar)
+    end
+
+    def first_day_of_week
+      Library.enum_type(:day_of_week)[Library.ucal_getAttribute(@calendar, :first_day_of_week)]
+    end
+
+    def first_day_of_week=(day_of_week)
+      day_of_week = Library.enum_type(:day_of_week)[day_of_week] if Symbol === day_of_week
+      Library.ucal_setAttribute(@calendar, :first_day_of_week, day_of_week)
+    end
+
+    def greatest_minimum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :greatest_minimum, status)
+      end)
+    end
+
+    def gregorian_change
+      Library.assert_success do |status|
+        Library.ucal_getGregorianChange(@calendar, status)
+      end
+    end
+
+    def gregorian_change=(time)
+      time = coerce_to_milliseconds(time)
+
+      Library.assert_success do |status|
+        Library.ucal_setGregorianChange(@calendar, time, status)
+      end
+    end
+
+    def initialize(options = {})
+      calendar = wchar_buffer_from_string_or_nil(options[:timezone]) do |timezone|
+        Library.assert_success do |status|
+          Library.ucal_open(timezone, -1, options[:locale], :default, status)
+        end
+      end
+
+      @calendar = automatically_close(calendar)
+      self.time = options[:time] if options[:time]
+    end
+
+    def is_set?(field)
+      Library.ucal_isSet(@calendar, field)
+    end
+
+    def least_maximum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :least_maximum, status)
+      end)
+    end
+
+    def lenient?
+      Library.ucal_getAttribute(@calendar, :lenient).nonzero?
+    end
+
+    def lenient=(value)
+      Library.ucal_setAttribute(@calendar, :lenient, value ? 1 : 0)
+    end
+
+    def locale(type = :valid)
+      Library.assert_success do |status|
+        Library.ucal_getLocaleByType(@calendar, type, status)
+      end
+    end
+
+    def maximum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :maximum, status)
+      end)
+    end
+
+    def minimal_days_in_first_week
+      Library.ucal_getAttribute(@calendar, :minimal_days_in_first_week)
+    end
+
+    def minimal_days_in_first_week=(value)
+      Library.ucal_setAttribute(@calendar, :minimal_days_in_first_week, value)
+    end
+
+    def minimum(field)
+      field_value_to_symbol(field, Library.assert_success do |status|
+        Library.ucal_getLimit(@calendar, field, :minimum, status)
+      end)
+    end
+
+    def next_timezone_transition(inclusive = false)
+      timezone_transition(inclusive ? :next_inclusive : :next)
+    end
+
+    def previous_timezone_transition(inclusive = false)
+      timezone_transition(inclusive ? :previous_inclusive : :previous)
+    end
+
+    def repeated_wall_time
+      Library.enum_type(:walltime_option)[Library.ucal_getAttribute(@calendar, :repeated_wall_time)]
+    end
+
+    def repeated_wall_time=(option)
+      option = Library.enum_type(:walltime_option)[option] if Symbol === option
+      Library.ucal_setAttribute(@calendar, :repeated_wall_time, option)
+    end
+
+    def roll(field, amount)
+      Library.assert_success do |status|
+        Library.ucal_roll(@calendar, field, amount, status)
+      end
+
+      self
+    end
+
+    def set_date(year, month, day)
+      Library.assert_success do |status|
+        Library.ucal_setDate(@calendar, year, month, day, status)
+      end
+    end
+
+    def set_date_and_time(year, month, day, hour, minute, second)
+      Library.assert_success do |status|
+        Library.ucal_setDateTime(@calendar, year, month, day, hour, minute, second, status)
+      end
+    end
+
+    def skipped_wall_time
+      Library.enum_type(:walltime_option)[Library.ucal_getAttribute(@calendar, :skipped_wall_time)]
+    end
+
+    def skipped_wall_time=(option)
+      option = Library.enum_type(:walltime_option)[option] if Symbol === option
+      Library.ucal_setAttribute(@calendar, :skipped_wall_time, option)
+    end
+
+    def time
+      Library.assert_success do |status|
+        Library.ucal_getMillis(@calendar, status)
+      end
+    end
+
+    def time=(time)
+      time = coerce_to_milliseconds(time)
+
+      Library.assert_success do |status|
+        Library.ucal_setMillis(@calendar, time, status)
+      end
+    end
+
+    def timezone
+      Library.read_into_wchar_buffer(32) do |buffer, status|
+        Library.ucal_getTimeZoneID(@calendar, buffer, buffer.size / buffer.type_size, status)
+      end
+    end
+
+    def timezone=(timezone)
+      wchar_buffer_from_string_or_nil(timezone) do |w_timezone|
+        Library.assert_success do |status|
+          Library.ucal_setTimeZone(@calendar, w_timezone, -1, status)
+        end
+      end
+    end
+
+    def timezone_display_name(type = :standard, locale = nil)
+      Library.read_into_wchar_buffer(32) do |buffer, status|
+        Library.ucal_getTimeZoneDisplayName(@calendar, type, locale, buffer, buffer.size / buffer.type_size, status)
+      end
+    end
+
+    def to_time
+      Time.new(
+        self[:year],
+        self[Library.enum_type(:date_field)[:month]] + 1,
+        self[:day_of_month],
+        self[:hour_of_day],
+        self[:minute],
+        self[:second] + Rational(self[:millisecond], 1000),
+        (self[:zone_offset] + self[:dst_offset]) / 1000
+      )
+    end
+
+    def type
+      Library.assert_success do |status|
+        Library.ucal_getType(@calendar, status)
+      end.to_sym
+    end
+
+    def weekday_type(day_of_week)
+      Library.assert_success do |status|
+        Library.ucal_getDayOfWeekType(@calendar, day_of_week, status)
+      end
+    end
+
+    def weekend?
+      Library.assert_success do |status|
+        Library.ucal_isWeekend(@calendar, time, status)
+      end
+    end
+
+    def weekend_transition(day_of_week)
+      Library.assert_success do |status|
+        Library.ucal_getWeekendTransition(@calendar, day_of_week, status)
+      end
+    end
+
+    protected
+
+    attr_reader :calendar
+
+    private
+
+    def automatically_close(calendar_pointer)
+      FFI::AutoPointer.new(calendar_pointer, Library.method(:ucal_close))
+    end
+
+    def coerce_to_milliseconds(value)
+      if Calendar === value
+        value.time
+      else
+        value = value.to_time if value.respond_to? :to_time
+        value = value.getutc.to_f * 1000 if value.is_a? Time
+        value
+      end
+    end
+
+    def field_value_to_symbol(field, value)
+      case field
+      when :am_pm, :day_of_week, :month
+        Library.enum_type(field)[value]
+      else
+        value
+      end
+    end
+
+    def initialize_copy(other)
+      super
+
+      @calendar = automatically_close(
+        Library.assert_success do |status|
+          Library.ucal_clone(@calendar, status)
+        end
+      )
+    end
+
+    def timezone_transition(type)
+      FFI::MemoryPointer.new(:double) do |time|
+        valid = Library.assert_success do |status|
+          Library.ucal_getTimeZoneTransitionDate(@calendar, type, time, status)
+        end
+
+        return valid ? time.read_double : nil
+      end
+    end
+
+    def wchar_buffer_from_string_or_nil(string)
+      if string.nil?
+        yield string
+      else
+        Library.wchar_buffer_from_string(string) do |buffer|
+          yield buffer
+        end
+      end
+    end
+  end
+end

data/lib/icu/calendar/library.rb

@@ -0,0 +1,198 @@
+require 'ffi'
+
+module ICU
+  class Calendar
+    module Library
+      extend FFI::Library
+
+      %w( icutu ).tap do |libraries|
+        begin
+          ffi_lib(*libraries)
+        rescue LoadError
+          ffi_lib(*libraries.map do |lib|
+            if 'dll' == FFI::Platform::LIBSUFFIX
+              [42, 44, 46, *(48..100)].map { |i| "#{lib}#{i}.#{FFI::Platform::LIBSUFFIX}" }
+            else
+              [42, 44, 46, *(48..100)].map { |i| "#{lib}.#{FFI::Platform::LIBSUFFIX}.#{i}" }
+            end
+          end)
+        end.each do |library|
+          @suffix ||= ['', '_4_2', '_44', '_46', *(48..100).map { |i| "_#{i}" }].find do |suffix|
+            function_names("u_errorName#{suffix}", nil).any? { |name| library.find_function(name) }
+          end
+        end
+      end
+
+      require_relative 'library/constants'
+      require_relative 'library/error_code'
+      require_relative 'library/version_info'
+
+      U_BUFFER_OVERFLOW_ERROR = 15
+      U_MAX_VERSION_LENGTH = 4
+      U_MAX_VERSION_STRING_LENGTH = 20
+      U_ZERO_ERROR = 0
+
+      class << self
+        def assert_success
+          ErrorCode.new do |status|
+            result = yield status
+            raise RuntimeError, status.to_s unless status.success?
+            return result
+          end
+        end
+
+        def read_into_wchar_buffer(length)
+          ErrorCode.new do |status|
+            for _ in 1..2
+              FFI::Buffer.new(:uint16, length, false) do |buffer|
+                length = yield buffer, status
+                return buffer.read_array_of_uint16(length).pack('U*') if status.success?
+                raise RuntimeError, status.to_s unless status.buffer_overflow?
+                status.clear
+              end
+            end
+            raise RuntimeError, "#{status}: Needed #{length}"
+          end
+        end
+
+        def read_wchar_enumeration(open)
+          return enum_for(:read_wchar_enumeration, open) unless block_given?
+
+          Library::ErrorCode.new do |status|
+            enumeration = open.call(status)
+            raise RuntimeError, status.to_s unless status.success?
+
+            begin
+              FFI::MemoryPointer.new(:int32) do |length|
+                loop do
+                  pointer = Library.uenum_unext(enumeration, length, status)
+                  raise RuntimeError, status.to_s unless status.success?
+                  break if pointer.null?
+                  yield pointer.read_array_of_uint16(length.read_int32).pack('U*')
+                end
+              end
+            ensure
+              Library.uenum_close(enumeration)
+            end
+          end
+        end
+
+        def version
+          @version ||= VersionInfo.new.tap { |version| u_getVersion(version) }
+        end
+
+        def wchar_buffer_from_string(string, &block)
+          codepoints = string.encode('UTF-8').unpack('U*') << 0
+          FFI::Buffer.new(:uint16, codepoints.length, false) do |buffer|
+            buffer.write_array_of_uint16(codepoints)
+            return yield buffer
+          end
+        end
+
+        private
+
+        def attach_icu_function(name, type, *args)
+          attach_function name, "#{name}#{@suffix}", *args, type
+        end
+
+        def icu_version_at_least(version)
+          Gem::Version.new(version) <= Gem::Version.new(self.version)
+        end
+      end
+
+      enum :am_pm,                    am_pm_enum
+      enum :attribute,                attribute_enum
+      enum :calendar_type,            calendar_type_enum
+      enum :date_field,               date_field_enum
+      enum :day_of_week,              day_of_week_enum
+      enum :display_name_type,        display_name_type_enum
+      enum :limit_type,               limit_type_enum
+      enum :locale_type,              locale_type_enum
+      enum :month,                    month_enum
+      enum :system_timezone_type,     system_timezone_type_enum
+      enum :timezone_transition_type, timezone_transition_type_enum
+      enum :walltime_option,          walltime_option_enum
+      enum :weekday_type,             weekday_type_enum
+
+      typedef :pointer,    :calendar
+      typedef :double,     :date
+      typedef :pointer,    :enumeration
+      typedef ErrorCode,   :status
+      typedef VersionInfo, :version
+
+      attach_icu_function :u_errorName, :string, [:int]
+
+      attach_icu_function :u_getVersion,      :void, [:version]
+      attach_icu_function :u_versionToString, :void, [:version, :buffer_out]
+
+      # Enumeration
+      attach_icu_function :uenum_close, :void,    [:enumeration]
+      attach_icu_function :uenum_next,  :string,  [:enumeration, :buffer_out, :status]
+      attach_icu_function :uenum_unext, :pointer, [:enumeration, :buffer_out, :status]
+
+      # Locales
+      attach_icu_function :ucal_countAvailable, :int32,  []
+      attach_icu_function :ucal_getAvailable,   :string, [:int32]
+      attach_icu_function :uloc_getDefault,     :string, []
+
+      # Time Zones
+      attach_icu_function :ucal_getCanonicalTimeZoneID, :int32,  [:buffer_in, :int32, :buffer_out, :int32, :buffer_out, :status]
+      attach_icu_function :ucal_getDefaultTimeZone,     :int32,  [:buffer_out, :int32, :status]
+      attach_icu_function :ucal_getDSTSavings,          :int32,  [:buffer_in, :status]
+      attach_icu_function :ucal_getTZDataVersion,       :string, [:status]
+      attach_icu_function :ucal_setDefaultTimeZone,     :void,   [:buffer_in, :status]
+
+      attach_icu_function :ucal_openTimeZones,          :enumeration, [:status]
+      attach_icu_function :ucal_openCountryTimeZones,   :enumeration, [:string, :status]
+
+      # Calendar
+      attach_icu_function :ucal_clone,        :calendar, [:calendar, :status]
+      attach_icu_function :ucal_close,        :void,     [:calendar]
+      attach_icu_function :ucal_equivalentTo, :bool,     [:calendar, :calendar]
+      attach_icu_function :ucal_open,         :calendar, [:buffer_in, :int32, :string, :calendar_type, :status]
+
+      attach_icu_function :ucal_getAttribute,           :int32,  [:calendar, :attribute]
+      attach_icu_function :ucal_getGregorianChange,     :date,   [:calendar, :status]
+      attach_icu_function :ucal_getLocaleByType,        :string, [:calendar, :locale_type, :status]
+      attach_icu_function :ucal_getMillis,              :date,   [:calendar, :status]
+      attach_icu_function :ucal_getTimeZoneDisplayName, :int32,  [:calendar, :display_name_type, :string, :buffer_out, :int32, :status]
+      attach_icu_function :ucal_getType,                :string, [:calendar, :status]
+      attach_icu_function :ucal_inDaylightTime,         :bool,   [:calendar, :status]
+      attach_icu_function :ucal_setAttribute,           :void,   [:calendar, :attribute, :int32]
+      attach_icu_function :ucal_setDate,                :void,   [:calendar, :int32, :month, :int32, :status]
+      attach_icu_function :ucal_setDateTime,            :void,   [:calendar, :int32, :month, :int32, :int32, :int32, :int32, :status]
+      attach_icu_function :ucal_setGregorianChange,     :void,   [:calendar, :date, :status]
+      attach_icu_function :ucal_setMillis,              :void,   [:calendar, :date, :status]
+      attach_icu_function :ucal_setTimeZone,            :void,   [:calendar, :buffer_in, :int32, :status]
+
+      # Calendar Fields
+      attach_icu_function :ucal_add,        :void,  [:calendar, :date_field, :int32, :status]
+      attach_icu_function :ucal_clear,      :void,  [:calendar]
+      attach_icu_function :ucal_clearField, :void,  [:calendar, :date_field]
+      attach_icu_function :ucal_get,        :int32, [:calendar, :date_field, :status]
+      attach_icu_function :ucal_getLimit,   :int32, [:calendar, :date_field, :limit_type, :status]
+      attach_icu_function :ucal_isSet,      :bool,  [:calendar, :date_field]
+      attach_icu_function :ucal_roll,       :void,  [:calendar, :date_field, :int32, :status]
+      attach_icu_function :ucal_set,        :void,  [:calendar, :date_field, :int32]
+
+      if icu_version_at_least('4.4')
+        attach_icu_function :ucal_getDayOfWeekType,     :weekday_type, [:calendar, :day_of_week, :status]
+        attach_icu_function :ucal_getWeekendTransition, :int32,        [:calendar, :day_of_week, :status]
+        attach_icu_function :ucal_isWeekend,            :bool,         [:calendar, :date, :status]
+      end
+
+      if icu_version_at_least('4.8')
+        attach_icu_function :ucal_getFieldDifference,        :int32,       [:calendar, :date, :date_field, :status]
+        attach_icu_function :ucal_openTimeZoneIDEnumeration, :enumeration, [:system_timezone_type, :string, :buffer_in, :status]
+      end
+
+      if icu_version_at_least('50')
+        attach_icu_function :ucal_getTimeZoneTransitionDate, :bool, [:calendar, :timezone_transition_type, :buffer_out, :status]
+      end
+
+      if icu_version_at_least('51')
+        attach_icu_function :ucal_getTimeZoneID, :int32, [:calendar, :buffer_out, :int32, :status]
+      end
+    end
+  end
+end

data/lib/icu/calendar/library/constants.rb

@@ -0,0 +1,71 @@
+class ICU::Calendar
+  module Library
+
+    class << self
+      private
+
+      def am_pm_enum
+        [:am, :pm]
+      end
+
+      def attribute_enum
+        [
+          :lenient, :first_day_of_week, :minimal_days_in_first_week,
+          # ICU >= 49
+          :repeated_wall_time, :skipped_wall_time,
+        ]
+      end
+
+      def calendar_type_enum
+        [:default, :gregorian]
+      end
+
+      def date_field_enum
+        [
+          :era, :year, :month, :week_of_year, :week_of_month,
+          :date, :day_of_year, :day_of_month, 5, :day_of_week, 7, :day_of_week_in_month,
+          :am_pm, :hour, :hour_of_day, :minute, :second, :millisecond, :zone_offset, :dst_offset,
+          :year_woy, :dow_local, :extended_year, :julian_day, :milliseconds_in_day, :is_leap_month,
+          :field_count
+        ]
+      end
+
+      def day_of_week_enum
+        [:sunday, 1, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday]
+      end
+
+      def display_name_type_enum
+        [:standard, :short_standard, :dst, :short_dst]
+      end
+
+      def limit_type_enum
+        [:minimum, :maximum, :greatest_minimum, :least_maximum, :actual_minimum, :actual_maximum]
+      end
+
+      def locale_type_enum
+        [:actual, :valid]
+      end
+
+      def month_enum
+        [:january, :february, :march, :april, :may, :june, :july, :august, :september, :october, :november, :december, :undecimber]
+      end
+
+      def system_timezone_type_enum
+        [:any, :canonical, :canonical_location]
+      end
+
+      def timezone_transition_type_enum
+        [:next, :next_inclusive, :previous, :previous_inclusive]
+      end
+
+      def walltime_option_enum
+        [:last, :first, :next_valid]
+      end
+
+      def weekday_type_enum
+        [:weekday, :weekend, :weekend_onset, :weekend_cease]
+      end
+    end
+
+  end
+end

data/lib/icu/calendar/library/error_code.rb

@@ -0,0 +1,33 @@
+class ICU::Calendar
+  module Library
+    class ErrorCode < FFI::MemoryPointer
+      extend FFI::DataConverter
+
+      def self.native_type
+        FFI::Type::POINTER
+      end
+
+      def initialize
+        super(:int)
+      end
+
+      def buffer_overflow?
+        to_i == U_BUFFER_OVERFLOW_ERROR
+      end
+
+      def failure?
+        to_i > U_ZERO_ERROR
+      end
+
+      def success?
+        to_i <= U_ZERO_ERROR
+      end
+
+      alias_method :to_i, :read_int
+
+      def to_s
+        Library.u_errorName(to_i)
+      end
+    end
+  end
+end

data/lib/icu/calendar/library/version_info.rb

@@ -0,0 +1,26 @@
+class ICU::Calendar
+  module Library
+    class VersionInfo < FFI::MemoryPointer
+      extend FFI::DataConverter
+
+      def self.native_type
+        FFI::Type::POINTER
+      end
+
+      def initialize
+        super(:uint8, U_MAX_VERSION_LENGTH)
+      end
+
+      def to_a
+        read_array_of_uint8(U_MAX_VERSION_LENGTH)
+      end
+
+      def to_s
+        FFI::MemoryPointer.new(:char, U_MAX_VERSION_STRING_LENGTH) do |buffer|
+          Library.u_versionToString(self, buffer)
+          return buffer.read_string_to_null
+        end
+      end
+    end
+  end
+end

data/lib/icu/calendar/version.rb

@@ -0,0 +1,5 @@
+module ICU
+  class Calendar
+    VERSION = '1.0.0'
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: icu-calendar
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Chris Bandy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: bandy.chris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/icu/calendar.rb
+- lib/icu/calendar/library.rb
+- lib/icu/calendar/version.rb
+- lib/icu/calendar/library/constants.rb
+- lib/icu/calendar/library/version_info.rb
+- lib/icu/calendar/library/error_code.rb
+homepage: https://github.com/cbandy/icu-calendar
+licenses:
+- Apache License Version 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- ICU 4.2 or greater, http://www.icu-project.org/
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Date arithmetic and calendar data from ICU
+test_files: []