epuber 0.3.5

data/lib/epuber/compiler/xhtml_processor.rb

@@ -0,0 +1,254 @@
+# encoding: utf-8
+
+require 'nokogiri'
+require 'uri'
+
+
+module Epuber
+  class Compiler
+    require_relative 'file_finders/normal'
+
+    class XHTMLProcessor
+      class UnparseableLinkError < StandardError; end
+
+      # Method for parsing incomplete XML, supports multiple root elements
+      #
+      # @warning Because of nature of XML, when input string don't contain root element, it will create own called `body`, since it will be used in next steps.
+      #
+      # @param [String] text  input XHTML text
+      #
+      # @return [Nokogiri::XML::Document] parsed document
+      #
+      def self.xml_document_from_string(text, file_path = nil)
+        if /\A[\n\r ]+(<\?xml)/ =~ text
+          UI.warning('XML header must be at the beginning of document', location: UI::Location.new(file_path, 1))
+
+          text = text.lstrip
+        end
+
+        doc = Nokogiri::XML(text)
+        doc.encoding = 'UTF-8'
+        doc.file_path = file_path
+
+        fragment = Nokogiri::XML.fragment(text)
+        root_elements = fragment.children.select { |el| el.element? }
+
+        if root_elements.count == 1
+          doc.root = root_elements.first
+        elsif fragment.at_css('body').nil?
+          doc.root = doc.create_element('body')
+
+          fragment.children.select do |child|
+            child.element? || child.comment? || child.text?
+          end.each do |child|
+            doc.root.add_child(child)
+          end
+        end
+
+        doc
+      end
+
+
+      # Method to add all missing items in XML root
+      #
+      # Required items:
+      #   - html (with all namespaces and other attributes)
+      #   - body
+      #     - head (with title)
+      #
+      # @param [Nokogiri::XML::Document] xhtml_doc  input XML document to work with
+      # @param [String] title  title of this document, since this is required by EPUB specification
+      # @param [Epuber::Version] epub_version  version of result EPUB
+      #
+      # @return nil
+      #
+      def self.add_missing_root_elements(xhtml_doc, title, epub_version)
+        # add missing body element
+        if xhtml_doc.at_css('body').nil?
+          xhtml_doc.root.surround_with_element('body')
+        end
+
+        # add missing root html element
+        if xhtml_doc.at_css('html').nil?
+          attrs               = {}
+          attrs['xmlns']      = 'http://www.w3.org/1999/xhtml'
+          attrs['xmlns:epub'] = 'http://www.idpf.org/2007/ops' if epub_version >= 3
+          xhtml_doc.root.surround_with_element('html', attrs)
+        end
+
+        # add missing head in html
+        if xhtml_doc.at_css('html > head').nil?
+          html = xhtml_doc.css('html').first
+          head = xhtml_doc.create_element('head')
+          head << xhtml_doc.create_element('title', title)
+          head << xhtml_doc.create_element('meta', charset: 'utf-8') if epub_version >= 3.0
+
+          html.children.first.before(head)
+        end
+      end
+
+      # Method for adding style sheets with links, method will not add duplicate items
+      #
+      # @param [Nokogiri::XML::Document] xhtml_doc  input XML document to work with
+      # @param [Array<String>] styles  links to files
+      #
+      # @return nil
+      #
+      def self.add_styles(xhtml_doc, styles)
+        head  = xhtml_doc.at_css('html > head')
+        old_links = head.css('link[rel="stylesheet"]').map { |node| node['href'] }
+
+        links_to_add = styles - old_links
+
+        links_to_add.each do |path|
+          head << xhtml_doc.create_element('link', href: path, rel: 'stylesheet', type: 'text/css')
+        end
+      end
+
+      # Adds viewport meta tag to head of some document, but only if there is not some existing tag
+      #
+      # @param [Nokogiri::XML::Document] xhtml_doc
+      # @param [Epuber::Size] viewport_size
+      #
+      def self.add_viewport(xhtml_doc, viewport_size)
+        head = xhtml_doc.at_css('html > head')
+        return unless head.at_css("meta[name='viewport']").nil?
+
+        s = viewport_size
+        head << xhtml_doc.create_element('meta', name: 'viewport', content: "width=#{s.width},height=#{s.height}")
+      end
+
+      # Method which will resolve path to file from pattern
+      #
+      # @param [String] path  pattern or path of the file
+      # @param [Symbol | Array<Symbol>] groups  groups of the searching file, could be for example :image when searching for file from tag <img>
+      # @param [String] file_path  path to file from which is searching for other file
+      # @param [Epuber::Compiler::FileFinder] file_finder  finder for searching for files
+      #
+      # @raise UnparseableLinkError, FileFinder::FileNotFoundError, FileFinder::MultipleFilesFoundError
+      #
+      # @return [URI] resolved path to file or remote web page
+      #
+      def self.resolved_link_to_file(path, groups, file_path, file_finder)
+        raise FileFinders::FileNotFoundError.new(path, file_path) if path.empty?
+
+        begin
+          uri = URI(path)
+        rescue URI::InvalidURIError
+          begin
+            uri = URI(URI::encode(path))
+          rescue URI::InvalidURIError
+            # skip not valid uri
+            raise UnparseableLinkError, "Unparseable link `#{path}`"
+          end
+        end
+
+        # skip uri with scheme (links to web pages)
+        return uri unless uri.scheme.nil?
+
+        # skip empty path
+        return uri if uri.path.empty? && !uri.fragment.nil? && !uri.fragment.empty?
+
+        uri.path = file_finder.find_file(uri.path, groups: groups, context_path: file_path)
+
+        uri
+      end
+
+      # Resolves all links to files in XHTML document and returns the valid and resolved versions
+      #
+      # @param [Nokogiri::XML::Document] xhtml_doc  input XML document to work with
+      # @param [String] tag_name  CSS selector for tag
+      # @param [String] attribute_name  name of attribute
+      # @param [Symbol | Array<Symbol>] groups  groups of the searching file, could be for example :image when searching for file from tag <img>
+      # @param [String] file_path  path to file from which is searching for other file
+      # @param [Epuber::Compiler::FileFinder] file_finder  finder for searching for files
+      #
+      # @return [Array<URI>] resolved links
+      #
+      def self.resolve_links_for(xhtml_doc, tag_name, attribute_name, groups, file_path, file_finder)
+        founded_links = []
+
+        xhtml_doc.css("#{tag_name}[#{attribute_name}]").each do |node|
+          begin
+            src = node[attribute_name]
+            # @type [String] src
+
+            next if src.nil?
+
+            target_file = resolved_link_to_file(src, groups, file_path, file_finder)
+            founded_links << target_file
+
+            node[attribute_name] = target_file.to_s
+          rescue UnparseableLinkError, FileFinders::FileNotFoundError, FileFinders::MultipleFilesFoundError => e
+            UI.warning(e.to_s, location: node)
+
+            # skip not found files
+            next
+          end
+        end
+
+        founded_links
+      end
+
+      # Resolves all links to files in XHTML document and returns the valid and resolved versions
+      #
+      # @param [Nokogiri::XML::Document] xhtml_doc  input XML document to work with
+      # @param [String] file_path  path to file from which is searching for other file
+      # @param [Epuber::Compiler::FileFinder] file_finder  finder for searching for files
+      #
+      # @return [Array<URI>] resolved links
+      #
+      def self.resolve_links(xhtml_doc, file_path, file_finder)
+        [
+          resolve_links_for(xhtml_doc, 'a', 'href', :text, file_path, file_finder),
+          resolve_links_for(xhtml_doc, 'map > area', 'href', :text, file_path, file_finder),
+        ].flatten
+      end
+
+      # @param [Nokogiri::XML::Document] xhtml_doc  input XML document to work with
+      #
+      # @return [Bool]
+      #
+      def self.using_javascript?(xhtml_doc)
+        !xhtml_doc.at_css('script').nil?
+      end
+
+      # @param [Nokogiri::XML::Document] xhtml_doc
+      # @param [String] file_path path of referring file
+      # @param [FileResolver] file_resolver
+      #
+      # @return nil
+      #
+      def self.resolve_images(xhtml_doc, file_path, file_resolver)
+        dirname = File.dirname(file_path)
+
+        xhtml_doc.css('img').each do |img|
+          path = img['src']
+          next if path.nil?
+
+          begin
+            new_path = file_resolver.dest_finder.find_file(path, groups: :image, context_path: dirname)
+
+          rescue UnparseableLinkError, FileFinders::FileNotFoundError, FileFinders::MultipleFilesFoundError
+            begin
+              new_path = resolved_link_to_file(path, :image, dirname, file_resolver.source_finder).to_s
+              pkg_abs_path = File.expand_path(new_path, dirname).unicode_normalize
+              pkg_new_path = Pathname.new(pkg_abs_path).relative_path_from(Pathname.new(file_resolver.source_path)).to_s
+
+              file = FileTypes::ImageFile.new(pkg_new_path)
+              file.path_type = :manifest
+              file_resolver.add_file(file)
+
+            rescue UnparseableLinkError, FileFinders::FileNotFoundError, FileFinders::MultipleFilesFoundError => e
+              UI.warning(e.to_s, location: img)
+
+              next
+            end
+          end
+
+          img['src'] = new_path
+        end
+      end
+    end
+  end
+end

