epub-maker 0.0.1

data/lib/epub/maker/publication.rb

@@ -0,0 +1,340 @@
+require 'epub/publication/package'
+
+module EPUB
+  module Publication
+    class Package
+      def to_xml(options={:encoding => 'UTF-8'})
+        Nokogiri::XML::Builder.new(options) {|xml|
+          attrs = {
+            'version'           => '3.0',
+            'xmlns'             => EPUB::NAMESPACES['opf'],
+            'unique-identifier' => unique_identifier.id
+          }
+          [
+           ['dir', dir],
+           ['id', id],
+           ['xml:lang', xml_lang],
+           ['prefix', prefix.reduce('') {|attr, (pfx, iri)| [attr, [pfx, iri].join(':')].join(' ')}]
+          ].each do |(name, value)|
+            next if value.nil? or value.empty?
+            attrs[name] = value
+          end
+          xml.package_(attrs) do
+            (EPUB::Publication::Package::CONTENT_MODELS - [:bindings, :guide]).each do |model|
+              __send__(model).to_xml_fragment xml
+            end
+            if bindings and !bindings.media_types.empty?
+              bindings.to_xml_fragment xml
+            end
+          end
+        }.to_xml
+      end
+
+      def make
+        (CONTENT_MODELS - [:bindings, :guide]).each do |model|
+          klass = self.class.const_get(model.to_s.capitalize)
+          obj = klass.new
+          __send__ "#{model}=", obj
+        end
+        yield self if block_given?
+        self
+      end
+
+      def make_metadata
+        self.metadata = Metadata.new
+        metadata.make do
+          yield metadata if block_given?
+        end
+        metadata
+      end
+
+      def make_manifest
+        self.manifest = Manifest.new
+        manifest.make do
+          yield manifest if block_given?
+        end
+        manifest
+      end
+
+      def make_spine
+        self.spine = Spine.new
+        spine.make do
+          yield spine if block_given?
+        end
+        spine
+      end
+
+      def make_bindings
+        self.bindings = Bindings.new
+        bindings.make do
+          yield bindings if block_given?
+        end
+        bindings
+      end
+
+      def save(archive)
+        archive.add_buffer book.rootfile_path, to_xml
+      end
+
+      module ContentModel
+        # @param [Nokogiri::XML::Builder::NodeBuilder] node
+        # @param [Object] model
+        # @param [Array<Symbol|String>] attributes names of attribute.
+        def to_xml_attribute(node, model, attributes)
+          attributes.each do |attr|
+            val = model.__send__(attr)
+            node[attr.to_s.gsub('_', '-')] = val if val
+          end
+        end
+      end
+
+      class Metadata
+        include ContentModel
+
+        def make
+          yield self if block_given?
+          unless unique_identifier
+            if identifiers.empty?
+              identifier = DCMES.new
+              identifier.id = 'pub-id'
+              identifier.content = UUID.create.to_s
+              self.dc_identifiers << identifier
+              self.unique_identifier = identifier
+            else
+              self.unique_identifier = identifiers.first
+            end
+          end
+
+          unless metas.any? {|meta| meta.property == 'dcterms:modified'}
+            modified = Meta.new
+            modified.property = 'dcterms:modified'
+            # modified.content = Time.now.utc.strftime('%FT%TZ')
+            modified.content = Time.now.utc.iso8601
+            self.metas << modified
+          end
+
+          self
+        end
+
+        def to_xml_fragment(xml)
+          xml.metadata_('xmlns:dc' => EPUB::NAMESPACES['dc']) {
+            (DC_ELEMS - [:languages]).each do |elems|
+              singular = elems[0..-2] + '_'
+              __send__("dc_#{elems}").each do |elem|
+                node = xml['dc'].__send__(singular, elem.content)
+                to_xml_attribute node, elem, [:id, :dir]
+                node['xml:lang'] = elem.lang if elem.lang
+              end
+            end
+
+            languages.each do |language|
+              xml['dc'].language language.content
+            end
+
+            metas.each do |meta|
+              node = xml.meta(meta.content)
+              to_xml_attribute node, meta, [:property, :id, :scheme]
+              node['refines'] = "##{meta.refines.id}" if meta.refines
+            end
+
+            links.each do |link|
+              node = xml.link
+              to_xml_attribute node, link, [:href, :id, :media_type]
+              node['rel'] = link.rel.join(' ') if link.rel
+              node['refines'] = "##{link.refines.id}" if link.refines
+            end
+          }
+        end
+
+        # Shortcut to set title from String
+        # @param title [String]
+        def title=(title)
+          t = Title.new
+          t.content = title
+          self.dc_titles = [t]
+          title
+        end
+
+        # Shortcut to set language from String
+        # @param lang_code [String]
+        def language=(lang_code)
+          lang = DCMES.new
+          lang.content = lang_code
+          self.dc_languages = [lang]
+          lang_code
+        end
+
+        # Shortcut to set one creator from String
+        # @param name [String]
+        def creator=(name)
+          creator = DCMES.new
+          creator.content = name
+          self.dc_creators = [creator]
+          name
+        end
+      end
+
+      class Manifest
+        include ContentModel
+
+        def make
+          yield self if block_given?
+
+          # @todo more careful
+          unless items.any? &:nav?
+            nav = Item.new
+            nav.id = 'toc'
+            nav.href = Addressable::URI.parse('nav.xhtml')
+            nav.media_type = 'application/xhtml+xml'
+            nav.properties << 'nav'
+
+            nav_doc = ContentDocument::Navigation.new
+            nav_doc.item = nav
+
+            nav_nav = ContentDocument::Navigation::Navigation.new
+            nav_nav.type = ContentDocument::Navigation::Navigation::Type::TOC
+            nav_nav.items = items.select(&:xhtml?).map {|item; nav|
+              nav = ContentDocument::Navigation::Item.new
+              nav.item = item
+              nav.href = item.href
+              nav.text = File.basename(item.href.normalize.request_uri, '.*')
+              nav
+            }
+            nav_doc.navigations << nav_nav
+
+            nav.content = nav_doc.to_xml
+
+            self << nav
+          end
+
+          self
+        end
+
+        def make_item(options={})
+          item = Item.new
+          [:id, :href, :media_type, :properties, :media_overlay].each do |attr|
+            next unless options.key? attr
+            item.__send__ "#{attr}=", options[attr]
+          end
+          item.manifest = self
+          yield item if block_given?
+          self << item
+          item
+        end
+
+        def to_xml_fragment(xml)
+          node = xml.manifest_ {
+            items.each do |item|
+              item_node = xml.item_
+              to_xml_attribute item_node, item, [:id, :href, :media_type, :media_overlay]
+              item_node['properties'] = item.properties.join(' ') unless item.properties.empty?
+              item_node['fallback'] = item.fallback.id if item.fallback
+            end
+          }
+          to_xml_attribute node, self, [:id]
+        end
+
+        class Item
+          attr_accessor :content, :content_file
+
+          # @param archive [Zip::Archive|nil] archive to save content. If nil, open archive in this method
+          # @raise StandardError when no content nor content_file
+          def save(archive=nil)
+            if archive
+              if content
+                archive.add_or_replace_buffer entry_name, content
+              elsif content_file
+                archive.add_or_replace_file entry_name, content_file
+              else
+                raise 'no content nor content_file'
+              end
+            else
+              Zip::Archive.open manifest.package.book.epub_file do |archive|
+                save archive
+              end
+            end
+          end
+
+          # Save document into EPUB archive when block ended
+          def edit
+            yield if block_given?
+            save
+          end
+
+          # Save document into EPUB archive at end of block
+          # @yield [REXML::Document]
+          def edit_with_rexml
+            require 'rexml/document'
+            doc = REXML::Document.new(read)
+            yield doc if block_given?
+            self.content = doc.to_s
+            save
+          end
+
+          # Save document into EPUB archive at end of block
+          # @yield [Nokgiri::XML::Document]
+          def edit_with_nokogiri
+            doc = Nokogiri.XML(read)
+            yield doc if block_given?
+            self.content = doc.to_xml
+            save
+          end
+        end
+      end
+
+      class Spine
+        include ContentModel
+
+        def make
+          yield self if block_given?
+          self
+        end
+
+        def make_itemref
+          itemref = Itemref.new
+          self << itemref
+          yield itemref if block_given?
+          itemref
+        end
+
+        def to_xml_fragment(xml)
+          node = xml.spine_ {
+            itemrefs.each do |itemref|
+              itemref_node = xml.itemref
+              to_xml_attribute itemref_node, itemref, [:idref, :id]
+              itemref_node['linear'] = 'no' unless itemref.linear?
+              itemref_node['properties'] = itemref.properties.join(' ') unless itemref.properties.empty?
+            end
+          }
+          to_xml_attribute node, self, [:id, :toc, :page_progression_direction]
+        end
+      end
+
+      class Bindings
+        include ContentModel
+
+        def make
+          yield self if block_given?
+          self
+        end
+
+        def make_media_type
+          media_type = MediaType.new
+          self << media_type
+          yield media_type if block_given?
+          media_type
+        end
+
+        def to_xml_fragment(xml)
+          xml.bindings_ {
+            media_types.each do |media_type|
+              media_type_node = xml.mediaType
+              to_xml_attribute media_type_node, media_type, [:media_type]
+              media_type_node['handler'] = media_type.handler.id if media_type.handler && media_type.handler.id
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/epub/maker/task.rb

@@ -0,0 +1,134 @@
+require 'rake'
+require 'rake/tasklib'
+require 'epub/maker'
+
+module EPUB
+  module Maker
+    class Task < ::Rake::TaskLib
+      attr_accessor :target, :base_dir, :files, :file_map_proc,
+                    :container, :rootfiles, :make_rootfiles, :package_direction, :language,
+                    :titles, :contributors,
+                    :resources, :navs, :cover_image, :media_types,
+                    :spine,
+                    :bindings
+
+      # @param name [String] EPUB file name
+      def initialize(name)
+        init name
+        yield self if block_given?
+        define
+      end
+
+      def init(name)
+        @target = :epub
+        @name = name
+        @files = FileList.new
+        @base_dir = Dir.pwd
+        @rootfiles = FileList.new
+        @make_rootfiles = false
+        @package_direction = 'rtl'
+        @language = 'en'
+        @file_map = {}
+        @file_map_proc = -> (src_name) {src_name.sub("#{@base_dir.sub(/\/\z/, '')}/", '')}
+        @navs = FileList.new
+        @media_types = {}
+        @spine = FileList.new
+        @bindings = {}
+      end
+
+      def define
+        desc 'Make EPUB file'
+        task @target do
+          EPUB::Maker.make @name do |book|
+            book.make_ocf do |ocf|
+              if container
+                ocf.container = EPUB::Parser::OCF.new(nil).parse_container(File.read(container))
+              else
+                raise 'Set at least one rootfile' if rootfiles.empty?
+                ocf.make_container do |container|
+                  rootfiles.each do |rootfile|
+                    container.make_rootfile full_path: Addressable::URI.parse(file_map[rootfile])
+                  end
+                end
+              end
+            end
+
+            if make_rootfiles
+              book.make_package do |package|
+                package.dir = package_direction
+
+                package.make_metadata do |metadata|
+                  metadata.title = @titles.first
+                  metadata.language = language
+                end
+
+                package.make_manifest do |manifest|
+                  rootfile_path = Pathname(package.book.rootfile_path)
+                  resources.each_with_index do |resource, index|
+                    resource_path = Pathname(file_map[resource])
+                    manifest.make_item do |item|
+                      item.id = "item-#{index + 1}"
+                      href = resource_path.relative_path_from(rootfile_path.parent)
+                      item.href = Addressable::URI.parse(href.to_path)
+                      item.media_type = media_types[resource] ||
+                        case resource_path.extname
+                        when '.xhtml', '.html' then 'application/xhtml+xml'
+                        end
+                      item.content_file = resource
+                      item.properties << 'nav' if navs.include? item.entry_name
+                      item.properties << 'scripted' unless Nokogiri.XML(open(resource)).search('script').empty?
+                    end
+                  end
+                end
+
+                package.make_spine do |spine|
+                  @spine.each do |item_path|
+                    entry_name = file_map[item_path]
+                    spine.make_itemref do |itemref|
+                      item = package.manifest.items.find {|i| i.entry_name == entry_name}
+                      itemref.item = item if item
+                      warn "missing item #{item_path}, referred by itemref" if itemref.item.nil?
+                      itemref.linear = true # TODO: Make more customizable
+                    end
+                  end
+                end
+
+                if @bindings and !@bindings.empty?
+                  package.make_bindings do |bindings|
+                    @bindings.each_pair do |media_type, handler_path|
+                      bindings.make_media_type do |mt|
+                        mt.media_type = media_type
+                        entry_name = file_map[handler_path]
+                        mt.handler = package.manifest.items.find {|item| item.entry_name == entry_name}
+                        warn "missing handler for #{media_type}" if mt.handler.nil?
+                      end
+                    end
+                  end
+                end
+              end
+            else
+              raise 'No rootfile set' if @rootfiles.empty?
+              rf = rootfiles.first
+              book.package = EPUB::Parser::Publication.new(File.read(rf), file_map[rf]).parse
+            end
+          end
+        end
+      end
+
+      def rootfile=(rootfile)
+        rootfiles.unshift rootfile
+        rootfile
+      end
+
+      def file_map(force_calculation=false)
+        if force_calculation or @file_map.empty?
+          @file_map.clear
+          @files.each do |src_name|
+            @file_map[src_name] = @file_map_proc[src_name]
+          end
+        end
+        @file_map
+      end
+    end
+  end
+end