epub-parser-io 0.1.6a

data/lib/epub/ocf/container.rb

@@ -0,0 +1,28 @@
+module EPUB
+  class OCF
+    class Container
+      FILE = 'container.xml'
+
+      attr_reader :rootfiles
+
+      def initialize
+        @rootfiles = []
+      end
+
+      # syntax sugar
+      def rootfile
+        rootfiles.first
+      end
+
+      class Rootfile
+        attr_accessor :full_path, :media_type
+
+        # @param full_path [Addressable::URI|nil]
+        # @param media_type [String]
+        def initialize(full_path=nil, media_type=EPUB::MediaType::ROOTFILE)
+          @full_path, @media_type = full_path, media_type
+        end
+      end
+    end
+  end
+end

data/lib/epub/ocf/encryption.rb

@@ -0,0 +1,7 @@
+module EPUB
+  class OCF
+    class Encryption
+      attr_accessor :content
+    end
+  end
+end

data/lib/epub/ocf/manifest.rb

@@ -0,0 +1,6 @@
+module EPUB
+  class OCF
+    class Manifest
+    end
+  end
+end

data/lib/epub/ocf/metadata.rb

@@ -0,0 +1,6 @@
+module EPUB
+  class OCF
+    class Metadata
+    end
+  end
+end

data/lib/epub/ocf/rights.rb

@@ -0,0 +1,6 @@
+module EPUB
+  class OCF
+    class Rights
+    end
+  end
+end

data/lib/epub/ocf/signatures.rb

@@ -0,0 +1,6 @@
+module EPUB
+  class OCF
+    class Signatures
+    end
+  end
+end

data/lib/epub/ocf.rb

@@ -0,0 +1,8 @@
+module EPUB
+  class OCF
+    MODULES = %w[container encryption manifest metadata rights signatures]
+    MODULES.each {|m| require "epub/ocf/#{m}"}
+
+    attr_accessor :book, *MODULES
+  end
+end

data/lib/epub/parser/content_document.rb

