yakg 0.0.10 → 0.0.11

data/vendor/gems/ruby/2.2.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.2.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.2.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

data/vendor/gems/ruby/2.2.0/gems/corefoundation-0.2.0/lib/corefoundation/string.rb

@@ -0,0 +1,91 @@
+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
+
+    # workaround for ruby 1.8.7 compat
+    HAS_ENCODING = "foo".respond_to? "encode"
+
+    # 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, src_encoding='UTF-8')
+      if HAS_ENCODING
+        s_utf = s.encode('UTF-8')
+      else
+        begin
+          s_utf = Iconv.conv('UTF-8', src_encoding, s.to_s)
+        rescue Iconv::IllegalSequence => e
+          return nil
+        end
+      end
+      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
+
+      if HAS_ENCODING
+        buffer.read_string(bytes_used).force_encoding(Encoding::UTF_8)
+      else
+        buffer.read_string(bytes_used)
+      end
+    end
+
+    alias_method :to_ruby, :to_s
+
+  end
+
+end

data/vendor/gems/ruby/2.2.0/gems/corefoundation-0.2.0/lib/corefoundation/version.rb

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

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

@@ -0,0 +1,13 @@
+require 'ffi'
+require 'iconv' if RUBY_VERSION < "1.9"
+
+require 'corefoundation/base'
+require 'corefoundation/null'
+require 'corefoundation/string'
+require 'corefoundation/array'
+require 'corefoundation/boolean'
+require 'corefoundation/data'
+require 'corefoundation/dictionary'
+require 'corefoundation/number'
+require 'corefoundation/date'
+require 'corefoundation/extensions'

data/vendor/gems/ruby/2.2.0/gems/ffi-1.9.10/COPYING

@@ -0,0 +1,49 @@
+Copyright (c) 2008-2013, Ruby FFI project contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Ruby FFI project nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+libffi, used by this project, is licensed under the MIT license:
+
+libffi - Copyright (c) 1996-2011  Anthony Green, Red Hat, Inc and others.
+See source files for details.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+``Software''), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/vendor/gems/ruby/2.2.0/gems/ffi-1.9.10/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2008-2013, Ruby FFI project contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Ruby FFI project nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/vendor/gems/ruby/2.2.0/gems/ffi-1.9.10/README.md

@@ -0,0 +1,109 @@
+# ruby-ffi https://wiki.github.com/ffi/ffi [![Build Status](https://travis-ci.org/ffi/ffi.png?branch=master)](https://travis-ci.org/ffi/ffi)
+
+## Description
+
+Ruby-FFI is a ruby extension for programmatically loading dynamic
+libraries, binding functions within them, and calling those functions
+from Ruby code. Moreover, a Ruby-FFI extension works without changes
+on Ruby and JRuby. [Discover why you should write your next extension
+using Ruby-FFI](https://wiki.github.com/ffi/ffi/why-use-ffi).
+
+## Features/problems
+
+* Intuitive DSL
+* Supports all C native types
+* C structs (also nested), enums and global variables
+* Callbacks from C to ruby
+* Automatic garbage collection of native memory
+
+## Synopsis
+
+```ruby
+require 'ffi'
+
+module MyLib
+  extend FFI::Library
+  ffi_lib 'c'
+  attach_function :puts, [ :string ], :int
+end
+
+MyLib.puts 'Hello, World using libc!'
+```
+
+For less minimalistic and more sane examples you may look at:
+
+* the samples/ folder
+* the examples on the [wiki](https://wiki.github.com/ffi/ffi)
+* the projects using FFI listed on this page (https://wiki.github.com/ffi/ffi/projects-using-ffi)
+
+## Requirements
+
+You need a sane building environment in order to compile the extension.
+At a minimum, you will need:
+* A C compiler (e.g. Xcode on OSX, gcc on everything else)
+* libffi development library - this is commonly in the libffi-dev or libffi-devel
+
+## Installation
+
+From rubygems:
+
+    [sudo] gem install ffi
+
+or from the git repository on github:
+
+    git clone git://github.com/ffi/ffi.git
+    cd ffi
+    rake gem:install
+
+## License
+
+The ffi library is covered by the BSD license, also see the LICENSE file.
+The specs are shared with Rubyspec and are licensed by the same license
+as Rubyspec, see the LICENSE.SPECS file.
+
+## Credits
+
+The following people have submitted code, bug reports, or otherwise contributed to the success of this project:
+
+* Alban Peignier <alban.peignier@free.fr>
+* Aman Gupta <aman@tmm1.net>
+* Andrea Fazzi <andrea.fazzi@alcacoop.it>
+* Andreas Niederl <rico32@gmx.net>
+* Andrew Cholakian <andrew@andrewvc.com>
+* Antonio Terceiro <terceiro@softwarelivre.org>
+* Brian Candler <B.Candler@pobox.com>
+* Brian D. Burns <burns180@gmail.com>
+* Bryan Kearney <bkearney@redhat.com>
+* Charlie Savage <cfis@zerista.com>
+* Chikanaga Tomoyuki <nagachika00@gmail.com>
+* Hongli Lai <hongli@phusion.nl>
+* Ian MacLeod <ian@nevir.net>
+* Jake Douglas <jake@shiftedlabs.com>
+* Jean-Dominique Morani <jdmorani@mac.com>
+* Jeremy Hinegardner <jeremy@hinegardner.org>
+* Jesús García Sáez <blaxter@gmail.com>
+* Joe Khoobyar <joe@ankhcraft.com>
+* Jurij Smakov <jurij@wooyd.org>
+* KISHIMOTO, Makoto <ksmakoto@dd.iij4u.or.jp>
+* Kim Burgestrand <kim@burgestrand.se>
+* Lars Kanis <kanis@comcard.de>
+* Luc Heinrich <luc@honk-honk.com>
+* Luis Lavena <luislavena@gmail.com>
+* Matijs van Zuijlen <matijs@matijs.net>
+* Matthew King <automatthew@gmail.com>
+* Mike Dalessio <mike.dalessio@gmail.com>
+* NARUSE, Yui <naruse@airemix.jp>
+* Park Heesob <phasis@gmail.com>
+* Shin Yee <shinyee@speedgocomputing.com>
+* Stephen Bannasch <stephen.bannasch@gmail.com>
+* Suraj N. Kurapati <sunaku@gmail.com>
+* Sylvain Daubert <sylvain.daubert@laposte.net>
+* Victor Costan
+* beoran@gmail.com
+* ctide <christide@christide.com>
+* emboss <Martin.Bosslet@googlemail.com>
+* hobophobe <unusualtears@gmail.com>
+* meh <meh@paranoici.org>
+* postmodern <postmodern.mod3@gmail.com>
+* wycats@gmail.com <wycats@gmail.com>
+* Wayne Meissner <wmeissner@gmail.com>