corefoundation 0.1.4

data/lib/corefoundation/date.rb

@@ -0,0 +1,32 @@
+module CF
+  typedef :pointer, :cfdateref
+  typedef :double, :cfabsolutetime
+
+  attach_function :CFDateCreate, [:pointer, :cfabsolutetime], :cfdateref
+  attach_function :CFDateGetAbsoluteTime, [:cfdateref], :cfabsolutetime
+  attach_variable :kCFAbsoluteTimeIntervalSince1970, :double
+
+  # Wrapper for CFDateRef
+  #
+  #
+  class Date < Base
+    register_type 'CFDate'
+
+    # constructs a CF::Date from a ruby time
+    #
+    # @param [Time] time
+    # @return [CF::Date] a CF::Date instance that will be released on garbage collection
+    def self.from_time(time)
+      new(CF.CFDateCreate(nil, time.to_f - CF.kCFAbsoluteTimeIntervalSince1970)).release_on_gc
+    end
+
+    # returns a ruby Time instance corresponding to the same point in time
+    #
+    # @return [Time]
+    def to_time
+      Time.at(CF.CFDateGetAbsoluteTime(self) + CF.kCFAbsoluteTimeIntervalSince1970)
+    end
+
+    alias_method :to_ruby, :to_time
+  end
+end

data/lib/corefoundation/dictionary.rb

@@ -0,0 +1,114 @@
+module CF
+  # @private
+  class DictionaryKeyCallbacks < FFI::Struct
+    layout :version, :cfindex,
+           :retain, :pointer,
+           :release, :pointer,
+           :copyDescription, :pointer,
+           :equal, :pointer,
+           :hash, :pointer
+  end
+  # @private
+  class DictionaryValueCallbacks < FFI::Struct
+    layout :version, :cfindex,
+           :retain, :pointer,
+           :release, :pointer,
+           :copyDescription, :pointer,
+           :equal, :pointer
+  end
+
+  typedef :pointer, :cfdictionaryref
+  attach_variable :kCFTypeDictionaryKeyCallBacks,  DictionaryKeyCallbacks
+  attach_variable :kCFTypeDictionaryValueCallBacks,  DictionaryValueCallbacks
+  attach_function :CFDictionaryCreateMutable, [:pointer, :cfindex, :pointer, :pointer], :cfdictionaryref
+
+  attach_function :CFDictionarySetValue, [:cfdictionaryref, :pointer, :pointer], :void
+  attach_function :CFDictionaryGetValue, [:cfdictionaryref, :pointer], :pointer
+
+  attach_function :CFDictionaryGetValue, [:cfdictionaryref, :pointer], :pointer
+  attach_function :CFDictionaryGetCount, [:cfdictionaryref], :cfindex
+
+  callback :each_applier, [:pointer, :pointer, :pointer], :void
+
+  attach_function :CFDictionaryApplyFunction, [:cfdictionaryref, :each_applier, :pointer], :void
+
+  # Wrapper class for CFDictionary. It implements Enumerable.
+  #
+  # Values returned by the accessor methods or yielded by the block are retained and marked as releasable on garbage collection
+  # This means you can safely use the returned values even if the CFDictionary itself has been destroyed
+  #
+  class Dictionary < Base
+    register_type("CFDictionary")
+    include Enumerable
+
+    # Return a new, empty mutable CF::Dictionary
+    #
+    #
+    # @return [CF::Dictionary]
+    def self.mutable
+      new(CF.CFDictionaryCreateMutable nil, 0, CF.kCFTypeDictionaryKeyCallBacks.to_ptr, CF.kCFTypeDictionaryValueCallBacks.to_ptr).release_on_gc
+    end
+
+    # Iterates over the array yielding the value to the block
+    # The value is wrapped in the appropriate CF::Base subclass and retained (but marked for releasing upon garbage collection)
+    # @return self
+
+    def each
+      callback = lambda do |key, value, _|
+        yield [Base.typecast(key).retain.release_on_gc, Base.typecast(value).retain.release_on_gc]
+      end
+      CF.CFDictionaryApplyFunction(self, callback, nil)
+      self
+    end
+
+    # Returns the value associated with the key, or nil
+    # The key should be a CF::Base instance. As a convenience, instances of string will be converted to CF::String
+    # @param [CF::Base, String] key the key to access
+    # @return [CF::Base, nil]
+
+    def [](key)
+      key = CF::String.from_string(key) if key.is_a?(::String)
+      self.class.check_cftype(key)
+      raw = CF.CFDictionaryGetValue(self, key)
+      raw.null? ? nil : self.class.typecast(raw).retain.release_on_gc
+    end
+
+    # Sets the value associated with the key, or nil
+    # The key should be a CF::Base instance. As a convenience, instances of string will be converted to CF::String
+    # @param [CF::Base, String] key the key to access
+    # @param [CF::Base] value the value to set
+    # @return [CF::Base] the value that was set
+    def []=(key, value)
+      key = CF::String.from_string(key) if key.is_a?(::String)
+      self.class.check_cftype(key)
+      self.class.check_cftype(value)
+      CF.CFDictionarySetValue(self, key, value)
+      value
+    end
+
+    # Adds the key value pairs from the argument to self
+    #
+    # @param [CF::Dictionary] other
+    # @return self
+    def merge!(other)
+      other.each do |k,v|
+        self[k] = v
+      end
+      self
+    end
+
+    # Returns the number of key value pairs in the dictionary
+    # @return [Integer]
+    def length
+      CF.CFDictionaryGetCount(self)
+    end
+
+    # Returns a ruby hash constructed by calling `to_ruby` on each key and value
+    #
+    # @return [Hash]
+    def to_ruby
+      Hash[collect {|k,v| [k.to_ruby, v.to_ruby]}]
+    end
+    alias_method :size, :length
+  end
+end

data/lib/corefoundation/extensions.rb

@@ -0,0 +1,81 @@
+# Rubyinteger
+class Integer
+  # Converts the Integer to a {CF::Number} using {CF::Number.from_i}
+  # @return [CF::Number]
+  def to_cf
+    CF::Number.from_i(self)
+  end
+end
+
+# Ruby float class
+class Float
+  # Converts the Float to a {CF::Number} using {CF::Number.from_f}
+  # @return [CF::Number]
+  def to_cf
+    CF::Number.from_f(self)
+  end
+end
+
+# Ruby array class
+class Array
+  # Converts the Array to an immutable {CF::Array} by calling `to_cf` on each element it contains
+  # @return [CF::Number]
+  def to_cf
+    CF::Array.immutable(collect(&:to_cf))
+  end
+end
+
+# Ruby true class
+class TrueClass
+  # Returns a CF::Boolean object representing true
+  # @return [CF::Boolean]
+  def to_cf
+    CF::Boolean::TRUE
+  end
+end
+
+# Ruby false class
+class FalseClass
+  # Returns a CF::Boolean object representing false
+  # @return [CF::Boolean]
+  def to_cf
+    CF::Boolean::FALSE
+  end
+end
+
+# Ruby String class
+class String
+  # Returns a {CF::String} or {CF::Data} representing the string.
+  # If the string has the encoding ASCII_8BIt a {CF::Data} is returned, if not a {CF::String} is returned
+  # 
+  # @return [CF::String, CF::Data]
+  def to_cf
+    if encoding == Encoding::ASCII_8BIT
+      CF::Data.from_string self
+    else
+      CF::String.from_string self
+    end
+  end
+end
+
+# Ruby Time class
+class Time
+  # Returns a {CF::Date} representing the time.
+  # @return [CF::Date]
+  def to_cf
+    CF::Date.from_time(self)
+  end
+end
+
+# Ruby Hash class
+class Hash
+  # Converts the Hash to an mutable {CF::Dictionary} by calling `to_cf` on each key and value it contains
+  # @return [CF::Dictionary]
+  def to_cf
+    CF::Dictionary.mutable.tap do |r|
+      each do |k,v|
+        r[k.to_cf] = v.to_cf
+      end
+    end
+  end
+end

data/lib/corefoundation/null.rb

@@ -0,0 +1,11 @@
+module CF
+  attach_variable 'kCFNull', :pointer
+
+  # Wrapper class for the cf null class
+  class Null < Base
+    register_type 'CFNull'
+  end
+
+  #The singleton CFNull instance
+  NULL = Null.new(CF.kCFNull)
+end

data/lib/corefoundation/number.rb

