bomdb 0.0.1 → 0.1.0

data/lib/bomdb/import/editions.rb

@@ -0,0 +1,26 @@
+require 'json'
+
+module BomDB
+  module Import
+    class Editions < Import::Base
+      tables :editions
+
+      # Expected data format is:
+      # [
+      #   [edition_year:Integer, edition_name:String],
+      #   ...
+      # ]
+      def import_json(data, **args)
+        data.each do |year, name|
+          @db[:editions].insert(
+            edition_year: year,
+            edition_name: name
+          )
+        end
+        Import::Result.new(success: true)
+      rescue Sequel::UniqueConstraintViolation => e
+        Import::Result.new(success: false, error: e)
+      end
+    end
+  end
+end

data/lib/bomdb/import/refs.rb

@@ -0,0 +1,65 @@
+require 'json'
+
+module BomDB
+  module Import
+    class Refs < Import::Base
+      tables :refs
+
+      # Expected data format is:
+      # {
+      #   (ref_name:String): [
+      #     {
+      #       "book":String,"chapter":Int,"verse":Int,
+      #       "ref_book":String,"ref_chapter":Int,"ref_verse":Int,
+      #       "is_parallel":Bool,"is_quotation":Bool
+      #     }
+      #     ...
+      #   ]
+      # }
+      def import_json(data, **args)
+        data.each_pair do |ref_name, rows|
+          rows.each do |r|
+            verse = @db[:verses].
+              join(:books, :book_id => :book_id).
+              where(
+                book_name:     r['book'],
+                verse_chapter: r['chapter'],
+                verse_number:  r['verse'],
+                verse_heading: nil).
+              first
+            if verse.nil?
+              return Import::Result.new(
+                success: false,
+                error: "Unable to find verse #{r['book']} #{r['chapter']}:#{r['verse']}"
+              )
+            end
+
+            @db[:refs].insert(
+              verse_id:         verse[:verse_id],
+              ref_name:         ref_name,
+              ref_book:         r['ref_book'],
+              ref_chapter:      r['ref_chapter'],
+              ref_verse:        r['ref_verse'],
+              ref_is_parallel:  r['is_parallel'],
+              ref_is_quotation: r['is_quotation']
+            )
+          end
+        end
+        Import::Result.new(success: true)
+      rescue Sequel::UniqueConstraintViolation => e
+        Import::Result.new(success: false, error: e)
+      end
+
+      # def list
+      #   @db[
+      #     "SELECT book_name, verse_chapter, verse_number, ref_name, ref_book, ref_chapter, ref_verse " +
+      #     "FROM `verses` v " +
+      #     "JOIN `books` b ON b.book_id = v.book_id " +
+      #     "JOIN `refs` r ON r.verse_id = v.verse_id " +
+      #     "ORDER BY ref_book, ref_chapter, ref_verse"
+      #   ].map(&:inspect).join("\n")
+      # end
+
+    end
+  end
+end

data/lib/bomdb/import/verses.rb

@@ -1,62 +1,43 @@
+require 'json'
+require 'bomdb/models/verse'
+
 module BomDB
   module Import
     class Verses < Import::Base
-      TABLES = [:books, :verses, :versions, :contents]
-
-      def reset
-        schema.reset(*(TABLES - [:books]))
-      end
-
-      def json(data)
-        if schema.has_tables?(*TABLES)
-          ensure_parsed_json(data).each_pair do |book_name, year_versions|
-            year_versions.each do |year_version|
-              year_version.each_pair do |year, d|
-                m = d["meta"]
-
-                book = @db[:books].where(:book_name => book_name).first
-                if book.nil?
-                  return Import::Result.new(success: false, error: "Unable to find book '#{book_name}'")
-                end
+      tables :books, :verses
 
-                verse = @db[:verses].where(
-                  :book_id => book[:book_id],
-                  :verse_chapter => m["chapter"],
-                  :verse_number  => m["verse"],
-                  :verse_heading => m["heading"] ? 0 : nil
-                ).first
-                verse_id = (verse && verse[:verse_id]) || @db[:verses].insert(
-                  book_id: book[:book_id],
-                  verse_chapter: m["chapter"],
-                  verse_number:  m["verse"],
-                  verse_heading: m["heading"] ? 0 : nil
-                )
-
-                version = @db[:versions].where(:version_year => year).first
-                version_id =  (version && version[:version_id]) || @db[:versions].insert(
-                  version_name: year.to_s,
-                  version_year: year
-                )
+      # Expected data format is:
+      # [
+      #   {
+      #     "book": String,
+      #     "chapter": Int,
+      #     "verses": Int
+      #   },
+      #   ...
+      # ]
+      def import_json(data, **args)
+        data.each do |r|
+          # Create a heading per chapter
+          Models::Verse.new(@db).find_or_create(
+            chapter:   r['chapter'],
+            verse:     nil,
+            book_name: r['book'],
+            heading:   true
+          )
 
