epuber 0.7.4 → 0.9.0

data/lib/epuber/dsl/tree_object.rb

@@ -10,7 +10,7 @@ module Epuber
       def initialize(parent = nil)
         super()
 
-        @parent      = parent
+        @parent = parent
         @sub_items = []
 
         parent.sub_items << self unless parent.nil?
@@ -94,8 +94,7 @@ module Epuber
 
       protected
 
-      attr_writer :parent
-      attr_writer :sub_items
+      attr_writer :parent, :sub_items
     end
   end
 end

data/lib/epuber/epubcheck.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Epuber
+  class Epubcheck
+    class << self
+      # @param [String] path path to file
+      #
+      def check(path)
+        res = system('epubcheck', path)
+
+        UI.error!('Epubcheck failed') unless res
+      end
+    end
+  end
+end

data/lib/epuber/from_file/bookspec_generator.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Epuber
+  class BookspecGenerator
+    class TocItem
+      # @return [String]
+      #
+      attr_accessor :href
+
+      # @return [String, nil]
+      #
+      attr_accessor :title
+
+      # @return [Array<TocItem>]
+      #
+      attr_accessor :children
+
+      # @return [Array<Symbol>]
+      #
+      attr_accessor :landmarks
+
+      def initialize(href, title = nil, landmarks = [], children = [])
+        @href = href
+        @title = title
+        @landmarks = landmarks
+        @children = children
+      end
+
+      def attribs
+        [href.inspect, title&.inspect, *landmarks.map(&:inspect)].compact.join(', ')
+      end
+
+      def ==(other)
+        other.is_a?(TocItem) &&
+          href == other.href &&
+          title == other.title &&
+          landmarks == other.landmarks &&
+          children == other.children
+      end
+
+      def to_s(level = 0)
+        indent = ' ' * level
+        children_str = children.map { |c| c.to_s(level + 2) }.join("\n")
+        %(#{indent}#{href.inspect} #{title.inspect} #{landmarks.inspect}\n#{children_str})
+      end
+
+      def inspect
+        %(#<#{self.class.name} #{self}>)
+      end
+    end
+
+    # @param [Epuber::OpfFile] opf
+    # @param [Epuber::NavFile, nil] nav
+    #
+    def initialize(opf, nav)
+      @opf = opf
+      @nav = nav
+    end
+
+    # @return [String]
+    #
+    def generate_bookspec
+      @indent = 0
+      @bookspec = []
+
+      add_code('Epuber::Book.new do |book|', after: 'end') do
+        generate_titles
+        generate_authors
+        add_empty_line
+        generate_id
+        generate_language
+        generate_published
+        generate_publisher
+        add_empty_line
+        generate_cover
+        add_empty_line
+        generate_toc
+      end
+      add_empty_line
+
+      @bookspec.join("\n")
+    end
+
+    # @return [void]
+    #
+    def generate_titles
+      titles = @opf.metadata.css('title')
+      titles.each do |title|
+        is_main = titles.count == 1
+
+        id = title['id']
+        is_main = @opf.find_refines(id, 'title-type') == 'main' if id && !is_main
+
+        add_comment('alternate title found from original EPUB file (Epuber supports only one title)') unless is_main
+        add_setting_property(:title, title.text.inspect, commented: !is_main)
+      end
+    end
+
+    # @return [void]
+    #
+    def generate_authors
+      authors = @opf.metadata.css('creator')
+      if authors.empty?
+        add_setting_property(:author, nil)
+      elsif authors.count == 1
+        add_setting_property(:author, format_author(authors.first))
+      else
+        add_setting_property(:authors, authors.map { |auth| format_author(auth) })
+      end
+    end
+
+    # @return [String]
+    #
+    def format_author(author_node)
+      name = author_node.text.strip
+      id = author_node['id']
+
+      if id
+        role = @opf.find_refines(id, 'role')
+        file_as = @opf.find_refines(id, 'file-as')
+      end
+
+      role ||= author_node['opf:role']
+      file_as ||= author_node['opf:file-as']
+
+      role_is_default = role.nil? || role == 'aut'
+      file_as_is_default = file_as.nil? || contributor_file_as_eq?(Book::Contributor.from_obj(name).file_as, file_as)
+
+      if role_is_default && file_as_is_default
+        name.inspect
+      elsif role_is_default && !file_as_is_default
+        %({ pretty_name: #{name.inspect}, file_as: #{file_as.inspect} })
+      elsif !role_is_default && file_as_is_default
+        %({ name: #{name.inspect}, role: #{role.inspect} })
+      else
+        %({ pretty_name: #{name.inspect}, file_as: #{file_as.inspect}, role: #{role.inspect} })
+      end
+    end
+
+    # @return [void]
+    #
+    def generate_id
+      nodes = @opf.metadata.css('identifier')
+
+      nodes.each do |id_node|
+        value = id_node.text.strip
+
+        is_main = @opf.package['unique-identifier'] == id_node['id']
+        is_isbn = value.start_with?('urn:isbn:')
+        value = value.sub(/^urn:isbn:/, '').strip if is_isbn
+        key = is_isbn ? :isbn : :identifier
+
+        if is_main
+          add_setting_property(key, value.inspect)
+        else
+          add_comment('alternate identifier found from original EPUB file (Epuber supports only one identifier)')
+          add_setting_property(key, value.inspect, commented: true)
+        end
+      end
+    end
+
+    # @return [void]
+    #
+    def generate_language
+      language = @opf.metadata.at_css('language')
+      add_setting_property(:language, language.text.strip.inspect) if language
+    end
+
+    # @return [void]
+    #
+    def generate_published
+      published = @opf.metadata.at_css('date')
+      add_setting_property(:published, published.text.strip.inspect) if published
+    end
+
+    # @return [void]
+    #
+    def generate_publisher
+      publisher = @opf.metadata.at_css('publisher')
+      add_setting_property(:publisher, publisher.text.strip.inspect) if publisher
+    end
+
+    # @return [void]
+    #
+    def generate_cover
+      cover_property = Compiler::OPFGenerator::PROPERTIES_MAP[:cover_image]
+
+      cover_id = @opf.manifest_items.find { |_, item| item.properties&.include?(cover_property) }&.last&.id
+      cover_id ||= @opf.metadata.at_css('meta[name="cover"]')&.[]('content')
+      cover = @opf.manifest_file_by_id(cover_id) if cover_id
+      return unless cover
+
+      href = cover.href.sub(/#{Regexp.escape(File.extname(cover.href))}$/, '')
+      add_setting_property(:cover_image, href.inspect)
+    end
+
+    # @return [void]
+    #
+    def generate_toc
+      items = calculate_toc_items
+
+      render_toc_item = lambda do |item|
+        if item.children.empty?
+          add_code(%(toc.file #{item.attribs}))
+        else
+          add_code(%(toc.file #{item.attribs} do), after: 'end') do
+            item.children.each do |child|
+              render_toc_item.call(child)
+            end
+          end
+        end
+      end
+
+      add_code('book.toc do |toc, target|', after: 'end') do
+        items.each do |toc_item|
+          render_toc_item.call(toc_item)
+        end
+      end
+    end
+
+    private
+
+    # Add code to final file. When block is given, it will be indented.
+    #
+    # @param [String] code  code to print into final file
+    # @param [Boolean] commented should be code commented?
+    # @param [String, nil] after code to print after this code
+    #
+    # @return [void]
+    #
+    def add_code(code, commented: false, after: nil)
+      indent_str = ' ' * @indent
+      comment_prefix = commented ? '# ' : ''
+
+      @bookspec << %(#{indent_str}#{comment_prefix}#{code})
+
+      if block_given?
+        increase_indent
+        yield
+        decrease_indent
+      end
+
+      add_code(after, commented: commented) if after
+    end
+
+    def add_setting_property(name, value, commented: false)
+      if value.is_a?(Array)
+        add_code(%(book.#{name} = [), commented: commented, after: ']') do
+          value.each do |v|
+            add_code(%(#{v},), commented: commented)
+          end
+        end
+      else
+        add_code(%(book.#{name} = #{value}), commented: commented)
+      end
+    end
+
+    def add_comment(text)
+      add_code(text, commented: true)
+    end
+
+    def add_empty_line
+      return if @bookspec.last == ''
+
+      @bookspec << ''
+    end
+
+    def increase_indent
+      @indent += 2
+    end
+
+    def decrease_indent
+      @indent -= 2
+      @indent = 0 if @indent.negative?
+    end
+
+    # Compares two contributors by file_as, it will return true if file_as is same even when case is different
+    #
+    # @param [String] file_as_a
+    # @param [String] file_as_b
+    #
+    # @return [Boolean]
+    #
+    def contributor_file_as_eq?(file_as_a, file_as_b)
+      file_as_a == file_as_b || file_as_a.mb_chars.downcase == file_as_b.mb_chars.downcase
+    end
+
+    # @param [String] href
+    #
+    # @return [Array<Symbol>]
+    #
+    def landmark_for_href(href)
+      landmarks = @nav&.landmarks
+      landmark_map = NavFile::LANDMARKS_MAP unless landmarks.nil?
+
+      if landmarks.nil?
+        landmarks = @opf.guide_items
+        landmark_map = OpfFile::LANDMARKS_MAP
+      end
+
+      found = landmarks.select { |l| l.href == href }
+                       .map(&:type)
+                       .compact
+                       .map { |t| landmark_map[t] }
+                       .compact
+
+      return found unless found.empty?
+
+      # try to find by href without fragment
+      if href.include?('#')
+        href = href.split('#').first
+        return landmark_for_href(href)
+      end
+
+      []
+    end
+
+    # @return [Array<Epuber::BookspecGenerator::TocItem>]
+    #
+    def calculate_toc_items
+      spine_items = @opf.spine_items
+      idrefs = spine_items.map(&:idref)
+      landmarks = Set.new
+
+      # @param [ManifestItem, nil] manifest_item
+      # @param [NavItem, nil] toc_item
+      #
+      # @return [Array<Epuber::BookspecGenerator::TocItem>]
+      #
+      render_toc_item = lambda do |manifest_item, toc_item|
+        # ignore this item when it was already rendered
+        next nil if manifest_item && !idrefs.include?(manifest_item.id)
+
+        manifest_item ||= @opf.manifest_file_by_href(toc_item.href)
+
+        href = toc_item&.href || manifest_item.href
+        toc_item ||= @nav&.find_by_href(href) || @nav&.find_by_href(href, ignore_fragment: true)
+        href = toc_item&.href || manifest_item.href
+
+        href_output = href.sub(/\.x?html$/, '')
+                          .sub(/\.x?html#/, '#')
+
+        landmarks_for_this = landmark_for_href(href)
+        unless landmarks_for_this.empty?
+          diff = Set.new(landmarks_for_this) - landmarks
+          landmarks += diff
+
+          landmarks_for_this = diff.to_a
+        end
+
+        item = TocItem.new(href_output, toc_item&.title, landmarks_for_this)
+        item.children = toc_item&.children&.map do |child|
+          render_toc_item.call(nil, child)
+        end || []
+
+        idrefs.delete(manifest_item.id) if manifest_item
+
+        item
+      end
+
+      spine_items.map do |itemref|
+        idref = itemref.idref
+        next unless idref
+
+        render_toc_item.call(@opf.manifest_file_by_id(idref), nil)
+      end.compact
+    end
+  end
+end

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