plist_lite 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 81c314a0ff465217564b4040a14bfc7a8913e26d9be6b365c489f4117f07fd76
+  data.tar.gz: 0ae9856ea9b8b13c691a4459ea907140d32d99cafedc6b726c570649a4ea77f3
+SHA512:
+  metadata.gz: c12c104cfd7c1daf21fc7813e7dacc6498ec14efce8e3950dafae565050ee6b6fa9488638a4fe9e254cdcfb4388776005ab22c6c3495ad8cc4e1f155212c3bc6
+  data.tar.gz: 49ef1de68941d7683ec69843dc9a607ca97b85de8f9b2a7fbf299ffd66d2f965ce445593405c492ef54f3a2d7ed080888ac8eb8d6a6d7522702607a4b06400e8

data/ext/plist_lite/ext/ext.c

@@ -0,0 +1,233 @@
+#include "ruby.h"
+#include "ruby/encoding.h"
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct
+{
+  char *head;
+  size_t size;
+  size_t length;
+} string;
+
+string *string_new(size_t size)
+{
+  string *ptr = malloc(sizeof(string));
+  ptr->size = size;
+  ptr->head = malloc(size);
+  ptr->head[0] = '\0';
+  ptr->length = 0;
+  return ptr;
+}
+
+void string_concat(string *recv, char *src)
+{
+  size_t len_src = strlen(src);
+  size_t new_size = recv->size;
+  while ((recv->length + len_src + 1) > new_size)
+    new_size <<= 1;
+  if (new_size > recv->size)
+    recv->head = realloc(recv->head, new_size);
+
+  char *ptr = recv->head + recv->length;
+  while ((*ptr++ = *src++))
+    ;
+  recv->length += len_src;
+}
+
+void string_free(string *recv)
+{
+  free(recv->head);
+  free(recv);
+}
+
+void time_to_plist_date(VALUE time, string *output)
+{
+  rb_funcall(time, rb_intern("utc"), 0);
+  VALUE str = rb_funcall(time, rb_intern("iso8601"), 0);
+  string_concat(output, (char *)"<date>");
+  string_concat(output, StringValueCStr(str));
+  string_concat(output, (char *)"</date>");
+}
+
+void dump_node(VALUE obj, string *output);
+
+VALUE to_utf8_xml_text(VALUE obj)
+{
+  int idx = rb_enc_get_index(obj);
+  if (idx < 0)
+    rb_raise(rb_eTypeError, "unknown encoding");
+  if (idx == rb_utf8_encindex())
+  {
+    VALUE options = rb_hash_new();
+    rb_hash_aset(options, ID2SYM(rb_intern("xml")), ID2SYM(rb_intern("text")));
+    return rb_funcallv_kw(obj, rb_intern("encode"), 1, &options, RB_PASS_KEYWORDS);
+  }
+  else
+  {
+    VALUE options = rb_hash_new();
+    rb_hash_aset(options, ID2SYM(rb_intern("xml")), ID2SYM(rb_intern("text")));
+    VALUE args[] = {rb_enc_from_encoding(rb_utf8_encoding()), options};
+    return rb_funcallv_kw(obj, rb_intern("encode"), 2, args, RB_PASS_KEYWORDS);
+  }
+}
+
+VALUE array_each_block(VALUE obj, string *output)
+{
+  dump_node(obj, output);
+  return Qnil;
+}
+
+VALUE hash_each_block(VALUE pair, string *output)
+{
+  VALUE value = rb_ary_pop(pair);
+  VALUE key = rb_ary_pop(pair);
+  string_concat(output, (char *)"<key>");
+  switch (TYPE(key))
+  {
+  case T_STRING:
+  {
+    VALUE encoded = to_utf8_xml_text(key);
+    string_concat(output, StringValueCStr(encoded));
+    break;
+  }
+  case T_SYMBOL:
+  {
+    VALUE str = rb_funcall(key, rb_intern("to_s"), 0);
+    string_concat(output, StringValueCStr(str));
+    break;
+  }
+  default:
+  {
+    VALUE encoded = to_utf8_xml_text(rb_funcall(key, rb_intern("to_s"), 0));
+    string_concat(output, StringValueCStr(encoded));
+    break;
+  }
+  }
+  string_concat(output, (char *)"</key>");
+  dump_node(value, output);
+  return Qnil;
+}
+
+void dump_node(VALUE obj, string *output)
+{
+  switch (TYPE(obj))
+  {
+  case T_ARRAY:
+    string_concat(output, (char *)"<array>");
+    rb_block_call(obj, rb_intern("each"), 0, NULL, (rb_block_call_func_t)array_each_block, (VALUE)output);
+    string_concat(output, (char *)"</array>");
+    break;
+  case T_HASH:
+    string_concat(output, (char *)"<dict>");
+    rb_block_call(obj, rb_intern("each"), 0, NULL, (rb_block_call_func_t)hash_each_block, (VALUE)output);
+    string_concat(output, (char *)"</dict>");
+    break;
+  case T_TRUE:
+    string_concat(output, (char *)"<true/>");
+    break;
+  case T_FALSE:
+  {
+    string_concat(output, (char *)"<false/>");
+    break;
+  }
+  case T_BIGNUM:
+  case T_FIXNUM:
+  {
+    VALUE str = rb_funcall(obj, rb_intern("to_s"), 0);
+    string_concat(output, (char *)"<integer>");
+    string_concat(output, StringValueCStr(str));
+    string_concat(output, (char *)"</integer>");
+    break;
+  }
+  case T_FLOAT:
+  {
+    VALUE str = rb_funcall(obj, rb_intern("to_s"), 0);
+    string_concat(output, (char *)"<real>");
+    string_concat(output, StringValueCStr(str));
+    string_concat(output, (char *)"</real>");
+    break;
+  }
+  case T_STRING:
+  {
+    int idx = rb_enc_get_index(obj);
+    if (idx == rb_ascii8bit_encindex())
+    {
+      string_concat(output, (char *)"<data>");
+      VALUE data = rb_funcall(
+          rb_ary_new_from_values(1, &obj),
+          rb_intern("pack"),
+          1,
+          rb_str_new_literal("m"));
+      string_concat(output, StringValueCStr(data));
+      string_concat(output, (char *)"</data>");
+    }
+    else
+    {
+      string_concat(output, (char *)"<string>");
+      VALUE encoded = to_utf8_xml_text(obj);
+      string_concat(output, StringValueCStr(encoded));
+      string_concat(output, (char *)"</string>");
+    }
+
+    break;
+  }
+  case T_SYMBOL:
+  {
+    VALUE str = rb_funcall(obj, rb_intern("to_s"), 0);
+    string_concat(output, (char *)"<string>");
+    string_concat(output, StringValueCStr(str));
+    string_concat(output, (char *)"</string>");
+    break;
+  }
+  default:
+  {
+    if (rb_obj_is_kind_of(obj, rb_cTime) == Qtrue)
+    {
+      VALUE time = rb_funcall(rb_cTime, rb_intern("at"), 1, obj);
+      time_to_plist_date(time, output);
+    }
+    else if (rb_obj_is_kind_of(obj, rb_const_get(rb_cObject, rb_intern("DateTime"))) == Qtrue)
+    {
+      VALUE time = rb_funcall(obj, rb_intern("to_time"), 0);
+      time_to_plist_date(time, output);
+    }
+    else if (rb_obj_is_kind_of(obj, rb_const_get(rb_cObject, rb_intern("Date"))) == Qtrue)
+    {
+      rb_warn("Consider not using Date object because it does not contain time zone information");
+      VALUE str = rb_funcall(obj, rb_intern("iso8601"), 0);
+      string_concat(output, (char *)"<date>");
+      string_concat(output, StringValueCStr(str));
+      string_concat(output, (char *)"T00:00:00Z</date>");
+    }
+    else
+    {
+      VALUE msg = rb_funcall(rb_obj_class(obj), rb_intern("to_s"), 0);
+      rb_raise(rb_eArgError, "Unsupported type: %s", StringValueCStr(msg));
+    }
+    break;
+  }
+  }
+}
+
+VALUE dump(VALUE recv, VALUE obj)
+{
+  string *output = string_new(2048);
+  string_concat(
+      output,
+      (char *)"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+              "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">"
+              "<plist version=\"1.0\">");
+  dump_node(obj, output);
+  string_concat(output, (char *)"</plist>");
+  VALUE ret = rb_utf8_str_new(output->head, output->length);
+  string_free(output);
+  return ret;
+}
+
+void Init_ext(void)
+{
+  rb_require("time");
+  VALUE cPlistLite = rb_define_module("PlistLite");
+  rb_define_singleton_method(cPlistLite, "dump", dump, 1);
+}

