corefoundation 0.2.0 → 0.3.4

data/lib/corefoundation/extensions.rb

@@ -1,158 +0,0 @@
-# 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 {#binary?} returns true a {CF::Data} is returned, if not a {CF::String} is returned
-  # 
-  # If you want a {CF::Data} with the contents of a non binary string, use {#to_cf_data}
-  #
-  # @return [CF::String, CF::Data]
-  def to_cf
-    self.binary? ? self.to_cf_data : self.to_cf_string
-  end
-
-  # @!method binary?
-  #
-  # used to determine whether {#to_cf} should return a {CF::String} or a {CF::Data}. On ruby 1.9 and above this simply 
-  # checks whether the encoding is ascii-8bit or not.
-  # 
-  # On ruby 1.8.7
-  #
-  # - A string is binary if you call {#binary!} with the default argument of true
-  # - A string is not binary if you call {#binary!} with the argument false
-  # 
-  # If you have never called {#binary!} then a string is binary if Iconv does not think it is valid utf-8
-  # @return whether the string is handled as binary data or not
-  #
-  if '<3'.respond_to? :encoding
-    def binary?
-      encoding == Encoding::ASCII_8BIT
-    end
-  else
-    def binary?
-      unless defined? @cf_is_binary
-        begin
-          ::Iconv.conv('UTF-8', 'UTF-8', self)
-          return false if self.frozen?
-          @cf_is_binary = false
-        rescue Iconv::IllegalSequence
-          return true if self.frozen?
-          @cf_is_binary = true
-        end
-      end
-      @cf_is_binary
-    end
-  end
-
-  if '<3'.respond_to? :encoding
-  # On ruby 1.8.7 sets or clears the flag used by {#binary?}. On ruby 1.9 the string's encoding is forced. 
-  # @see #binary?
-  # 
-  # @note There is no advantage to using this over the standard encoding methods unless you wish to retain 1.8.7 compatibility
-  #
-  # @param [optional, Boolean, Encoding] bin On ruby 1.8.7 only boolean values are admissible. On ruby 1.9 you can pass a specific encoding to force. 
-  #   If you pass `true` then `Encoding::ASCII_BIT` is used, if you pass `false` then `Encoding::UTF_8`
-  #
-    def binary!(bin=true)
-      if bin == true
-        self.force_encoding Encoding::ASCII_8BIT
-      else
-        # default to utf-8
-        self.force_encoding( (bin == false) ? "UTF-8" : bin)
-      end
-      self
-    end
-  else
-  # On ruby 1.8.7 sets or clears the flag used by {#binary?}. On ruby 1.9 the string's encoding is forced. 
-  # @see #binary?
-  # 
-  # @note There is no advantage to using this over the standard encoding methods unless you wish to retain 1.8.7 compatibility
-  #
-  # @param [optional, Boolean, Encoding] bin On ruby 1.8.7 only boolean values are admissible. On ruby 1.9 you can pass a specific encoding to force. 
-  #   If you pass `true` then `Encoding::ASCII_BIT` is used, if you pass `false` then `Encoding::UTF_8`
-  #
-    def binary!(bin=true)
-      @cf_is_binary = !! bin
-      self
-    end
-  end
-  
-  # Returns a {CF::String} representing the string
-  # @return [CF::String]
-  def to_cf_string
-    CF::String.from_string self
-  end
-  
-  # Returns a {CF::Data} representing the string
-  # @return [CF::Data]
-  def to_cf_data
-    CF::Data.from_string self
-  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/spec/array_spec.rb

@@ -1,92 +0,0 @@
-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

data/spec/boolean_spec.rb

@@ -1,24 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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'
-      if CF::String::HAS_ENCODING
-        ruby_string.encoding.should == Encoding::ASCII_8BIT
-      end
-    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'
-      if 'A CF string'.respond_to? "encoding"
-        subject.to_ruby.encoding.should == Encoding::ASCII_8BIT
-      end
-    end
-  end
-end

data/spec/date_spec.rb

@@ -1,25 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,127 +0,0 @@
-# -*- coding: utf-8 -*-
-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
-
-  describe String do
-    uber = [195, 188, 98, 101, 114]
-    
-    describe 'to_cf' do
-
-      unless defined? RUBY_ENGINE and RUBY_ENGINE == 'jruby'
-        context 'with data incorrectly marked as non binary' do
-          it 'returns nil' do
-            [0xff, 0xff, 0xff].pack("C*").binary!(false).to_cf.should be_nil
-          end
-        end
-      end
-
-      context 'with a non binary string' do
-        it 'should return a cf string' do
-          '123'.to_cf.should be_a(CF::String)
-        end
-      end
-
-      context 'with a string marked as binary' do
-        it 'should return a cf data' do
-          '123'.binary!.to_cf.should be_a(CF::Data)
-        end
-      end
-
-      context 'with a binary string' do    
-        it 'should return a cf data' do
-          [0xff, 0xff, 0xff].pack("C*").to_cf.should be_a(CF::Data)
-        end
-      end
-
-      context 'with a utf-8 string' do
-        it 'should return a cfstring' do
-          uber.pack("C*").should_not be_a(CF::String)
-        end
-      end
-    end
-
-    describe 'binary?' do
-
-      it 'should return false on a plain ascii string' do
-        '123'.should_not be_binary
-      end
-
-      if CF::String::HAS_ENCODING
-        it 'should return false on valid utf data' do
-          "\xc3\xc9".should_not be_binary
-        end
-      else
-        it 'should return false on valid utf data' do
-          uber.pack("C*").should_not be_binary
-        end
-      end
-
-      it 'should return false on string forced to non binary' do
-        "\xc3\xc9".binary!(false).should_not be_binary
-      end
-
-      it 'should return true if binary! has been called' do
-        '123'.binary!.should be_binary
-      end
-
-      if CF::String::HAS_ENCODING
-        it 'should return true for ascii 8bit strings' do
-          '123'.encode(Encoding::ASCII_8BIT).should be_binary
-        end
-      else
-        it 'should return true for data that cannot be converted to utf8' do
-          "\xff\xff\xff".should be_binary
-        end
-      end
-    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

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

data/spec/number_spec.rb

@@ -1,52 +0,0 @@
-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

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

data/spec/string_spec.rb

@@ -1,48 +0,0 @@
-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 defined? RUBY_ENGINE and RUBY_ENGINE == 'jruby'
-      context 'with invalid data' do
-        it 'returns nil' do
-          if CF::String::HAS_ENCODING
-            CF::String.from_string("\xff\xff\xff".force_encoding('UTF-8')).should be_nil
-          else
-            CF::String.from_string("\xff\xff\xff").should be_nil
-          end
-        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'
-      if CF::String::HAS_ENCODING
-        ruby_string.encoding.should == Encoding::UTF_8
-      else
-      end
-    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'
-      if CF::String::HAS_ENCODING
-        CF::String.from_string('A CF string').to_ruby.encoding.should == Encoding::UTF_8
-      end
-    end
-  end
-
-  it 'should be comparable' do
-    CF::String.from_string('aaa').should  <= CF::String.from_string('zzz')
-  end
-end