plist4r 0.0.0 → 0.1.0

data/lib/plist4r/backend/plutil.rb

@@ -0,0 +1,19 @@
+
+module Plist4r::Backend::Plutil
+  # maybe this should be a helper, included by other backends
+  class << self
+    # use tempfile to write out data
+    # convert it into target format
+
+    # plutil -convert xml1 @filename
+    # plutil -convert binary1 @filename
+    # next step is not supported
+
+    # def validate
+    #   system "plutil #{@filename}"
+    # end
+  end
+end
+
+
+

data/lib/plist4r/backend/ruby_cocoa.rb

@@ -0,0 +1,191 @@
+
+require 'plist4r/backend'
+
+module Plist4r::Backend::RubyCocoa
+  class << self
+    def ruby_cocoa_wrapper_rb
+      @ruby_cocoa_wrapper_rb ||= <<-'EOC'
+#!/usr/bin/ruby
+
+include_endpath = "plist4r/mixin/ordered_hash.rb"
+raise "No path given to include #{include_endpath}" unless ARGV[0] && ARGV[0] =~ /#{include_endpath}$/
+ordered_hash_rb = ARGV[0]
+
+require ordered_hash_rb
+
+class OSX::NSObject
+  def to_ruby
+    case self 
+    when OSX::NSDate
+      self.to_time
+    when OSX::NSCFBoolean
+      self.boolValue
+    when OSX::NSNumber
+      self.integer? ? self.to_i : self.to_f
+    when OSX::NSString
+      self.to_s
+    when OSX::NSAttributedString
+      self.string.to_s
+    when OSX::NSArray
+      self.to_a.map { |x| x.is_a?(OSX::NSObject) ? x.to_ruby : x }
+    when OSX::NSDictionary
+      h = ::ActiveSupport::OrderedHash.new
+      self.each do |x, y| 
+        x = x.to_ruby if x.is_a?(OSX::NSObject)
+        y = y.to_ruby if y.is_a?(OSX::NSObject)
+        h[x] = y
+      end
+      h
+    else
+      self
+    end
+  end
+end
+
+module Plist
+  def to_xml hash
+    # to_plist defaults to NSPropertyListXMLFormat_v1_0
+    x = hash.to_ruby.to_plist
+    puts "#{x}"
+  end
+  def to_binary hash
+    # Here 200 == NSPropertyListBinaryFormat_v1_0
+    x = hash.to_ruby.to_plist 200
+    puts "#{x}"
+  end
+
+  def open filename
+    plist_dict = ::OSX::NSDictionary.dictionaryWithContentsOfFile(filename)
+    puts "#{plist_dict.to_ruby.inspect}"
+  end
+
+  def save hash, filename, file_format
+    case file_format.to_sym
+    when :xml
+      x = hash.to_plist # NSPropertyListXMLFormat_v1_0
+    when :binary
+      x = hash.to_plist 200 # NSPropertyListBinaryFormat_v1_0
+    when :next_step
+      raise "File format #{file_format.inspect} is not supported by RubyCocoa"
+    else
+      raise "File format #{file_format.inspect} not recognised"
+    end
+    File.open(filename,'w'){ |o| o << x }
+  end
+end
+
+class RubyCocoaWrapper
+  include Plist
+
+  def exec stdin
+    begin
+      require 'osx/cocoa'
+      instance_eval stdin
+      exit 0
+    rescue LoadError
+      raise $!
+    rescue
+      raise $!
+    end
+  end
+end
+
+stdin = $stdin.read()
+wrapper = RubyCocoaWrapper.new()
+wrapper.exec stdin
+EOC
+    end
+
+    def ruby_cocoa_exec stdin_str
+      rubycocoa_framework = "/System/Library/Frameworks/RubyCocoa.framework"
+      raise "RubyCocoa Framework not found. Searched in: #{rubycocoa_framework}" unless File.exists? rubycocoa_framework
+
+      require 'tempfile'
+      require 'plist4r/mixin/popen4'
+
+      if @rb_script && File.exists?(@rb_script.path)
+        @rb_script ||= Tempfile.new("ruby_cocoa_wrapper.rb") do |o|
+          o << ruby_cocoa_rb
+        end
+        File.chmod 0755, @rb_script.path
+      end
+
+      cmd = @rb_script.path
+      ordered_hash_rb = File.join(File.dirname(__FILE__), "..", "mixin", "ordered_hash.rb")
+
+      pid, stdin, stdout, stderr = Popen4::popen4 [cmd, ordered_hash_rb]
+
+        stdin.puts stdin_str
+
+        stdin.close
+        ignored, status = Process::waitpid2 pid
+
+        stdout_result = stdout.read.strip
+        stderr_result = stderr.read.strip
+
+      return [cmd, status, stdout_result, stderr_result]    
+    end
+
+    def from_string plist, string
+      raise "method not implemented yet (unfinished)"
+    end
+
+    def to_xml plist
+      hash = plist.to_hash
+      result = ruby_cocoa_exec "to_xml(\"#{hash}\")"
+      case result[1].exitstatus
+      when 0
+        xml_string = eval result[2]
+        return xml_string
+      else
+        $stderr.puts result[3]
+        raise "Error executing #{result[0]}. See stderr for more information"
+      end
+    end
+
+    def to_binary plist
+      hash = plist.to_hash
+      result = ruby_cocoa_exec "to_binary(\"#{hash}\")"
+      case result[1].exitstatus
+      when 0
+        binary_string = eval result[2]
+        return binary_string
+      else
+        $stderr.puts result[3]
+        raise "Error executing #{result[0]}. See stderr for more information"
+      end
+    end
+
+    def open plist
+      filename = plist.filename
+      result = ruby_cocoa_exec "open(\"#{filename}\")"
+      case result[1].exitstatus
+      when 0
+        hash = eval result[2]
+        plist.import_hash hash
+      else
+        $stderr.puts result[3]
+        raise "Error executing #{result[0]}. See stderr for more information"
+      end
+      file_format = Plist4r.file_detect_format filename
+      plist.file_format = file_format
+      return plist
+    end
+
+    def save hash, filename, file_format
+      filename = plist.filename_path
+      file_format = plist.file_format || Config[:default_format]
+      raise "#{self} - cant save file of format #{file_format}" unless [:xml,:binary].include? file_format
+
+      hash = plist.to_hash
+      result = ruby_cocoa_exec "save(\"#{hash}\",#{filename},#{file_format})"
+      case result[1].exitstatus
+      when 0
+        return true
+      else
+        raise "Error executing #{result[0]}. See stderr for more information"
+      end
+    end
+  end
+end
+

