yakg 0.0.10 → 0.0.11

data/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/lib/corefoundation/base.rb

@@ -0,0 +1,197 @@
+
+# The top level namespace for the corefoundation library. The raw FFI generated methods are attached here
+#
+#
+module CF
+  extend FFI::Library
+  ffi_lib '/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation'
+
+  if FFI::Platform::ARCH == 'x86_64'
+    typedef :long_long, :cfindex
+    typedef :long_long, :cfcomparisonresult
+    typedef :ulong_long, :cfoptionflags
+    typedef :ulong_long, :cftypeid
+    typedef :ulong_long, :cfhashcode
+  else
+    typedef :long, :cfindex
+    typedef :long, :cfcomparisonresult
+    typedef :ulong, :cfoptionflags
+    typedef :ulong, :cftypeid
+    typedef :ulong, :cfhashcode
+  end
+
+
+  # @private
+  class Range < FFI::Struct
+    layout :location, :cfindex,
+           :length, :cfindex
+  end
+
+  typedef :pointer, :cftyperef
+
+  #general utility functions
+  attach_function :show, 'CFShow', [:cftyperef], :void
+  attach_function :release, 'CFRelease', [:cftyperef], :void
+  attach_function :retain, 'CFRetain', [:cftyperef], :cftyperef
+  attach_function 'CFEqual', [:cftyperef, :cftyperef], :char
+  attach_function 'CFHash', [:cftyperef], :cfhashcode
+  attach_function 'CFCopyDescription', [:cftyperef], :cftyperef
+  attach_function 'CFGetTypeID', [:cftyperef], :cftypeid
+
+  # The base class for all of the wrapper classes 
+  #
+  # @abstract
+  class Base  
+    @@type_map = {}
+
+    # @private
+    class Releaser
+      def initialize(ptr)
+        @address  = ptr.address
+      end
+
+      def call *ignored
+        if @address != 0
+          CF.release(@address)
+          @address = 0
+        end
+      end
+    end
+
+    class << self
+      # Raises an exception if the argument does not inherit from CF::Base
+      #
+      # @param cftyperef object to check
+      def check_cftype(cftyperef)
+        raise TypeError, "#{cftyperef.inspect} is not a cftype" unless cftyperef.is_a?(CF::Base)
+      end
+
+      # Wraps an FFI::Pointer with the appropriate subclass of CF::Base
+      # If the pointer is not a CFTypeRef behaviour is undefined
+      # @param [FFI::Pointer] cftyperef Object to wrap
+      # @return A wrapper object inheriting from CF::Base
+      def typecast(cftyperef)
+        klass = klass_from_cf_type cftyperef
+        klass.new(cftyperef)
+      end
+
+      private
+      def klass_from_cf_type cftyperef
+        klass = @@type_map[CF.CFGetTypeID(cftyperef)]
+        if !klass
+          raise TypeError, "No class registered for cf type #{cftyperef.inspect}"
+        end
+        klass
+      end
+
+      def register_type(type_name)
+        CF.attach_function "#{type_name}GetTypeID", [], :cftypeid
+        @@type_map[CF.send("#{type_name}GetTypeID")] = self
+      end
+
+    end
+
+    # 
+    #
+    # @param [FFI::Pointer] ptr The pointer to wrap
+    def initialize(ptr)
+      @ptr = FFI::Pointer.new(ptr)
+    end
+
+    # Whether the instance is the CFNull singleton
+    #
+    # @return [Boolean]
+    def null?
+      equals?(CF::NULL)
+    end
+
+    # Returns the wrapped pointer
+    # @return [FFI::Pointer]
+    def to_ptr
+      @ptr
+    end
+
+    # Sets the wrapper pointer. You should only do this rarely. If you have used release_on_gc then that
+    # finalizer will still be called on the original pointer value
+    #
+    def ptr= ptr
+      @ptr = ptr
+    end
+
+    # Calls CFRetain on the wrapped pointer
+    # @return Returns self
+    def retain
+      CF.retain(self)
+      self
+    end
+
+    # Calls CFRelease on the wrapped pointer
+    # @return Returns self
+    def release
+      CF.release(self)
+      self
+    end
+
+    # Installs a finalizer on the wrapper object that will cause it to call CFRelease on the pointer
+    # when the wrapper is garbage collected
+    # @return Returns self
+    def release_on_gc
+      ObjectSpace.define_finalizer(@ptr, Releaser.new(@ptr))
+      self
+    end
+
+    # Returns a ruby string containing the output of CFCopyDescription for the wrapped object
+    #
+    # @return [String]
+    def inspect
+      cf = CF::String.new(CF.CFCopyDescription(self))
+      cf.to_s.tap {cf.release}
+    end
+
+    # Uses CFHash to  return a hash code
+    #
+    # @return [Integer]
+    def hash
+      CF.CFHash(self)
+    end
+
+    # eql? (and ==) are implemented using CFEqual
+    #
+    #
+    def eql?(other)
+      if other.is_a?(CF::Base)
+        CF.CFEqual(self, other) != 0
+      else
+        false
+      end
+    end
+    
+    # equals? is defined as returning true if the wrapped pointer is the same
+    #
+    #
+    def equals?(other)
+      if other.is_a?(CF::Base)
+        @ptr.address == other.to_ptr.address
+      else
+        false
+      end
+    end
+    
+    alias_method :==, :eql?
+
+    # Converts the CF object into a ruby object. Subclasses typically override this to return
+    # an appropriate object (for example CF::String returns a String)
+    #
+    def to_ruby
+      self
+    end
+
+    # to_cf is a no-op on CF::Base and its descendants - it always returns self
+    #
+    #
+    def to_cf
+      self
+    end
+  end
+
+end

