sqlbible 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '066989f0d6675a25e650331321207e088e1ad798518020ccaa3745b7e56faf1b'
-  data.tar.gz: fd47a661496035fedeca803311e80c83eb8a4d2211695d7ad6049c7b00648320
+  metadata.gz: b620e9b57b9ffdc57b71231b5a6bfb0619dd196dd99428a4f3ab71d682f60b72
+  data.tar.gz: 196e6a8907ab5b90adce9d9d2c935593796e9b86eb6b7d362a0ca419436b76ad
 SHA512:
-  metadata.gz: 27e852c018052bfe6f5d00a185ce22ffa746b80b3a8b4857968d4bf740a5ad4eaf0e0d140a0da6ad66637518e5f6384c53d8d0da04ef65f40488fea928dd4b95
-  data.tar.gz: b7904cc0c6891a437d65a3e609296dd183b7aa22ad001dbb87f74079f133142052b8552f85b0e88e373996d4baf3c163a600634229580751484e579a0d36e328
+  metadata.gz: 2ac874cb85c60996f406f522f6d010e9e6c07c950b10ed1d9783a87ac936bc1ddc8123dc382ae92298e15382962faed773c2b43b4e6a35e4787e06a3183c5e58
+  data.tar.gz: 927964e349b1e54f5156b3e994ef704411ed5845a0c7c13edabe175170a2d759801525438e1459c76598100159f7e7b8b07d13f39f6043edc5872f71bfa22261

data/README.md

@@ -19,7 +19,7 @@ bible = Sqlbible.new('kjv.sqlite')
 # simple search
 bible.search(/Jesus/)
 
-# Sqlbible is designed to use well with Scripref references and passages
+# Sqlbible is designed to work well with Scripref references and passages
 require 'scripref'
 
 # define a reference for the gospels
@@ -35,6 +35,9 @@ bible.reference(ref)
 
 ### Sqlbible as command-line application
 
