epub-parser-io 0.1.6a

data/lib/epub/parser/utils.rb

@@ -0,0 +1,20 @@
+module EPUB
+  class Parser
+    module Utils
+      # Extract the value of attribute of element
+      # 
+      # @todo Refinement Nokogiri::XML::Node instead of use this method after Ruby 2.0 becomes popular
+      # 
+      # @param [Nokogiri::XML::Element] element
+      # @param [String] name name of attribute excluding namespace prefix
+      # @param [String, nil] prefix XML namespace prefix in {EPUB::Constants::NAMESPACES} keys
+      # @return [String] value of attribute when the attribute exists
+      # @return nil when the attribute doesn't exist
+      def extract_attribute(element, name, prefix=nil)
+        attr = element.attribute_with_ns(name, EPUB::NAMESPACES[prefix])
+        attr.nil? ? nil : attr.value
+      end
+      module_function :extract_attribute
+    end
+  end
+end

data/lib/epub/parser/version.rb

@@ -0,0 +1,5 @@
+module EPUB
+  class Parser
+    VERSION = "0.1.6a"
+  end
+end

data/lib/epub/parser.rb

@@ -0,0 +1,103 @@
+require 'epub'
+require 'epub/constants'
+require 'zipruby'
+require 'nokogiri'
+require 'tempfile'
+
+module EPUB
+  class Parser
+    class << self
+      # Parse an EPUB file
+      #
+      # @example
+      #   EPUB::Parser.parse('path/to/book.epub') # => EPUB::Book object
+      #
+      # @example
+      #   class MyBook
+      #     include EPUB
+      #   end
+      #   book = MyBook.new
+      #   parsed_book = EPUB::Parser.parse('path/to/book.epub', :book => book) # => #<MyBook:0x000000019760e8 @epub_file=..>
+      #   parsed_book.equal? book # => true
+      #
+      # @example
+      #   book = EPUB::Parser.parse('path/to/book.epub', :class => MyBook) # => #<MyBook:0x000000019b0568 @epub_file=...>
+      #   book.instance_of? MyBook # => true
+      #
+      # @param [String] filepath
+      # @param [Hash] options the type of return is specified by this argument.
+      #   If no options, returns {EPUB::Book} object.
+      #   For details of options, see below.
+      # @option options [EPUB] :book instance of class which includes {EPUB} module
+      # @option options [Class] :class class which includes {EPUB} module
+      # @return [EPUB] object which is an instance of class including {EPUB} module.
+      #   When option :book passed, returns the same object whose attributes about EPUB are set.
+      #   When option :class passed, returns the instance of the class.
+      #   Otherwise returns {EPUB::Book} object.
+      def parse(filepath, options = {})
+        new(filepath, options).parse
+      end
+
+      def parse_io(io_stream, options = {})
+        new(io_stream, options.merge(io: true)).parse_io
+      end
+    end
+
+    def initialize(datasource, options = {})
+      if options[:io]
+        raise "IO source not readable" unless datasource.respond_to?(:read)
+
+        @io_stream = datasource
+        @book = create_book options
+        file = Tempfile.new('epub_string')
+        file.write(@io_stream)
+        @filepath = file.path
+        @book.epub_file = @filepath
+      else
+        raise "File #{datasource} not readable" unless File.readable_real? datasource
+
+        @filepath = File.realpath datasource
+        @book = create_book options
+        @book.epub_file = @filepath
+      end
+    end
+
+    def parse
+      Zip::Archive.open @filepath do |zip|
+        @book.ocf = OCF.parse(zip)
+        @book.package = Publication.parse(zip, @book.ocf.container.rootfile.full_path.to_s)
+      end
+
+      @book
+    end
+
+    def parse_io # unnecessary, but desirable maybe?
+      Zip::Archive.open_buffer @io_stream do |zip|
+        @book.ocf = OCF.parse(zip)
+        @book.package = Publication.parse(zip, @book.ocf.container.rootfile.full_path.to_s)
+      end
+
+      @book
+    end
+
+    private
+
+    def create_book(params)
+      case
+      when params[:book]
+        params[:book]
+      when params[:class]
+        params[:class].new
+      else
+        require 'epub/book'
+        Book.new
+      end
+    end
+  end
+end
+
+require 'epub/parser/version'
+require 'epub/parser/utils'
+require 'epub/parser/ocf'
+require 'epub/parser/publication'
+require 'epub/parser/content_document'

data/lib/epub/publication/fixed_layout.rb