data/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/lib/corefoundation/boolean.rb

@@ -0,0 +1,25 @@
+module CF
+  attach_variable 'kCFBooleanTrue', :pointer
+  attach_variable 'kCFBooleanFalse', :pointer
+  attach_function 'CFBooleanGetValue', [:pointer], :uchar
+
+  # Wrapper for CFBooleanRef.
+  # Typically you use the CF::Boolean::TRUE and CF::Boolean::FALSE constants
+  #
+  class Boolean < Base
+    register_type("CFBoolean")
+    # A constant containing kCFBooleanTrue
+    TRUE = new(CF.kCFBooleanTrue)
+    # A constant containing kCFBooleanFalse
+    FALSE = new(CF.kCFBooleanFalse)
+
+    # returns a ruby true/false value
+    #
+    # @return [Boolean]
+    def value
+      CF.CFBooleanGetValue(self) != 0
+    end
+
+    alias_method :to_ruby, :value
+  end
+end

data/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/lib/corefoundation/data.rb

@@ -0,0 +1,42 @@
+module CF
+  typedef :pointer, :cfdataref
+
+  attach_function 'CFDataCreate', [:pointer, :buffer_in, :cfindex], :cfdataref  
+  attach_function 'CFDataGetLength', [:cfdataref], :cfindex  
+  attach_function 'CFDataGetBytePtr', [:cfdataref], :pointer
+
+  # Wrapper for CFData
+  #
+  #
+  class Data < Base
+    register_type("CFData")
+
+    # Creates a CFData from a ruby string
+    # @param [String] s the string to use
+    # @return [CF::Data]
+    def self.from_string(s)
+      new(CF.CFDataCreate(nil, s, s.bytesize)).release_on_gc
+    end
+
+    # Creates a ruby string from the wrapped data. The encoding will always be ASCII_8BIT
+    #
+    # @return [String]
+    def to_s
+      ptr = CF.CFDataGetBytePtr(self)
+      if CF::String::HAS_ENCODING
+        ptr.read_string(CF.CFDataGetLength(self)).force_encoding(Encoding::ASCII_8BIT)
+      else
+        ptr.read_string(CF.CFDataGetLength(self))
+      end
+    end
+
+    # The size in bytes of the CFData
+    # @return [Integer]
+    def size
+      CF.CFDataGetLength(self)
+    end
+
+    alias_method :to_ruby, :to_s
+  end
+end
+

data/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/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/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/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/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/lib/corefoundation/extensions.rb

@@ -0,0 +1,158 @@
+# 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/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/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/vendor/gems/ruby/2.1.0/gems/corefoundation-0.2.0/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