plist4r 0.2.1 → 0.2.2

data/lib/plist4r/commands.rb

@@ -0,0 +1,61 @@
+require 'plist4r/config'
+require 'fileutils'
+
+module Plist4r
+  # This objects manages all of the commands to be executed by an instance of {Plist4r::Application}
+  # @see Plist4r::Application
+  # @see Plist4r::CLI
+  class Commands
+    PriorityOrder = [:ruby_lib]
+
+    # To be executed once. Branches out to subroutines, and handles the order-of-execution of
+    # those main subrountines.
+    def run
+      PriorityOrder.each do |command|
+        send command if self.class.method_defined?(command) && Plist4r::Config[:args][command]
+      end
+
+      left_to_execute = Plist4r::Config[:args].keys - PriorityOrder
+      Plist4r::Config[:args].each do |command, value|
+        send command if left_to_execute.include?(command) && self.class.method_defined?(command) && value
+      end
+    end
+
+    # Implements the `plist4r --ruby-lib` subcommand.
+    # @see Plist4r::CLI
+    def ruby_lib
+      plist4r_lib = File.expand_path "../../lib", File.dirname(__FILE__)
+      dest = File.expand_path(Plist4r::Config[:args][:dir] || FileUtils.pwd)
+
+      raise "sorry, cant write to the same source and destination" if plist4r_lib == dest
+      raise "sorry, cant write to a destination within the source folder" if dest =~ /^#{plist4r_lib}/
+
+      FileUtils.mkdir_p dest
+      FileUtils.rm_rf "#{dest}/plist4r"
+      FileUtils.cp_r Dir.glob("#{plist4r_lib}/*"), dest
+      
+      if Plist4r::Config[:args][:brew]
+        backends = Dir.glob "#{dest}/plist4r/backend/*"
+        non_brew_files = [
+          backends - ["#{dest}/plist4r/backend/ruby_cocoa.rb"],
+          "#{dest}/plist4r/mixin/mixlib_cli.rb",
+          "#{dest}/plist4r/options.rb",
+          "#{dest}/plist4r/commands.rb",
+          "#{dest}/plist4r/application.rb",
+          # "#{dest}/plist4r/",
+        ].flatten
+        FileUtils.rm_rf(non_brew_files)
+
+        config = File.read "#{dest}/plist4r/config.rb"
+        config.gsub! /\n(\s*)backends \[.*\](\s*)\n/ do |match|
+          "\n#{$1}backends [\"ruby_cocoa\"]#{$2}\n"
+        end
+
+        File.open("#{dest}/plist4r/config.rb",'w') do |o|
+          o << config
+        end
+      end
+
+    end
+  end
+end

data/lib/plist4r/config.rb

@@ -4,6 +4,26 @@ require 'plist4r/backend'
 Dir.glob(File.dirname(__FILE__) + "/backend/**/*.rb").each {|b| require File.expand_path b}
 
 module Plist4r
+
+  # The special configuration object, which holds all runtime defaults for individual plist instances.
+  # When we create a new {Plist4r::Plist} object, it will inherit these defaults.
+  # @example 
+  # # Reverse the priority order of backends
+  # Plist4r::Config[:backends].reverse!
+  # 
+  # # Set the default folder from which to load / save plist files
+  # Plist4r::Config[:default_path] "/path/to/my/plist/files"
+  # 
+  # # Save new plist files as binary plists (when format not known)
+  # Plist4r::Config[:default_format] :binary
+  # 
+  # # Add custom / application specific Plist Type. You'll also need to subclass {Plist4r::PlistType}
+  # Expects class Plist4r::PlistType::MyPlistType to be defined
+  # require 'my_plist_type.rb'
+  # Plist4r::Config[:types] << "my_plist_type"
+  # 
+  # # Raise an exception plist keys which dont belong to the selected Plist type
+  # Plist4r::Config[:strict_keys] true
   class Config
     extend Mixlib::Config
 
@@ -14,7 +34,7 @@ module Plist4r
     backends << Dir.glob(File.dirname(__FILE__) + "/backend/**/*.rb").collect {|b| File.basename(b,".rb") }
     backends.flatten!.uniq!
 
-    unsupported_keys true
+    strict_keys false
     raise_any_failure true
     deafult_format :xml
     default_path nil

