corefoundation 0.1.4

data/spec/boolean_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe CF do
+
+
+  describe CF::Boolean do
+    describe 'value' do
+      it 'should return true for CF::Boolean::TRUE' do
+        CF::Boolean::TRUE.value.should == true
+      end
+      it 'should return false for CF::Boolean::FALSE' do
+        CF::Boolean::FALSE.value.should == false
+      end
+    end
+
+    describe 'to_ruby' do
+      it 'should behave like value' do
+        CF::Boolean::FALSE.to_ruby.should == false
+      end
+    end
+
+  end
+
+end

data/spec/data_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+
+describe CF::Data do
+  subject {CF::Data.from_string('A CF string')}
+  describe '#to_s' do
+    it 'should return a binary ruby string' do
+      ruby_string = subject.to_s
+      ruby_string.should == 'A CF string'
+      ruby_string.encoding.should == Encoding::ASCII_8BIT
+    end
+  end
+
+  describe '#size' do
+    it 'should return the size in bytes of the cfdata' do
+      subject.size.should == 11
+    end
+  end
+
+  describe 'to_ruby' do
+    it 'should behave like to_s' do
+      subject.to_ruby.should == 'A CF string'
+      subject.to_ruby.encoding.should == Encoding::ASCII_8BIT
+    end
+  end
+end

data/spec/date_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe CF::Date do
+  describe('from_time') do
+    it 'should create a cf date from a time' do
+      CF::Date.from_time(Time.now).should be_a(CF::Date)
+    end
+  end
+
+  describe('to_time') do
+    it 'should return a time' do
+      t = CF::Date.from_time(Time.now).to_time
+      t.should be_a(Time)
+      t.should be_within(0.01).of(Time.now)
+    end
+  end
+
+  describe 'to_ruby' do
+    it 'should behave like to_time' do
+      t = CF::Date.from_time(Time.now).to_ruby
+      t.should be_a(Time)
+    end
+  end
+end
+

data/spec/dictionary_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+
+describe CF::Dictionary do
+  describe 'mutable' do
+    it 'should return  a cf dictionary' do
+      CF::Dictionary.mutable.should be_a(CF::Dictionary)
+    end
+  end
+
+  describe 'hash access' do
+    subject {CF::Dictionary.mutable}
+
+    it 'should return nil when the key does not exist' do
+      subject['doesnotexist'].should be_nil
+    end
+
+    it 'should raise when trying to store a non cf value' do
+      expect {subject[CF::String.from_string('key')]=1}.to raise_error(TypeError)
+    end
+
+    it 'should raise when trying to store a non cf key' do
+      expect {subject[1]=CF::String.from_string('value')}.to raise_error(TypeError)
+    end
+
+    it 'should allow storing and retrieving a cf key pair' do
+      subject[CF::String.from_string('key')] = CF::String.from_string('value')
+    end
+
+    it 'should instantiate the correct type on retrieval' do
+      subject[CF::String.from_string('key')] = CF::String.from_string('value')
+      subject[CF::String.from_string('key')].should be_a(CF::String)
+    end
+
+    it 'should coerce string keys' do
+      subject['key'] = CF::String.from_string('value')
+      subject['key'].to_s.should == 'value'
+    end
+  end
+
+  describe 'merge!' do
+    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Boolean::FALSE}}
+    it 'should merge the argument into the receiver' do
+      argument = {'1' => false, 'foo' => 'bar'}.to_cf
+      subject.merge! argument
+      subject.to_ruby.should == {'1' => false, '2' => false, 'foo' => 'bar'}
+    end
+  end
+
+  describe 'length' do
+    it 'should return the count of items in the dictionary' do
+      dict = CF::Dictionary.mutable
+      dict['one'] = CF::Boolean::TRUE
+      dict['two'] = CF::Boolean::TRUE
+
+      dict.length.should == 2
+    end
+  end
+
+  describe 'enumeration' do
+    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Boolean::FALSE}}
+
+    it 'should yield each key value pair in the dictionary' do
+      hash = {}
+      subject.each do |k,v|
+        hash[k] = v
+      end
+      hash.should == {CF::String.from_string('1') => CF::Boolean::TRUE, 
+                      CF::String.from_string('2') => CF::Boolean::FALSE}
+    end
+  end
+
+  describe 'to_ruby' do
+    subject { CF::Dictionary.mutable.tap {|dict| dict['1'] = CF::Boolean::TRUE; dict['2'] = CF::Array.immutable([CF::Boolean::FALSE])}}
+
+    it 'should return a ruby hash where keys and values have been converted to ruby types' do
+      subject.to_ruby.should == {'1' => true, '2' => [false]}
+    end
+  end
+
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe 'extensions' do
+  context 'with an integer' do
+    it 'should return a cfnumber' do
+      1.to_cf.should be_a(CF::Number)
+    end
+  end
+
+  context 'with a float' do
+    it 'should return a cfnumber' do
+      (1.0).to_cf.should be_a(CF::Number)
+    end
+  end
+
+  context 'with a 8bit string' do
+    it 'should return a cf data' do
+      '123'.encode(Encoding::ASCII_8BIT).to_cf.should be_a(CF::Data)
+    end
+  end
+
+  context 'with an asciistring' do
+    it 'should return a cf string' do
+      '123'.to_cf.should be_a(CF::String)
+    end
+  end
+
+  context 'with true' do
+    it 'should return CF::Boolean::TRUE' do
+      true.to_cf.should == CF::Boolean::TRUE
+    end
+  end
+
+  context 'with false' do
+    it 'should return CF::Boolean::FALSE' do
+      false.to_cf.should == CF::Boolean::FALSE
+    end
+  end
+
+  context 'with a time' do
+    it 'should return a CFDate' do
+      Time.now.to_cf.should be_a(CF::Date)
+    end
+  end
+
+  context 'with an array' do
+    it 'should return a cfarray containing cf objects' do
+      cf_array = [true, 1, 'hello'].to_cf
+      cf_array.should be_a(CF::Array)
+      cf_array[0].should == CF::Boolean::TRUE
+      cf_array[1].should be_a(CF::Number)
+      cf_array[2].should == CF::String.from_string('hello')
+    end
+  end
+
+  context 'with a dictionary' do
+    it 'should return a cfdictionary containing cf objects' do
+      cf_hash = {'key_1' => true, 'key_2' => false}.to_cf
+      cf_hash['key_1'].should == CF::Boolean::TRUE
+      cf_hash['key_2'].should == CF::Boolean::FALSE
+    end
+  end
+end