data/lib/epuber/config.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+require_relative 'lockfile'
+
+
+module Epuber
+  class Config
+    WORKING_PATH = '.epuber'
+
+    # @return [String]
+    #
+    def project_path
+      @project_path ||= Dir.pwd.unicode_normalize
+    end
+
+    # @param of_file [String] absolute path to file
+    #
+    # @return [String] relative path to file from root of project
+    #
+    def pretty_path_from_project(of_file)
+      Pathname.new(of_file.unicode_normalize).relative_path_from(Pathname.new(project_path))
+    end
+
+    # @return [String]
+    #
+    def working_path
+      @working_path ||= File.join(project_path, WORKING_PATH)
+    end
+
+    # @return [String]
+    #
+    def bookspec_path
+      @bookspec_path ||= find_all_bookspecs.first
+    end
+
+    # @return [String]
+    #
+    def bookspec_lockfile_path
+      "#{bookspec_path}.lock"
+    end
+
+    # @return [Array<String>]
+    #
+    def find_all_bookspecs
+      Dir.chdir(project_path) do
+        Dir.glob('*.bookspec').map do |path|
+          File.expand_path(path)
+        end
+      end
+    end
+
+    # @return [Epuber::Book]
+    #
+    def bookspec
+      require_relative 'book'
+      @bookspec ||= (
+        book = Epuber::Book.from_file(bookspec_path)
+        book.finish_toc
+        book.validate
+        book.freeze
+        book
+      )
+    end
+
+    # @param [Epuber::Book] bookspec
+    #
+    # @return [Epuber::Book]
+    #
+    def bookspec=(bookspec)
+      @bookspec = bookspec
+    end
+
+    # @return [Epuber::Lockfile]
+    #
+    def bookspec_lockfile
+      @bookspec_lockfile ||= (
+        lockfile = Lockfile.from_file(bookspec_lockfile_path)
+        lockfile.version = Epuber::VERSION
+        lockfile
+      )
+    end
+
+    # @return nil
+    #
+    def save_lockfile
+      bookspec_lockfile.write_to_file
+    end
+
+    # @param target [Epuber::Book::Target]
+    #
+    # @return [String]
+    #
+    def build_path(target)
+      File.join(working_path, 'build', target.name.to_s)
+    end
+
+    # @param target [Epuber::Book::Target]
+    #
+    # @return [String]
+    #
+    def release_build_path(target)
+      File.join(working_path, 'release_build', target.name.to_s)
+    end
+
+    # ---------------------------------------------------------------------------------------------------------------- #
+
+    # Singleton
+    #
+    # @return [Epuber::Config]
+    #
+    def self.instance
+      @instance ||= new
+    end
+
+    class << self
+      attr_accessor :test
+
+      def test?
+        test
+      end
+    end
+
+    self.test = false
+  end
+end
+
+# HACK: this should be done with nicer way
+#
+at_exit do
+  unless Epuber::Config.test?
+    Epuber::Config.instance.save_lockfile
+  end
+end