data/lib/plist4r/mixin/data_methods.rb

@@ -24,7 +24,6 @@ module Plist4r
     def method_missing method_symbol, *args, &blk
       # puts "method_missing: #{method_symbol.inspect}, args: #{args.inspect}"
       # puts "@hash = #{@hash.inspect}"
-      # puts "hi"
       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}"
@@ -32,9 +31,8 @@ module Plist4r
           return set_or_return key_type, method_symbol.to_s.camelcase, *args, &blk
         end
       end
-      # puts "there"
       # puts @plist.inspect
-      if @plist.unsupported_keys
+      unless @plist.strict_keys
         key_type = nil
         # return eval("set_or_return key_type, method_symbol.to_s.camelcase, *args, &blk")
         return set_or_return key_type, method_symbol.to_s.camelcase, *args, &blk
@@ -66,6 +64,28 @@ module Plist4r
       end
     end
 
+    # Set a plist key to a specific value
+    # @param [String] The Plist key, as-is
+    # @param value A ruby object (Hash, String, Array, etc) to set as the value of the plist key
+    # @example
+    # plist.set "CFBundleIdentifier", "com.apple.myapp"
+    # @see #set_or_return
+    def set key, value
+      set_or_return nil, key, value
+    end
+
+    # Return the value of an existing plist key
+    # @return The key's current value, at the time this method was called 
+    # @see #set_or_return
+    def value_of key
+      set_or_return nil, key
+    end
+
+    # Set or return a plist key, value pair
+    # @param [Symbol, nil] key_type The type of class which the value of the key must belong to. Used for validity check.
+    # If key_type is set to nil, then skip value data check
+    # @return the key's value
+    # @see #validate_value
     def set_or_return key_type, key, value=nil
       # puts "#{method_name}, key_type: #{key_type.inspect}, key: #{key.inspect}, value: #{value.inspect}"
       if value

data/lib/plist4r/mixin/mixlib_cli.rb