+It is possible to convert bibles in OSIS XML format to SQLite databases for
+Sqlbible, to search for regular expressions and show text for references.
+
 See help of the command-line application:
 
 ```shell

data/bin/sqlbible

@@ -2,18 +2,103 @@
 # encoding: utf-8
 # frozen_string_literal: false
 
-require 'optimist'
+require 'optimist_xl'
+require 'scripref'
+require 'sqlbible'
 
-opts = Optimist.options do
-  opt :convert, 'Convert a bible from OSIS-XML to Sqlbible format', type: String
+result = OptimistXL.options do
+  synopsis 'Usage: sqlbible [options] [<command> [suboptions] <filename>]'
+  subcmd :convert, 'Convert a bible from OSIS-XML to Sqlbible format' do
+    opt :name, 'Name of the converted bible module or output filename of the generated .sqlbible file', type: String, required: true
+    opt :overwrite, 'Overwrite existing module or output file if exist', type: :Boolean, default: false
+  end
+  subcmd :search, 'Search with regular expressions' do
+    opt :name, 'Name of the bible module filename of an .sqlbible file', type: String
+    opt :search, 'Regular expression to search (multiple allowed)', type: String, multi: true, required: true
+    opt :lang, 'Language for parsing and formatting scripture references', type: String, permitted: %w(de en), default: 'en'
+    opt :output, 'Output filename', type: String
+    opt :range, 'Search range, example: "John 1-10"', type: String
+  end
+  subcmd :text, 'Show text of references' do
+    opt :name, 'Name of the bible module filename of an .sqlbible file', type: String
+    opt :lang, 'Language for parsing and formatting scripture references', type: String, permitted: %w(de en), default: 'en'
+    opt :output, 'Output filename', type: String
+    opt :reference, 'Reference to show, example: "John 3:16; 10:27-30"', type: String, required: true
+  end
+  version format("sqlbible %s\nschema version %s", Sqlbible::VERSION, Sqlbible.schema_version)
+end
+
+def determine_lang_mod subopts
+  case l = subopts[:lang]
+  when 'en', nil
+    Scripref::English
+  when 'de'
+    Scripref::German
+  else
+    fail format("lang option #{l} is not supported")
+  end
 end
 
-if osis_fn = opts[:convert]
+def determine_out subopts
+  if fn = subopts[:output]
+    out = File.open(opts[:output], 'w')
+  else
+    out = $stdout
+  end
+end
+
+def format_verse f, v
+  format('%s: %s', f.format(v.scripref_passage), v.plaintext)
+end
+
+subopts = result.subcommand_options
+
+case result.subcommand
+when 'convert'
+  require 'fileutils'
   require 'sqlbible/convert'
-  sqlite_fn = osis_fn.sub(/\.xml/i, '') << '.sqlite'
+  unless osis_fn = result.leftovers.first
+    $stderr.puts 'no filename given'
+    exit 1
+  end
+  sqlbible_fn = Sqlbible.resolve_db_filename(subopts[:name])
+  if !subopts[:overwrite] && File.exist?(sqlbible_fn)
+    $stderr.puts format('file %s exist, conversion aborted', sqlbible_fn)
+    exit 1
+  end
+  unless File.exist?(dir = Sqlbible.bibles_dir)
+    puts format('create directory %s', dir)
+    FileUtils.mkdir_p dir
+  end
   if $stdout.tty?
-    puts "convert #{osis_fn} to #{sqlite_fn} ..."
+    puts "convert #{osis_fn} to #{sqlbible_fn} ..."
+  end
+  Sqlbible.convert osis_fn, sqlbible_fn
+  exit
+when 'search'
+  searches = subopts[:search]
+  lang_mod = determine_lang_mod(subopts)
+  if r = subopts[:range]
+    p = Scripref::Parser.new(lang_mod)
+    range = p.parse(r)
+  else
+    range = nil
+  end
+  out = determine_out(subopts)
+  bible = Sqlbible.new(subopts[:name])
+  regexes = searches.map {|s| Regexp.new(s)}
+  f = Scripref::Formatter.new(lang_mod, bookformat: :abbrev)
+  bible.search(regexes, range: range).each do |v|
+    out.puts format_verse(f, v)
+  end
+when 'text'
+  lang_mod = determine_lang_mod(subopts)
+  p = Scripref::Parser.new(lang_mod)
+  f = Scripref::Formatter.new(lang_mod, bookformat: :abbrev)
+  ref = p.parse(subopts[:reference])
+  bible = Sqlbible.new(subopts[:name])
+  out = determine_out subopts
+  bible.reference(ref).flatten.each do |v|
+    out.puts format_verse(f, v)
   end
-  Sqlbible.convert osis_fn, sqlite_fn
 end
-

data/lib/sqlbible/convert.rb

@@ -8,6 +8,8 @@ require_relative '../sqlbible'
 
 class Sqlbible
 
+  # Convert a bible file in OSIS XML format to another file in SQLite format
+  # for Sqlbible
   def self.convert osis_fn, sqlite_fn
     last_bookid = nil
     booknumber = 0

data/lib/sqlbible/version.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+class Sqlbible
+  VERSION = '1.2.0'
+end

data/lib/sqlbible.rb

@@ -1,76 +1,127 @@
-# encooding: utf-8
+# encoding: utf-8
 # frozen_string_literal: true
 
 require 'scripref'
 require 'sqlite3'
 
+require_relative 'sqlbible/version'
+
 class Sqlbible
 
-  VERSION = '1.0.1'
+  attr_reader :db_filename
 
-  def initialize db_filename
-    @db = SQLite3::Database.new(db_filename)
+  def initialize db_name
+    @db_filename = Sqlbible.resolve_db_filename(db_name)
+    unless File.exist? @db_filename
+      fail ArgumentError, format('database %s not found, file %s does not exist', db_name, @db_filename)
+    end
+    @db = SQLite3::Database.new(@db_filename)
     @db.enable_load_extension(true)
     pcre_extension_file = ENV['SQLITE_PCRE_EXTENSION']
     @db.load_extension(pcre_extension_file) if pcre_extension_file
     check_schema_version
   end
 
+  # Get an array of Verse instances for a Scripref::Passage
   def passage pass
     rowid1, rowid2 = passage2rowids(pass)
     res = select_text(where: 'rowid between ? and ?', args: [rowid1, rowid2])
     parse_verse_list(res)
   end
 
+  # Get an array of arrays of Verse instances for a Scripref reference (array
+  # of Scripref::Passage instances)
   def reference ref
     ref.select {|e| e.kind_of?(Scripref::Passage)}.map {|pass| passage(pass)}
   end
 
-  def search obj, range: nil
+  # Get an array of Verse instances for a search with one ore more regular
+  # expressions (optional a search range of a Scripref reference is possible)
+  def search *searches, range: nil
     where_arr = []
     args = []
     if range
       passages = Array(range).select {|e| e.kind_of? Scripref::Passage}
       passages.size.times {where_arr << 'rowid between ? and ?'}
-      where_arr == [or_join_where(where_arr)]
+      where_arr = [or_join_where(where_arr)]
       args = passages.map {|p| passage2rowids(p)}.flatten
     end
-    case obj
-    when Regexp
-      where_arr << 'plaintext regexp ?'
-      args << obj.to_s
-      res = select_text(where: and_join_where(where_arr), args: args)
-    else
-      fail 'unknown search object'
+    searches.flatten.each do |o|
+      case o
+      when Regexp
+        where_arr << 'plaintext regexp ?'
+        args << o.to_s
+      else
+        fail format('search objects of class %s are not (yet) supported', o.class)
+      end
     end
+    where = and_join_where(where_arr)
+    res = select_text(where: where, args: args)
     parse_verse_list(res)
   end
 
+  # Get the schema version of the SQLite database of the instance
+  def schema_version
+    Sqlbible.select_schema_version(@db)
+  end
+
+  # Representation of a verse
   Verse = Struct.new :osisid, :bookid, :chapter, :verse, :xml, :plaintext, keyword_init: true do
     def scripref_passage
       Scripref::Passage.new(b1: bookid, c1: chapter, v1: verse, b2: bookid, c2: chapter, v2: verse)
     end
   end
 
+  @bibles_dir = File.join(Dir.home, '.sqlbible/bibles')
+
   class << self
 
+    attr_reader :bibles_dir
+
+    # Get the database schema as string
     def db_schema
       File.read(File.join(__dir__, '../schema.sql'))
     end
 
-  end
+    # Get an array of the major and minor version of the database schema of the
+    # actual version of the lib
+    def schema_major_minor
+      lib_db = SQLite3::Database.new(':memory:')
+      lib_db.execute_batch(Sqlbible.db_schema)
+      select_schema_major_minor(lib_db)
+    end
 
-  private
+    # Get the version of the database schema of the actual version of the lib
+    def schema_version
+      schema_major_minor.join('.')
+    end
+
+    # Get an array of the major and minor version of an Sqlbible database
+    def select_schema_major_minor db
+      db.execute("select major, minor from schema_version").first
+    end
+
+    # Get the version of an Sqlbible database
+    def select_schema_version db
+      select_schema_major_minor(db).join('.')
+    end
+
+    def resolve_db_filename db_name
+      fn = db_name.to_s
+      if File.basename(fn) == fn
+        File.join(bibles_dir, format('%s.sqlbible', fn.sub(/\.sqlbible$/, '')))
+      else
+        fn
+      end
+    end
 
-  def select_schema_version db
-    db.execute("select major, minor from schema_version").first
   end
 
+  private
+
   def check_schema_version
-    lib_db = SQLite3::Database.new(':memory:')
-    lib_db.execute_batch(Sqlbible.db_schema)
-    major_lib, minor_lib = select_schema_version(lib_db)
-    major_bible, minor_bible = select_schema_version(@db)
+    major_lib, minor_lib = Sqlbible.schema_major_minor
+    major_bible, minor_bible = Sqlbible.select_schema_major_minor(@db)
     if major_bible < major_lib || major_bible == major_lib && minor_bible < minor_lib
       fail 'database schema of bible database is too old'
     end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlbible
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.2.0
 platform: ruby
+original_platform: ''
 authors:
 - Jan Friedrich
 bindir: bin
 cert_chain: []
-date: 2024-11-01 00:00:00.000000000 Z
+date: 2024-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -24,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
-  name: optimist
+  name: optimist_xl
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: scripref
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +91,7 @@ files:
 - bin/sqlbible
 - lib/sqlbible.rb
 - lib/sqlbible/convert.rb
+- lib/sqlbible/version.rb
 - schema.sql
 homepage: https://bitbucket.org/janfri/sqlbible
 licenses: