media_processing_tool 1.0.0

data/lib/final_cut_pro/xml_parser.rb

@@ -0,0 +1,15 @@
+require 'final_cut_pro/xml_parser/document'
+module FinalCutPro
+  class XMLParser
+
+    def self.load(xml, options = { })
+      return Document.load(xml, options = { })
+    end # self.load
+
+    def self.parse(xml, options = { })
+      doc = load(xml, options)
+      doc.parse
+    end # self.parse
+
+  end
+end

data/lib/final_cut_pro/xml_parser/common.rb

@@ -0,0 +1,121 @@
+require 'axml'
+require 'cgi'
+require 'uri'
+require 'final_cut_pro'
+
+module FinalCutPro
+  class XMLParser
+    class Common
+
+      attr_accessor :logger
+      attr_accessor :sequences, :files
+
+      def self.xml_as_document(xml, options = { })
+        AXML.xml_as_document(xml)
+      end # xml_as_document
+
+      def initialize(xml, options = { })
+        @logger = FinalCutPro.process_options_for_logger(options)
+        @xml_document = xml_as_document(xml)
+      end # initialize
+
+      def xml_as_document(xml)
+        self.class.xml_as_document(xml)
+      end # xml_as_document
+
+      def to_hash(keys_to_symbols = true)
+        rt = keys_to_symbols ? root_type.to_sym : root_type
+        { rt => xml_node_to_hash(root, keys_to_symbols) }
+      end # to_hash
+
+      def xml_node_to_hash(node, keys_to_symbols = true)
+        # If we are at the root of the document, start the hash
+        return node.content.to_s unless node.element?
+        result_hash = {}
+
+        # Add the attributes for the node to the hash
+        node.each_attr { |a| a_name = keys_to_symbols ? a.name.to_sym : a.name; result_hash[a_name] = a.value }
+        return result_hash.empty? ? nil : result_hash unless node.children?
+
+        node.each_child do |child|
+          result = xml_node_to_hash(child, keys_to_symbols)
+
+          if child.name == 'text' or child.cdata?
+            return result if !child.next? and !child.prev?
+            next
+          end
+
+          begin
+            key = keys_to_symbols ? child.name.to_sym : child.name
+          rescue
+            # FCP CDATA Fields usually fail to convert to a sym.
+            logger.error { "Error Converting #{child.name} to symbol.\nCHILD: #{child.inspect}\nNODE: #{node}" }
+            key = child.name
+          end
+          if result_hash[key]
+            # We don't want to overwrite a value for an existing key so the value needs to be an array
+            if result_hash[key].is_a?(Array)
+              result_hash[key] << result
+            else
+              # Create an array
+              result_hash[key] = [ result_hash[key], result ]
+            end
+          else
+            result_hash[key] = result
+          end
+        end
+        return result_hash
+      end # xml_node_to_hash
+
+      def xml_document
+        @xml_document
+      end # xml_document
+      alias :xmldoc :xml_document
+
+      def root
+        xml_document.root
+      end # root
+
+      # Gets the
+      def root_type
+        @root_type ||= root.name
+      end # type
+
+      def is_xmeml?
+        root_type == 'xmeml'
+      end # is_xmeml?
+
+      def is_fcpxml?
+        root_type == 'fcpxml'
+      end # is_fcpxml?
+
+
+      # The fcpxml or xmeml version
+      def version
+        @version ||= root.attributes['version']
+      end
+
+      # The tag inside of the xmeml or fcpxml tag
+      def top_level_container
+        @top_level_container ||= root.children.first.name
+      end #
+
+      def is_clip?
+        top_level_container == 'clip'
+      end # is_clip?
+
+      def is_project?
+        top_level_container == 'project'
+      end # is_project?
+
+      def is_sequence?
+        top_level_container == 'sequence'
+      end # is_sequence?
+
+      def sequences
+        @sequences ||= xml_document.find('//sequence')
+      end # sequences
+
+    end # Common
+  end # XMLParser
+end # FinalCutPro

data/lib/final_cut_pro/xml_parser/document.rb

