plist4r 0.0.0 → 0.1.0

data/lib/plist4r/mixin/ordered_hash.rb

@@ -0,0 +1,168 @@
+#--
+# Copyright (c) 2005 David Hansson, 
+# Copyright (c) 2007 Mauricio Fernandez, Sam Stephenson
+# Copyright (c) 2008 Steve Purcell, Josh Peek
+# Copyright (c) 2009 Christoffer Sawicki
+#
+# 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.
+#++
+
+# OrderedHash is namespaced to prevent conflicts with other implementations
+module ActiveSupport
+  # Hash is ordered in Ruby 1.9!
+  if RUBY_VERSION >= '1.9'
+    class OrderedHash < ::Hash #:nodoc:
+    end
+  else
+    class OrderedHash < Hash #:nodoc:
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def self.[](*args)
+        ordered_hash = new
+
+        if (args.length == 1 && args.first.is_a?(Array))
+          args.first.each do |key_value_pair|
+            next unless (key_value_pair.is_a?(Array))
+            ordered_hash[key_value_pair[0]] = key_value_pair[1]
+          end
+
+          return ordered_hash
+        end
+
+        unless (args.size % 2 == 0)
+          raise ArgumentError.new("odd number of arguments for Hash")
+        end
+
+        args.each_with_index do |val, ind|
+          next if (ind % 2 != 0)
+          ordered_hash[val] = args[ind + 1]
+        end
+
+        ordered_hash
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def []=(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+      
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        @keys.dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def to_a
+        @keys.map { |key| [ key, self[key] ] }
+      end
+
+      def each_key
+        @keys.each { |key| yield key }
+      end
+
+      def each_value
+        @keys.each { |key| yield self[key]}
+      end
+
+      def each
+        @keys.each {|key| yield [key, self[key]]}
+      end
+
+      alias_method :each_pair, :each
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        other_hash.each {|k,v| self[k] = v }
+        self
+      end
+
+      def merge(other_hash)
+        dup.merge!(other_hash)
+      end
+
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+    private
+
+      def sync_keys!
+        @keys.delete_if {|k| !has_key?(k)}
+      end
+    end
+  end
+end

data/lib/plist4r/mixin/popen4.rb

@@ -0,0 +1,193 @@
+
+
+module Plist4r::Popen4
+
+  # This is taken directly from Ara T Howard's Open4 library, and then 
+  # modified to suit the needs of Chef.  Any bugs here are most likely
+  # my own, and not Ara's.
+  #
+  # The original appears in external/open4.rb in its unmodified form. 
+  #
+  # Thanks Ara!
+  def popen4(cmd, args={}, &b)
+   
+    # Waitlast - this is magic.  
+    # 
+    # Do we wait for the child process to die before we yield
+    # to the block, or after?  That is the magic of waitlast.
+    #
+    # By default, we are waiting before we yield the block.
+    args[:waitlast] ||= false
+    
+    args[:user] ||= nil
+    unless args[:user].kind_of?(Integer)
+      args[:user] = Etc.getpwnam(args[:user]).uid if args[:user]
+    end
+    args[:group] ||= nil
+    unless args[:group].kind_of?(Integer)
+      args[:group] = Etc.getgrnam(args[:group]).gid if args[:group]
+    end
+    args[:environment] ||= {}
+
+    # Default on C locale so parsing commands output can be done
+    # independently of the node's default locale.
+    # "LC_ALL" could be set to nil, in which case we also must ignore it.
+    unless args[:environment].has_key?("LC_ALL")
+      args[:environment]["LC_ALL"] = "C"
+    end
+    
+    pw, pr, pe, ps = IO.pipe, IO.pipe, IO.pipe, IO.pipe
+
+    verbose = $VERBOSE
+    begin
+      $VERBOSE = nil
+      ps.last.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
+
+      cid = fork {
+        pw.last.close
+        STDIN.reopen pw.first
+        pw.first.close
+
+        pr.first.close
+        STDOUT.reopen pr.last
+        pr.last.close
+
+        pe.first.close
+        STDERR.reopen pe.last
+        pe.last.close
+
+        STDOUT.sync = STDERR.sync = true
+
+        if args[:group]
+          Process.egid = args[:group]
+          Process.gid = args[:group]
+        end
+
+        if args[:user]
+          Process.euid = args[:user]
+          Process.uid = args[:user]
+        end
+        
+        args[:environment].each do |key,value|
+          ENV[key] = value
+        end
+
+        if args[:umask]
+          umask = ((args[:umask].respond_to?(:oct) ? args[:umask].oct : args[:umask].to_i) & 007777)
+          File.umask(umask)
+        end
+        
+        begin
+          if cmd.kind_of?(Array)
+            exec(*cmd)
+          else
+            exec(cmd)
+          end
+          raise 'forty-two' 
+        rescue Exception => e
+          Marshal.dump(e, ps.last)
+          ps.last.flush
+        end
+        ps.last.close unless (ps.last.closed?)
+        exit!
+      }
+    ensure
+      $VERBOSE = verbose
+    end
+
+    [pw.first, pr.last, pe.last, ps.last].each{|fd| fd.close}
+
+    begin
+      e = Marshal.load ps.first
+      raise(Exception === e ? e : "unknown failure!")
+    rescue EOFError # If we get an EOF error, then the exec was successful
+      42
+    ensure
+      ps.first.close
+    end
+
+    pw.last.sync = true
+
+    pi = [pw.last, pr.first, pe.first]
+
+    if b 
+      begin
+        if args[:waitlast]
+          b[cid, *pi]
+          # send EOF so that if the child process is reading from STDIN
+          # it will actually finish up and exit
+          pi[0].close_write
+          Process.waitpid2(cid).last
+        else
+          # This took some doing.
+          # The trick here is to close STDIN
+          # Then set our end of the childs pipes to be O_NONBLOCK
+          # Then wait for the child to die, which means any IO it
+          # wants to do must be done - it's dead.  If it isn't,
+          # it's because something totally skanky is happening,
+          # and we don't care.
+          o = StringIO.new
+          e = StringIO.new
+
+          pi[0].close
+          
+          stdout = pi[1]
+          stderr = pi[2]
+
+          stdout.sync = true
+          stderr.sync = true
+
+          stdout.fcntl(Fcntl::F_SETFL, pi[1].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+          stderr.fcntl(Fcntl::F_SETFL, pi[2].fcntl(Fcntl::F_GETFL) | Fcntl::O_NONBLOCK)
+          
+          stdout_finished = false
+          stderr_finished = false
+         
+          results = nil
+
+          while !stdout_finished || !stderr_finished
+            begin
+              channels_to_watch = []
+              channels_to_watch << stdout if !stdout_finished
+              channels_to_watch << stderr if !stderr_finished
+              ready = IO.select(channels_to_watch, nil, nil, 1.0)
+            rescue Errno::EAGAIN
+            ensure
+              results = Process.waitpid2(cid, Process::WNOHANG)
+              if results
+                stdout_finished = true
+                stderr_finished = true 
+              end
+            end
+
+            if ready && ready.first.include?(stdout)
+              line = results ? stdout.gets(nil) : stdout.gets
+              if line
+                o.write(line)
+              else
+                stdout_finished = true
+              end
+            end
+            if ready && ready.first.include?(stderr)
+              line = results ? stderr.gets(nil) : stderr.gets
+              if line
+                e.write(line)
+              else
+                stderr_finished = true
+              end
+            end
+          end
+          results = Process.waitpid2(cid) unless results
+          o.rewind
+          e.rewind
+          b[cid, pi[0], o, e]
+          results.last
+        end
+      ensure
+        pi.each{|fd| fd.close unless fd.closed?}
+      end
+    else
+      [cid, pw.last, pr.first, pe.first]
+    end
+  end
+end

data/lib/plist4r/mixin/ruby_stdlib.rb

@@ -0,0 +1,24 @@
+
+
+class Object
+  def method_name
+    if  /`(.*)'/.match(caller.first)
+      return $1
+    end
+    nil
+  end
+end
+
+
+class String
+  def camelcase
+    str = self.dup.capitalize.gsub(/[-_.\s]([a-zA-Z0-9])/) { $1.upcase } \
+                  .gsub('+', 'x')
+  end
+
+  def snake_case
+    str = self.dup.gsub(/[A-Z]/) {|s| "_" + s}
+    str = str.downcase.sub(/^\_/, "")
+  end
+end
+

data/lib/plist4r/plist.rb

@@ -0,0 +1,256 @@
+
+require 'plist4r/mixin/ordered_hash'
+require 'plist4r/plist_type'
+require 'plist4r/backend'
+
+
+class Plist4r::Plist
+  PlistOptionsHash = %w[from_string filename path file_format plist_type unsupported_keys]
+  FileFormats      = %w[binary xml next_step]
+  
+  def initialize *args, &blk
+    @hash             = ::ActiveSupport::OrderedHash.new
+    @plist_cache      = PlistCache.new self
+    @plist_type       = plist_type PlistType::Plist
+    @unsupported_keys = Config[:unsupported_keys]
+    @from_string      = nil
+    @filename         = nil
+    @file_format      = nil
+    @path             = Config[:default_path]
+
+    case args.first
+    when Hash
+      parse_opts args.first
+
+    when String, Symbol
+      @filename = args.first.to_s
+    when nil
+    else
+      raise "Unrecognized first argument: #{args.first.inspect}"
+    end
+  end
+
+  def from_string string=nil
+    case string
+    when String
+      plist_format = ::Plist4r.string_detect_format string
+      if plist_format
+        eval "@plist_cache.from_#{format}, string"
+      else
+        raise "Unknown plist format for string: #{string}"
+      end
+      @from_string = string
+    when nil
+      @from_string
+    else
+      raise "Please specify a string of plist data"
+    end
+  end
+
+  def filename filename=nil
+    case filename
+    when String
+      @filename = filename
+    when nil
+      @filename
+    else
+      raise "Please specify a filename"
+    end
+  end
+
+  def path path=nil
+    case path
+    when String
+      @path = path
+    when nil
+      @path
+    else
+      raise "Please specify a directory"
+    end
+  end
+
+  def filename_path filename_path=nil
+    case path
+    when String
+      @filename = File.basename filename_path
+      @path     = File.dirname  filename_path
+    when nil
+      File.expand_path @filename, @path    
+    else
+      raise "Please specify directory + filename"
+    end
+  end
+
+  def file_format file_format=nil
+    begin
+      case file_format
+      when Symbol, String
+        if FileFormats.include? file_format.to_s.snake_case
+          @file_format = file_format.to_s.snake_case
+        else
+          raise "Unrecognized plist file format: \"#{file_format.inspect}\". Please specify a valid plist file format, #{FileFormats.inspect}"
+        end
+      when nil
+        @file_format
+      else
+        raise "Please specify a valid plist file format, #{FileFormats.inspect}"
+      end
+    rescue
+      raise "Please specify a valid plist file format, #{FileFormats.inspect}"
+    end
+  end
+
+  def plist_type plist_type=nil
+    begin
+      case plist_type
+      when Class
+        @plist_type = PlistType::Plist.new :hash => @hash
+      when Symbol, String
+        eval "pt_klass = PlistType::#{plist_type.to_s.camelcase}"
+        @plist_type = pt_klass.new :hash => @hash
+      when nil
+        @plist_type
+      else
+        raise "Please specify a valid plist class name, eg ::Plist4r::PlistType::ClassName, \"class_name\" or :class_name"
+      end
+    rescue
+      raise "Please specify a valid plist class name, eg ::Plist4r::PlistType::ClassName, \"class_name\" or :class_name"
+    end
+  end
+  
+  def unsupported_keys bool
+    case bool
+    when true,false
+      @unsupported_keys = bool
+    when nil
+      @unsupported_keys
+    else
+      raise "Please specify true or false to enable / disable this option"
+    end
+  end
+  
+  def parse_opts opts
+    PlistOptionsHash.each do |opt|
+      eval "@#{opt} = #{opts[opt.to_sym]}" if opts[opt.to_sym]
+    end
+  end
+
+  def open filename=nil
+    @filename = filename if filename
+    raise "No filename specified" unless @filename
+    @hash = @plist_cache.open
+  end
+
+  def << *args, &blk
+    edit *args, &blk
+  end
+
+  def edit *args, &blk
+    instance_eval &blk
+  end
+  
+  def method_missing method_sym, *args, &blk
+    @plist_type.send method_sym, *args, &blk
+  end
+  
+  def import_hash hash=nil
+    case path
+    when ::ActiveSupport::OrderedHash
+      @hash = hash
+    when nil
+      @hash = ::ActiveSupport::OrderedHash.new
+    else
+      raise "Please use ::ActiveSupport::OrderedHash.new for your hashes"
+    end
+  end
+  
+  def to_hash
+    @hash
+  end
+  
+  def to_xml
+    @plist_cache.to_xml
+  end
+  
+  def to_binary
+    @plist_cache.to_binary
+  end
+
+  def to_next_step
+    @plist_cache.to_next_step
+  end
+  
+  def save
+    raise "No filename specified" unless @filename
+    @plist_cache.save
+  end
+  
+  def save_as filename
+    @filename = filename
+    save
+  end
+end
+
+
+
+# plutil -convert xml1 @filename
+# plutil -convert binary1 @filename
+
+
+module Plist4r
+  class Plist
+    include ::Plist4r::Popen4
+  
+    def initialize path_prefix, plist_str, &blk
+      plist_str << ".plist" unless plist_str =~ /\.plist$/
+
+      @filename = nil
+      if plist_str =~ /^\//
+        @filename = plist_str
+      else
+        @filename = "#{path_prefix}/#{plist_str}"
+      end
+    
+      @label = @filename.match(/^.*\/(.*)\.plist$/)[1]
+      @shortname = @filename.match(/^.*\.(.*)$/)[1]
+
+      @block = blk
+      @hash = @orig = ::ActiveSupport::OrderedHash.new
+
+      instance_eval(&@block) if @block
+    end
+
+    def finalize
+      if File.exists? @filename
+        if override_plist_keys?
+          # @hash = @obj = ::LibxmlLaunchdPlistParser.new(@filename).plist_struct
+          # eval_plist_block(&@block) if @block
+          write_plist
+        end
+      else
+        write_plist
+      end
+      validate
+    end
+  
+    def override_plist_keys?
+      return true unless @label == @filename.match(/^.*\/(.*)\.plist$/)[1]
+      vars = self.instance_variables - ["@filename","@label","@shortname","@block","@hash","@obj"]
+      return true unless vars.empty?
+    end
+
+    def write_plist
+      require 'haml'
+      engine = Haml::Engine.new File.read("launchd_plist.haml")
+      rendered_xml_output = engine.render self
+      File.open(@filename,'w') do |o|
+        o << rendered_xml_output
+      end
+
+    end
+
+    def validate
+      system "/usr/bin/plutil #{@filename}"
+    end
+  end
+end