@@ -0,0 +1,98 @@
+module CF
+  typedef :pointer, :cfnumberref
+  enum :cf_number_type, [
+    :kCFNumberSInt8Type,1,
+    :kCFNumberSInt16Type,2,
+    :kCFNumberSInt32Type,3,
+    :kCFNumberSInt64Type,4,
+    :kCFNumberFloat32Type,5,
+    :kCFNumberFloat64Type,6,
+    :kCFNumberCharType,7,
+    :kCFNumberShortType,8,
+    :kCFNumberIntType,9,
+    :kCFNumberLongType,10,
+    :kCFNumberLongLongType,11,
+    :kCFNumberFloatType,12,
+    :kCFNumberDoubleType,13,
+    :kCFNumberCFIndexType,14,
+    :kCFNumberNSIntegerType,15,
+    :kCFNumberCGFloatType,16,
+    :kCFNumberMaxType,16
+  ]
+
+  attach_function 'CFNumberGetValue', [:cfnumberref, :cf_number_type, :pointer], :uchar
+  attach_function 'CFNumberCreate', [:pointer, :cf_number_type, :pointer], :cfnumberref
+  attach_function 'CFNumberIsFloatType', [:pointer], :uchar
+  attach_function 'CFNumberCompare', [:cfnumberref, :cfnumberref, :pointer], :cfcomparisonresult
+
+  # Wrapper for CFNumberRef
+  #
+  #
+  class Number < Base
+    register_type 'CFNumber'
+    include Comparable
+
+
+    # Constructs a CF::Number from a float
+    # @param [Float] float
+    # @return [CF::Number]
+    def self.from_f(float)
+      p = FFI::MemoryPointer.new(:double)
+      p.write_double(float.to_f)
+      new(CF.CFNumberCreate(nil, :kCFNumberDoubleType, p)).release_on_gc
+    end
+
+    # Constructs a CF::Number from an integer
+    # @param [Integer] int
+    # @return [CF::Number]
+    def self.from_i(int)
+      p = FFI::MemoryPointer.new(:int64)
+      p.put_int64(0,int.to_i)
+      new(CF.CFNumberCreate(nil, :kCFNumberSInt64Type, p)).release_on_gc
+    end
+
+    # Compares the receiver with the argument
+    # @param [CF::Number] other
+    # @return [Integer]
+    def <=>(other)
+      raise TypeError, "argument should be CF::Number" unless other.is_a?(CF::Number)
+      CF.CFNumberCompare(self,other,nil)
+    end
+
+
+    # Converts the CF::Number to either an Integer or a Float, depending on the result of CFNumberIsFloatType
+    #
+    # @return [Integer, Float]
+    def to_ruby
+      if CF.CFNumberIsFloatType(self) == 0
+        to_i
+      else
+        to_f
+      end
+    end
+
+    # Converts the CF::Number to an integer
+    # May raise if the conversion cannot be done without loss of precision
+    # @return [Integer]
+    def to_i
+      p = FFI::MemoryPointer.new(:int64)
+      if CF.CFNumberGetValue(self, :kCFNumberSInt64Type, p) != 0
+        p.get_int64 0
+      else
+        raise "CF.CFNumberGetValue failed to convert #{self.inspect} to kCFNumberSInt64Type"
+      end
+    end
+
+    # Converts the CF::Number to a float
+    # May raise if the conversion cannot be done without loss of precision
+    # @return [Float]
+    def to_f
+      p = FFI::MemoryPointer.new(:double)
+      if CF.CFNumberGetValue(self, :kCFNumberDoubleType, p) != 0
+        p.read_double
+      else
+        raise "CF.CFNumberGetValue failed to convert #{self.inspect} to kCFNumberDoubleType"
+      end
+    end
+  end
+end

data/lib/corefoundation/string.rb