@@ -0,0 +1,111 @@
+require 'epub/content_document'
+require 'epub/constants'
+require 'epub/parser/utils'
+require 'nokogiri'
+
+module EPUB
+  class Parser
+    class ContentDocument
+      include Utils
+
+      # @param [EPUB::Publication::Package::Manifest::Item] item
+      def initialize(item)
+        @item = item
+      end
+
+      def parse
+        content_document = case @item.media_type
+                           when 'application/xhtml+xml'
+                             if @item.nav?
+                               EPUB::ContentDocument::Navigation.new
+                             else
+                               EPUB::ContentDocument::XHTML.new
+                             end
+                           when 'image/svg+xml'
+                             EPUB::ContentDocument::SVG.new
+                           else
+                             nil
+                           end
+        return content_document if content_document.nil?
+        content_document.item = @item
+        document = Nokogiri.XML(@item.read)
+        # parse_content_document(document)
+        if @item.nav?
+          content_document.navigations = parse_navigations(document)
+        end
+        content_document
+      end
+
+      # @param [Nokogiri::HTML::Document] document HTML document or element including nav
+      # @return [Array<EPUB::ContentDocument::Navigation::Nav>] navs array of Nav object
+      def parse_navigations(document)
+        document.search('/xhtml:html/xhtml:body//xhtml:nav', EPUB::NAMESPACES).collect {|elem| parse_navigation elem}
+      end
+
+      # @param [Nokogiri::XML::Element] element nav element
+      # @return [EPUB::ContentDocument::Navigation::Nav] nav Nav object
+      def parse_navigation(element)
+        nav = EPUB::ContentDocument::Navigation::Navigation.new
+        nav.text = find_heading(element)
+        hidden = extract_attribute(element, 'hidden')
+        nav.hidden = hidden.nil? ? nil : true
+        nav.type = extract_attribute(element, 'type', 'epub')
+        element.xpath('./xhtml:ol/xhtml:li', EPUB::NAMESPACES).map do |elem|
+          nav.items << parse_navigation_item(elem)
+        end
+
+        nav
+      end
+
+      # @param [Nokogiri::XML::Element] element li element
+      def parse_navigation_item(element)
+        item = EPUB::ContentDocument::Navigation::Item.new
+        a_or_span = element.xpath('./xhtml:a[1]|xhtml:span[1]', EPUB::NAMESPACES).first
+        return a_or_span if a_or_span.nil?
+
+        item.text = a_or_span.text
+        if a_or_span.name == 'a'
+          if item.text.empty?
+            embedded_content = a_or_span.xpath('./xhtml:audio[1]|xhtml:canvas[1]|xhtml:embed[1]|xhtml:iframe[1]|xhtml:img[1]|xhtml:math[1]|xhtml:object[1]|xhtml:svg[1]|xhtml:video[1]', EPUB::NAMESPACES).first
+            unless embedded_content.nil?
+              case embedded_content.name
+              when 'audio'
+              when 'canvas'
+              when 'embed'
+              when 'iframe'
+                item.text = extract_attribute(embedded_content, 'name') || extract_attribute(embedded_content, 'srcdoc')
+              when 'img'
+                item.text = extract_attribute(embedded_content, 'alt')
+              when 'math'
+              when 'object'
+                item.text = extract_attribute(embedded_content, 'name')
+              when 'svg'
+              when 'video'
+              else
+              end
+            end
+            item.text = extract_attribute(a_or_span, 'title').to_s if item.text.nil? || item.text.empty?
+          end
+          item.href = Addressable::URI.parse(extract_attribute(a_or_span, 'href'))
+          item.item = @item.manifest.items.selector {|it| it.href.request_uri == item.href.request_uri}.first
+        end
+        item.items = element.xpath('./xhtml:ol[1]/xhtml:li', EPUB::NAMESPACES).map {|li| parse_navigation_item(li)}
+
+        item
+      end
+
+      private
+
+      # @param [Nokogiri::XML::Element] element nav element
+      # @return [String] heading heading text
+      def find_heading(element)
+        heading = element.xpath('./xhtml:h1|xhtml:h2|xhtml:h3|xhtml:h4|xhtml:h5|xhtml:h6|xhtml:hgroup', EPUB::NAMESPACES).first
+
+        return nil if heading.nil?
+        return heading.text unless heading.name == 'hgroup'
+
+        (heading/'h1' || heading/'h2' || heading/'h3' || heading/'h4' || heading/'h5' || heading/'h6').first.text
+      end
+    end
+  end
+end

data/lib/epub/parser/ocf.rb

@@ -0,0 +1,73 @@
+require 'epub/constants'
+require 'epub/ocf'
+require 'zipruby'
+require 'nokogiri'
+
+module EPUB
+  class Parser
+    class OCF
+      include Utils
+
+      DIRECTORY = 'META-INF'
+      EPUB::OCF::MODULES.each {|m| self.const_set "#{m.upcase}_FILE", "#{m}.xml"} # Deprecated
+
+      class << self
+        def parse(zip_archive)
+          new(zip_archive).parse
+        end
+      end
+
+      def initialize(zip_archive)
+        @zip = zip_archive
+        @ocf = EPUB::OCF.new
+      end
+
+      def parse
+        EPUB::OCF::MODULES.each do |m|
+          begin
+            file = @zip.fopen(File.join(DIRECTORY, "#{m}.xml"))
+            @ocf.__send__ "#{m}=", __send__("parse_#{m}", file.read)
+          rescue Zip::Error
+          end
+        end
+
+        @ocf
+      end
+
+      def parse_container(xml)
+        container = EPUB::OCF::Container.new
+        doc = Nokogiri.XML(xml)
+        doc.xpath('/ocf:container/ocf:rootfiles/ocf:rootfile', EPUB::NAMESPACES).each do |elem|
+          rootfile = EPUB::OCF::Container::Rootfile.new
+          rootfile.full_path = Addressable::URI.parse(extract_attribute(elem, 'full-path'))
+          rootfile.media_type = extract_attribute(elem, 'media-type')
+          container.rootfiles << rootfile
+        end
+
+        container
+      end
+
+      def parse_encryption(content)
+        encryption = EPUB::OCF::Encryption.new
+        encryption.content = content
+        encryption
+      end
+
+      def parse_manifest(content)
+        warn "Not implemented: #{self.class}##{__method__}" if $VERBOSE
+      end
+
+      def parse_metadata(content)
+        warn "Not implemented: #{self.class}##{__method__}" if $VERBOSE
+      end
+
+      def parse_rights(content)
+        warn "Not implemented: #{self.class}##{__method__}" if $VERBOSE
+      end
+
+      def parse_signatures(content)
+        warn "Not implemented: #{self.class}##{__method__}" if $VERBOSE
+      end
+    end
+  end
+end

