binary_plist 0.0.1

data/Changelog.markdown

@@ -0,0 +1,3 @@
+0.0.1 (Jul 23, 2010)
+
+* Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Sam Soffes
+
+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/Readme.markdown

@@ -0,0 +1,55 @@
+# BinaryPlist
+
+Rails plugin for easily adding a binary plist format. The binary plist format is ideal for transferring data to an Objective-C based application.
+
+## Installation
+
+Add the following line to your bundle and run `bundle install`.
+
+    gem "binary_plist"
+
+## Usage
+
+All you have to do is add the `bplist` format to your `respond_to` block:
+
+    def index
+      @posts = Post.all
+      respond_to do |format|
+        format.html
+        format.bplist { render :bplist => @posts }
+      end
+    end
+
+You can do the combined style if you're support multiple formats like `json` or `xml`.
+
+    def index
+      @posts = Post.all
+      respond_to do |format|
+        format.html
+        format.any(:json, :bplist) { render request.format.to_sym => @posts }
+      end
+    end
+
+## Consuming
+
+On the Objective-C side, it's ridiculously easy to consume the plist data.
+
+    NSURL *url = [NSURL URLWithString:@"http://localhost:3000/posts.bplist"];
+    NSArray *posts = [NSArray arrayWithContentsOfURL:url];
+
+You can also use the more flexible syntax:
+
+    NSURL *url = [NSURL URLWithString:@"http://localhost:3000/posts.bplist"];
+    NSDate *date = [NSData dataWithContentsOfURL:url];
+    id result = [NSPropertyListSerialization propertyListFromData:data
+			     mutabilityOption:NSPropertyListImmutable format:NULL errorDescription:nil];
+	
+	if ([result isKindOfClass:[NSArray class]]) {
+	    // Handle array response
+	} else if ([result isKindOfClass:[NSDictionary class]]) {
+	    // Handle dictionary response
+	} else {
+	    // Etc...
+	}
+
+Copyright (c) 2010 Sam Soffes, released under the MIT license

data/init.rb

@@ -0,0 +1,11 @@
+require "binary_plist"
+
+Mime::Type.register BinaryPlist::MIME_TYPE, :bplist
+
+ActionController::Renderers.add :bplist do |data, options|
+  # TODO: Make this less hacky
+  data = ActiveSupport::JSON.decode(ActiveSupport::JSON.encode(data, options))
+  
+  self.content_type ||= Mime::BPLIST
+  self.response_body = BinaryPlist::Converter.convert(data)
+end

data/lib/binary_plist.rb

