epub-cfi 0.1.0

data/lib/epub/cfi/parser.rb

@@ -0,0 +1,88 @@
+require "epub/cfi/parser.tab"
+
+class EPUB::CFI::Parser
+  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
+
+module EPUB::CFI
+  module_function
+
+  def parse(string)
+    EPUB::CFI::Parser.parse(string)
+  end
+end
+
+def EPUB::CFI(string)
+  EPUB::CFI.parse(string)
+end

data/lib/epub/cfi/parser.y

@@ -0,0 +1,184 @@
+class EPUB::CFI::Parser
+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/cfi/version.rb

@@ -0,0 +1,23 @@
+#
+# Copyright (c) 2017 KITAITI Makoto (KitaitiMakoto at gmail.com)
+#
+# EPUB CFI is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# EPUB CFI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with EPUB CFI.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+module EPUB
+  module CFI
+    # epub-cfi version
+    VERSION = "0.1.0"
+  end
+end

data/test/helper.rb

@@ -0,0 +1,13 @@
+require "simplecov"
+SimpleCov.start do
+  add_filter "/test/"
+end
+
+require 'test/unit'
+require "test/unit/notify"
+
+require "pretty_backtrace"
+PrettyBacktrace.enable
+
+class Test::Unit::TestCase
+end

data/test/test_cfi.rb

@@ -0,0 +1,196 @@
+# coding: utf-8
+require 'helper'
+require 'epub/cfi'
+
+class TestCFI < Test::Unit::TestCase
+  def test_escape
+    assert_equal '^^^[^]^(^)^,^;^=', EPUB::CFI.escape('^[](),;=')
+  end
+
+  def test_unescape
+    assert_equal '^[](),;=', EPUB::CFI.unescape('^^^[^]^(^)^,^;^=')
+  end
+
+  class TestPath < self
+    data([
+      'epubcfi(/6/14[chap05ref]!/4[body01]/10/2/1:3[2^[1^]])',
+      'epubcfi(/6/4!/4/10/2/1:3[Ф-"spa ce"-99%-aa^[bb^]^^])',
+      'epubcfi(/6/4!/4/10/2/1:3[Ф-"spa%20ce"-99%25-aa^[bb^]^^])',
+      'epubcfi(/6/4!/4/10/2/1:3[%d0%a4-"spa%20ce"-99%25-aa^[bb^]^^])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3[yyy])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/1:3[xx,y])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3[,y])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3[;s=b])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3[yyy;s=b])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2[;s=b])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/3:10)',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/16[svgimg])',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/1:0)',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:0)',
+      'epubcfi(/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3)',
+    ].reduce({}) {|data, cfi|
+      data[cfi] = cfi
+      data
+    })
+    def test_to_s(cfi)
+      assert_equal cfi, EPUB::CFI::Parser.parse(cfi).to_s
+    end
+
+    def test_compare
+      assert_equal -1, epubcfi('/6/4[id]') <=> epubcfi('/6/5')
+      assert_equal 0, epubcfi('/6/4') <=> epubcfi('/6/4')
+      assert_equal 1, epubcfi('/6/4') <=> epubcfi('/4/6')
+      assert_equal 1, epubcfi('/6/4!/4@3:7') <=> epubcfi('/6/4!/4')
+      assert_equal 1,
+        epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/2/1:3[yyy]') <=>
+        epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/1:3[xx,y]')
+      assert_nil epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/3:10') <=>
+        epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/3!:10')
+      assert_equal 1, epubcfi('/6/4') <=> epubcfi('/6')
+    end
+  end
+
+  class TestRange < self
+    def test_attributes
+      parent = epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]')
+      first = epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/2/1:1')
+      last = epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/3:4')
+      range = epubcfi('/6/4[chap01ref]!/4[body01]/10[para05],/2/1:1,/3:4')
+      assert_equal 0, first <=> range.first
+      assert_equal 0, last <=> range.last
+
+      assert_equal 0, parent <=> range.parent_path
+    end
+
+    def test_to_s
+      cfi = '/6/4[chap01ref]!/4[body01]/10[para05],/2/1:1,/3:4'
+      assert_equal 'epubcfi(' + cfi + ')', epubcfi('/6/4[chap01ref]!/4[body01]/10[para05],/2/1:1,/3:4').to_s
+    end
+
+    def test_cover
+      assert_true epubcfi('/6/4[chap01ref]!/4[body01]/10[para05],/2/1:1,/3:4').cover? epubcfi('/6/4[chap01ref]!/4[body01]/10[para05]/2/2/4')
+    end
+  end
+
+  class TestStep < self
+    def test_to_s
+      assert_equal '/6', EPUB::CFI::Step.new(6).to_s
+      assert_equal '/4[id]', EPUB::CFI::Step.new(4, EPUB::CFI::IDAssertion.new('id')).to_s
+    end
+
+    def test_compare
+      assert_equal 0, EPUB::CFI::Step.new(6) <=> EPUB::CFI::Step.new(6, 'assertion')
+      assert_equal -1, EPUB::CFI::Step.new(6) <=> EPUB::CFI::Step.new(7)
+    end
+  end
+
+  class TestIDAssertion < self
+    def test_to_s
+      assert_equal '[id]', EPUB::CFI::IDAssertion.new('id').to_s
+      assert_equal '[id;p=a]', EPUB::CFI::IDAssertion.new('id', {'p' => ['a']}).to_s
+    end
+  end
+
+  class TestTextLocationAssertion < self
+    def test_to_s
+      assert_equal '[yyy]', EPUB::CFI::TextLocationAssertion.new('yyy').to_s
+      assert_equal '[xx,y]', EPUB::CFI::TextLocationAssertion.new('xx', 'y').to_s
+      assert_equal '[,y]', EPUB::CFI::TextLocationAssertion.new(nil, 'y').to_s
+      assert_equal '[;s=b]', EPUB::CFI::TextLocationAssertion.new(nil, nil, {'s' => ['b']}).to_s
+      assert_equal '[yyy;s=b]', EPUB::CFI::TextLocationAssertion.new('yyy', nil, {'s' => ['b']}).to_s
+    end
+  end
+
+  class TestCharacterOffset < self
+    def test_to_s
+      assert_equal ':1', EPUB::CFI::CharacterOffset.new(1).to_s
+      assert_equal ':2[yyy]', EPUB::CFI::CharacterOffset.new(2, EPUB::CFI::TextLocationAssertion.new('yyy')).to_s
+    end
+
+    def test_compare
+      assert_equal 0,
+        EPUB::CFI::CharacterOffset.new(3) <=>
+        EPUB::CFI::CharacterOffset.new(3, EPUB::CFI::TextLocationAssertion.new('yyy'))
+      assert_equal -1,
+        EPUB::CFI::CharacterOffset.new(4) <=>
+        EPUB::CFI::CharacterOffset.new(5)
+      assert_equal 1,
+        EPUB::CFI::CharacterOffset.new(4, EPUB::CFI::TextLocationAssertion.new(nil, 'xx')) <=>
+        EPUB::CFI::CharacterOffset.new(2)
+    end
+  end
+
+  class TestSpatialOffset < self
+    def test_to_s
+      assert_equal '@0.5:30.2', EPUB::CFI::TemporalSpatialOffset.new(nil, 0.5, 30.2).to_s
+      assert_equal '@0:100', EPUB::CFI::TemporalSpatialOffset.new(nil, 0, 100).to_s
+      assert_equal '@50:50.0', EPUB::CFI::TemporalSpatialOffset.new(nil, 50, 50.0).to_s
+    end
+
+    def test_compare
+      assert_equal 0,
+        EPUB::CFI::TemporalSpatialOffset.new(nil, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(nil, 30, 40)
+      assert_equal 1,
+        EPUB::CFI::TemporalSpatialOffset.new(nil, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(nil, 40, 30)
+    end
+  end
+
+  class TestTemporalOffset < self
+    def test_to_s
+      assert_equal '~23.5', EPUB::CFI::TemporalSpatialOffset.new(23.5).to_s
+    end
+
+    def test_compare
+      assert_equal 0,
+        EPUB::CFI::TemporalSpatialOffset.new(23.5) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5)
+      assert_equal -1,
+        EPUB::CFI::TemporalSpatialOffset.new(23) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5)
+    end
+  end
+
+  class TestTemporalSpatialOffset < self
+    def test_to_s
+      assert_equal '~23.5@50:30.0', EPUB::CFI::TemporalSpatialOffset.new(23.5, 50, 30.0).to_s
+    end
+
+    def test_compare
+      assert_equal 0,
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 40.0)
+      assert_equal 1,
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5)
+      assert_equal -1,
+        EPUB::CFI::TemporalSpatialOffset.new(nil, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 40)
+      assert_equal -1,
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 30, 50)
+      assert_equal 1,
+        EPUB::CFI::TemporalSpatialOffset.new(24, 30, 40) <=>
+        EPUB::CFI::TemporalSpatialOffset.new(23.5, 100, 100)
+    end
+  end
+
+  private
+
+  def epubcfi(string)
+    EPUB::CFI::Parser.new.parse(string)
+  end
+
+  def assert_equal_node(expected, actual, message='')
+    diff = AssertionMessage.delayed_diff(expected.to_s, actual.to_s)
+    message = build_message(message, <<EOT, expected, actual, diff)
+<?>
+expected but was
+<?>.?
+EOT
+    assert_block message do
+      expected.tdiff_equal actual
+    end
+  end
+end