eeepub_ext 0.8.2

data/lib/eeepub/maker.rb

@@ -0,0 +1,156 @@
+require 'tmpdir'
+require 'fileutils'
+
+module EeePub
+  # The class to make ePub easily
+  #
+  # Note on unique identifiers:
+  #
+  #   At least one 'identifier' must be the unique identifer represented by the name
+  #   given to 'uid' and set via the hash option :id => {name}.  The default name for
+  #   uid is 'BookId' and doesn't need to be specified explicitly.  If no identifier is
+  #   marked as the unique identifier, the first one give will be chosen.
+  #
+  # @example
+  #   epub = EeePub.make do
+  #     title       'sample'
+  #     creator     'jugyo'
+  #     publisher   'jugyo.org'
+  #     date        '2010-05-06'
+  #     uid         'BookId'
+  #     identifier  'http://example.com/book/foo', :scheme => 'URL', :id => 'BookId'
+  #
+  #     files ['/path/to/foo.html', '/path/to/bar.html']
+  #     nav [
+  #       {:label => '1. foo', :content => 'foo.html', :nav => [
+  #         {:label => '1.1 foo-1', :content => 'foo.html#foo-1'}
+  #       ]},
+  #       {:label => '1. bar', :content => 'bar.html'}
+  #     ]
+  #   end
+  #   epub.save('sample.epub')
+  class Maker
+    [
+      :title,
+      :creator,
+      :publisher,
+      :date,
+      :language,
+      :subject,
+      :description,
+      :rights,
+      :relation
+    ].each do |name|
+      class_eval <<-DELIM
+        def #{name}(value)
+          @#{name}s ||= []
+          @#{name}s << value
+        end
+      DELIM
+    end
+
+    [
+      :uid,
+      :files,
+      :nav,
+      :cover,
+      :ncx_file,
+      :opf_file,
+      :guide
+    ].each do |name|
+      define_method(name) do |arg|
+        instance_variable_set("@#{name}", arg)
+      end
+    end
+
+    def identifier(id, options)
+      @identifiers ||= []
+      @identifiers << {:value => id, :scheme => options[:scheme], :id => options[:id]}
+    end
+
+    # @param [Proc] block the block for initialize
+    def initialize(&block)
+      @files ||= []
+      @nav ||= []
+      @ncx_file ||= 'toc.ncx'
+      @opf_file ||= 'content.opf'
+
+      instance_eval(&block) if block_given?
+    end
+
+    # Save as ePub file
+    #
+    # @param [String] filename the ePub file name to save
+    def save(filename)
+      create_epub.save(filename)
+    end
+
+    # instead of saving to file, output the file contents.
+    # important for serving on-the-fly doc creation from
+    # web interface where we don't want to allow file system
+    # writes (Heroku, et al.)
+    def render
+      create_epub.render
+    end
+
+    private
+
+    def create_epub
+      @uid ||= 'BookId'
+      unique_identifier = @identifiers.select{ |i| i[:id] == @uid }.first
+      unless unique_identifier
+        unique_identifier = @identifiers.first
+        unique_identifier[:id] = @uid
+      end
+      dir = Dir.mktmpdir
+      @files.each do |file|
+        case file
+        when String
+          FileUtils.cp(file, dir)
+        when Hash
+          file_path, dir_path = *file.first
+          dest_dir = File.join(dir, dir_path)
+          FileUtils.mkdir_p(dest_dir)
+          FileUtils.cp(file_path, dest_dir)
+        end
+      end
+
+      NCX.new(
+        :uid => @identifiers.select{ |i| i[:id] == @uid }.first,
+        :title => @titles[0],
+        :nav => @nav
+      ).save(File.join(dir, @ncx_file))
+
+      OPF.new(
+        :title => @titles,
+        :unique_identifier => @uid,
+        :identifier => @identifiers,
+        :creator => @creators,
+        :publisher => @publishers,
+        :date => @dates,
+        :language => @languages,
+        :subject => @subjects,
+        :description => @descriptions,
+        :rights => @rightss,
+        :cover => @cover,
+        :relation => @relations,
+        :manifest => @files.map{|file|
+          case file
+          when String
+            File.basename(file)
+          when Hash
+            file_path, dir_path = *file.first
+            File.join(dir_path, File.basename(file_path))
+          end
+        },
+        :ncx => @ncx_file,
+        :guide => @guide
+      ).save(File.join(dir, @opf_file))
+
+      OCF.new(
+        :dir => dir,
+        :container => @opf_file
+      )
+    end
+  end
+end

data/lib/eeepub/ncx.rb

@@ -0,0 +1,68 @@
+module EeePub
+  class NCX < ContainerItem
+    attr_accessor :uid,
+                  :depth,
+                  :total_page_count,
+                  :max_page_number,
+                  :doc_title,
+                  :nav_map
+
+    attr_alias :title, :doc_title
+    attr_alias :nav, :nav_map
+
+    default_value :depth, 1
+    default_value :total_page_count, 0
+    default_value :max_page_number, 0
+    default_value :doc_title, 'Untitled'
+
+    def build_xml(builder)
+      builder.declare! :DOCTYPE, :ncx, :PUBLIC, "-//NISO//DTD ncx 2005-1//EN", "http://www.daisy.org/z3986/2005/ncx-2005-1.dtd"
+      builder.ncx :xmlns => "http://www.daisy.org/z3986/2005/ncx/", :version => "2005-1" do
+        build_head(builder)
+        builder.docTitle { builder.text doc_title }
+        build_nav_map(builder)
+      end
+    end
+
+    def build_head(builder)
+      builder.head do
+        {
+          :uid => uid,
+          :depth => depth,
+          :totalPageCount => total_page_count,
+          :maxPageNumber => max_page_number
+        }.each do |k, v|
+          builder.meta :name => "dtb:#{k}", :content => v
+        end
+      end
+    end
+
+    def build_nav_map(builder)
+      builder.navMap do
+        builder_nav_point(builder, nav_map)
+      end
+    end
+
+    def builder_nav_point(builder, nav_point, play_order = 1)
+      case nav_point
+      when Array
+        nav_point.each do |point|
+          play_order = builder_nav_point(builder, point, play_order)
+        end
+      when Hash
+        id = nav_point[:id] || "navPoint-#{play_order}"
+        builder.navPoint :id => id, :playOrder => play_order do
+          builder.navLabel { builder.text nav_point[:label] }
+          builder.content :src => nav_point[:content]
+          play_order += 1
+          if nav_point[:nav]
+            play_order = builder_nav_point(builder, nav_point[:nav], play_order)
+          end
+        end
+      else
+        raise "nav_point must be Array or Hash"
+      end
+      play_order
+    end
+  end
+end

data/lib/eeepub/ocf.rb

@@ -0,0 +1,129 @@
+require 'zip'
+module EeePub
+  # Class to create OCF
+  class OCF
+    # Class for 'container.xml' of OCF
+    class Container < ContainerItem
+      attr_accessor :rootfiles
+
+      # @param [String or Array or Hash]
+      #
+      # @example
+      #   # with String
+      #   EeePub::OCF::Container.new('container.opf')
+      #
+      # @example
+      #   # with Array
+      #   EeePub::OCF::Container.new(['container.opf', 'other.opf'])
+      #
+      # @example
+      #   # with Hash
+      #   EeePub::OCF::Container.new(
+      #     :rootfiles => [
+      #       {:full_path => 'container.opf', :media_type => 'application/oebps-package+xml'}
+      #     ]
+      #   )
+      def initialize(arg)
+        case arg
+        when String
+          set_values(
+            :rootfiles => [
+              {:full_path => arg, :media_type => guess_media_type(arg)}
+            ]
+          )
+        when Array
+          # TODO: spec
+          set_values(
+            :rootfiles => arg.keys.map { |k|
+              filename = arg[k]
+              {:full_path => filename, :media_type => guess_media_type(filename)}
+            }
+          )
+        when Hash
+          set_values(arg)
+        end
+      end
+
+      private
+
+      def build_xml(builder)
+        builder.container :xmlns => "urn:oasis:names:tc:opendocument:xmlns:container", :version => "1.0" do
+          builder.rootfiles do
+            rootfiles.each do |i|
+              builder.rootfile convert_to_xml_attributes(i)
+            end
+          end
+        end
+      end
+    end
+
+    attr_accessor :dir, :container
+
+    # @param [Hash<Symbol, Object>] values the values of symbols and objects for OCF
+    #
+    # @example
+    #   EeePub::OCF.new(
+    #     :dir => '/path/to/dir',
+    #     :container => 'container.opf'
+    #   )
+    def initialize(values)
+      values.each do |k, v|
+        self.send(:"#{k}=", v)
+      end
+    end
+
+    # Set container
+    #
+    # @param [EeePub::OCF::Container or args for EeePub::OCF::Container]
+    def container=(arg)
+      if arg.is_a?(EeePub::OCF::Container)
+        @container = arg
+      else
+        # TODO: spec
+        @container = EeePub::OCF::Container.new(arg)
+      end
+    end
+
+    # Save as OCF
+    #
+    # @param [String] output_path the output file path of ePub
+    def save(output_path)
+      output_path = File.expand_path(output_path)
+      create_epub do
+        mimetype = Zip::OutputStream::open(output_path) do |os|
+          os.put_next_entry("mimetype", nil, nil, Zip::Entry::STORED, Zlib::NO_COMPRESSION)
+          os << "application/epub+zip"
+        end
+        zipfile = Zip::File.open(output_path)
+        Dir.glob('**/*').each do |path|
+          zipfile.add(path, path)
+        end
+        zipfile.commit
+      end
+      FileUtils.remove_entry_secure dir
+    end
+
+    # Stream OCF
+    #
+    # @return [String] streaming output of the zip/epub file.
+    def render
+      create_epub do
+        temp_file = Tempfile.new("ocf")
+        self.save(temp_file.path)
+        return temp_file.read
+      end
+    end
+
+    private
+    def create_epub
+      FileUtils.chdir(dir) do
+        meta_inf = 'META-INF'
+        FileUtils.mkdir_p(meta_inf)
+
+        container.save(File.join(meta_inf, 'container.xml'))
+        yield
+      end
+
+    end
+  end
+end