@@ -0,0 +1,199 @@
+
+require 'optparse'
+
+module Plist4r
+  module Mixlib
+    #
+    # Author:: Adam Jacob (<adam@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.
+    #
+    module CLI
+      module ClassMethods       
+        # Add a command line option.
+        #
+        # === Parameters
+        # name<Symbol>:: The name of the option to add
+        # args<Hash>:: A hash of arguments for the option, specifying how it should be parsed.
+        # === Returns
+        # true:: Always returns true.
+        def option(name, args)
+          @options ||= {}
+          raise(ArgumentError, "Option name must be a symbol") unless name.kind_of?(Symbol)
+          @options[name.to_sym] = args
+        end
+      
+        # Get the hash of current options.
+        #
+        # === Returns
+        # @options<Hash>:: The current options hash.
+        def options
+          @options ||= {}
+          @options
+        end
+      
+        # Set the current options hash
+        #
+        # === Parameters
+        # val<Hash>:: The hash to set the options to
+        #
+        # === Returns
+        # @options<Hash>:: The current options hash.
+        def options=(val)
+          raise(ArgumentError, "Options must recieve a hash") unless val.kind_of?(Hash)
+          @options = val
+        end
+      
+        # Change the banner.  Defaults to:
+        #   Usage: #{0} (options)
+        #
+        # === Parameters
+        # bstring<String>:: The string to set the banner to
+        # 
+        # === Returns
+        # @banner<String>:: The current banner
+        def banner(bstring=nil)
+          if bstring
+            @banner = bstring
+          else
+            @banner ||= "Usage: #{$0} (options)"
+            @banner
+          end
+        end
+      end
+    
+      attr_accessor :options, :config, :banner, :opt_parser
+    
+      # Create a new Mixlib::CLI class.  If you override this, make sure you call super!
+      #
+      # === Parameters
+      # *args<Array>:: The array of arguments passed to the initializer
+      #
+      # === Returns
+      # object<Mixlib::Config>:: Returns an instance of whatever you wanted :)
+      def initialize(*args)
+        @options = Hash.new
+        @config  = Hash.new
+      
+        # Set the banner
+        @banner  = self.class.banner
+      
+        # Dupe the class options for this instance
+        klass_options = self.class.options
+        klass_options.keys.inject(@options) { |memo, key| memo[key] = klass_options[key].dup; memo }
+      
+        # Set the default configuration values for this instance
+        @options.each do |config_key, config_opts|
+          config_opts[:on] ||= :on
+          config_opts[:boolean] ||= false
+          config_opts[:required] ||= false
+          config_opts[:proc] ||= nil
+          config_opts[:show_options] ||= false
+          config_opts[:exit] ||= nil
+        
+          if config_opts.has_key?(:default)
+            @config[config_key] = config_opts[:default]
+          end
+        end
+      
+        super(*args)
+      end
+    
+      # Parses an array, by default ARGV, for command line options (as configured at 
+      # the class level).
+      # === Parameters
+      # argv<Array>:: The array of arguments to parse; defaults to ARGV
+      #
+      # === Returns
+      # argv<Array>:: Returns any un-parsed elements.
+      def parse_options(argv=ARGV)
+        argv = argv.dup
+        @opt_parser = OptionParser.new do |opts|  
+          # Set the banner
+          opts.banner = banner        
+        
+          # Create new options
+          options.sort { |a, b| a[0].to_s <=> b[0].to_s }.each do |opt_key, opt_val|          
+            opt_args = build_option_arguments(opt_val)
+          
+            opt_method = case opt_val[:on]
+              when :on
+                :on
+              when :tail
+                :on_tail
+              when :head
+                :on_head
+              else
+                raise ArgumentError, "You must pass :on, :tail, or :head to :on"
+              end
+                      
+            parse_block = case opt_val[:boolean]
+              when true
+                Proc.new() do
+                  config[opt_key] = (opt_val[:proc] && opt_val[:proc].call(true)) || true
+                  puts opts if opt_val[:show_options]
+                  exit opt_val[:exit] if opt_val[:exit]
+                end
+              when false
+                Proc.new() do |c|
+                  config[opt_key] = (opt_val[:proc] && opt_val[:proc].call(c)) || c
+                  puts opts if opt_val[:show_options]
+                  exit opt_val[:exit] if opt_val[:exit]
+                end
+              end
+                    
+            full_opt = [ opt_method ]
+            opt_args.inject(full_opt) { |memo, arg| memo << arg; memo }
+            full_opt << parse_block
+            opts.send(*full_opt)
+          end
+        end
+        @opt_parser.parse!(argv)
+      
+        # Deal with any required values
+        options.each do |opt_key, opt_value|
+          if opt_value[:required] && ! config[opt_key]
+            reqarg = opt_value[:short] || opt_value[:long]
+            puts "You must supply #{reqarg}!"
+            puts @opt_parser
+            exit 2
+          end
+        end
+      
+        argv
+      end
+    
+      def build_option_arguments(opt_setting)      
+        arguments = Array.new
+      
+        arguments << opt_setting[:short] if opt_setting.has_key?(:short)
+        arguments << opt_setting[:long] if opt_setting.has_key?(:long)
+      
+        if opt_setting.has_key?(:description)
+          description = opt_setting[:description]
+          description << " (required)" if opt_setting[:required]
+          arguments << description
+        end
+          
+        arguments
+      end
+    
+      def self.included(receiver)
+        receiver.extend(Mixlib::CLI::ClassMethods)
+      end
+    
+    end
+  end
+end

data/lib/plist4r/mixin/mixlib_config.rb

@@ -1,178 +1,184 @@
-#
-# 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
+class Object
+  # http://dannytatom.github.com/metaid
+  # 
+  # http://www.bestechvideos.com/2008/07/01/ruby-plus-59-ruby-metaclasses-part-5
+  # 
+  # @see Plist4r::Mixlib::Config
   def meta_def name, &blk
     (class << self; self; end).instance_eval { define_method name, &blk }
   end
 end
 
-module Mixlib
-  module Config
+module Plist4r
+  module Mixlib
+    #
+    # 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.
+    #
+    module Config
 
-    def self.extended(base)
-      class << base; attr_accessor :configuration; end
-      base.configuration = Hash.new
-    end 
+      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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
+      # 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
-    end
 
-    protected :internal_set
+      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)
+      # 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
-    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
+      # 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]        
+        # Returning
+        self.configuration[method_symbol]        
 
+      end
     end
   end
 end
-