-                @db[:contents].insert(
-                  version_id:   version_id,
-                  verse_id:     verse_id,
-                  content_body: d["content"]
-                )
-              end
-            end
+          # Create as many verses as is called for per chapter
+          (1..r['verses']).each do |verse_number|
+            Models::Verse.new(@db).find_or_create(
+              chapter:   r['chapter'],
+              verse:     verse_number,
+              book_name: r['book']
+            )
           end
-          Import::Result.new(success: true)
-        else
-          Import::Result.new(
-            success: false,
-            error: "Database tables #{TABLES.join(', ')} not ready. Try again with --reset."
-          )
         end
+        Import::Result.new(success: true)
       rescue Sequel::UniqueConstraintViolation => e
         Import::Result.new(success: false, error: e)
       end
-
     end
   end
-end
+end

data/lib/bomdb/models/edition.rb

@@ -0,0 +1,27 @@
+module BomDB
+  module Models
+    class Edition
+      def initialize(db)
+        @db = db
+      end
+
+      # Find an edition and return a hash, or nil if not found
+      def find(edition_name_prefix)
+        @db[:editions].
+          where(Sequel.like(:edition_name, "#{edition_name_prefix}%")).
+          or(:edition_year => edition_name_prefix).
+          first
+      end
+
+      # Returns an edition_id, either found in the db, or created as necessary
+      def find_or_create(year, name)
+        found = @db[:editions].where(edition_year: year, edition_name: name).first
+        return found[:edition_id] if found
+        @db[:editions].insert(
+          edition_year: year,
+          edition_name: name
+        )
+      end
+    end
+  end
+end

data/lib/bomdb/models/verse.rb

@@ -0,0 +1,47 @@
+module BomDB
+  module Models
+    class Verse
+      def initialize(db)
+        @db = db
+      end
+
+      # Find a verse and return a hash, or nil if not found
+      def find(chapter:, verse:, book_name: nil, book_id: nil, heading: false)
+        @db[:verses].where(
+          book_id:       book_by_name_or_id(book_name, book_id),
+          verse_chapter: chapter,
+          verse_number:  verse,
+          verse_heading: heading ? 0 : nil
+        ).first
+      end
+
+      # Create a verse and return its verse_id
+      def create(chapter:, verse:, book_name: nil, book_id: nil, heading: false)
+        @db[:verses].insert(
+          book_id:       book_by_name_or_id(book_name, book_id),
+          verse_chapter: chapter,
+          verse_number:  verse,
+          verse_heading: heading ? 0 : nil
+        )
+      end
+
+      # Returns a verse_id after finding or creating the verse
+      def find_or_create(**args)
+        verse = find(**args)
+        (verse && verse[:verse_id]) || create(**args)
+      end
+
+      protected
+
+      def book_by_name_or_id(book_name, book_id)
+        if book_id.nil? and book_name.nil?
+          raise ArgumentError, "book_name or book_id is required"
+        elsif book_id.nil?
+          @db[:books].where(book_name: book_name).first[:book_id]
+        else
+          book_id
+        end
+      end
+    end
+  end
+end

data/lib/bomdb/query.rb

@@ -1,40 +1,51 @@
+require 'bomdb/models/edition'
+
 module BomDB
   class Query
-    def initialize(edition:, exclude: nil)
+    def initialize(edition:, exclude: nil, headings: false)
       @edition = edition
       @exclude = exclude
+      @headings = headings
     end
 
-    def query(headings: false)
+    def query
       db = BomDB.db
+      edition_model = Models::Edition.new(db)
+      edition = edition_model.find(@edition)
+      if edition.nil?
+        raise "Unable to find edition: #{@edition}"
+      end
       q = db[:verses].
         join(:books, :book_id => :book_id).
-        join(:versions).
-        join(:contents, :version_id => :version_id, :verse_id => :verses__verse_id).
+        join(:editions).
+        join(:contents, :edition_id => :edition_id, :verse_id => :verses__verse_id).
         order(:book_sort, :verse_heading, :verse_chapter, :verse_number).
         select(:book_name, :verse_chapter, :verse_number, :content_body)
-      q.where!(:version_name => @edition) if @edition
-      q.where!(:verse_heading => nil) unless headings
+      q.where!(:editions__edition_id => edition[:edition_id]) if @edition
+      q.where!(:verse_heading => nil) unless @headings
       q.exclude!(:verses__verse_id => db[:refs].select(:verse_id).where(:ref_name => @exclude)) if @exclude
