plist4r 0.2.2 → 1.0.0

data/lib/plist4r/mixin/haml4r/table_section.rb

@@ -0,0 +1,101 @@
+
+require 'plist4r/mixin/haml4r/table_cells'
+
+module Haml4r
+
+  # A TableSection is a container object. Its responsibility is to forward messages to
+  # the TableCells instance object. TableSection also holds css attributes for that 
+  # sub-section (if applicable, these will be applied to thead, and tbody html tags).
+  # 
+  # The TableSection contains other instance objects.
+  # 
+  #   :----------------------------------------------------:
+  #   |                                                    |
+  #   |   :--------------------------------------------:   |
+  #   |   |                                            |   |
+  #   |   |  :-------------------:------------------:  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |    TableCell      |    TableCell     |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  :-------------------:------------------:  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |    TableCell      |    TableCell     |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  |                   |                  |  |   |
+  #   |   |  :- @array ----------:------------------:  |   |
+  #   |   |                 TableCells                 |   |
+  #   |   :- @cells -----------------------------------:   |
+  #   |                    TableSection                    |
+  #   :----------------------------------------------------:
+  #       
+	class TableSection
+
+    def haml
+      @haml ||= <<-'EOC'
+%table
+  %tbody{:class => self.css_class, :id => self.css_id, :style => self.css_style}
+    - @cells.row_range.each do |row|
+      %tr
+        - @cells.col_range.each do |col|
+          - c = @cells.cell col, row
+          - unless c.spanee
+            %td{:class => c.css_class, :id => c.css_id, :style => c.css_style, :colspan => @cells.colspan(col,row), :rowspan => @cells.rowspan(col,row)} #{c.content}
+EOC
+    end
+
+    def to_s
+      require 'haml'
+      engine = ::Haml::Engine.new self.haml
+      rendered_html_output = engine.render self
+    end
+
+    Attributes = Haml4r::CssAttributes
+
+    def initialize *args, &blk
+      @cells ||= TableCells.new *args, &blk
+    end
+
+    def method_missing method_sym, *args, &blk
+      if Attributes.include? method_sym.to_s.chomp('=')
+        set_or_return method_sym.to_s, *args, &blk
+
+      elsif @cells.respond_to? method_sym
+        @cells.send method_sym, *args, &blk
+
+      else
+        super
+      end
+    end
+
+    def respond_to? method_sym
+      return true if Attributes.include? method_sym.to_s.chomp('=')
+      return true if @cells.respond_to? method_sym
+      super
+    end
+
+    def set attribute, value
+      eval "@#{attribute} = value"
+    end
+
+    def value_for attribute
+      eval "@#{attribute}"
+    end
+
+    def set_or_return attribute, value=nil
+      case attribute
+      when /\=$/
+        set attribute.to_s.chomp('='), value
+      else
+        value_for attribute.to_s
+      end
+    end
+
+    def inspect start_col=0
+      @cells.inspect start_col
+    end
+  end
+
+end

data/lib/plist4r/mixin/ordered_hash.rb

@@ -6,8 +6,11 @@ module Plist4r
       # {ActiveSupport::OrderedHash}
       #
       # 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
@@ -65,6 +68,11 @@ module Plist4r
           @keys = other.keys
         end
 
+        def store(key, value)
+          @keys << key if !has_key?(key)
+          super
+        end
+
         def []=(key, value)
           @keys << key if !has_key?(key)
           super
@@ -77,7 +85,7 @@ module Plist4r
           end
           super
         end
-      
+
         def delete_if
           super
           sync_keys!

data/lib/plist4r/mixin/popen4.rb

@@ -15,7 +15,7 @@ module Plist4r
       # 
       # Don't use the "Block form" calling method. It screws up on the pipes IO.
       # 
-      # Use "Simple form", always. Simple form == more robust IO handling.
+      # Use "Simple form", always. Simple form = more robust IO handling.
       #
       # @example Simple form
       #  def popen4_exec stdin_str, cmd, *args

data/lib/plist4r/mixin/ruby_stdlib.rb

@@ -16,14 +16,158 @@ class Object
     end
     nil
   end