data/ext/plist_lite/ext/extconf.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+create_makefile('plist_lite/ext')

data/lib/minimal.plist

@@ -0,0 +1 @@
+<?xml version="1.0"?><!DOCTYPE plist SYSTEM "plist.dtd"><_/>

data/lib/plist.dtd

@@ -0,0 +1,19 @@
+<!ENTITY % plistObject "(array | data | date | dict | real | integer | string | true | false )" >
+<!ELEMENT plist %plistObject;>
+<!ATTLIST plist version CDATA "1.0" >
+
+<!-- Collections -->
+<!ELEMENT array (%plistObject;)*>
+<!ELEMENT dict (key, %plistObject;)*>
+<!ELEMENT key (#PCDATA)>
+
+<!--- Primitive types -->
+<!ELEMENT string (#PCDATA)>
+<!ELEMENT data (#PCDATA)> <!-- Contents interpreted as Base-64 encoded -->
+<!ELEMENT date (#PCDATA)> <!-- Contents should conform to a subset of ISO 8601 (in particular, YYYY '-' MM '-' DD 'T' HH ':' MM ':' SS 'Z'.  Smaller units may be omitted with a loss of precision) -->
+
+<!-- Numerical primitives -->
+<!ELEMENT true EMPTY>  <!-- Boolean constant true -->
+<!ELEMENT false EMPTY> <!-- Boolean constant false -->
+<!ELEMENT real (#PCDATA)> <!-- Contents should represent a floating point number matching ("+" | "-")? d+ ("."d*)? ("E" ("+" | "-") d+)? where d is a digit 0-9.  -->
+<!ELEMENT integer (#PCDATA)> <!-- Contents should represent a (possibly signed) integer number in base 10 -->

data/lib/plist_lite.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'time'
+module PlistLite
+  DTD = Dir.chdir(__dir__) do
+    Nokogiri::XML::Document.parse(
+      IO.read("#{__dir__}/minimal.plist"), nil, nil,
+      Nokogiri::XML::ParseOptions.new(Nokogiri::XML::ParseOptions::DTDLOAD)
+    )
+  end.external_subset
+
+  class << self
+    def load(source)
+      doc = Nokogiri::XML::Document.parse(
+        source, nil, nil,
+        Nokogiri::XML::ParseOptions.new(Nokogiri::XML::ParseOptions::STRICT)
+      )
+      raise doc.errors.first unless doc.errors.empty?
+
+      errors = DTD.validate(doc)
+      raise errors.first unless errors.empty?
+
+      load_node(doc.root.elements.first)
+    end
+
+    def dump(obj)
+      output = +'<?xml version="1.0" encoding="UTF-8"?>' \
+      '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">' \
+      '<plist version="1.0">'
+      dump_node(obj, output)
+      output << '</plist>'
+    end
+
+    private
+
+    def load_node(node)
+      case node.name
+      when 'dict'
+        hash = {}
+        node.elements.each_slice(2) do |key_node, value_node|
+          hash[key_node.text] = load_node(value_node)
+        end
+        hash
+      when 'array'
+        array = []
+        node.elements.each { |element| array << load_node(element) }
+        array
+      when 'integer' then node.text.to_i
+      when 'real' then node.text.to_f
+      when 'date' then Time.iso8601(node.text)
+      when 'string' then node.text
+      when 'data' then node.text.unpack1('m')
+      when 'true' then true
+      when 'false' then false
+      end
+    end
+
+    def dump_node(obj, output)
+      case obj
+      when Hash
+        output << '<dict>'
+        obj.each do |key, value|
+          case key
+          when String then output << "<key>#{key.encode(xml: :text)}</key>"
+          when Symbol then output << "<key>#{key}</key>"
+          else
+            raise TypeError, 'Hash key should be String or Symbol'
+          end
+          dump_node(value, output)
+        end
+        output << '</dict>'
+      when Array
+        output << '<array>'
+        obj.each { |i| dump_node(i, output) }
+        output << '</array>'
+      when Symbol then output << "<string>#{obj}</string>"
+      when String
+        output <<
+          case obj.encoding
+          when Encoding::ASCII_8BIT then "<data>#{[obj].pack('m')}</data>"
+          when Encoding::UTF_8 then "<string>#{obj.encode(xml: :text)}</string>"
+          else "<string>#{obj.encode(Encoding::UTF_8, xml: :text)}</string>"
+          end
+      when Integer then output << "<integer>#{obj}</integer>"
+      when Float then output << "<real>#{obj}</real>"
+      when true then output << '<true/>'
+      when false then output << '<false/>'
+      when Time then output << "<date>#{Time.at(obj).utc.iso8601}</date>"
+      when DateTime then output << "<date>#{obj.to_time.utc.iso8601}</date>"
+      when Date
+        warn 'Consider not using Date object because it does not contain time zone information'
+        output << "<date>#{obj.iso8601}T00:00:00Z</date>"
+      else raise ArgumentError, "unknown type: #{obj.class}"
+      end
+    end
+  end
+end
+
+require 'plist_lite/ext'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: plist_lite
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Weihang Jian
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: plist_lite is the fastest plist processor for Ruby written in C.It can
+  convert Ruby object to XML plist (a.k.a. property list), vice versa.
+email: tonytonyjan@gmail.com
+executables: []
+extensions:
+- ext/plist_lite/ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/plist_lite/ext/ext.c
+- ext/plist_lite/ext/extconf.rb
+- lib/minimal.plist
+- lib/plist.dtd
+- lib/plist_lite.rb
+- lib/plist_lite/ext.bundle
+homepage: https://github.com/tonytonyjan/plist_lite
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: plist_lite is the fastest plist processor for Ruby written in C.
+test_files: []