cskit 1.0.1 → 1.1.0

data/lib/cskit/parsers/bible/bible.treetop

@@ -1,64 +0,0 @@
-# encoding: UTF-8
-
-require 'cskit/parsers/bible/nodes'
-require 'cskit/parsers/bible/objects'
-
-module CSKit
-  module Parsers
-
-    grammar Bible
-      rule citation
-        book [\s]* chapter_list <CitationNode>
-      end
-
-      rule chapter_list
-        chapter ([\s]* ";" [\s]* chapter_list)? <ChapterListNode>
-      end
-
-      rule book
-        [a-zA-Z\.\s]+ <BookNode>
-      end
-
-      rule chapter
-        [\d]+ [\s]* ":" [\s]* verse_list <ChapterNode>
-      end
-
-      rule verse_list
-        verse ([\s]* "," [\s]* verse_list)? <VerseListNode>
-      end
-
-      rule verse
-        (compound_verse_number / verse_number) [\s]* starter [\s]* terminator <VerseNode>
-      end
-
-      rule compound_verse_number
-        verse_number [\s]* "-" [\s]* verse_number <CompoundVerseNumberNode>
-      end
-
-      rule verse_number
-        [\d]+ <VerseNumberNode>
-      end
-
-      rule starter
-        (cardinality [\s]* starter_fragment <StarterNode>)?
-      end
-
-      rule starter_fragment
-        ([^\(\)\,\;]+ <FragmentNode>)?
-      end
-
-      rule terminator
-        ("(" [\s]* "to" [\s]* cardinality [\s]* terminator_fragment [\s]* ")" <TerminatorNode>)?
-      end
-
-      rule terminator_fragment
-        ([^\(\)]+ <FragmentNode>)?
-      end
-
-      rule cardinality
-        ("1st" / "2nd" / "3rd")?
-      end
-    end
-
-  end
-end

data/lib/cskit/parsers/bible/nodes.rb

@@ -1,153 +0,0 @@
-# encoding: UTF-8
-
-module CSKit
-  module Parsers
-    module Bible
-
-      class CitationNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[:book, book.to_sexp], [:chapters, chapter_list.to_sexp]]
-        end
-
-        def to_object
-          CSKit::Parsers::Bible::Citation.new(
-            book.text_value,
-            chapter_list.to_object
-          )
-        end
-      end
-
-      class BookNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          text_value
-        end
-      end
-
-      class ChapterListNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          result = [chapter.to_sexp]
-
-          if elements[1] && elements[1].respond_to?(:chapter_list)
-            result += elements[1].chapter_list.to_sexp
-          end
-
-          result
-        end
-
-        def to_object
-          result = [chapter.to_object]
-
-          if elements[1] && elements[1].respond_to?(:chapter_list)
-            result += elements[1].chapter_list.to_object
-          end
-
-          result
-        end
-      end
-
-      class ChapterNode < Treetop::Runtime::SyntaxNode
-        def text_value
-          super.to_i
-        end
-
-        def to_sexp
-          [text_value, verse_list.to_sexp]
-        end
-
-        def to_object
-          CSKit::Parsers::Bible::Chapter.new(
-            text_value,
-            verse_list.to_object
-          )
-        end
-      end
-
-      class VerseListNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          result = [verse.to_sexp]
-
-          if elements[1] && elements[1].respond_to?(:verse_list)
-            result += elements[1].verse_list.to_sexp
-          end
-
-          result
-        end
-
-        def to_object
-          result = [verse.to_object]
-
-          if elements[1] && elements[1].respond_to?(:verse_list)
-            result += elements[1].verse_list.to_object
-          end
-
-          result
-        end
-      end
-
-      class VerseNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          elements.flat_map { |e| e.to_sexp if e.respond_to?(:to_sexp) }
-        end
-
-        def to_object
-          line_numbers = elements[0].to_sexp.first
-
-          CSKit::Parsers::Bible::Verse.new(
-            line_numbers.first,
-            line_numbers.last,
-            (starter.to_object rescue nil),
-            (terminator.to_object rescue nil)
-          )
-        end
-      end
-
-      class CompoundVerseNumberNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[verse_number1.text_value.to_i, verse_number2.text_value.to_i]]
-        end
-      end
-
-      class VerseNumberNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[text_value.to_i, text_value.to_i]]
-        end
-      end
-
-      class PositionalNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [get_cardinality, fragment.value]
-        end
-
-        def get_cardinality
-          card_val = cardinality.text_value.to_i
-          card_val == 0 ? 1 : card_val
-        end
-
-        def to_object
-          Positional.new(get_cardinality, fragment.value)
-        end
-      end
-
-      class StarterNode < PositionalNode
-        def fragment
-          starter_fragment
-        end
-      end
-
-      class TerminatorNode < PositionalNode
-        def fragment
-          terminator_fragment
-        end
-      end
-
-      class FragmentNode < Treetop::Runtime::SyntaxNode
-        def value
-          text_value.strip
-        end
-
-        alias :to_sexp :value
-      end
-
-    end
-  end
-end