+
+  # Make a deep copy of an object. Including a deep copy of all the object's instance data.
+  # @example
+  #  copy_of_obj = obj.deep_clone
+  # @return [Object] A new copy of the object
+  def deep_clone; Marshal::load(Marshal.dump(self)); end
+end
+
+class Array
+  # And array is considered multi-dimensional if all of the first-order elements are also arrays.
+  # @example
+  #  [[1],[2],[3]].multidim?
+  #  => true
+  #  
+  #  [[1],2,[3]].multidim?
+  #  => false
+  # @return [true,false] true for a Multi-Dimensional array, false otherwise
+  def multidim?
+    case self.size
+    when 0
+      false
+    else
+      each do |e|
+        return false unless e.class == Array
+      end
+      true
+    end
+  end
+
+  # Converts an array of values (which must respond to #succ) to an array of ranges. For example,
+  # @example
+  #  [3,4,5,1,6,9,8].to_ranges => [1,3..6,8..9] 
+  def to_ranges
+    array = self.compact.uniq.sort
+    ranges = []
+    if !array.empty?
+      # Initialize the left and right endpoints of the range
+      left, right = array.first, nil
+      array.each do |obj|
+        # If the right endpoint is set and obj is not equal to right's successor 
+        # then we need to create a range.
+        if right && obj != right.succ
+          ranges << Range.new(left,right)
+          left = obj
+        end
+        right = obj
+      end
+      ranges << Range.new(left,right)
+    end
+    ranges
+  end
+end
+
+class Hash
+  def merge_array_of_hashes_of_arrays array_of_hashes_of_arrays
+    a = array_of_hashes_of_arrays
+    raise "not an array_of_hashes_of_arrays" unless a.is_a? Array
+    if a[0].is_a? Hash
+      h = self.deep_clone
+      a.each_index do |i|
+        raise "not an array_of_hashes_of_arrays" unless a[i].is_a? Hash
+        a[i].each do |k,v|
+          raise "not an array_of_hashes_of_arrays" unless v.is_a? Array
+          h[k] = [h[k]].flatten.compact + v
+        end
+      end
+    else
+      raise "not an array_of_hashes_of_arrays"
+    end
+    h
+  end
+
+  def merge_array_of_hashes_of_arrays! array_of_hashes_of_arrays
+    h = merge_array_of_hashes_of_arrays array_of_hashes_of_arrays
+    self.replace h
+    self
+  end
+end
+
+class Range
+  # The Range's computed size, ie the number of elements in range.
+  # @example
+  #  (3..3).size
+  #  => 1
+  #  
+  #  (0..9).size
+  #  => 10
+  # @return The size of the range
+  def size
+    last - first + 1
+  end
+
+  # The intersection of 2 ranges. Returns nil if there are no common elements.
+  # @example
+  #  1..10 & 5..15 => 5..10
+  # @return [Range, nil] The intesection between 2 overlapping ranges, or zero
+  def & other_range
+    case other_range
+    when Range
+      intersection = []
+      each do |i|
+        intersection << i if other_range.include? i
+      end
+      result = intersection.to_ranges
+      case result[0]
+      when Integer
+        return (result[0])..(result[0])
+      when Range, nil
+        return result[0]
+      end
+    else
+      raise "unsupported type"
+    end
+  end
+
+  # Does this range wholely include other_range? (true or false)
+  # @example
+  #  (3..5).include_range? (3..3)
+  #  => true
+  # 
+  #  (0..4).include_range? (6..7)
+  #  => false
+  # @return [true, false]
+  def include_range? other_range
+    case other_range
+    when Range
+      if other_range.first >= self.first && other_range.last <= self.last
+        return true
+      else
+        return false
+      end
+    else
+      raise "unsupported type"
+    end
+  end
 end
 
 class String
+  # The blob status of this string (set this to true if a binary string)
+  attr_accessor :blob
+
+  # Returns whether or not +str+ is a blob.
+  # @return [true,false] If true, this string contains binary data. If false, its a regular string
+  def blob?
+    @blob
+  end
+
   # A Camel-ized string. The reverse of {#snake_case}
   # @example
   #  "my_plist_key".camelcase => "MyPlistKey"
   def camelcase
-    str = self.dup.capitalize.gsub(/[-_.\s]([a-zA-Z0-9])/) { $1.upcase } \
+    str = self.dup.gsub(/(^|[-_.\s])([a-zA-Z0-9])/) { $2.upcase } \
                   .gsub('+', 'x')
   end
 
@@ -36,3 +180,12 @@ class String
   end
 end
 
+class Float
+    alias_method :round_orig, :round
+    # Round to nearest n decimal places
+    # @example
+    #  16.347.round(2) => 16.35
+    def round(n=0)
+        (self * (10.0 ** n)).round_orig * (10.0 ** (-n))
+    end
+end