@@ -0,0 +1,179 @@
+# Based on Apple Binary Property List serializer - http://gist.github.com/303378
+require 'iconv'
+
+module BinaryPlist
+  
+  # Very generic type for now
+  MIME_TYPE = 'application/octet-stream'
+  
+  module Converter
+
+    # Difference between Apple and UNIX timestamps
+    DATE_EPOCH_OFFSET_APPLE_UNIX = 978307200
+
+    # Text encoding
+    INPUT_TEXT_ENCODING = 'UTF-8'
+    PLIST_TEXT_ENCODING = 'UTF-16BE'
+  
+    # For marking strings as binary data which will be decoded as a CFData object
+    CFData = Struct.new(:data)
+  
+    # Convert a Ruby data structure into an OS X binary property list file. (.plist)
+    # Works as you'd expect. Integers are limited to 4 bytes, even though the format implies longer values can be written.
+    # Strings are assumed to be in UTF-8 format. Symbols are written as strings.
+    def self.convert(data)
+      write("", data)
+    end
+  
+    # Alternative interface which writes data to the out object using <<
+    def self.write(out, data)
+      # Find out how many objects there are, so we know how big the references are
+      count = count_objects(data)
+      ref_format, ref_size = int_format_and_size(count)
+    
+      # Now serialize all the objects
+      values = Array.new
+      append_values(data, values, ref_format)
+    
+      # Write header, then the values, calculating offsets as they're written
+      out << 'bplist00'
+      offset = 8
+      offsets = Array.new
+      values.each do |v|
+        offsets << offset
+        out << v
+        offset += v.length
+      end
+
+      # How big should the offset ints be?
+      # Decoder gets upset if the size can't fit the entire file, even if it's not strictly needed, so add the length of the last value.
+      offset_format, offset_size = int_format_and_size(offsets.last + values.last.length)
+    
+      # Write the offsets
+      out << offsets.pack(offset_format)
+    
+      # Write trailer
+      out << [0,0,offset_size,ref_size, 0,values.length, 0,0, 0,offset].pack("NnCCNNNNNN")
+    
+      out
+    end
+  
+    private
+  
+      def self.count_objects(data)
+        case data
+        when Array
+          data.inject(1) { |sum,x| sum + count_objects(x) }
+        when Hash
+          # Note: Assumes that the keys aren't a Hash or Array
+          data.length + count_objects(data.values)
+        else
+          1
+        end
+      end
+  
+      def self.append_values(data, values, ref_format)
+        case data
+
+        # Constant values
+        when nil
+          # values << "\x00"
+          # raise "Can't store a nil in a binary plist. While the format supports it, decoders don't like it."
+          append_values("", values, ref_format)
+        when false
+          values << "\x08"
+        when true
+          values << "\x09"
+
+        when Integer
+          raise "Integer out of range to write in binary plist" if data < -2147483648 || data > 0x7FFFFFFF
+          values << packed_int(data)
+
+        when Float
+          values << "\x23#{[data].pack("d").reverse}"
+
+        when Symbol
+          append_values(data.to_s, values, ref_format)
+
+        when String
+          if data =~ /[\x80-\xff]/
+            # Has high bits set, so is UTF-8 and must be reencoded for the plist file
+            c = Iconv.iconv(PLIST_TEXT_ENCODING, INPUT_TEXT_ENCODING, data).join
+            values << "#{objhdr_with_length(0x60, c.length / 2)}#{c}"
+          else
+            # Just ASCII
+            o = objhdr_with_length(0x50, data.length)
+            o << data
+            values << o
+          end
+
+        when CFData
+          o = objhdr_with_length(0x40, data.data.length)
+          o << data.data
+          values << o
+
+        when Time
+          v = data.getutc.to_f - DATE_EPOCH_OFFSET_APPLE_UNIX
+          values << "\x33#{[v].pack("d").reverse}"
+
+        when Hash
+          o = objhdr_with_length(0xd0, data.length)
+          values << o # now, so we get the refs of other objects right
+          ks = Array.new
+          vs = Array.new
+          data.each do |k,v|
+            ks << values.length
+            append_values(k, values, ref_format)
+            vs << values.length
+            append_values(v, values, ref_format)
+          end
+          o << ks.pack(ref_format)
+          o << vs.pack(ref_format)
+
+        when Array
+          o = objhdr_with_length(0xa0, data.length)
+          values << o # now, so we get the refs of other objects right
+          refs = Array.new
+          data.each do |e|
+            refs << values.length # index in array of object we're about to write
+            append_values(e, values, ref_format)
+          end
+          o << refs.pack(ref_format)
+
+        else
+          raise "Couldn't serialize value of class #{data.class.name}"
+        end
+      end
+  
+      def self.int_format_and_size(i)
+        if i > 0xffff
+          ['N*',4]
+        elsif i > 0xff
+          ['n*',2]
+        else
+          ['C*',1]
+        end
+      end
+
+      def self.packed_int(data)
+        if data < 0
+          # Need to use 64 bits for negative numbers.
+          [0x13,0xffffffff,data].pack("CNN")
+        elsif data > 0xffff
+          [0x12,data].pack("CN")
+        elsif data > 0xff
+          [0x11,data].pack("Cn")
+        else
+          [0x10,data].pack("CC")
+        end
+      end
+    
+      def self.objhdr_with_length(id, length)
+        if length < 0xf
+          (id + length).chr
+        else
+          (id + 0xf).chr + packed_int(length)
+        end
+      end
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: binary_plist
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sam Soffes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-23 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+description: Easily add the Apple Binary Plist format to your controllers for transferring data to Objective-C applications.
+email: sam@samsoff.es
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/binary_plist.rb
+- Changelog.markdown
+- LICENSE
+- Readme.markdown
+- init.rb
+has_rdoc: true
+homepage: http://github.com/samsoffes/binary_plist
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easily add the Apple Binary Plist format to your controllers.
+test_files: []
+