data/lib/cskit/parsers/bible/objects.rb

@@ -1,81 +0,0 @@
-# encoding: UTF-8
-
-module CSKit
-  module Parsers
-    module Bible
-
-      Citation = Struct.new(:book, :chapter_list) do
-        def to_s
-          "#{book.strip} #{chapter_list.map(&:to_s).join("; ")}"
-        end
-
-        def to_hash
-          {
-            :book => book,
-            :chapters => chapter_list.map(&:to_hash)
-          }
-        end
-      end
-
-      Chapter = Struct.new(:chapter_number, :verse_list) do
-        def to_s
-          "#{chapter_number}:#{verse_list.map(&:to_s).join(", ")}"
-        end
-
-        def to_hash
-          {
-            :chapter_number => chapter_number,
-            :verses => verse_list.map(&:to_hash)
-          }
-        end
-      end
-
-      Verse = Struct.new(:start, :finish, :starter, :terminator) do
-        def to_s
-          str = if start == finish
-            start.to_s
-          else
-            "#{start}-#{finish}"
-          end
-
-          str << " #{starter}" if starter
-          str << " (to #{terminator})" if terminator
-          str
-        end
-
-        def to_hash
-          {
-            :start => start,
-            :finish => finish,
-            :starter => starter ? starter.to_hash : nil,
-            :terminator => terminator ? terminator.to_hash : nil
-          }
-        end
-      end
-
-      Positional = Struct.new(:cardinality, :fragment) do
-        def to_s
-          card_s = case cardinality
-            when 1 then "1st"
-            when 2 then "2nd"
-            when 3 then "3rd"
-          end
-
-          if cardinality
-            "#{card_s} #{fragment}"
-          else
-            fragment
-          end
-        end
-
-        def to_hash
-          {
-            :cardinality => cardinality,
-            :fragment => fragment
-          }
-        end
-      end
-
-    end
-  end
-end

data/lib/cskit/parsers/science_health/nodes.rb

@@ -1,82 +0,0 @@
-# encoding: UTF-8
-
-module CSKit
-  module Parsers
-    module ScienceHealth
-
-      class CitationNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[:page, page.to_sexp], [:lines, line_list.to_sexp]]
-        end
-
-        def to_object
-          CSKit::Parsers::ScienceHealth::Citation.new(
-            page.text_value,
-            line_list.to_object
-          )
-        end
-      end
-
-      class PageNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          text_value
-        end
-      end
-
-      class LineListNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          result = [line.to_sexp]
-
-          if elements[1] && elements[1].respond_to?(:line_list)
-            result += elements[1].line_list.to_sexp
-          end
-
-          result
-        end
-
-        def to_object
-          to_sexp.map do |line|
-            only = line[1] == :only
-            CSKit::Parsers::ScienceHealth::Line.new(
-              line[0].first,
-              line[0].last,
-              only,
-              only ? nil : line[1]
-            )
-          end
-        end
-      end
-
-      class LineNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          elements.flat_map { |e| e.to_sexp if e.respond_to?(:to_sexp) }
-        end
-      end
-
-      class CompoundLineNumberNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[line_number1.text_value.to_i, line_number2.text_value.to_i]]
-        end
-      end
-
-      class LineNumberNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          [[text_value.to_i, nil]]
-        end
-      end
-
-      class OnlyNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          :only
-        end
-      end
-
-      class StartFragmentNode < Treetop::Runtime::SyntaxNode
-        def to_sexp
-          text_value.strip
-        end
-      end
-
-    end
-  end
-end