data/spec/null_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe CF::Null do
+  it 'should be null' do
+    CF::NULL.should be_null
+  end
+end

data/spec/number_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe CF::Number do
+
+  describe 'to_ruby' do
+    context 'with a number created from a float' do
+      subject {CF::Number.from_f('3.1415')} 
+      it 'should return a float' do
+        subject.to_ruby.should be_within(0.0000001).of(3.14150)
+      end
+    end
+    context 'with a number created from a int' do
+      subject {CF::Number.from_i('31415')} 
+      it 'should return a int' do
+        subject.to_ruby.should == 31415
+        subject.to_ruby.should be_a(Integer)
+      end
+    end
+  end
+
+  it 'should be comparable' do
+    (CF::Number.from_f('3.1415') <= CF::Number.from_i(4)).should be_true
+  end
+
+  describe('from_f') do 
+    it 'should create a cf number from a float' do
+      CF::Number.from_f('3.1415').should be_a(CF::Number)
+    end
+  end
+
+  describe('from_i') do 
+    it 'should create a cf number from a 32 bit sized int' do
+      CF::Number.from_i(2**30).should be_a(CF::Number)
+    end
+
+    it 'should create a cf number from a 64 bit sized int' do
+      CF::Number.from_i(2**60).should be_a(CF::Number)
+    end
+  end
+
+  describe('to_i') do
+    it 'should return a ruby integer representing the cfnumber' do
+      CF::Number.from_i(2**60).to_i.should == 2**60
+    end
+  end
+
+  describe('to_f') do
+    it 'should return a ruby float representing the cfnumber' do
+      CF::Number.from_f(3.1415).to_f.should be_within(0.0000001).of(3.14150)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+$: << File.dirname(__FILE__) + '/../lib'
+
+require 'corefoundation'
+
+RSpec.configure do |config|
+  
+end

data/spec/string_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe CF::String do
+
+  describe 'from_string' do
+    it 'should return a CF::String' do
+      CF::String.from_string('A CF string').should be_a(CF::String)
+    end
+
+    # The intent is to force feed CF::String with an invalid utf-8 string
+    # but jruby doesn't seem to allow this to be constructed
+    unless RUBY_ENGINE == 'jruby'
+      context 'with invalid data' do
+        it 'returns nil' do
+          CF::String.from_string("\xff\xff\xff".force_encoding('UTF-8')).should be_nil
+        end
+      end
+    end
+  end
+
+  describe '#to_s' do
+    it 'should return a utf ruby string' do
+      ruby_string = CF::String.from_string('A CF string').to_s
+      ruby_string.should == 'A CF string'
+      ruby_string.encoding.should == Encoding::UTF_8
+    end
+  end
+
+  describe 'to_ruby' do
+    it 'should behave like to_s' do
+      CF::String.from_string('A CF string').to_ruby.should == 'A CF string'
+      CF::String.from_string('A CF string').to_ruby.encoding.should == Encoding::UTF_8
+    end
+  end
+
+  it 'should be comparable' do
+    CF::String.from_string('aaa').should  <= CF::String.from_string('zzz')
+  end
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: corefoundation
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+  prerelease: 
+platform: ruby
+authors:
+- Frederick Cheung
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! 'FFI based Ruby wrappers for Core Foundation '
+email: frederick.cheung@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/corefoundation/array.rb
+- lib/corefoundation/base.rb
+- lib/corefoundation/boolean.rb
+- lib/corefoundation/data.rb
+- lib/corefoundation/date.rb
+- lib/corefoundation/dictionary.rb
+- lib/corefoundation/extensions.rb
+- lib/corefoundation/null.rb
+- lib/corefoundation/number.rb
+- lib/corefoundation/string.rb
+- lib/corefoundation/version.rb
+- lib/corefoundation.rb
+- spec/array_spec.rb
+- spec/boolean_spec.rb
+- spec/data_spec.rb
+- spec/date_spec.rb
+- spec/dictionary_spec.rb
+- spec/extensions_spec.rb
+- spec/null_spec.rb
+- spec/number_spec.rb
+- spec/spec_helper.rb
+- spec/string_spec.rb
+- README.md
+- LICENSE
+homepage: http://github.com/fcheung/corefoundation
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby wrapper for  OS X's corefoundation
+test_files: []
+has_rdoc: