epub-parser 0.2.2 → 0.2.3

data/lib/epub/content_document/navigation.rb

@@ -70,13 +70,18 @@ module EPUB
         include Hidable
 
         attr_accessor :items, :text,
-                      :content_document, :href, :item
+                      :content_document, :item
+        attr_reader :href
 
         def initialize
           @items = ItemList.new
           @items.parent = self
         end
 
+        def href=(iri)
+          @href = iri.kind_of?(Addressable::URI) ? iri : Addressable::URI.parse(iri)
+        end
+
         def traverse(depth=0, &block)
           block.call self, depth
           items.each do |item|

data/lib/epub/content_document/xhtml.rb

@@ -34,8 +34,7 @@ module EPUB
 
       # @return [Nokogiri::XML::Document] content as Nokogiri::XML::Document object
       def nokogiri
-        require 'nokogumbo' unless Nokogiri.respond_to? :HTML5
-        @nokogiri ||= Nokogiri.HTML5(raw_document)
+        @nokogiri ||= Nokogiri.XML(raw_document)
       end
     end
   end

data/lib/epub/ocf/physical_container.rb

@@ -1,9 +1,10 @@
 require 'epub/ocf/physical_container/zipruby'
-require 'epub/ocf/physical_container/file'
+require 'epub/ocf/physical_container/unpacked_directory'
 require 'epub/ocf/physical_container/unpacked_uri'
 
 module EPUB
   class OCF
+    # @todo: Make thread save
     class PhysicalContainer
       @adapter = Zipruby
 

data/lib/epub/ocf/physical_container/{file.rb → unpacked_directory.rb}

@@ -1,7 +1,7 @@
 module EPUB
   class OCF
     class PhysicalContainer
-      class File < self
+      class UnpackedDirectory < self
         def open
           yield self
         end

data/lib/epub/parser/cfi.rb

@@ -0,0 +1,84 @@
+require 'strscan'
+require 'epub/parser/cfi.tab'
+require 'epub/cfi'
+
+EPUB::Parser::CFI = EPUB::CFIParser
+
+class EPUB::Parser::CFI
+  include Comparable
+
+  UNICODE_CHARACTER_EXCLUDING_SPECIAL_CHARS_AND_SPACE_AND_DOT_AND_COLON_AND_TILDE_AND_ATMARK_AND_SOLIDUS_AND_EXCLAMATION_MARK_PATTERN = /\u0009|\u000A|\u000D|[\u0022-\u0027]|[\u002A-\u002B]|\u002D|[\u0030-\u0039]|\u003C|[\u003E-\u0040]|[\u0041-\u005A]|\u005C|[\u005F-\u007D]|[\u007F-\uD7FF]|[\uE000-\uFFFD]|[\u10000-\u10FFFF]/ # excluding special chars and space(\u0020) and dot(\u002E) and colon(\u003A) and tilde(\u007E) and atmark(\u0040) and solidus(\u002F) and exclamation mark(\u0021)
+  UNICODE_CHARACTER_PATTERN = Regexp.union(UNICODE_CHARACTER_EXCLUDING_SPECIAL_CHARS_AND_SPACE_AND_DOT_AND_COLON_AND_TILDE_AND_ATMARK_AND_SOLIDUS_AND_EXCLAMATION_MARK_PATTERN, Regexp.new(Regexp.escape(EPUB::CFI::SPECIAL_CHARS), / \.:~@!/))
+
+  class << self
+    def parse(string, debug: false)
+      new(debug: debug).parse(string)
+    end
+  end
+
+  def initialize(debug: false)
+    @yydebug = debug
+    super()
+  end
+
+  def parse(string)
+    if string.start_with? 'epubcfi('
+      string = string['epubcfi('.length .. -2]
+    end
+    @scanner = StringScanner.new(string, true)
+    @q = []
+    until @scanner.eos?
+      case
+      when @scanner.scan(/[1-9]/)
+        @q << [:DIGIT_NON_ZERO, @scanner[0]]
+      when @scanner.scan(/0/)
+        @q << [:ZERO, @scanner[0]]
+      when @scanner.scan(/ /)
+        @q << [:SPACE, @scanner[0]]
+      when @scanner.scan(/\^/)
+        @q << [:CIRCUMFLEX, @scanner[0]]
+      when @scanner.scan(/\[/)
+        @q << [:OPENING_SQUARE_BRACKET, @scanner[0]]
+      when @scanner.scan(/\]/)
+        @q << [:CLOSING_SQUARE_BRACKET, @scanner[0]]
+      when @scanner.scan(/\(/)
+        @q << [:OPENING_PARENTHESIS, @scanner[0]]
+      when @scanner.scan(/\)/)
+        @q << [:CLOSING_PARENTHESIS, @scanner[0]]
+      when @scanner.scan(/,/)
+        @q << [:COMMA, @scanner[0]]
+      when @scanner.scan(/;/)
+        @q << [:SEMICOLON, @scanner[0]]
+      when @scanner.scan(/=/)
+        @q << [:EQUAL, @scanner[0]]
+      when @scanner.scan(/\./)
+        @q << [:DOT, @scanner[0]]
+      when @scanner.scan(/:/)
+        @q << [:COLON, @scanner[0]]
+      when @scanner.scan(/~/)
+        @q << [:TILDE, @scanner[0]]
+      when @scanner.scan(/@/)
+        @q << [:ATMARK, @scanner[0]]
+      when @scanner.scan(/\//)
+        @q << [:SOLIDUS, @scanner[0]]
+      when @scanner.scan(/!/)
+        @q << [:EXCLAMATION_MARK, @scanner[0]]
+      when @scanner.scan(UNICODE_CHARACTER_EXCLUDING_SPECIAL_CHARS_AND_SPACE_AND_DOT_AND_COLON_AND_TILDE_AND_ATMARK_AND_SOLIDUS_AND_EXCLAMATION_MARK_PATTERN)
+        @q << [:UNICODE_CHARACTER_EXCLUDING_SPECIAL_CHARS_AND_SPACE_AND_DOT_AND_COLON_AND_TILDE_AND_ATMARK_AND_SOLIDUS_AND_EXCLAMATION_MARK, @scanner[0]]
+      else
+        raise 'unexpected character'
+      end
+    end
+    @q << [false, false]
+
+    do_parse
+  end
+
+  def next_token
+    @q.shift
+  end
+end
+
+def EPUB::CFI(string)
+  EPUB::Parser::CFI.parse('epubcfi(' + string + ')')
+end

data/lib/epub/parser/cfi.y

@@ -0,0 +1,187 @@
+# EPUB::Parser::CFI is prefered but cannot be used.
+# Racc automatically declare module EPUB::Parser
+# but EPUB::Parser have been declared as a class.
+class EPUB::CFIParser
+rule
+
+  fragment : path range_zero_or_one
+             {
+               if val[1]
+                 result = CFI::Range.from_parent_and_start_and_end(val[0], *val[1])
+               else
+                 result = CFI::Location.new(val[0])
+               end
+             }
+
+  range_zero_or_one : range
+                    |
+
+  path : step local_path
+           {
+             path, redirected_path = *val[1]
+             path.steps.unshift val[0]
+             result = val[1]
+           }
+
+  range : COMMA local_path COMMA local_path
+            {result = [val[1], val[3]]}
+
+  local_path : step_zero_or_more redirected_path
+                 {result = [CFI::Path.new(val[0])] + val[1]}
+             | step_zero_or_more offset_zero_or_one
+                 {result = [CFI::Path.new(val[0], val[1])]}
+
+  step_zero_or_more : step_zero_or_more step
+                        {result = val[0] + [val[1]]}
+                    | step
+                        {result = [val[0]]}
+                    |
+                        {result = []}
+
+  redirected_path : EXCLAMATION_MARK offset
+                      {result = [CFI::Path.new([], val[1])]}
+                  | EXCLAMATION_MARK path
+                      {result = val[1]}
+
+  step : SOLIDUS integer assertion_part_zero_or_one
+           {
+             assertion = val[2] ? CFI::IDAssertion.new(val[2][0], val[2][2]) : nil
+             result = CFI::Step.new(val[1].to_i, assertion)
+           }
+
+  offset_zero_or_one : offset
+                     |
+
+  offset : COLON integer assertion_part_zero_or_one
+             {
+               assertion = val[2] ? CFI::TextLocationAssertion.new(*val[2]) : nil
+               result = CFI::CharacterOffset.new(val[1].to_i, assertion)
+             }
+         | spatial_offset assertion_part_zero_or_one
+         {result = CFI::TemporalSpatialOffset.new(nil, val[0][0].to_f, val[0][1].to_f, val[2])}
+         | TILDE number spatial_offset_zero_or_one assertion_part_zero_or_one
+             {
+               x = val[2] ? val[2][0].to_f : nil
+               y = val[2] ? val[2][1].to_f : nil
+               result = CFI::TemporalSpatialOffset.new(val[1].to_f, x, y, val[3])
+             }
+
+  spatial_offset_zero_or_one : spatial_offset
+                             |
+
+  spatial_offset : ATMARK number COLON number
+                     {result = [val[1], val[3]]}
+
+  assertion_part_zero_or_one : opening_square_bracket assertion closing_square_bracket
+                                 {result = val[1]}
+                             |
+
+  number : DIGIT_NON_ZERO digit_zero_or_more fractional_portion_zero_or_one
+             {result = val.join}
+         | ZERO fractional_portion_zero_or_one
+             {result = val.join}
+
+  fractional_portion_zero_or_one : fractional_portion
+                                 |
+
+  fractional_portion : DOT digit_zero_or_more DIGIT_NON_ZERO
+                         {result = val.join}
+                     | DOT DIGIT_NON_ZERO
+                         {result = val.join}
+
+  integer : ZERO
+          | DIGIT_NON_ZERO digit_zero_or_more
+              {result = val.join}
+
+  digit_zero_or_more : digit_zero_or_more digit
+                         {result = val.join}
+                     | digit
+                     |
+
+  assertion : value_csv_one_or_two parameter_zero_or_more
+                {result = [val[0][0], val[0][1], val[1]]} # Cannot see id assertion or text location assertion when val[0]'s length is 1. It can be done by context.
+            | COMMA value parameter_zero_or_more
+                {result = [nil, val[1], val[2]]}
+            | parameter parameter_zero_or_more
+                {result = [nil, nil, val[0].merge(val[1])]} # Cannot see id assertion or text location assertion when val[0]'s length is 1. It can be done by context. In EPUBCFI 3.0.1 spec, only side-bias parameter is defined and we can say it's text location assertion of the assertion has parameters. But when the spec is extended and other parameter definitions added, we might become not able to say so.
+
+  value_csv_one_or_two : value COMMA value
+                           {result = [val[0], val[2]]}
+                       | value
+                           {result = [val[0]]}
+
+  parameter_zero_or_more : parameter_zero_or_more parameter
+                             {result = val[0].merge(val[1])}
+                         | parameter
+                             {result = val[0]}
+                         |
+                             {result = {}}
+
+  parameter : SEMICOLON value_no_space EQUAL csv
+                {result = {val[1] => val[3]}}
+
+  csv : csv COMMA value
+          {result = val[0] + [val[2]]}
+      | value
+          {result = [val[0]]}
+
+  value : string_escaped_special_chars
+            {result = val[0]}
+
+  value_no_space: string_escaped_special_chars_excluding_space
+
+  escaped_special_chars : CIRCUMFLEX CIRCUMFLEX
+                            {result = val[1]}
+                        | CIRCUMFLEX square_brackets
+                            {result = val[1]}
+                        | CIRCUMFLEX parentheses
+                            {result = val[1]}
+                        | CIRCUMFLEX COMMA
+                            {result = val[1]}
+                        | CIRCUMFLEX SEMICOLON
+                            {result = val[1]}
+                        | CIRCUMFLEX EQUAL
+                            {result = val[1]}
+
+  character_escaped_special : character_excluding_special_chars
+                            | escaped_special_chars
+
+  string_escaped_special_chars : string_escaped_special_chars character_escaped_special
+                                   {result = val.join}
+                               | character_escaped_special
+                                   {result = val[0]}
+
+  string_escaped_special_chars_excluding_space : string_escaped_special_chars_excluding_space character_escaped_special_excluding_space
+                                               | character_escaped_special_excluding_space
+
+  character_escaped_special_excluding_space : character_excluding_special_chars_and_space
+                                            | escaped_special_chars
+
+  digit : ZERO
+        | DIGIT_NON_ZERO
+
+  square_brackets : opening_square_bracket
+                  | closing_square_bracket
+
+  opening_square_bracket : OPENING_SQUARE_BRACKET
+
+  closing_square_bracket : CLOSING_SQUARE_BRACKET
+
+  parentheses : OPENING_PARENTHESIS
+              | CLOSING_PARENTHESIS
+
+  character_excluding_special_chars : character_excluding_special_chars_and_space
+                                    | SPACE
+
+  character_excluding_special_chars_and_space : character_excluding_special_chars_and_space_and_dot_and_colon_and_tilde_and_atmark_and_solidus_and_exclamation_mark
+                                              | DOT
+                                              | COLON
+                                              | TILDE
+                                              | ATMARK
+                                              | SOLIDUS
+                                              | EXCLAMATION_MARK
+
+  character_excluding_special_chars_and_space_and_dot_and_colon_and_tilde_and_atmark_and_solidus_and_exclamation_mark : UNICODE_CHARACTER_EXCLUDING_SPECIAL_CHARS_AND_SPACE_AND_DOT_AND_COLON_AND_TILDE_AND_ATMARK_AND_SOLIDUS_AND_EXCLAMATION_MARK
+                                              | digit
+
+end

data/lib/epub/parser/content_document.rb

@@ -81,7 +81,7 @@ module EPUB
             end
             item.text = extract_attribute(a_or_span, 'title').to_s if item.text.nil? || item.text.empty?
           end
-          item.href = Addressable::URI.parse(extract_attribute(a_or_span, 'href'))
+          item.href = extract_attribute(a_or_span, 'href')
           item.item = @item.manifest.items.find {|it| it.href.request_uri == item.href.request_uri}
         end
         item.items = element.xpath('./xhtml:ol[1]/xhtml:li', EPUB::NAMESPACES).map {|li| parse_navigation_item(li)}

data/lib/epub/parser/publication.rb

@@ -1,7 +1,6 @@
 require 'strscan'
 require 'zipruby'
 require 'nokogiri'
-require 'addressable/uri'
 require 'epub/publication'
 require 'epub/constants'
 
@@ -61,7 +60,7 @@ module EPUB
         metadata.rights = extract_model(elem, id_map, './dc:rights')
         metadata.metas = extract_refinee(elem, id_map, './opf:meta', :Meta, %w[property id scheme])
         metadata.links = extract_refinee(elem, id_map, './opf:link', :Link, %w[id media-type]) {|link, e|
-          link.href = Addressable::URI.parse(extract_attribute(e, 'href'))
+          link.href = extract_attribute(e, 'href')
           link.rel = Set.new(extract_attribute(e, 'rel').split(nil))
         }
 
@@ -85,7 +84,7 @@ module EPUB
           %w[id media-type media-overlay].each do |attr|
             item.__send__ "#{attr.gsub(/-/, '_')}=", extract_attribute(e, attr)
           end
-          item.href = Addressable::URI.parse(extract_attribute(e, 'href'))
+          item.href = extract_attribute(e, 'href')
           fallback = extract_attribute(e, 'fallback')
           fallback_map[fallback] = item if fallback
           properties = extract_attribute(e, 'properties')
@@ -127,7 +126,7 @@ module EPUB
           %w[type title].each do |attr|
             reference.__send__ "#{attr}=", extract_attribute(ref, attr)
           end
-          reference.href = Addressable::URI.parse(extract_attribute(ref, 'href'))
+          reference.href = extract_attribute(ref, 'href')
           guide << reference
         end
 

data/lib/epub/parser/version.rb

@@ -1,5 +1,5 @@
 module EPUB
   class Parser
-    VERSION = "0.2.2"
+    VERSION = "0.2.3"
   end
 end

data/lib/epub/publication/package/guide.rb

@@ -21,7 +21,12 @@ module EPUB
         class Reference
           TYPES = %w[cover title-page toc index glossary acknowledgements bibliography colophon copyright-page dedication epigraph foreword loi lot notes preface text]
           attr_accessor :guide,
-                        :type, :title, :href
+                        :type, :title
+          attr_reader :href
+
+          def href=(iri)
+            @href = iri.kind_of?(Addressable::URI) ? iri : Addressable::URI.parse(iri)
+          end
 
           def item
             return @item if @item

data/lib/epub/publication/package/manifest.rb

@@ -1,4 +1,5 @@
 require 'set'
+require 'addressable/uri'
 require 'rchardet'
 require 'epub/constants'
 require 'epub/parser/content_document'
@@ -64,6 +65,8 @@ module EPUB
         end
 
         class Item
+          DUMMY_ROOT_IRI = Addressable::URI.parse('http://example.net/').freeze
+
           include Inspector
 
           # @!attribute [rw] manifest
@@ -82,8 +85,8 @@ module EPUB
           # @!attribute [rw] fallback
           #   @return [Item] Returns the value of attribute fallback
           attr_accessor :manifest,
-                        :id, :href, :media_type, :fallback, :media_overlay
-          attr_reader :properties
+                        :id, :media_type, :fallback, :media_overlay
+          attr_reader :properties, :href
 
           def initialize
             @properties = Set.new
@@ -93,18 +96,31 @@ module EPUB
             @properties = props.kind_of?(Set) ? props : Set.new(props)
           end
 
+          def href=(iri)
+            @href = iri.kind_of?(Addressable::URI) ? iri : Addressable::URI.parse(iri)
+          end
+
           # @todo Handle circular fallback chain
           def fallback_chain
             @fallback_chain ||= traverse_fallback_chain([])
           end
 
           # full path in archive
-          def entry_name
-            dummy_root_iri = Addressable::URI.parse('http://example.net/') # FIXME: Use constant
+          # @return [Addressable::URI]
+          def full_path
+            return @full_path if @full_path
             rootfile = manifest.package.book.ocf.container.rootfile.full_path
-            en = Addressable::URI.unencode((dummy_root_iri + rootfile + href).normalize.request_uri)
-            en.slice!(0) if en.start_with? '/'
-            en
+            path = DUMMY_ROOT_IRI + rootfile + href
+            path.scheme = nil
+            path.host = nil
+            path.path = path.path[1..-1]
+            @full_path = path
+          end
+
+          # full path in archive
+          # @return [String]
+          def entry_name
+            Addressable::URI.unencode(full_path)
           end
 
           def read
@@ -178,7 +194,7 @@ module EPUB
           # @note Algorithm stolen form Rack::Utils#clean_path_info
           def find_item_by_relative_iri(iri)
             raise ArgumentError, "Not relative: #{iri.inspect}" unless iri.relative?
-            raise ArgumentError, "Start with slash: #{iri.inspect}" if iri.to_s.start_with? Addressable::URI::SLASH
+            raise ArgumentError, "Start with slash: #{iri.inspect}" if iri.path.start_with? Addressable::URI::SLASH
             target_href = href + iri
             segments = target_href.to_s.split(Addressable::URI::SLASH)
             clean_segments = []