data/lib/cskit/parsers/science_health/objects.rb

@@ -1,47 +0,0 @@
-# encoding: UTF-8
-
-module CSKit
-  module Parsers
-    module ScienceHealth
-
-      Citation = Struct.new(:page, :lines) do
-        def to_s
-          "#{page}:#{lines.map(&:to_s).join(", ")}"
-        end
-
-        def to_hash
-          {
-            :page => page,
-            :lines => lines.map(&:to_hash)
-          }
-        end
-      end
-
-      Line = Struct.new(:start, :finish, :only, :start_fragment) do
-        alias :only? :only
-
-        def to_s
-          str = if finish
-            "#{start}-#{finish}"
-          else
-            start.to_s
-          end
-
-          str << " (only)" if only?
-          str << " #{start_fragment}" if start_fragment
-          str
-        end
-
-        def to_hash
-          {
-            :start => start,
-            :finish => finish,
-            :only => only,
-            :start_fragment => start_fragment
-          }
-        end
-      end
-
-    end
-  end
-end

data/lib/cskit/parsers/science_health/science_health.rb

@@ -1,607 +0,0 @@
-# Autogenerated from a Treetop grammar. Edits may be lost.
-
-
-# encoding: UTF-8
-
-require 'cskit/parsers/science_health/nodes'
-require 'cskit/parsers/science_health/objects'
-
-module CSKit
-  module Parsers
-
-    module ScienceHealth
-      include Treetop::Runtime
-
-      def root
-        @root ||= :citation
-      end
-
-      module Citation0
-        def page
-          elements[0]
-        end
-
-        def line_list
-          elements[4]
-        end
-      end
-
-      def _nt_citation
-        start_index = index
-        if node_cache[:citation].has_key?(index)
-          cached = node_cache[:citation][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        r1 = _nt_page
-        s0 << r1
-        if r1
-          s2, i2 = [], index
-          loop do
-            if has_terminal?('\G[\\s]', true, index)
-              r3 = true
-              @index += 1
-            else
-              r3 = nil
-            end
-            if r3
-              s2 << r3
-            else
-              break
-            end
-          end
-          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-          s0 << r2
-          if r2
-            if has_terminal?(":", false, index)
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure(":")
-              r4 = nil
-            end
-            s0 << r4
-            if r4
-              s5, i5 = [], index
-              loop do
-                if has_terminal?('\G[\\s]', true, index)
-                  r6 = true
-                  @index += 1
-                else
-                  r6 = nil
-                end
-                if r6
-                  s5 << r6
-                else
-                  break
-                end
-              end
-              r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-              s0 << r5
-              if r5
-                r7 = _nt_line_list
-                s0 << r7
-              end
-            end
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(CitationNode,input, i0...index, s0)
-          r0.extend(Citation0)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:citation][start_index] = r0
-
-        r0
-      end
-
-      def _nt_page
-        start_index = index
-        if node_cache[:page].has_key?(index)
-          cached = node_cache[:page][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        s0, i0 = [], index
-        loop do
-          if has_terminal?('\G[\\d{1,3}|vi{2}|xi{1,2}|i{0,1}x]', true, index)
-            r1 = true
-            @index += 1
-          else
-            r1 = nil
-          end
-          if r1
-            s0 << r1
-          else
-            break
-          end
-        end
-        if s0.empty?
-          @index = i0
-          r0 = nil
-        else
-          r0 = instantiate_node(PageNode,input, i0...index, s0)
-        end
-
-        node_cache[:page][start_index] = r0
-
-        r0
-      end
-
-      module LineList0
-        def line_list
-          elements[3]
-        end
-      end
-
-      module LineList1
-        def line
-          elements[0]
-        end
-
-      end
-
-      def _nt_line_list
-        start_index = index
-        if node_cache[:line_list].has_key?(index)
-          cached = node_cache[:line_list][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        r1 = _nt_line
-        s0 << r1
-        if r1
-          i3, s3 = index, []
-          s4, i4 = [], index
-          loop do
-            if has_terminal?('\G[\\s]', true, index)
-              r5 = true
-              @index += 1
-            else
-              r5 = nil
-            end
-            if r5
-              s4 << r5
-            else
-              break
-            end
-          end
-          r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-          s3 << r4
-          if r4
-            if has_terminal?(",", false, index)
-              r6 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure(",")
-              r6 = nil
-            end
-            s3 << r6
-            if r6
-              s7, i7 = [], index
-              loop do
-                if has_terminal?('\G[\\s]', true, index)
-                  r8 = true
-                  @index += 1
-                else
-                  r8 = nil
-                end
-                if r8
-                  s7 << r8
-                else
-                  break
-                end
-              end
-              r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-              s3 << r7
-              if r7
-                r9 = _nt_line_list
-                s3 << r9
-              end
-            end
-          end
-          if s3.last
-            r3 = instantiate_node(SyntaxNode,input, i3...index, s3)
-            r3.extend(LineList0)
-          else
-            @index = i3
-            r3 = nil
-          end
-          if r3
-            r2 = r3
-          else
-            r2 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s0 << r2
-        end
-        if s0.last
-          r0 = instantiate_node(LineListNode,input, i0...index, s0)
-          r0.extend(LineList1)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:line_list][start_index] = r0
-
-        r0
-      end
-
-      module Line0
-      end
-
-      def _nt_line
-        start_index = index
-        if node_cache[:line].has_key?(index)
-          cached = node_cache[:line][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        i1 = index
-        r2 = _nt_compound_line_number
-        if r2
-          r1 = r2
-        else
-          r3 = _nt_line_number
-          if r3
-            r1 = r3
-          else
-            @index = i1
-            r1 = nil
-          end
-        end
-        s0 << r1
-        if r1
-          i5 = index
-          r6 = _nt_only
-          if r6
-            r5 = r6
-          else
-            r7 = _nt_start_fragment
-            if r7
-              r5 = r7
-            else
-              @index = i5
-              r5 = nil
-            end
-          end
-          if r5
-            r4 = r5
-          else
-            r4 = instantiate_node(SyntaxNode,input, index...index)
-          end
-          s0 << r4
-        end
-        if s0.last
-          r0 = instantiate_node(LineNode,input, i0...index, s0)
-          r0.extend(Line0)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:line][start_index] = r0
-
-        r0
-      end
-
-      module CompoundLineNumber0
-        def line_number1
-          elements[0]
-        end
-
-        def line_number2
-          elements[4]
-        end
-      end
-
-      def _nt_compound_line_number
-        start_index = index
-        if node_cache[:compound_line_number].has_key?(index)
-          cached = node_cache[:compound_line_number][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        r1 = _nt_line_number
-        s0 << r1
-        if r1
-          s2, i2 = [], index
-          loop do
-            if has_terminal?('\G[\\s]', true, index)
-              r3 = true
-              @index += 1
-            else
-              r3 = nil
-            end
-            if r3
-              s2 << r3
-            else
-              break
-            end
-          end
-          r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
-          s0 << r2
-          if r2
-            if has_terminal?("-", false, index)
-              r4 = instantiate_node(SyntaxNode,input, index...(index + 1))
-              @index += 1
-            else
-              terminal_parse_failure("-")
-              r4 = nil
-            end
-            s0 << r4
-            if r4
-              s5, i5 = [], index
-              loop do
-                if has_terminal?('\G[\\s]', true, index)
-                  r6 = true
-                  @index += 1
-                else
-                  r6 = nil
-                end
-                if r6
-                  s5 << r6
-                else
-                  break
-                end
-              end
-              r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
-              s0 << r5
-              if r5
-                r7 = _nt_line_number
-                s0 << r7
-              end
-            end
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(CompoundLineNumberNode,input, i0...index, s0)
-          r0.extend(CompoundLineNumber0)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:compound_line_number][start_index] = r0
-
-        r0
-      end
-
-      def _nt_line_number
-        start_index = index
-        if node_cache[:line_number].has_key?(index)
-          cached = node_cache[:line_number][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        s0, i0 = [], index
-        loop do
-          if has_terminal?('\G[\\d]', true, index)
-            r1 = true
-            @index += 1
-          else
-            r1 = nil
-          end
-          if r1
-            s0 << r1
-          else
-            break
-          end
-        end
-        if s0.empty?
-          @index = i0
-          r0 = nil
-        else
-          r0 = instantiate_node(LineNumberNode,input, i0...index, s0)
-        end
-
-        node_cache[:line_number][start_index] = r0
-
-        r0
-      end
-
-      module Only0
-      end
-
-      def _nt_only
-        start_index = index
-        if node_cache[:only].has_key?(index)
-          cached = node_cache[:only][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        i0, s0 = index, []
-        s1, i1 = [], index
-        loop do
-          if has_terminal?('\G[\\s]', true, index)
-            r2 = true
-            @index += 1
-          else
-            r2 = nil
-          end
-          if r2
-            s1 << r2
-          else
-            break
-          end
-        end
-        r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
-        s0 << r1
-        if r1
-          if has_terminal?("(", false, index)
-            r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
-            @index += 1
-          else
-            terminal_parse_failure("(")
-            r3 = nil
-          end
-          s0 << r3
-          if r3
-            s4, i4 = [], index
-            loop do
-              if has_terminal?('\G[\\s]', true, index)
-                r5 = true
-                @index += 1
-              else
-                r5 = nil
-              end
-              if r5
-                s4 << r5
-              else
-                break
-              end
-            end
-            r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
-            s0 << r4
-            if r4
-              if has_terminal?("only", false, index)
-                r6 = instantiate_node(SyntaxNode,input, index...(index + 4))
-                @index += 4
-              else
-                terminal_parse_failure("only")
-                r6 = nil
-              end
-              s0 << r6
-              if r6
-                s7, i7 = [], index
-                loop do
-                  if has_terminal?('\G[\\s]', true, index)
-                    r8 = true
-                    @index += 1
-                  else
-                    r8 = nil
-                  end
-                  if r8
-                    s7 << r8
-                  else
-                    break
-                  end
-                end
-                r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
-                s0 << r7
-                if r7
-                  if has_terminal?(")", false, index)
-                    r9 = instantiate_node(SyntaxNode,input, index...(index + 1))
-                    @index += 1
-                  else
-                    terminal_parse_failure(")")
-                    r9 = nil
-                  end
-                  s0 << r9
-                  if r9
-                    s10, i10 = [], index
-                    loop do
-                      if has_terminal?('\G[\\s]', true, index)
-                        r11 = true
-                        @index += 1
-                      else
-                        r11 = nil
-                      end
-                      if r11
-                        s10 << r11
-                      else
-                        break
-                      end
-                    end
-                    r10 = instantiate_node(SyntaxNode,input, i10...index, s10)
-                    s0 << r10
-                  end
-                end
-              end
-            end
-          end
-        end
-        if s0.last
-          r0 = instantiate_node(OnlyNode,input, i0...index, s0)
-          r0.extend(Only0)
-        else
-          @index = i0
-          r0 = nil
-        end
-
-        node_cache[:only][start_index] = r0
-
-        r0
-      end
-
-      def _nt_start_fragment
-        start_index = index
-        if node_cache[:start_fragment].has_key?(index)
-          cached = node_cache[:start_fragment][index]
-          if cached
-            cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
-            @index = cached.interval.end
-          end
-          return cached
-        end
-
-        s0, i0 = [], index
-        loop do
-          if has_terminal?('\G[^,]', true, index)
-            r1 = true
-            @index += 1
-          else
-            r1 = nil
-          end
-          if r1
-            s0 << r1
-          else
-            break
-          end
-        end
-        if s0.empty?
-          @index = i0
-          r0 = nil
-        else
-          r0 = instantiate_node(StartFragmentNode,input, i0...index, s0)
-        end
-
-        node_cache[:start_fragment][start_index] = r0
-
-        r0
-      end
-
-    end
-
-    class ScienceHealthParser < Treetop::Runtime::CompiledParser
-      include ScienceHealth
-    end
-
-
-  end
-end