data/lib/plist4r/config.rb

@@ -0,0 +1,18 @@
+
+require 'plist4r/mixin/mixlib_config'
+
+class Plist4r::Config
+  extend Mixlib::Config
+
+  backends [
+    Plist4r::Backend::RubyCocoa,
+    Plist4r::Backend::Haml,
+    Plist4r::Backend::Libxml4r
+  ]
+
+  unsupported_keys true
+  raise_any_failure false
+  deafult_format :xml
+  default_path nil
+end
+

data/lib/plist4r/mixin.rb

@@ -0,0 +1,7 @@
+
+require 'plist4r/mixin/object'
+require 'plist4r/mixin/string'
+require 'plist4r/mixin/ordered_hash'
+require 'plist4r/mixin/popen4'
+require 'plist4r/mixin/data_methods'
+

data/lib/plist4r/mixin/class_attributes.rb

@@ -0,0 +1,128 @@
+# class_attributes.rb - Class Attributes
+# A Feature-complete alternative to @@
+
+class Object
+  def deep_clone; Marshal::load(Marshal.dump(self)); end
+end
+
+module ClassAttributes
+
+  def cattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @cattr ||= []
+    @cattr.concat(args)
+  end
+
+  def iattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @iattr ||= []
+    @iattr.concat(args)
+  end
+
+  def oattr(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @oattr ||= []
+    @oattr.concat(args)
+  end
+
+  def oattr_i(*args, &block)
+    (class << self; self; end).class_eval do
+      attr_accessor *args
+    end
+    @oattr_i ||= []
+    @oattr_i.concat(args)
+  end
+
+  def co_attr(*args, &block)
+    cattr(*args,&block)
+    oattr(*args,&block)    
+  end
+
+  def co_attr_i(*args, &block)
+    iattr(*args,&block)
+    oattr_i(*args,&block)
+  end
+
+  alias_method :class_inherited_attribute_shared,                 :cattr
+  alias_method :class_inherited_attribute_independant,            :iattr
+
+  alias_method :object_inherited_attribute_shared,                :oattr
+  alias_method :object_inherited_attribute_independant,           :oattr_i
+
+  alias_method :class_and_object_shared_inherited_attribute,      :co_attr
+  alias_method :class_and_object_independant_inherited_attribute, :co_attr_i
+
+  def inherited(subclass)
+    super(subclass) if respond_to?('super')
+    iattr.each do |a|
+      # puts "a=#{a}"
+      subclass.send("#{a}=", send(a).deep_clone)
+      subclass.send("iattr", a.to_sym)
+    end
+    cattr.each do |a|
+      subclass.send("#{a}=", send(a))
+      subclass.send("cattr", a.to_sym)
+    end
+    oattr.each do |a|
+      subclass.send("oattr", a.to_sym)
+    end
+    oattr_i.each do |a|
+      subclass.send("oattr_i", a.to_sym)
+    end
+    subclass.send(:inherit) if subclass.respond_to?('inherit')
+  end
+
+  def inherit(*args, &block)
+    super if respond_to?('super')
+  end
+end
+
+module ObjectPreInitialize
+  private
+  def pre_initialize(*args, &block)
+    super if respond_to?('super')
+
+    class_attrs = self.class.cattr + self.class.iattr
+
+    self.class.oattr.each do |a|
+      sac = self.class.send(a)
+      eval "@#{a.to_s}=sac" if class_attrs.include? a
+    end
+
+    self.class.oattr_i.each do |a|
+      sac = self.class.send(a)
+      eval "@#{a.to_s}=sac.deep_clone" if class_attrs.include? a
+    end
+  end
+
+  # def postinitialize(*args, &block)
+  # end
+end
+
+module OverloadNew
+  def new(*args, &block)
+    newObj = self.allocate
+    newObj.send :extend, ObjectPreInitialize
+    newObj.send :pre_initialize, *args, &block
+    newObj.send :initialize,     *args, &block
+    # newObj.send :postinitialize, *args, &block
+    return newObj
+  end
+end
+
+def has_class_attributes
+  extend ClassAttributes
+end
+
+def has_class_object_attributes
+  extend ClassAttributes
+  extend OverloadNew
+end
+
+

data/lib/plist4r/mixin/data_methods.rb

@@ -0,0 +1,63 @@
+
+require 'plist4r/mixins/ordered_hash'
+
+module Plst4r::DataMethods
+
+  def classes_for_key_type
+    {
+      :string => [String], 
+      :bool => [TrueClass,FalseClass],
+      :integer => [Fixnum], 
+      :array_of_strings => [Array],
+      :hash_of_bools => [Hash],
+      :hash => [Hash],
+      :bool_or_string_or_array_of_strings => [TrueClass,FalseClass,String,Array]
+    }
+  end
+
+  def valid_keys
+    {}
+  end
+
+  def method_missing method_symbol, *args, &blk
+    puts "method_missing: #{method_symbol.inspect}, args: #{args.inspect}"
+    valid_keys.each do |key_type, valid_keys_of_those_type|
+      if valid_keys_of_those_type.include?(method_symbol.to_s.camelcase)
+        puts "key_type = #{key_type}, method_symbol.to_s.camelcase = #{method_symbol.to_s.camelcase}, args = #{args.inspect}"
+        return eval("set_or_return key_type, method_symbol.to_s.camelcase, *args, &blk")
+      end
+    end
+  end
+
+  def validate_value key_type, key, value
+    unless classes_for_key_type[key_type].include? value.class
+      raise "Key: #{key}, value: #{value.inspect} is of type #{value.class}. Should be: #{classes_for_key_type[key_type].join ", "}"
+    end
+    case key_type
+    when :array_of_strings, :bool_or_string_or_array_of_strings
+      if value.class == Array
+        value.each_index do |i|
+          unless value[i].class == String
+            raise "Element: #{key}[#{i}], value: #{value[i].inspect} is of type #{value[i].class}. Should be: #{classes_for_key_type[:string].join ", "}"
+          end
+        end
+      end
+    when :hash_of_bools
+      value.each do |k,v|
+        unless [TrueClass,FalseClass].include? v.class
+          raise "Key: #{key}[#{k}], value: #{v.inspect} is of type #{v.class}. Should be: #{classes_for_key_type[:bool].join ", "}"
+        end
+      end
+    end
+  end
+
+  def set_or_return key_type, key, value=nil
+    puts "#{method_name}, key_type: #{key_type.inspect}, value: #{value.inspect}"
+    if value
+      validate_value key_type, key, value unless key_type == nil
+      @hash[key] = value
+    else
+      @orig[key]
+    end
+  end
+end

data/lib/plist4r/mixin/mixlib_config.rb

@@ -0,0 +1,178 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Nuo Yan (<nuo@opscode.com>)
+# Author:: Christopher Brown (<cb@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Object # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+  def meta_def name, &blk
+    (class << self; self; end).instance_eval { define_method name, &blk }
+  end
+end
+
+module Mixlib
+  module Config
+
+    def self.extended(base)
+      class << base; attr_accessor :configuration; end
+      base.configuration = Hash.new
+    end 
+    
+    # Loads a given ruby file, and runs instance_eval against it in the context of the current 
+    # object.  
+    #
+    # Raises an IOError if the file cannot be found, or is not readable.
+    #
+    # === Parameters
+    # <string>:: A filename to read from
+    def from_file(filename)
+      self.instance_eval(IO.read(filename), filename, 1)
+    end
+    
+    # Pass Mixlib::Config.configure() a block, and it will yield self.configuration.
+    #
+    # === Parameters
+    # <block>:: A block that is sent self.configuration as its argument
+    def configure(&block)
+      block.call(self.configuration)
+    end
+    
+    # Get the value of a configuration option
+    #
+    # === Parameters
+    # config_option<Symbol>:: The configuration option to return
+    #
+    # === Returns
+    # value:: The value of the configuration option
+    #
+    # === Raises
+    # <ArgumentError>:: If the configuration option does not exist
+    def [](config_option)
+      self.configuration[config_option.to_sym]
+    end
+      
+    # Set the value of a configuration option
+    #
+    # === Parameters
+    # config_option<Symbol>:: The configuration option to set (within the [])
+    # value:: The value for the configuration option
+    #
+    # === Returns
+    # value:: The new value of the configuration option
+    def []=(config_option, value)
+      internal_set(config_option,value)
+    end
+    
+    # Check if Mixlib::Config has a configuration option.
+    #
+    # === Parameters
+    # key<Symbol>:: The configuration option to check for
+    #
+    # === Returns
+    # <True>:: If the configuration option exists
+    # <False>:: If the configuration option does not exist
+    def has_key?(key)
+      self.configuration.has_key?(key.to_sym)
+    end
+
+    # Merge an incoming hash with our config options
+    #
+    # === Parameters
+    # hash<Hash>:: The incoming hash
+    #
+    # === Returns
+    # result of Hash#merge!
+    def merge!(hash)
+      self.configuration.merge!(hash)
+    end
+    
+    # Return the set of config hash keys
+    #
+    # === Returns
+    # result of Hash#keys
+    def keys
+      self.configuration.keys
+    end
+    
+    # Creates a shallow copy of the internal hash
+    #
+    # === Returns
+    # result of Hash#dup
+    def hash_dup
+      self.configuration.dup
+    end
+    
+    # Internal dispatch setter, calling either the real defined method or setting the
+    # hash value directly
+    #
+    # === Parameters
+    # method_symbol<Symbol>:: Name of the method (variable setter)
+    # value<Object>:: Value to be set in config hash
+    #      
+    def internal_set(method_symbol,value)
+      method_name = method_symbol.id2name
+      if (self.public_methods - ["[]="]).include?("#{method_name}=")
+        self.send("#{method_name}=", value)
+      else
+        self.configuration[method_symbol] = value
+      end
+    end
+
+    protected :internal_set
+    
+    # metaprogramming to ensure that the slot for method_symbol 
+    # gets set to value after any other logic is run
+    # === Parameters
+    # method_symbol<Symbol>:: Name of the method (variable setter)
+    # blk<Block>:: logic block to run in setting slot method_symbol to value
+    # value<Object>:: Value to be set in config hash
+    #          
+    def config_attr_writer(method_symbol, &blk)
+      method_name = "#{method_symbol.to_s}="
+      meta_def method_name do |value|
+        self.configuration[method_symbol] = blk.call(value)
+      end
+    end
+
+    # Allows for simple lookups and setting of configuration options via method calls
+    # on Mixlib::Config.  If there any arguments to the method, they are used to set
+    # the value of the configuration option.  Otherwise, it's a simple get operation.
+    #
+    # === Parameters
+    # method_symbol<Symbol>:: The method called.  Must match a configuration option.
+    # *args:: Any arguments passed to the method
+    #
+    # === Returns
+    # value:: The value of the configuration option.
+    #
+    # === Raises
+    # <ArgumentError>:: If the method_symbol does not match a configuration option.
+    def method_missing(method_symbol, *args)
+      num_args = args.length
+      # Setting
+      if num_args > 0
+        method_symbol = $1.to_sym unless (method_symbol.to_s =~ /(.+)=$/).nil?
+        internal_set method_symbol, (num_args == 1 ? args[0] : args)
+      end
+      
+      # Returning
+      self.configuration[method_symbol]        
+
+    end
+  end
+end
+