@@ -0,0 +1,208 @@
+module EPUB
+  module Publication
+    module FixedLayout
+      PREFIX_KEY = 'rendition'.freeze
+      PREFIX_VALUE = 'http://www.idpf.org/vocab/rendition/#'.freeze
+
+      RENDITION_PROPERTIES = {
+        'layout'      => ['reflowable'.freeze, 'pre-paginated'.freeze].freeze,
+        'orientation' => ['auto'.freeze, 'landscape'.freeze, 'portrait'.freeze].freeze,
+        'spread'      => ['auto'.freeze, 'none'.freeze, 'landscape'.freeze, 'portrait'.freeze, 'both'.freeze].freeze
+      }.freeze
+
+      class UnsupportedRenditionValue < StandardError; end
+
+      class << self
+        def included(package_class)
+          [
+           [Package, PackageMixin],
+           [Package::Metadata, MetadataMixin],
+           [Package::Spine::Itemref, ItemrefMixin],
+           [Package::Manifest::Item, ItemMixin],
+           [ContentDocument::XHTML, ContentDocumentMixin],
+          ].each do |(base, mixin)|
+            base.__send__ :include, mixin
+          end
+        end
+      end
+
+      module Rendition
+        # @note Call after defining #rendition_xxx and #renditionn_xxx=
+        def def_rendition_methods
+          RENDITION_PROPERTIES.each_key do |property|
+            alias_method property, "rendition_#{property}"
+            alias_method "#{property}=", "rendition_#{property}="
+          end
+          def_rendition_layout_methods
+        end
+
+        def def_rendition_layout_methods
+          property = 'layout'
+          RENDITION_PROPERTIES[property].each do |value|
+            method_name_base = value.gsub('-', '_')
+            writer_name = "#{method_name_base}="
+            define_method writer_name do |new_value|
+              new_prop = new_value ? value : values.find {|l| l != value}
+              __send__ "rendition_#{property}=", new_prop
+            end
+
+            maker_name = "make_#{method_name_base}"
+            define_method maker_name do
+              __send__ "rendition_#{property}=", value
+            end
+            destructive_method_name = "#{method_name_base}!"
+            alias_method destructive_method_name, maker_name
+
+            predicate_name = "#{method_name_base}?"
+            define_method predicate_name do
+              __send__("rendition_#{property}") == value
+            end
+          end
+        end
+      end
+
+      module PackageMixin
+        # @return [true, false]
+        def using_fixed_layout
+          prefix.has_key? PREFIX_KEY and
+            prefix[PREFIX_KEY] == PREFIX_VALUE
+        end
+        alias using_fixed_layout? using_fixed_layout
+
+        # @param using_fixed_layout [true, false]
+        def using_fixed_layout=(using_fixed_layout)
+          if using_fixed_layout
+            prefix[PREFIX_KEY] = PREFIX_VALUE
+          else
+            prefix.delete PREFIX_KEY
+          end
+        end
+      end
+
+      module MetadataMixin
+        extend Rendition
+
+        RENDITION_PROPERTIES.each_pair do |property, values|
+          define_method "rendition_#{property}" do
+            meta = metas.find {|m| m.property == "rendition:#{property}"}
+            meta ? meta.content : values.first
+          end
+
+          define_method "rendition_#{property}=" do |new_value|
+            raise UnsupportedRenditionValue, new_value unless values.include? new_value
+
+            prefixed_property = "rendition:#{property}"
+            values_to_be_deleted = values - [new_value]
+            metas.delete_if {|meta| meta.property == prefixed_property && values_to_be_deleted.include?(meta.content)}
+            unless metas.any? {|meta| meta.property == prefixed_property && meta.content == new_value}
+              meta = Package::Metadata::Meta.new
+              meta.property = prefixed_property
+              meta.content = new_value
+              metas << meta
+            end
+            new_value
+          end
+        end
+
+        def_rendition_methods
+      end
+
+      module ItemrefMixin
+        extend Rendition
+
+        PAGE_SPREAD_PROPERTY = 'center'
+        PAGE_SPREAD_PREFIX = 'rendition:page-spread-'
+
+        class << self
+          # @todo Define using Module#prepend after Ruby 2.0 will become popular
+          def included(base)
+            return if base.instance_methods.include? :page_spread_without_fixed_layout
+            base.__send__ :alias_method, :page_spread_without_fixed_layout, :page_spread
+            base.__send__ :alias_method, :page_spread_writer_without_fixed_layout, :page_spread=
+
+            prefixed_page_spread_property = "#{PAGE_SPREAD_PREFIX}#{PAGE_SPREAD_PROPERTY}"
+            base.__send__ :define_method, :page_spread do
+              property = page_spread_without_fixed_layout
+              return property if property
+              properties.include?(prefixed_page_spread_property) ? PAGE_SPREAD_PROPERTY : nil
+            end
+
+            base.__send__ :define_method, :page_spread= do |new_value|
+              if new_value == PAGE_SPREAD_PROPERTY
+                page_spread_writer_without_fixed_layout nil
+                properties << prefixed_page_spread_property
+              else
+                page_spread_writer_without_fixed_layout new_value
+              end
+              new_value
+            end
+          end
+        end
+
+        RENDITION_PROPERTIES.each do |property, values|
+          rendition_property_prefix = "rendition:#{property}-"
+
+          reader_name = "rendition_#{property}"
+          define_method reader_name do
+            prop_value = properties.find {|prop| prop.start_with? rendition_property_prefix}
+            prop_value ? prop_value.gsub(/\A#{Regexp.escape(rendition_property_prefix)}/, '') :
+              spine.package.metadata.__send__(reader_name)
+          end
+
+          writer_name = "#{reader_name}="
+          define_method writer_name do |new_value|
+            if new_value.nil?
+              properties.delete_if {|prop| prop.start_with? rendition_property_prefix}
+              return new_value
+            end
+
+            raise UnsupportedRenditionValue, new_value unless values.include? new_value
+
+            values_to_be_deleted = (values - [new_value]).map {|value| "#{rendition_property_prefix}#{value}"}
+            properties.delete_if {|prop| values_to_be_deleted.include? prop}
+            new_property = "#{rendition_property_prefix}#{new_value}"
+            properties << new_property unless properties.include? new_property
+            new_value
+          end
+        end
+
+        def_rendition_methods
+      end
+
+      module ItemMixin
+        extend Rendition
+
+        RENDITION_PROPERTIES.each_key do |property|
+          define_method "rendition_#{property}" do
+            itemref.__send__ property
+          end
+
+          writer_name = "rendition_#{property}="
+          define_method writer_name do |value|
+            itemref.__send__ writer_name, value
+          end
+        end
+
+        def_rendition_methods
+      end
+
+      module ContentDocumentMixin
+        extend Rendition
+
+        RENDITION_PROPERTIES.each_key do |property|
+          reader_name = "rendition_#{property}"
+          define_method reader_name do
+            item.__send__ reader_name
+          end
+
+          writer_name = "rendition_#{property}="
+          define_method writer_name do |value|
+            item.__send__ writer_name, value
+          end
+        end
+
+        def_rendition_methods
+      end
+    end
+  end
+end

data/lib/epub/publication/package/bindings.rb

@@ -0,0 +1,31 @@
+module EPUB
+  module Publication
+    class Package
+      class Bindings
+        include Inspector::PublicationModel
+        attr_accessor :package
+
+        def initialize
+          @media_types = {}
+        end
+
+        def <<(media_type)
+          @media_types[media_type.media_type] = media_type
+        end
+
+        def [](media_type)
+          _, mt = @media_types.detect {|key, _| key == media_type}
+          mt
+        end
+
+        def media_types
+          @media_types.values
+        end
+
+        class MediaType
+          attr_accessor :media_type, :handler
+        end
+      end
+    end
+  end
+end

data/lib/epub/publication/package/guide.rb

@@ -0,0 +1,51 @@
+require 'enumerabler'
+
+module EPUB
+  module Publication
+    class Package
+      class Guide
+        include Inspector::PublicationModel
+        attr_accessor :package, :references
+
+        def initialize
+          Reference::TYPES.each do |type|
+            variable_name = '@' + type.gsub('-', '_')
+            instance_variable_set variable_name, nil
+          end
+          @references = []
+        end
+
+        def <<(reference)
+          reference.guide = self
+          references << reference
+        end
+
+        class Reference
+          TYPES = %w[cover title-page toc index glossary acknowledgements bibliography colophon copyright-page dedication epigraph foreword loi lot notes preface text]
+          attr_accessor :guide,
+                        :type, :title, :href
+
+          def item
+            return @item if @item
+
+            request_uri = href.request_uri
+            @item = @guide.package.manifest.items.selector do |item|
+              item.href.request_uri == request_uri
+            end.first
+          end
+        end
+
+        Reference::TYPES.each do |type|
+          method_name = type.gsub('-', '_')
+          define_method method_name do
+            var = instance_variable_get "@#{method_name}"
+            return var if var
+
+            var = references.selector {|ref| ref.type == type}.first
+            instance_variable_set "@#{method_name}", var
+          end
+        end
+      end
+    end
+  end
+end

data/lib/epub/publication/package/manifest.rb

@@ -0,0 +1,180 @@
+require 'set'
+require 'enumerabler'
+require 'epub/constants'
+require 'epub/parser/content_document'
+
+module EPUB
+  module Publication
+    class Package
+      class Manifest
+        include Inspector::PublicationModel
+
+        attr_accessor :package,
+                      :id
+
+        def initialize
+          @items = {}
+        end
+
+        # @return self
+        def <<(item)
+          item.manifest = self
+          @items[item.id] = item
+          self
+        end
+
+        def navs
+          items.selector(&:nav?)
+        end
+
+        def nav
+          navs.first
+        end
+
+        def cover_image
+          items.selector(&:cover_image?).first
+        end
+
+        def each_item
+          @items.each_value do |item|
+            yield item
+          end
+        end
+
+        def items
+          @items.values
+        end
+
+        def [](item_id)
+          @items[item_id]
+        end
+
+        class Item
+          include Inspector
+
+          # @!attribute [rw] manifest
+          #   @return [Manifest] Returns the value of manifest
+          # @!attribute [rw] id
+          #   @return [String] Returns the value of id
+          # @!attribute [rw] href
+          #   @return [Addressable::URI] Returns the value of href,
+          #                              which is relative IRI from rootfile(OPF file)
+          # @!attribute [rw] media_type
+          #   @return [String] Returns the value of media_type
+          # @!attribute [rw] properties
+          #   @return [Set<String>] Returns the value of properties
+          # @!attribute [rw] media_overlay
+          #   @return [String] Returns the value of media_overlay
+          # @!attribute [rw] fallback
+          #   @return [Item] Returns the value of attribute fallback
+          attr_accessor :manifest,
+                        :id, :href, :media_type, :fallback, :media_overlay
+          attr_reader :properties
+
+          def initialize
+            @properties = Set.new
+          end
+
+          def properties=(props)
+            @properties = props.kind_of?(Set) ? props : Set.new(props)
+          end
+
+          # @todo Handle circular fallback chain
+          def fallback_chain
+            @fallback_chain ||= traverse_fallback_chain([])
+          end
+
+          # full path in archive
+          def entry_name
+            rootfile = manifest.package.book.ocf.container.rootfile.full_path
+            Addressable::URI.unescape(rootfile + href.normalize.request_uri)
+          end
+
+          def read
+            Zip::Archive.open(manifest.package.book.epub_file) {|zip|
+              zip.fopen(entry_name).read
+            }
+          end
+
+          def xhtml?
+            media_type == 'application/xhtml+xml'
+          end
+
+          def nav?
+            properties.include? 'nav'
+          end
+
+          def cover_image?
+            properties.include? 'cover-image'
+          end
+
+          # @todo Handle circular fallback chain
+          def use_fallback_chain(options = {})
+            supported = EPUB::MediaType::CORE
+            if ad = options[:supported]
+              supported = supported | (ad.respond_to?(:to_ary) ? ad : [ad])
+            end
+            if del = options[:unsupported]
+              supported = supported - (del.respond_to?(:to_ary) ? del : [del])
+            end
+
+            return yield self if supported.include? media_type
+            if (bindings = manifest.package.bindings) && (binding_media_type = bindings[media_type])
+              return yield binding_media_type.handler
+            end
+            return fallback.use_fallback_chain(options) {|fb| yield fb} if fallback
+            raise EPUB::MediaType::UnsupportedMediaType
+          end
+
+          def content_document
+            return nil unless %w[application/xhtml+xml image/svg+xml].include? media_type
+            @content_document ||= Parser::ContentDocument.new(self).parse
+          end
+
+          # @return [Package::Spine::Itemref]
+          # @return nil when no Itemref refers this Item
+          def itemref
+            manifest.package.spine.itemrefs.find {|itemref| itemref.idref == id}
+          end
+
+          # @param iri [Addressable::URI] relative iri
+          # @return [Item]
+          # @return [nil] when item not found
+          # @raise ArgumentError when +iri+ is not relative
+          # @raise ArgumentError when +iri+ starts with "/"(slash)
+          # @note Algorithm stolen form Rack::Utils#clean_path_info
+          def find_item_by_relative_iri(iri)
+            raise ArgumentError, "Not relative: #{iri.inspect}" unless iri.relative?
+            raise ArgumentError, "Start with slash: #{iri.inspect}" if iri.to_s.start_with? Addressable::URI::SLASH
+            target_href = href + iri
+            segments = target_href.to_s.split(Addressable::URI::SLASH)
+            clean_segments = []
+            segments.each do |segment|
+              next if segment.empty? || segment == '.'
+              segment == '..' ? clean_segments.pop : clean_segments << segment
+            end
+            target_iri = Addressable::URI.parse(clean_segments.join(Addressable::URI::SLASH))
+            manifest.items.find { |item| item.href == target_iri}
+          end
+
+          def inspect
+            "#<%{class}:%{object_id} %{manifest} %{attributes}>" % {
+              :class      => self.class,
+              :object_id  => inspect_object_id,
+              :manifest   => "@manifest=#{@manifest.inspect_simply}",
+              :attributes => inspect_instance_variables(exclude: [:@manifest])
+            }
+          end
+
+          protected
+
+          def traverse_fallback_chain(chain)
+            chain << self
+            return chain unless fallback
+            fallback.traverse_fallback_chain(chain)
+          end
+        end
+      end
+    end
+  end
+end