@@ -0,0 +1,77 @@
+module CF
+  typedef :pointer, :cfstringref
+
+  attach_function 'CFStringCreateWithBytes', [:pointer, :buffer_in, :cfindex, :uint, :char], :cfstringref  
+  attach_function 'CFStringGetBytes', [:cfstringref, :uint], :pointer
+  attach_function 'CFStringGetMaximumSizeForEncoding', [:cfindex, :uint], :cfindex
+  attach_function 'CFStringGetLength', [:cfstringref], :cfindex
+
+  attach_function 'CFStringGetBytes', [:cfstringref, CF::Range.by_value, :uint, :uchar, :char, :buffer_out, :cfindex, :buffer_out], :cfindex
+
+  attach_function 'CFStringCompare', [:cfstringref, :cfstringref, :cfoptionflags], :cfcomparisonresult
+
+  # Wrapper class for CFString
+  #
+  # Unlike ruby, CFString is not an arbitrary bag of bytes - the data will be converted to a collection of unicode characters
+  class String < Base
+    include Comparable
+    register_type("CFString")
+
+    # The cfstring encoding for UTF8
+    UTF8 = 0x08000100 #From cfstring.h
+
+
+    # Creates a string from a ruby string
+    # The string must be convertable to UTF-8
+    #
+    # @param [String] s 
+    # @return [CF::String]
+    def self.from_string(s)
+      s_utf = s.encode('UTF-8')
+      raw = CF.CFStringCreateWithBytes(nil, s_utf, s_utf.bytesize, UTF8, 0)
+      raw.null? ? nil : new(raw).release_on_gc
+    end
+
+    # Returns the length, in unicode characters of the string
+    # @return [Integer]
+    def length
+      CF.CFStringGetLength(self)
+    end
+
+    # Compares the receiver with the argument
+    # @param [CF::String] other
+    # @return [Integer]
+    def <=>(other)
+      Base.check_cftype(other)
+      CF.CFStringCompare(self,other,0)
+    end
+
+    # Converts the CF::String to a UTF-8 ruby string 
+    #
+    # @return [String]
+    def to_s
+      max_size = CF.CFStringGetMaximumSizeForEncoding(length, UTF8)
+      range = CF::Range.new
+      range[:location] = 0
+      range[:length] = length
+      buffer = FFI::MemoryPointer.new(:char, max_size)
+
+      cfindex = CF.find_type(:cfindex)
+      bytes_used_buffer = FFI::MemoryPointer.new(cfindex)
+
+      CF.CFStringGetBytes(self, range, UTF8, 0, 0, buffer, max_size, bytes_used_buffer)
+
+      bytes_used = if cfindex == CF.find_type(:long_long)
+        bytes_used_buffer.read_long_long
+      else
+        bytes_used_buffer.read_long
+      end
+
+      buffer.read_string(bytes_used).force_encoding(Encoding::UTF_8)
+    end
+
+    alias_method :to_ruby, :to_s
+
+  end
+
+end

data/lib/corefoundation/version.rb

@@ -0,0 +1,4 @@
+module CF
+  # The current version string
+  VERSION = "0.1.4"
+end

data/spec/array_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe CF::Array do
+  describe 'mutable' do
+    subject { CF::Array.mutable}
+    
+    it { should be_a(CF::Array)}
+    it { should be_mutable}
+
+    describe '[]=' do
+      it 'should raise when trying to store a non cf value' do
+        expect {subject[0] = 123}.to raise_error(TypeError)
+      end
+    end
+
+    describe '<<' do
+      it 'should raise when trying to store a non cf value' do
+        expect {subject << 123}.to raise_error(TypeError)
+      end
+    end
+
+  end
+
+  describe 'immutable' do
+    it 'should raise if all of the array elements are not cf values' do
+      expect {CF::Array.immutable([CF::Boolean::TRUE, 1])}.to raise_error(TypeError)
+    end
+
+    it 'should return an immutable cfarray' do
+      CF::Array.immutable([CF::Boolean::TRUE]).should be_a(CF::Array)
+    end
+    
+    context 'with an immutable array' do
+      subject { CF::Array.immutable([CF::Boolean::TRUE, CF::String.from_string('123')])}
+
+      describe '[]=' do
+        it 'should raise TypeError' do
+          expect {subject[0] = CF::Boolean::TRUE}.to raise_error(TypeError)
+        end
+      end
+
+      describe '<<' do
+        it 'should raise TypeError' do
+          expect {subject << CF::Boolean::TRUE}.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+
+  context "with an array" do
+    subject { CF::Array.immutable([CF::Boolean::TRUE, CF::String.from_string('123')])}
+
+    describe '[]' do
+      it 'should return the typecast value at the index' do
+        subject[1].should be_a(CF::String)
+        subject[1].should == CF::String.from_string('123')
+      end
+    end
+
+
+    describe 'length' do
+      it 'should return the count of items in the dictionary' do
+        subject.length.should == 2
+      end
+    end
+
+    describe 'to_ruby' do
+      it 'should return the result of calling to ruby on its contents' do
+        subject.to_ruby.should == [true, '123']
+      end
+    end
+
+    describe 'each' do 
+      it 'should iterate over each value' do
+        values = []
+        subject.each do |v|
+          values << v
+        end
+        values[0].should == CF::Boolean::TRUE
+        values[1].should == CF::String.from_string('123')
+      end
+    end
+
+    it 'should be enumerable' do
+      values = {}
+      subject.each_with_index do |value, index|
+        values[index] = value
+      end
+      values.should == {0 => CF::Boolean::TRUE, 1 => CF::String.from_string('123')}
+    end
+  end
+end