-      # require 'byebug'; byebug
-      # p q
       q
     end
 
-    def print(book: true, chapter: true, verse: true, sep: ' ')
+    def each(&block)
+      query.each(&block)
+    end
+
+    def print(verse_format: nil, body_format: nil, sep: ' ', linesep: "\n", io: $stdout)
       shown = false
+      verse_format ||= lambda{ |book, chapter, verse| "#{book}#{sep}#{chapter}:#{verse}" }
+      body_format ||= lambda{ |body| body + linesep }
       query.each do |row|
         shown = true
-        puts [
-          book && row[:book_name] || nil,
-          (chapter || verse) && [
-            chapter && row[:verse_chapter] || nil,
-            verse && row[:verse_number] || nil
-          ].compact.join(":") || nil,
-          row[:content_body]
-        ].compact.join(sep)
+        io.print verse_format[
+          row[:book_name],
+          row[:verse_chapter],
+          row[:verse_number]
+        ]
+        io.print sep
+        io.print body_format[ row[:content_body] ]
       end
-      puts "Nothing found" unless shown
+      io.puts "Nothing found" unless shown
     end
   end
 end

data/lib/bomdb/schema.rb

@@ -1,62 +1,61 @@
 require 'set'
+require 'sequel'
+require 'fileutils'
 
 module BomDB
   class Schema
+    attr_reader :db
+
     def initialize(db)
       @db = db
     end
 
-    def has_tables?(*table_names)
-      Set.new(@db.tables) >= Set.new(table_names)
-    end
-
-    def reset(*table_names)
-      drop_tables(table_names)
-      create_tables(table_names)
+    # create a new database
+    def self.create(db_path, tables = :all)
+      FileUtils.rm(db_path) if File.exist?(db_path)
+      new(Sequel.sqlite(db_path)).create_tables(tables)
     end
 
-    def drop_tables(table_names = nil)
-      (table_names || @db.tables).each do |name|
-        @db.drop_table(name) if @db.tables.include?(name)
-      end
+    def has_tables?(tables)
+      Set.new(@db.tables) >= Set.new(tables)
     end
 
-    def create_tables(table_names = nil)
+    def create_tables(tables = :all)
       @db.create_table(:books) do
         primary_key :book_id
 
         string  :book_name, :unique => true
         string  :book_group
         integer :book_sort
-      end if include?(table_names, :books)
+      end if include?(tables, :books)
 
       @db.create_table(:verses) do
         primary_key :verse_id
         foreign_key :book_id, :books
 
         integer :verse_chapter, :null => true
-        integer :verse_number,   :null => true
+        integer :verse_number,  :null => true
         integer :verse_heading, :null => true
 
         index [:book_id, :verse_chapter, :verse_number, :verse_heading], :unique => true
-      end if include?(table_names, :verses)
+      end if include?(tables, :verses)
 
-      @db.create_table(:versions) do
-        primary_key :version_id
+      @db.create_table(:editions) do
+        primary_key :edition_id
 
-        string      :version_name
-        integer     :version_year
-      end if include?(table_names, :versions)
+        integer     :edition_year
+        string      :edition_name, :unique => true
+      end if include?(tables, :editions)
 
       @db.create_table(:contents) do
         primary_key :content_id
-        foreign_key :version_id, :versions
+        foreign_key :edition_id, :editions
         foreign_key :verse_id, :verses
 
         string :content_body
 
-        index [:version_id, :verse_id], :unique => true
-      end if include?(table_names, :contents)
+        index [:edition_id, :verse_id], :unique => true
+      end if include?(tables, :contents)
 
       @db.create_table(:refs) do
         primary_key :ref_id
@@ -71,7 +70,7 @@ module BomDB
         integer :ref_page_end
         boolean :ref_is_parallel
         boolean :ref_is_quotation
-      end if include?(table_names, :refs)
+      end if include?(tables, :refs)
 
       @db.create_table(:notes) do
         primary_key :note_id
@@ -79,14 +78,15 @@ module BomDB
 
         string :note_highlight
         string :note_body
-      end if include?(table_names, :notes)
+      end if include?(tables, :notes)
+
+      self
     end
 
     protected
 
-    def include?(table_names, name)
-      table_names.nil? ||
-      table_names.map{ |n| n.to_sym }.include?(name.to_sym)
+    def include?(tables, name)
+      tables == :all || tables.map{ |n| n.to_sym }.include?(name.to_sym)
     end
   end
 end