data/lib/eeepub/opf.rb

@@ -0,0 +1,150 @@
+module EeePub
+  class OPF < ContainerItem
+    attr_accessor :unique_identifier,
+                  :title,
+                  :language,
+                  :identifier,
+                  :date,
+                  :subject,
+                  :description,
+                  :relation,
+                  :creator,
+                  :publisher,
+                  :rights,
+                  :manifest,
+                  :spine,
+                  :guide,
+                  :cover,
+                  :ncx,
+                  :toc
+
+    default_value :toc, 'ncx'
+    default_value :unique_identifier, 'BookId'
+    default_value :title, 'Untitled'
+    default_value :language, 'en'
+
+    attr_alias :files, :manifest
+
+    def identifier
+      case @identifier
+      when Array
+        @identifier
+      when String
+        [{:value => @identifier, :id => unique_identifier}]
+      when Hash
+        @identifier[:id] = unique_identifier
+        [@identifier]
+      else
+        @identifier
+      end
+    end
+
+    def spine
+      @spine ||
+        complete_manifest.
+          select { |i| i[:media_type] == 'application/xhtml+xml' }.
+          map { |i| i[:id]}
+    end
+
+    def build_xml(builder)
+      builder.package :xmlns => "http://www.idpf.org/2007/opf",
+          'unique-identifier' => unique_identifier,
+          'version' => "2.0" do
+
+        build_metadata(builder)
+        build_manifest(builder)
+        build_spine(builder)
+        build_guide(builder)
+      end
+    end
+
+    def build_metadata(builder)
+      builder.metadata 'xmlns:dc' => "http://purl.org/dc/elements/1.1/",
+        'xmlns:dcterms' => "http://purl.org/dc/terms/",
+        'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
+        'xmlns:opf' => "http://www.idpf.org/2007/opf" do
+
+        identifier.each do |i|
+          attrs = {}
+          attrs['opf:scheme'] = i[:scheme] if i[:scheme]
+          attrs[:id] = i[:id] if i[:id]
+          builder.dc :identifier, i[:value], attrs
+        end
+
+        [:title, :language, :subject, :description, :relation, :creator, :publisher, :date, :rights].each do |i|
+          value = self.send(i)
+          next unless value
+
+          [value].flatten.each do |v|
+            case v
+            when Hash
+              builder.dc i, v[:value], convert_to_xml_attributes(v.reject {|k, v| k == :value})
+            else
+              builder.dc i, v
+            end
+          end
+        end
+        builder.meta(:name => 'cover', :content => self.cover) if self.cover
+      end
+    end
+
+    def build_manifest(builder)
+      builder.manifest do
+        complete_manifest.each do |i|
+          builder.item :id => i[:id], :href => i[:href], 'media-type' => i[:media_type]
+        end
+      end
+    end
+
+    def build_spine(builder)
+      builder.spine :toc => toc do
+        spine.each do |i|
+          builder.itemref :idref => i
+        end
+      end
+    end
+
+    def build_guide(builder)
+      return if guide.nil? || guide.empty?
+
+      builder.guide do
+        guide.each do |i|
+          builder.reference convert_to_xml_attributes(i)
+        end
+      end
+    end
+
+    def complete_manifest
+      item_id_cache = {}
+
+      result = manifest.map do |i|
+        case i
+        when String
+          id = create_unique_item_id(i, item_id_cache)
+          href = i
+          media_type = guess_media_type(i)
+        when Hash
+          id = i[:id] || create_unique_item_id(i[:href], item_id_cache)
+          href = i[:href]
+          media_type = i[:media_type] || guess_media_type(i[:href])
+        end
+        {:id => id, :href => href, :media_type => media_type}
+      end
+
+      result += [{:id => 'ncx', :href => ncx, :media_type => 'application/x-dtbncx+xml'}] if ncx
+      result
+    end
+
+    def create_unique_item_id(filename, id_cache)
+      basename = File.basename(filename)
+      unless id_cache[basename]
+        id_cache[basename] = 0
+        name = basename
+      else
+        name = "#{basename}-#{id_cache[basename]}"
+      end
+      id_cache[basename] += 1
+      name
+    end
+  end
+end