epuber 0.8.0 → 0.9.0

data/lib/epuber/from_file/encryption_handler.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'uuidtools'
+require 'digest'
+
+module Epuber
+  class EncryptionHandler
+    class EncryptionItem
+      # Encryption algorithm (probably EncryptionHandler::ADOBE_OBFUSCATION or EncryptionHandler::IDPF_OBFUSCATION)
+      #
+      # @return [String]
+      #
+      attr_accessor :algorithm
+
+      # Absolute path to file (from root of EPUB)
+      #
+      # @return [String]
+      #
+      attr_accessor :file_path
+
+      # Encryption key for this file
+      #
+      # @return [String, nil]
+      #
+      attr_accessor :key
+
+      # @param [String] algorithm
+      # @param [String] file_path
+      #
+      def initialize(algorithm, file_path)
+        @algorithm = algorithm
+        @file_path = file_path
+      end
+    end
+
+    ADOBE_OBFUSCATION = 'http://ns.adobe.com/pdf/enc#RC'
+    IDPF_OBFUSCATION = 'http://www.idpf.org/2008/embedding'
+
+    # @return [Hash<String, EncryptionItem>] key is abs file path (from root of EPUB), value is EncryptionItem
+    #
+    attr_reader :encryption_items
+
+    # @param [String] encryption_file contents of META-INF/encryption.xml file
+    # @param [Epuber::OpfFile] opf
+    #
+    def initialize(encryption_file, opf)
+      @opf = opf
+      @encryption_items = _prepare_items(encryption_file)
+    end
+
+    # @param [String] path
+    # @param [String] data
+    def process_file(path, data)
+      enc_item = @encryption_items[path]
+      data = EncryptionHandler.decrypt_data(enc_item.key, data, enc_item.algorithm) if enc_item
+
+      data
+    end
+
+    # Decrypt data with given key and algorithm
+    #
+    # @param [String] key
+    # @param [String] data
+    # @param [String] algorithm
+    #
+    def self.decrypt_data(key, data, algorithm)
+      is_adobe = algorithm == ADOBE_OBFUSCATION
+      crypt_len = is_adobe ? 1024 : 1040
+      crypt = data.byteslice(0, crypt_len)
+                  .bytes
+      key_cycle = key.bytes
+                     .cycle
+      decrypt = crypt.each_with_object([]) { |x, acc| acc << (x ^ key_cycle.next) }
+                     .pack('C*')
+      decrypt + data.byteslice(crypt_len..-1)
+    end
+
+    # Parse IDPF key from unique identifier (main identifier from OPF file)
+    #
+    # @param [String] raw_unique_identifier
+    #
+    # @return [String, nil]
+    #
+    def self.parse_idpf_key(raw_unique_identifier)
+      key = raw_unique_identifier.strip.gsub(/[\u0020\u0009\u000d\u000a]/, '')
+      Digest::SHA1.digest(key)
+    end
+
+    # @param [String] raw_unique_identifier
+    # @param [Array<Nokogiri::XML::Node>] identifiers
+    #
+    # @return [String, nil]
+    #
+    def self.find_and_parse_encryption_key(identifiers)
+      raw_identifier = identifiers.find do |i|
+        i['scheme']&.downcase == 'uuid' || i.text.strip.start_with?('urn:uuid:')
+      end&.text&.strip
+      return nil unless raw_identifier
+
+      uuid_str = raw_identifier.sub(/^urn:uuid:/, '')
+      UUIDTools::UUID.parse(uuid_str).raw
+    end
+
+    # Parse META-INF/encryption.xml file
+    #
+    # @return [Array<EncryptionItem>, nil]
+    #
+    def self.parse_encryption_file(string)
+      doc = Nokogiri::XML(string)
+      doc.remove_namespaces!
+
+      encryption_node = doc.at_css('encryption')
+      return nil unless encryption_node
+
+      encryption_node.css('EncryptedData')
+                     .map do |encrypted_data_node|
+                       algorithm = encrypted_data_node.at_css('EncryptionMethod')['Algorithm']
+                       file_path = encrypted_data_node.at_css('CipherData CipherReference')['URI']
+
+                       EncryptionItem.new(algorithm, file_path)
+                     end
+    end
+
+    # Prepare encryption items with correct keys
+    #
+    # @param [String] encryption_file
+    #
+    # @return [Hash<String, EncryptionItem>]
+    #
+    def _prepare_items(encryption_file)
+      idpf_key = EncryptionHandler.parse_idpf_key(@opf.raw_unique_identifier)
+      adobe_key = EncryptionHandler.find_and_parse_encryption_key(@opf.identifiers)
+
+      items = EncryptionHandler.parse_encryption_file(encryption_file)
+      items.each do |i|
+        if i.algorithm == EncryptionHandler::IDPF_OBFUSCATION
+          i.key = idpf_key
+        elsif i.algorithm == EncryptionHandler::ADOBE_OBFUSCATION
+          i.key = adobe_key
+        end
+      end
+      items.map { |i| [i.file_path, i] }.to_h
+    end
+  end
+end