data/lib/epub/parser/publication.rb

@@ -0,0 +1,200 @@
+require 'strscan'
+require 'zipruby'
+require 'nokogiri'
+require 'addressable/uri'
+require 'epub/publication'
+require 'epub/constants'
+
+module EPUB
+  class Parser
+    class Publication
+      include Utils
+
+      class << self
+        def parse(zip_archive, file)
+          opf = zip_archive.fopen(Addressable::URI.unencode(file)).read
+          new(opf, file).parse
+        end
+      end
+
+      def initialize(opf, rootfile)
+        @package = EPUB::Publication::Package.new
+        @rootfile = Addressable::URI.parse(rootfile)
+        @doc = Nokogiri.XML(opf)
+      end
+
+      def parse
+        ([:package] + EPUB::Publication::Package::CONTENT_MODELS).each do |model|
+          __send__ "parse_#{model}"
+        end
+
+        @package
+      end
+
+      def parse_package
+        elem = @doc.root
+        %w[version xml:lang dir id].each do |attr|
+          @package.__send__ "#{attr.gsub(/\:/, '_')}=", extract_attribute(elem, attr)
+        end
+        @unique_identifier_id = elem['unique-identifier']
+        @package.prefix = parse_prefix(extract_attribute(elem, 'prefix'))
+        EPUB::Publication.__send__ :include, EPUB::Publication::FixedLayout if @package.prefix.key? EPUB::Publication::FixedLayout::PREFIX_KEY
+
+        @package
+      end
+
+      def parse_metadata
+        metadata = @package.metadata = EPUB::Publication::Package::Metadata.new
+        elem = @doc.xpath('/opf:package/opf:metadata', EPUB::NAMESPACES).first
+        id_map = {}
+
+        metadata.identifiers = extract_model(elem, id_map, './dc:identifier', :Identifier, ['id']) {|identifier, e|
+          identifier.scheme = extract_attribute(e, 'scheme', 'opf')
+          metadata.unique_identifier = identifier if identifier.id == @unique_identifier_id
+        }
+        metadata.titles = extract_model(elem, id_map, './dc:title', :Title)
+        metadata.languages = extract_model(elem, id_map, './dc:language', :DCMES, %w[id])
+        %w[ contributor coverage creator date description format publisher relation source subject type ].each do |dcmes|
+          metadata.__send__ "#{dcmes}s=", extract_model(elem, id_map, "./dc:#{dcmes}")
+        end
+        metadata.rights = extract_model(elem, id_map, './dc:rights')
+        metadata.metas = extract_refinee(elem, id_map, './opf:meta', :Meta, %w[property id scheme])
+        metadata.links = extract_refinee(elem, id_map, './opf:link', :Link, %w[id media-type]) {|link, e|
+          link.href = Addressable::URI.parse(extract_attribute(e, 'href'))
+          link.rel = Set.new(extract_attribute(e, 'rel').split(nil))
+        }
+
+        id_map.values.each do |hsh|
+          next unless hsh[:refiners]
+          next unless hsh[:metadata]
+          hsh[:refiners].each {|meta| meta.refines = hsh[:metadata]}
+        end
+
+        metadata
+      end
+
+      def parse_manifest
+        manifest = @package.manifest = EPUB::Publication::Package::Manifest.new
+        elem = @doc.xpath('/opf:package/opf:manifest', EPUB::NAMESPACES).first
+        manifest.id = extract_attribute(elem, 'id')
+
+        fallback_map = {}
+        elem.xpath('./opf:item', EPUB::NAMESPACES).each do |e|
+          item = EPUB::Publication::Package::Manifest::Item.new
+          %w[ id media-type media-overlay ].each do |attr|
+            item.__send__ "#{attr.gsub(/-/, '_')}=", extract_attribute(e, attr)
+          end
+          item.href = Addressable::URI.parse(extract_attribute(e, 'href'))
+          fallback = extract_attribute(e, 'fallback')
+          fallback_map[fallback] = item if fallback
+          properties = extract_attribute(e, 'properties')
+          item.properties = properties.split(' ') if properties
+          manifest << item
+        end
+        fallback_map.each_pair do |id, from|
+          from.fallback = manifest[id]
+        end
+
+        manifest
+      end
+
+      def parse_spine
+        spine = @package.spine = EPUB::Publication::Package::Spine.new
+        elem = @doc.xpath('/opf:package/opf:spine', EPUB::NAMESPACES).first
+        %w[ id toc page-progression-direction ].each do |attr|
+          spine.__send__ "#{attr.gsub(/-/, '_')}=", extract_attribute(elem, attr)
+        end
+
+        elem.xpath('./opf:itemref', EPUB::NAMESPACES).each do |e|
+          itemref = EPUB::Publication::Package::Spine::Itemref.new
+          %w[ idref id ].each do |attr|
+            itemref.__send__ "#{attr}=", extract_attribute(e, attr)
+          end
+          itemref.linear = (extract_attribute(e, 'linear') != 'no')
+          properties = extract_attribute(e, 'properties')
+          itemref.properties = properties.split(' ') if properties
+          spine << itemref
+        end
+
+        spine
+      end
+
+      def parse_guide
+        guide = @package.guide = EPUB::Publication::Package::Guide.new
+        @doc.xpath('/opf:package/opf:guide/opf:reference', EPUB::NAMESPACES).each do |ref|
+          reference = EPUB::Publication::Package::Guide::Reference.new
+          %w[ type title ].each do |attr|
+            reference.__send__ "#{attr}=", extract_attribute(ref, attr)
+          end
+          reference.href = Addressable::URI.parse(extract_attribute(ref, 'href'))
+          guide << reference
+        end
+
+        guide
+      end
+
+      def parse_bindings
+        bindings = @package.bindings = EPUB::Publication::Package::Bindings.new
+        @doc.xpath('/opf:package/opf:bindings/opf:mediaType', EPUB::NAMESPACES).each do |elem|
+          media_type = EPUB::Publication::Package::Bindings::MediaType.new
+          media_type.media_type = extract_attribute(elem, 'media-type')
+          media_type.handler = @package.manifest[extract_attribute(elem, 'handler')]
+          bindings << media_type
+        end
+
+        bindings
+      end
+
+      def parse_prefix(str)
+        prefixes = {}
+        return prefixes if str.nil? or str.empty?
+        scanner = StringScanner.new(str)
+        scanner.scan /\s*/
+        while prefix = scanner.scan(/[^\:\s]+/)
+          scanner.scan /[\:\s]+/
+          iri = scanner.scan(/[^\s]+/)
+          if iri.nil? or iri.empty?
+            warn "no IRI detected for prefix `#{prefix}`"
+          else
+            prefixes[prefix] = iri
+          end
+          scanner.scan /\s*/
+        end
+        prefixes
+      end
+
+      def extract_model(elem, id_map, xpath, klass=:DCMES, attributes=%w[id lang dir])
+        models = elem.xpath(xpath, EPUB::NAMESPACES).collect do |e|
+          model = EPUB::Publication::Package::Metadata.const_get(klass).new
+          attributes.each do |attr|
+            model.__send__ "#{attr.gsub(/-/, '_')}=", extract_attribute(e, attr)
+          end
+          model.content = e.content unless klass == :Link
+
+          yield model, e if block_given?
+
+          model
+        end
+
+        models.each do |model|
+          id_map[model.id] = {metadata: model} if model.respond_to?(:id) && model.id
+        end
+
+        models
+      end
+
+      def extract_refinee(elem, id_map, xpath, klass, attributes)
+        extract_model(elem, id_map, xpath, klass, attributes) {|model, e|
+          yield model, e if block_given?
+          refines = extract_attribute(e, 'refines')
+          if refines && refines[0] == '#'
+            id = refines[1..-1]
+            id_map[id] ||= {}
+            id_map[id][:refiners] ||= []
+            id_map[id][:refiners] << model
+          end
+        }
+      end
+    end
+  end
+end