@@ -0,0 +1,18 @@
+require 'final_cut_pro/xml_parser/common'
+require 'final_cut_pro/xml_parser/xmeml/version_5'
+require 'final_cut_pro/xml_parser/fcpxml/version_1'
+
+module FinalCutPro
+  class XMLParser
+    class Document < Common
+
+      def self.load(xml, options = { })
+        doc = new(xml, options = { })
+        return XMEML::Version5.new(doc.xml_document, options = { }) if doc.is_xmeml?
+        return FCPXML::Version1.new(doc.xml_document, options = { }) if doc.is_fcpxml?
+        return false
+      end # self.load
+
+    end # Document
+  end # XMLParser
+end # FinalCutPro

data/lib/final_cut_pro/xml_parser/fcpxml/version_1.rb

@@ -0,0 +1,28 @@
+# https://developer.apple.com/library/mac/#documentation/FinalCutProX/Reference/FinalCutProXXMLFormat/FCPXMLDTDv1.1/FCPXMLDTDv1.1.html
+require 'final_cut_pro/xml_parser/common'
+module FinalCutPro
+  class XMLParser
+    class FCPXML
+      class Version1 < FinalCutPro::XMLParser::Common
+
+        def self.parse(xml, params = {})
+          parser = new(xml)
+          parser.parse(parser.xml_document, params)
+        end # self.parse
+
+        def parse(xml = @xml_document, options = { })
+          @files = parse_files(xml, options)
+          return self
+        end # parse
+
+        def parse_files(xml = @xml_document, options = { })
+          xml.find('//asset').map do |asset_node|
+            hash = xml_node_to_hash(asset_node)
+            hash.merge!({ :path_on_file_system => CGI::unescape(URI(hash[:src]).path) })
+          end
+        end # parse_files
+
+      end # Version1
+    end # FCPXML
+  end # XMLParser
+end # FinalCutPro

data/lib/final_cut_pro/xml_parser/xmeml/version_5.rb