data/lib/epuber/dsl/attribute.rb

@@ -0,0 +1,248 @@
+# encoding: utf-8
+
+require 'date'
+
+require 'active_support/core_ext/string/inflections'
+
+module Epuber
+  module DSL
+    # Stores the information of an attribute. It also provides logic to implement any required logic.
+    #
+    class Attribute
+      # @return [Symbol] name of attribute
+      #
+      attr_reader :name
+
+      # rubocop:disable Metrics/ParameterLists
+
+      # Returns a new attribute initialized with the given options.
+      #
+      # @param name [Symbol]
+      #
+      # @see #name
+      #
+      # @raise    If there are unrecognized options.
+      #
+      def initialize(name, inherited: false,
+                     root_only: false,
+                     required: false,
+                     singularize: false,
+                     file_patterns: false,
+                     container: nil,
+                     keys: nil,
+                     default_value: nil,
+                     auto_convert: {},
+                     types: nil)
+
+        @name = name
+
+        @inherited     = inherited
+        @root_only     = root_only
+        @required      = required
+        @singularize   = singularize
+        @file_patterns = file_patterns
+        @container     = container
+        @keys          = keys
+        @default_value = default_value
+        @auto_convert  = auto_convert
+        @types         = if !types.nil?
+                           types
+                         elsif @default_value
+                           [@default_value.class]
+                         else
+                           [String]
+                         end
+      end
+
+      # rubocop:enable Metrics/ParameterLists
+
+      # @return [String] A string representation suitable for UI.
+      #
+      def to_s
+        "Attribute `#{name}`"
+      end
+
+      # @return [String] A string representation suitable for debugging.
+      #
+      def inspect
+        "<#{self.class} name=#{name} types=#{types}>"
+      end
+
+      #---------------------------------------------------------------------#
+
+      # @!group Options
+
+      # @return [Array<Class>] the list of the classes of the values supported by the attribute writer.
+      #         If not specified defaults to [String].
+      #
+      attr_reader :types
+
+      # @return [Array<Class>] the list of the classes of the values supported by the attribute, including
+      #         the container.
+      #
+      def supported_types
+        @supported_types ||= @types.dup.push(container).compact
+      end
+
+      # @return [Class] if defined it can be [Array] or [Hash]. It is used as default initialization value
+      #         and to automatically wrap other values to arrays.
+      #
+      attr_reader :container
+
+      # @return [Array, Hash] the list of the accepted keys for an attribute wrapped by a Hash.
+      #
+      # @note   A hash is accepted to group the keys associated only with certain keys (see the source
+      #         attribute of a Book).
+      #
+      attr_reader :keys
+
+      # @return [Object] if the attribute follows configuration over convention it can specify a default value.
+      #
+      # @note   The default value is not automatically wrapped and should be specified within the container
+      #         if any.
+      #
+      attr_reader :default_value
+
+      # @return [Bool] whether the specification should be considered invalid if a value for the attribute
+      #         is not specified.
+      #
+      attr_reader :required
+      alias_method :required?, :required
+
+      # @return [Bool] whether the attribute should be specified only on the root specification.
+      #
+      attr_reader :root_only
+      alias_method :root_only?, :root_only
+
+
+      # @return [Bool] whether there should be a singular alias for the attribute writer.
+      #
+      attr_reader :singularize
+      alias_method :singularize?, :singularize
+
+      # @return [Bool] whether the attribute describes file patterns.
+      #
+      # @note   This is mostly used by the linter.
+      #
+      attr_reader :file_patterns
+      alias_method :file_patterns?, :file_patterns
+
+      # @return [Bool] defines whether the attribute reader should join the values with the parent.
+      #
+      # @note   Attributes stored in wrappers are always inherited.
+      #
+      def inherited?
+        !root_only? && @inherited
+      end
+
+      #---------------------------------------------------------------------#
+
+      # @return [String] the name of the setter method for the attribute.
+      #
+      def writer_name
+        "#{name}="
+      end
+
+      # @return [String] an aliased attribute writer offered for convenience on the DSL.
+      #
+      def writer_singular_form
+        "#{name.to_s.singularize}=" if singularize?
+      end
+
+      #---------------------------------------------------------------------#
+
+      # @!group Values validation
+
+      # Validates the value for an attribute. This validation should be performed before the value is
+      # prepared or wrapped.
+      #
+      # @note   The this is called before preparing the value.
+      #
+      # @raise  If the type is not in the allowed list.
+      #
+      # @return [void]
+      #
+      def validate_type(value)
+        return if value.nil?
+        return if supported_types.any? { |klass| value.class == klass }
+
+        raise StandardError, "Non acceptable type `#{value.class}` for #{self}. Allowed types: `#{types.inspect}`"
+      end
+
+      # Validates a value before storing.
+      #
+      # @raise If a root only attribute is set in a subspec.
+      #
+      # @raise If a unknown key is added to a hash.
+      #
+      # @return [void]
+      #
+      def validate_for_writing(spec, value)
+        if root_only? && !spec.root?
+          raise StandardError, "Can't set `#{name}` attribute for subspecs (in `#{spec.name}`)."
+        end
+
+        if keys
+          value.keys.each do |key|
+            unless allowed_keys.include?(key)
+              raise StandardError, "Unknown key `#{key}` for #{self}. Allowed keys: `#{allowed_keys.inspect}`"
+            end
+          end
+        end
+
+        # @return [Array] the flattened list of the allowed keys for the hash of a given specification.
+        #
+        def allowed_keys
+          if keys.is_a?(Hash)
+            keys.keys.concat(keys.values.flatten.compact)
+          else
+            keys
+          end
+        end
+      end
+
+
+      #---------------------------------------------------------------------#
+
+      # @!group Automatic conversion
+
+      # Converts value to compatible type of attribute
+      #
+      # Can be configured with option :auto_convert
+      #    Supports conversion from type to type, eg `{ String => Fixnum }`
+      #        also from types to type eg `{ [String, Date] => Fixnum }`
+      #    Supports custom conversion with Proc, eg `{ String => lambda { |value| value.to_s } }`
+      #        also with multiple types
+      #
+      def converted_value(value)
+        begin
+          validate_type(value)
+        rescue StandardError
+          raise if @auto_convert.nil?
+          dest_class = @auto_convert[value.class]
+
+          if dest_class.nil?
+            array_keys           = @auto_convert.select { |k, _v| k.is_a?(Array) }
+            array_keys_with_type = array_keys.select { |k, _v| k.include?(value.class) }
+
+            if array_keys_with_type.count > 0
+              dest_class = array_keys_with_type.values.first
+            end
+          end
+
+          if dest_class.respond_to?(:call)
+            return dest_class.call(value)
+          elsif dest_class.respond_to?(:parse)
+            return dest_class.parse(value)
+          elsif dest_class.respond_to?(:new)
+            return dest_class.new(value)
+          else
+            raise StandardError, "Object/class #{dest_class} doesn't support any convert method (#call, .parse or implicit .new)"
+          end
+        end
+
+        value
+      end
+    end
+  end
+end