data/lib/plist4r/mixin/script.rb

@@ -0,0 +1,133 @@
+module Plist4r
+  # A module which is an instance of the Script class encapsulates in its scope
+  # the top-level methods, top-level constants, and instance variables defined in
+  # a ruby script file (and its subfiles) loaded by a ruby program. This allows
+  # use of script files to define objects that can be loaded into a program in
+  # much the same way that objects can be loaded from YAML or Marshal files.
+  #
+  # See intro.txt[link:files/intro_txt.html] for an overview.
+  # 
+  # Usable under the Ruby license. Copyright (C)2004 Joel VanderWerf. Questions to
+  # mailto:vjoel@users.sourceforge.net.
+  class Script < Module
+    # The file with which the Script was instantiated.
+    attr_reader :__main_file
+
+    # The directory in which main_file is located, and relative to which
+    # #load searches for files before falling back to Kernel#load.
+    attr_reader :__dir
+  
+    # A hash that maps <tt>filename=>true</tt> for each file that has been
+    # required locally by the script. This has the same semantics as <tt>$"</tt>,
+    # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+    attr_reader :__loaded_features
+
+    class << self
+      alias load new
+    end
+  
+    # Creates new Script, and loads _main_file_ in the scope of the Script. If a
+    # block is given, the script is passed to it before loading from the file, and
+    # constants can be defined as inputs to the script.
+  
+    def initialize(main_file)   # :yields: self
+      extend ScriptModuleMethods
+      @__main_file = File.expand_path(main_file)
+      @__dir = File.dirname(@__main_file)
+      @__loaded_features = {}
+    
+      yield self if block_given?
+      load_in_module(@__main_file)
+    end
+  
+    # Loads _file_ into this Script. Searches relative to the local dir, that is,
+    # the dir of the file given in the original call to
+    # <tt>Script.load(file)</tt>, loads the file, if found, into this Script's
+    # scope, and returns true. If the file is not found, falls back to
+    # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+    # if found, into global scope, and returns true. Otherwise, raises
+    # <tt>LoadError</tt>.
+    #
+    # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+    # when the file is not found locally.
+    #
+    # Typically called from within the main file to load additional sub files, or
+    # from those sub files.
+  
+    def load(file, wrap = false)
+      load_in_module(file)
+      true
+    rescue MissingFile
+      super
+    end
+
+    # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+    # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+    #
+    # Note that extensions (*.so, *.dll) can be required in the global scope, as
+    # usual, but not in the local scope. (This is not much of a limitation in
+    # practice--you wouldn't want to load an extension more than once.) This
+    # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+    # extension or is not found locally.
+  
+    def require(feature)
+      unless @__loaded_features[feature]
+        @__loaded_features[feature] = true
+        file = feature
+        file += ".rb" unless /\.rb$/ =~ file
+        load_in_module(file)
+      end
+    rescue MissingFile
+      @__loaded_features[feature] = false
+      super
+    end
+  
+    # Raised by #load_in_module, caught by #load and #require.
+    class MissingFile < LoadError; end
+  
+    # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+    # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+    # Called by #load and #require; not normally called directly.
+  
+    def load_in_module(__file__)
+      __file__ = File.expand_path(__file__, @__dir)
+      module_eval("@__script_scope ||= binding\n" + IO.read(__file__),
+        __file__, 0)
+        # start numbering at 0 because of the extra line.
+        # The extra line does nothing in sub-script files.
+    rescue Errno::ENOENT
+      if /#{__file__}$/ =~ $!.message # No extra locals in this scope.
+        raise MissingFile, $!.message
+      else
+        raise
+      end
+    end
+  
+    def to_s # :nodoc:
+      "#<#{self.class}:#{File.join(__dir, File.basename(__main_file))}>"
+    end
+
+    module ScriptModuleMethods
+      # This is so that <tt>def meth...</tt> behaves like in Ruby's top-level
+      # context. The implementation simply calls
+      # <tt>Module#module_function(name)</tt>.
+      def method_added(name) # :nodoc:
+        module_function(name)
+      end
+    
+      attr_reader :__script_scope
+
+      # Gets list of local vars in the script. Does not see local vars in files
+      # loaded or required by that script.
+      def __local_variables
+        eval("local_variables", __script_scope)
+      end
+    
+      # Gets value of local var in the script. Does not see local vars in files
+      # loaded or required by that script.
+      def __local_variable_get(name)
+        eval(name.to_s, __script_scope)
+      end
+    end
+  end
+end