@@ -0,0 +1,234 @@
+# http://developer.apple.com/library/mac/#documentation/AppleApplications/Reference/FinalCutPro_XML/DTD/DTD.html#//apple_ref/doc/uid/TP30001157-BCIHDFGD
+require 'final_cut_pro/xml_parser/common'
+module FinalCutPro
+  class XMLParser
+    class XMEML
+      class Version5 < FinalCutPro::XMLParser::Common
+
+        def self.parse_clips(xml, options = { })
+          parser = new
+          parser.parse_clips(xml_as_document(xml, options))
+        end # self.parse_clips
+
+        def self.parse_sequences(xml, options = { })
+          parser = new
+          parser.parse_sequences(xml_as_document(xml, options))
+        end # self.parse_sequences
+
+        def self.parse_files(xml, options = { })
+          parser = new
+          parser.parse_files(xml, options)
+        end # self.parse_files
+
+        def get_project_name(node)
+          #@project_name = node.find('ancestor::project').first.find('./name').first.content.to_s
+          project_node = node.find_first('ancestor::project')
+          unless project_node.nil?
+            project_name_node = project_node.find_first('./name')
+            unless project_name_node.nil? or project_name_node.content.nil?
+              project_name = project_name_node.content.to_s
+              return project_name
+            end
+          end
+        end
+
+        def get_bin_path(node)
+          bin_path = []
+          node.find('ancestor::bin').each do |ancestor_node|
+            bin_path << ancestor_node.find('./name').first.content.to_s unless ancestor_node.find('./name').first.content.to_s.empty?
+          end
+          return '' if bin_path.empty?
+          return "/#{bin_path.join('/')}/"
+        end
+
+        def get_clip_hash_by_id(doc, id)
+          #puts "ID: #{id}"
+          id = id.dup.gsub(/["\s]/, ' ' => "\\s", '"' => '&quot;')
+          clip = doc.find("//clip[@id=\"#{id}\"]").first
+          return { } unless clip
+          return xml_node_to_hash(clip) || { }
+        end
+
+        def get_clipitem_hash(node)
+          return xml_node_to_hash(node.parent)
+        end
+
+        def get_file_clipitems(node, file_id = nil)
+
+        end
+
+        def get_all_metadata(node)
+          metadata = {}
+          node.find('descendant::metadata|metadata').each do |metadata_node|
+            metadata[metadata_node.find('./key').first.content.to_s] = metadata_node.find('./value').first.content.to_s unless metadata_node.find('./key').first.nil? or metadata_node.find('./key').first.empty? or  metadata_node.find('./value').first.nil? or  metadata_node.find('./value').first.empty?
+          end
+          return metadata
+        end
+
+        def get_all_labels(node)
+          labels = []
+          node.find('ancestor::bin/labels|ancestor::clip/labels|ancestor::sequence/labels|ancestor::clipitem/labels|ancestor::generatoritem/labels').each do |labels_node|
+            parent = labels_node.parent
+            first_from = parent.find('./name|@id').first
+
+            # Name field responds to .content where as id attribute value is found with .value
+            from_name_or_id = first_from.respond_to?(:content) ? first_from.content : first_from.value
+
+            label_set = {}
+            label_set[:from] = { parent.name.to_s => from_name_or_id }
+            label_set[:labels] = []
+
+            labels_node.find('./*').each do |label_node_item|
+              label_node_item_content = label_node_item.content
+              label_set[:labels] << {label_node_item.name.to_s => label_node_item_content.to_s} unless label_node_item_content.nil? or label_node_item_content.empty?
+            end
+            labels << label_set
+          end
+          return labels
+        end
+
+        def get_all_comments(node)
+          comments = []
+          node.find('ancestor::bin/comments|ancestor::clip/comments|ancestor::sequence/comments|ancestor::clipitem/comments|ancestor::generatoritem/comments').each do |comments_node|
+            parent = comments_node.parent
+            first_from = parent.find('./name|@id').first
+
+            # Name field responds to .content where as id attribute value is found with .value
+            from_name_or_id = first_from.respond_to?(:content) ? first_from.content : first_from.value
+
+            comment_set = {}
+            comment_set[:from] = { parent.name.to_s => from_name_or_id }
+            comment_set[:comments] = []
+            comments_node.find('./*').each do |comment_node_item|
+              comment_set[:comments] << {comment_node_item.name.to_s => comment_node_item.content.to_s} unless comment_node_item.content.nil? or comment_node_item.content.empty?
+            end
+            comments << comment_set
+          end
+          return comments
+        end
+
+        def get_logging_info(node)
+          logginginfos = []
+          node.find('ancestor::clip/logginginfo|ancestor::sequence/logginginfo|ancestor::clipitem/logginginfo|ancestor::generatoritem/logginginfo').each do |logginginfo_node|
+            parent = logginginfo_node.parent
+            first_from = parent.find('./name|@id').first
+
+            # Name field responds to .content where as id attribute value is found with .value
+            from_name_or_id = first_from.respond_to?(:content) ? first_from.content : first_from.value
+
+            logginginfo_set = {}
+            logginginfo_set[:from] = { parent.name.to_s => from_name_or_id }
+            logginginfo_set[:logginginfo] = {}
+            logginginfo_node.find('./*').each do |logginginfo_node_item|
+              logginginfo_set[:logginginfo][logginginfo_node_item.name.to_s] = logginginfo_node_item.content.to_s unless logginginfo_node_item.content.nil? or logginginfo_node_item.content.empty?
+            end
+            logginginfos << logginginfo_set
+          end
+          return logginginfos
+        end
+
+        def get_files_as_nodes(doc)
+          doc.find('//file[pathurl]')
+        end # get_files_as_nodes
+
+        def build_file_hash_hash(params = {})
+          _files = { }
+          key = params[:key_on] || :id
+          files_array = build_file_hash_array(@xml_document)
+          files_array.each {|file| _files[file[key]] = file }
+          _files
+        end # build_file_hash_hash
+
+        def build_file_hash_array(doc, options = { })
+          _files = []
+
+          nodes = get_files_as_nodes(doc)
+          total_files = nodes.count
+
+          counter = 0
+
+          nodes.each do |node|
+            counter += 1
+            logger.debug { "Processing file #{counter} of #{total_files}" }
+            file_hash = build_file_hash(node)
+            next unless file_hash
+            logger.debug { "file_hash => #{file_hash}" }
+            _files << file_hash
+          end
+
+          return _files
+        end
+
+        def build_file_hash(node)
+          file_id = node.attributes.get_attribute('id').value.to_s
+          logger.debug { "Processing File with an ID of: #{file_id}" }
+
+          path_url_element = node.find('./pathurl').first
+          unless !path_url_element.nil?
+            logger.debug { 'Skipping File Node. No pathurl attribute found.' }
+            return false
+          end
+
+          file_name = node.find('./name').first.content.to_s # Should equal the base name from the path url
+          file_path_url = path_url_element.content.to_s
+          file_hash = {
+            :id => file_id,
+            :name => file_name,
+            :path_url => file_path_url
+          }
+
+          # a plus (+) would be converted to a space using CGI.unescape so we only escape %## encoded values from the pathurl
+          #file_hash[:path_on_file_system] = CGI::unescape(URI(file_hash[:path_url]).path)
+          file_hash[:path_on_file_system] = URI(file_path_url).path.gsub(/(%(?:[2-9]|[A-F])(?:\d|[A-F]))/) { |v| CGI.unescape(v) }
+          file_hash[:file_node_full] = xml_node_to_hash node
+          file_hash[:project_name] = get_project_name node
+          file_hash[:bin_path] = get_bin_path node
+          file_hash[:clipitem_node_full] = get_clipitem_hash node
+
+          file_hash[:clipitems] = get_file_clipitems(node, file_id)
+
+          master_clip_id = file_hash[:clipitem_node_full][:masterclipid]
+          file_hash[:masterclip_node_full] = (master_clip_id.nil? or master_clip_id.empty?) ? { } : get_clip_hash_by_id(node.doc, master_clip_id)
+          file_hash[:metadata] = get_all_metadata node
+          file_hash[:labels] = get_all_labels node
+          file_hash[:comments] = get_all_comments node
+          file_hash[:logginginfo] = get_logging_info node
+          file_hash
+        end
+
+        def parse(xml = @xml_document, options = { })
+          xml_doc = self.class.xml_as_document(xml)
+          @files = parse_files(xml_doc, options)
+          @sequences = parse_sequences(xml_doc, options)
+          @clips = parse_clips(xml_doc)
+          return self
+        end # parse
+
+        def parse_files(xml = @xml_document, options = { })
+          build_file_hash_array(self.class.xml_as_document(xml), options = { }) || [ ]
+        end # parse_files
+
+        def parse_clips(xml = @xml_document, options = { })
+          self.class.xml_as_document(xml).find('//clip').map do |clip_node|
+            # 'clipitem[(not(enabled) or enabled[text()="TRUE"]) and ancestor::video/track[enabled[text()="TRUE"]]]'
+            # enabled tag may be missing on some clipitems such as those that link to other clipitems. This could cause a problem following links.
+            clip_items = clip_node.find('clipitem[(not(enabled) or enabled[text()="TRUE"]) and ../../../../media/video/track[enabled[text()="TRUE"]]]').map do |clip_item_node|
+              xml_node_to_hash(clip_item_node)
+            end
+            xml_node_to_hash(clip_node).merge({ :clip_items => clip_items })
+          end
+        end # parse_clips
+
+        def parse_sequences(xml = @xml_document, options = { })
+          self.class.xml_as_document(xml).find('//sequence').map do |sequence_node|
+            clip_items = sequence_node.find('media/video/track/clipitem[not(enabled) or enabled[text()="TRUE"]]').map do |clip_item_node|
+              xml_node_to_hash(clip_item_node)
+            end
+            xml_node_to_hash(sequence_node).merge({ :clip_items => clip_items })
+          end
+        end # parse_sequences
+
+      end # Version5
+    end # XMEML
+  end # XMLParser
+end # FinalCutPro

data/lib/itunes/xml_parser.rb

@@ -0,0 +1,51 @@
+require 'cgi'
+require 'plist'
+require 'uri'
+module ITunes
+
+  class XMLParser
+
+    def self.parse(xml, params = {})
+      new(params.merge(:file => xml))
+    end # self.parse
+
+    attr_reader :parsed
+
+    def initialize(params = {})
+      @file_name = params[:file]
+      parse if @file_name
+    end # initialize
+
+    def parse(params = {})
+      @parsed = Plist.parse_xml(@file_name)
+    end # parse
+
+    def tracks
+      @tracks ||= parsed['Tracks']
+    end # tracks
+
+    def files
+      @files ||= begin
+        _files = [ ]
+        tracks.each do |id, track|
+          _files << track.merge(:path_on_file_system => CGI.unescape(URI(track['Location']).path))
+        end
+        _files
+      end
+    end # files
+
+    # Performs additional processing to each tracks fields
+    # @param [Hash] _tracks
+    def process_tracks(_tracks = @tracks)
+      _tracks.dup.each do |id, track|
+        add_path_to_track(id, track)
+      end
+    end # process_tracks
+
+    def add_path_to_track(id, track)
+      tracks[id]['Path'] = CGI.unescape(URI.parse(track['Location']).path)
+    end # add_path_to_track
+
+  end # XMLParser
+
+end # ITunes