data/lib/epuber/from_file/from_file_executor.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'zip'
+
+require_relative 'bookspec_generator'
+require_relative 'opf_file'
+require_relative 'nav_file'
+require_relative 'encryption_handler'
+
+module Epuber
+  class FromFileExecutor
+    MIMETYPE_PATH = 'mimetype'
+
+    ENCRYPTION_PATH = 'META-INF/encryption.xml'
+    CONTAINER_PATH = 'META-INF/container.xml'
+
+    # @param [String] filepath path to EPUB file
+    #
+    def initialize(filepath)
+      @filepath = filepath
+    end
+
+    def run
+      UI.puts "📖 Loading EPUB file #{@filepath}"
+
+      Zip::File.open(@filepath) do |zip_file|
+        @zip_file = zip_file
+
+        validate_mimetype
+
+        @opf_path = content_opf_path
+        UI.puts "  Parsing OPF file at #{@opf_path}"
+        @opf = OpfFile.new(zip_file.read(@opf_path))
+
+        if zip_file.find_entry(ENCRYPTION_PATH)
+          UI.puts '  Parsing encryption.xml file'
+          @encryption_handler = EncryptionHandler.new(zip_file.read(ENCRYPTION_PATH), @opf)
+        end
+
+        UI.puts '  Generating bookspec file'
+        basename = File.basename(@filepath, File.extname(@filepath))
+        File.write("#{basename}.bookspec", generate_bookspec)
+
+        export_files
+
+        UI.puts '' # empty line
+        UI.puts <<~TEXT.rstrip.ansi.green
+          🎉 Project initialized.
+          Please review generated #{basename}.bookspec file and start using Epuber.
+
+          For more information about Epuber, please visit https://github.com/epuber-io/epuber/tree/master/docs.
+        TEXT
+      end
+    end
+
+    # @param [Zip::File] zip_file
+    #
+    # @return [void]
+    #
+    def validate_mimetype
+      entry = @zip_file.find_entry(MIMETYPE_PATH)
+      UI.error! "This is not valid EPUB file (#{MIMETYPE_PATH} file is missing)" if entry.nil?
+
+      mimetype = @zip_file.read(entry)
+
+      return if mimetype == 'application/epub+zip'
+
+      UI.error! <<~MSG
+        This is not valid EPUB file (#{MIMETYPE_PATH} file does not contain required application/epub+zip, it is #{mimetype} instead)
+      MSG
+    end
+
+    # @param [Zip::File] zip_file
+    #
+    # @return [String]
+    def content_opf_path
+      entry = @zip_file.find_entry(CONTAINER_PATH)
+      UI.error! "This is not valid EPUB file (#{CONTAINER_PATH} file is missing)" if entry.nil?
+
+      doc = Nokogiri::XML(@zip_file.read(entry))
+      doc.remove_namespaces!
+
+      rootfile = doc.at_xpath('//rootfile')
+      if rootfile.nil?
+        UI.error! "This is not valid EPUB file (#{CONTAINER_PATH} file does not contain any <rootfile> element)"
+      end
+
+      rootfile['full-path']
+    end
+
+    # @param [Nokogiri::XML::Document] opf
+    # @param [Zip::File] zip_file
+    #
+    # @return [String]
+    def generate_bookspec
+      nav_node, nav_mode = @opf.find_nav
+      if nav_node
+        nav_path = Pathname.new(@opf_path)
+                           .dirname
+                           .join(nav_node.href)
+                           .to_s
+        nav = NavFile.new(@zip_file.read(nav_path), nav_mode)
+      end
+
+      BookspecGenerator.new(@opf, nav).generate_bookspec
+    end
+
+    def export_files
+      @opf.manifest_items.each_value do |item|
+        # ignore text files which are not in spine
+        text_file_extensions = %w[.xhtml .html]
+        extension = File.extname(item.href).downcase
+        if text_file_extensions.include?(extension) &&
+           @opf.spine_items.none? { |spine_item| spine_item.idref == item.id }
+          UI.puts "  Skipping #{item.href} (not in spine)"
+          next
+        end
+
+        # ignore ncx file
+        if item.media_type == 'application/x-dtbncx+xml'
+          UI.puts "  Skipping #{item.href} (ncx file)"
+          next
+        end
+
+        full_path = Pathname.new(@opf_path)
+                            .dirname
+                            .join(item.href)
+                            .to_s
+
+        UI.puts "  Exporting #{item.href} (from #{full_path})"
+
+        contents = @zip_file.read(full_path)
+        contents = @encryption_handler.process_file(full_path, contents) if @encryption_handler
+
+        FileUtils.mkdir_p(File.dirname(item.href))
+        File.write(item.href, contents)
+      end
+    end
+  end
+end

data/lib/epuber/from_file/nav_file.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Epuber
+  class NavFile
+    class NavItem
+      # @return [String]
+      attr_accessor :href
+      # @return [String]
+      attr_accessor :title
+      # @return [Array<NavItem>]
+      attr_accessor :children
+
+      # @param [String] href
+      # @param [String] title
+      #
+      def initialize(href, title)
+        @href = href
+        @title = title
+        @children = []
+      end
+
+      # @param [String] other_href
+      # @param [Boolean] ignore_fragment
+      #
+      # @return [NavItem, nil]
+      #
+      def find_by_href(other_href, ignore_fragment: false)
+        if ignore_fragment
+          other_href = other_href.split('#').first
+          self_href = @href.split('#').first
+          return self if self_href == other_href
+        elsif @href == other_href
+          return self
+        end
+
+        @children.find { |item| item.find_by_href(other_href) }
+      end
+    end
+
+    class LandmarkItem
+      # @return [String]
+      #
+      attr_accessor :href
+
+      # @return [String]
+      #
+      attr_accessor :type
+
+      # @param [String] href
+      # @param [String] type
+      #
+      def initialize(href, type)
+        @href = href
+        @type = type
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [LandmarkItem]
+      #
+      def self.from_node(node)
+        new(node['href'], node['type'])
+      end
+    end
+
+    LANDMARKS_MAP = {
+      'cover' => :landmark_cover,
+      'bodymatter' => :landmark_start_page,
+      'copyright-page' => :landmark_copyright,
+      'toc' => :landmark_toc,
+    }.freeze
+
+    MODE_NCX = :ncx
+    MODE_XHTML = :xhtml
+
+    # @return [Nokogiri::XML::Document]
+    #
+    attr_reader :document
+
+    # @return [:ncx, :xhtml]
+    #
+    attr_reader :mode
+
+    # @return [Array<NavItem>]
+    #
+    attr_reader :items
+
+    # @return [Array<LandmarkItem>, nil]
+    #
+    attr_reader :landmarks
+
+    # @param [string] document
+    # @param [:ncx, :xhtml] mode
+    #
+    def initialize(document, mode)
+      raise ArgumentError, 'mode must be :ncx or :xhtml' unless [MODE_NCX, MODE_XHTML].include?(mode)
+
+      @document = Nokogiri::XML(document)
+      @document.remove_namespaces!
+
+      @mode = mode
+      @items = _parse
+
+      @landmarks = _parse_landmarks
+    end
+
+    # @param [String] href
+    # @param [Boolean] ignore_fragment
+    #
+    # @return [NavItem, nil]
+    #
+    def find_by_href(href, ignore_fragment: false)
+      @items.find { |item| item.find_by_href(href, ignore_fragment: ignore_fragment) }
+    end
+
+    private
+
+    # @param [Nokogiri::XML::Element] li_node
+    #
+    # @return [NavItem]
+    #
+    def _parse_nav_xhtml_item(li_node)
+      href = li_node.at_css('a')['href'].strip
+      title = li_node.at_css('a').text.strip
+
+      item = NavItem.new(href, title)
+      item.children = li_node.css('ol > li').map { |p| _parse_nav_xhtml_item(p) }
+      item
+    end
+
+    # @param [Nokogiri::XML::Element] point_node
+    #
+    # @return [NavItem]
+    #
+    def _parse_nav_ncx_item(point_node)
+      href = point_node.at_css('content')['src'].strip
+      title = point_node.at_css('navLabel text').text.strip
+
+      item = NavItem.new(href, title)
+      item.children = point_node.css('> navPoint').map { |p| _parse_nav_ncx_item(p) }
+      item
+    end
+
+    # @return [Array<NavItem>]
+    #
+    def _parse
+      if @mode == MODE_XHTML
+        @document.css('nav[type="toc"] > ol > li')
+                 .map { |point| _parse_nav_xhtml_item(point) }
+      elsif @mode == MODE_NCX
+        @document.css('navMap > navPoint')
+                 .map { |point| _parse_nav_ncx_item(point) }
+      end
+    end
+
+    def _parse_landmarks
+      return nil if @mode != MODE_XHTML
+
+      @document.css('nav[type="landmarks"] > ol > li > a')
+               .map { |node| LandmarkItem.from_node(node) }
+    end
+  end
+end

data/lib/epuber/from_file/opf_file.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Epuber
+  class OpfFile
+    class ManifestItem
+      # @return [String]
+      #
+      attr_accessor :id
+
+      # @return [String]
+      #
+      attr_accessor :href
+
+      # @return [String]
+      #
+      attr_accessor :media_type
+
+      # @return [String, nil]
+      #
+      attr_accessor :properties
+
+      def initialize(id, href, media_type, properties)
+        @id = id
+        @href = href
+        @media_type = media_type
+        @properties = properties
+      end
+
+      # @param [ManifestItem] other
+      #
+      # @return [Boolean]
+      #
+      def ==(other)
+        @id == other.id
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [ManifestItem]
+      #
+      def self.from_node(node)
+        new(node['id'], node['href'], node['media-type'], node['properties'])
+      end
+    end
+
+    class SpineItem
+      # @return [String]
+      #
+      attr_accessor :idref
+
+      # @return [String]
+      #
+      attr_accessor :linear
+
+      def initialize(idref, linear)
+        @idref = idref
+        @linear = linear
+      end
+
+      # @param [SpineItem] other
+      #
+      # @return [Boolean]
+      #
+      def ==(other)
+        @idref == other.idref
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [SpineItem]
+      #
+      def self.from_node(node)
+        new(node['idref'], node['linear'])
+      end
+    end
+
+    class GuideItem
+      # @return [String]
+      #
+      attr_accessor :type
+
+      # @return [String]
+      #
+      attr_accessor :href
+
+      def initialize(type, href)
+        @type = type
+        @href = href
+      end
+
+      # @param [Nokogiri::XML::Node] node
+      #
+      # @return [GuideItem]
+      #
+      def self.from_node(node)
+        new(node['type'], node['href'])
+      end
+    end
+
+    # reversed map of generator's map
+    LANDMARKS_MAP = Compiler::OPFGenerator::LANDMARKS_MAP.map { |k, v| [v, k] }
+                                                         .to_h
+                                                         .freeze
+
+    # @return [Nokogiri::XML::Document]
+    #
+    attr_reader :document
+
+    # @return [Nokogiri::XML::Node, nil]
+    #
+    attr_reader :package, :metadata, :manifest, :spine
+
+    # @return [Hash<String, ManifestItem>]
+    #
+    attr_reader :manifest_items
+
+    # @return [Array<SpineItem>]
+    #
+    attr_reader :spine_items
+
+    # @return [Array<GuideItem>]
+    #
+    attr_reader :guide_items
+
+    # @param [String] document
+    def initialize(xml)
+      @document = Nokogiri::XML(xml)
+      @document.remove_namespaces!
+
+      @package = @document.at_css('package')
+      @metadata = @document.at_css('package metadata')
+      @manifest = @document.at_css('package manifest')
+      @spine = @document.at_css('package spine')
+
+      @manifest_items = @document.css('package manifest item')
+                                 .map { |node| ManifestItem.from_node(node) }
+                                 .map { |item| [item.id, item] }
+                                 .to_h
+      @spine_items = @document.css('package spine itemref')
+                              .map { |node| SpineItem.from_node(node) }
+      @guide_items = @document.css('package guide reference')
+                              .map { |node| GuideItem.from_node(node) }
+    end
+
+    # Find nav file in EPUB (both EPUB 2 and EPUB 3). Returns array with nav and type of nav (:xhtml or :ncx).
+    #
+    # @return [Array<ManifestItem, [:ncx, :xhtml]>, nil] nav, ncx
+    #
+    def find_nav
+      nav = @manifest_items.find { |_, item| item.properties == 'nav' }&.last
+      return [nav, NavFile::MODE_XHTML] if nav
+
+      ncx_id = @spine['toc'] if @spine
+      ncx = manifest_file_by_id(ncx_id) if ncx_id
+      return [ncx, NavFile::MODE_NCX] if ncx
+
+      nil
+    end
+
+    # Returns main unique identifier of this EPUB
+    #
+    # @return [String, nil]
+    #
+    def raw_unique_identifier
+      id = @package['unique-identifier']
+      return unless id
+
+      @metadata.at_css(%(identifier[id="#{id}"]))&.text
+    end
+
+    # Return all identifiers from EPUB metadata
+    #
+    # @return [Array<Nokogiri::XML::Node>]
+    #
+    def identifiers
+      @metadata.css('identifier')
+    end
+
+    # Find meta refines in EPUB 3 metadata
+    #
+    # @param [String] id
+    # @param [String] property
+    #
+    # @return [String, nil]
+    #
+    def find_refines(id, property)
+      @metadata.at_css(%(meta[refines="##{id}"][property="#{property}"]))&.text
+    end
+
+    # Find file in <manifest> by id. Throws exception when not found.
+    #
+    # @param [String] id
+    #
+    # @return [ManifestItem]
+    #
+    def manifest_file_by_id(id)
+      item = @manifest_items[id]
+      raise "Manifest item with id #{id.inspect} not found" unless item
+
+      item
+    end
+
+    # Find file in <manifest> by href. Throws exception when not found.
+    #
+    # @param [String] href
+    #
+    # @return [ManifestItem]
+    #
+    def manifest_file_by_href(href)
+      # remove anchor
+      href = href.sub(/#.*$/, '')
+
+      item = @manifest_items.find { |_, i| i.href == href }&.last
+      raise "Manifest item with href #{href.inspect} not found" unless item
+
+      item
+    end
+  end
+end

data/lib/epuber/plugin.rb

@@ -66,7 +66,7 @@ module Epuber
     #
     attr_reader :files
 
-    # @param path [String]
+    # @param [String] path
     #
     def initialize(path)
       @path = path