litestack 0.4.1 → 0.4.3

data/lib/litestack/litesearch.rb

@@ -1,13 +1,13 @@
 module Litesearch
   class Index; end
+
   class Schema; end
 end
 
-require_relative './litesearch/index'
-require_relative './litesearch/model'
+require_relative "./litesearch/index"
+require_relative "./litesearch/model"
 
 module Litesearch
-  
   def litesearch_index_cache
     @litesearch_index_cache ||= {}
   end
@@ -21,17 +21,14 @@ module Litesearch
     return index if index && !block_given?
     # if either there is no index in the cache or a block is given
     # create a new index instance and then place it in the cache and return
-    if block_given?
-      index = Index.new(self, name) do |schema|
+    index = if block_given?
+      Index.new(self, name) do |schema|
         yield schema
         schema.name(name)
       end
     else
-      index = Index.new(self, name)
+      Index.new(self, name)
     end
     litesearch_index_cache[name] = index
   end
-
 end
-
-

data/lib/litestack/litesupport.rb

@@ -1,16 +1,15 @@
 # frozen_stringe_literal: true
 
-require 'sqlite3'
-require 'logger'
-require 'oj'
-require 'yaml'
-require 'pathname'
-require 'fileutils'
+require "sqlite3"
+require "logger"
+require "oj"
+require "yaml"
+require "pathname"
+require "fileutils"
 
 require_relative "./litescheduler"
 
 module Litesupport
-
   class Error < StandardError; end
 
   # Detect the Rack or Rails environment.
@@ -29,11 +28,11 @@ module Litesupport
   def self.environment
     @environment ||= detect_environment
   end
-  
+
   # common db object options
   def self.create_db(path)
     db = SQLite3::Database.new(path)
-    db.busy_handler{ Litescheduler.switch || sleep(0.0001) }
+    db.busy_handler { Litescheduler.switch || sleep(0.0001) }
     db.journal_mode = "WAL"
     db.instance_variable_set(:@stmts, {})
     class << db
@@ -43,12 +42,12 @@ module Litesupport
   end
 
   # Databases will be stored by default at this path.
-  def self.root
-    @root ||= ensure_root_volume detect_root
+  def self.root(env = Litesupport.environment)
+    ensure_root_volume detect_root(env)
   end
 
   # Default path where we'll store all of the databases.
-  def self.detect_root
+  def self.detect_root(env)
     path = if ENV["LITESTACK_DATA_PATH"]
       ENV["LITESTACK_DATA_PATH"]
     elsif defined? Rails
@@ -57,7 +56,7 @@ module Litesupport
       "."
     end
 
-    Pathname.new(path).join(Litesupport.environment)
+    Pathname.new(path).join(env)
   end
 
   def self.ensure_root_volume(path)
@@ -66,115 +65,106 @@ module Litesupport
   end
 
   class Mutex
-  
     def initialize
       @mutex = Thread::Mutex.new
     end
-    
+
     def synchronize(&block)
       if Litescheduler.backend == :threaded || Litescheduler.backend == :iodine
-        @mutex.synchronize{ block.call }
+        @mutex.synchronize { block.call }
       else
         block.call
       end
     end
-  
   end
-   
+
   class Pool
-  
     def initialize(count, &block)
       @count = count
       @block = block
       @resources = Thread::Queue.new
       @mutex = Litesupport::Mutex.new
       @count.times do
-        resource = @mutex.synchronize{ block.call }
-        @resources << resource 
+        resource = @mutex.synchronize { block.call }
+        @resources << resource
       end
     end
-    
+
     def acquire
       result = nil
       resource = @resources.pop
       begin
         result = yield resource
-      rescue Exception => e
-        raise e
       ensure
         @resources << resource
       end
       result
     end
-        
   end
-     
+
   module ForkListener
     def self.listeners
       @listeners ||= []
     end
-    
+
     def self.listen(&block)
       listeners << block
     end
   end
 
   module Forkable
-      
     def _fork(*args)
       ppid = Process.pid
       result = super
       if Process.pid != ppid && [:threaded, :iodine].include?(Litescheduler.backend)
-        ForkListener.listeners.each{|l| l.call }
+        ForkListener.listeners.each { |l| l.call }
       end
       result
     end
-    
   end
-  
+
   module Liteconnection
-    
     include Forkable
 
     # close, setup, run_stmt and run_sql assume a single connection was created
-    
+
     def options
       @options
     end
-    
+
     def close
       @running = false
-      @conn.acquire do |q| 
-        q.stmts.each_pair {|k, v| q.stmts[k].close }
+      @conn.acquire do |q|
+        q.stmts.each_pair { |k, v| q.stmts[k].close }
         q.close
       end
     end
 
     def size
-      run_sql("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count")[0][0].to_f / (1024*1024)
+      run_sql("SELECT size.page_size * count.page_count FROM pragma_page_size() AS size, pragma_page_count() AS count")[0][0].to_f / (1024 * 1024)
     end
 
     def journal_mode
       run_method(:journal_mode)
     end
-    
+
     def synchronous
       run_method(:synchronous)
     end
-    
+
     def path
       run_method(:filename)
     end
-    
+
     private # all methods are private
-        
+
     def init(options = {})
-      #c configure the object, loading options from the appropriate location
-      configure(options)    
+      # c configure the object, loading options from the appropriate location
+      configure(options)
       # setup connections and background threads
-      setup      
+      setup
       # handle process exiting
-      at_exit do 
+      at_exit do
         exit_callback
       end
       # handle forking (restart connections and background threads)
@@ -185,9 +175,17 @@ module Litesupport
 
     def configure(options = {})
       # detect enviornment (production, development, etc.)
-      defaults = self.class::DEFAULT_OPTIONS rescue {}
+      defaults = begin
+        self.class::DEFAULT_OPTIONS
+      rescue
+        {}
+      end
       @options = defaults.merge(options)
-      config = YAML.load_file(@options[:config_path]) rescue {} # an empty hash won't hurt
+      config = begin
+        YAML.load_file(@options[:config_path])
+      rescue
+        {}
+      end # an empty hash won't hurt
       config = config[Litesupport.environment] if config[Litesupport.environment] # if there is a config for the current enviornment defined then use it, otherwise use the top level declaration
       config.keys.each do |k| # symbolize keys
         config[k.to_sym] = config[k]
@@ -196,51 +194,51 @@ module Litesupport
       @options.merge!(config)
       @options.merge!(options) # make sure options passed to initialize trump everything else
     end
-    
+
     def setup
-      @conn = create_pooled_connection
+      @conn = create_pooled_connection(@options[:connection_count])
       @logger = create_logger
       @running = true
     end
-    
+
     def create_logger
       @options[:logger] = nil unless @options[:logger]
       return @options[:logger] if @options[:logger].respond_to? :info
-      return Logger.new(STDOUT) if @options[:logger] == 'STDOUT'
-      return Logger.new(STDERR) if @options[:logger] == 'STDERR'
-      return Logger.new(@options[:logger]) if @options[:logger].is_a? String 
-      return Logger.new(IO::NULL)         
+      return Logger.new($stdout) if @options[:logger] == "STDOUT"
+      return Logger.new($stderr) if @options[:logger] == "STDERR"
+      return Logger.new(@options[:logger]) if @options[:logger].is_a? String
+      Logger.new(IO::NULL)
     end
-    
+
     def exit_callback
       close
     end
-    
+
     def run_stmt(stmt, *args)
-      @conn.acquire{|q| q.stmts[stmt].execute!(*args) }
+      @conn.acquire { |q| q.stmts[stmt].execute!(*args) }
     end
 
     def run_sql(sql, *args)
-      @conn.acquire{|q| q.execute(sql, *args) }
+      @conn.acquire { |q| q.execute(sql, args) }
     end
-    
+
     def run_method(method, *args)
-      @conn.acquire{|q| q.send(method, *args)}
+      @conn.acquire { |q| q.send(method, *args) }
     end
 
     def run_stmt_method(stmt, method, *args)
-      @conn.acquire{|q| q.stmts[stmt].send(method, *args)}
+      @conn.acquire { |q| q.stmts[stmt].send(method, *args) }
     end
 
-    
     def create_pooled_connection(count = 1)
-      Litesupport::Pool.new(1){create_connection}  
+      count = 1 unless count and count.is_a? Integer
+      Litesupport::Pool.new(count) { create_connection }
     end
 
     # common db object options
     def create_connection(path_to_sql_file = nil)
       conn = SQLite3::Database.new(@options[:path])
-      conn.busy_handler{ Litescheduler.switch || sleep(rand * 0.002) }
+      conn.busy_handler { Litescheduler.switch || sleep(rand * 0.002) }
       conn.journal_mode = "WAL"
       conn.synchronous = @options[:sync] || 1
       conn.mmap_size = @options[:mmap_size] || 0
@@ -253,38 +251,31 @@ module Litesupport
       unless path_to_sql_file.nil?
         sql = YAML.load_file(path_to_sql_file)
         version = conn.get_first_value("PRAGMA user_version")
-        sql["schema"].each_pair do |v, obj| 
+        sql["schema"].each_pair do |v, obj|
           if v > version
-            conn.transaction do 
-              obj.each do |k, s| 
-                begin
-                  conn.execute(s)
-                rescue Exception => e
-                  STDERR.puts "Error parsing #{k}"
-                  STDERR.puts s
-                  raise e               
-                end
+            conn.transaction do
+              obj.each do |k, s|
+                conn.execute(s)
+              rescue Exception => e # standard:disable Lint/RescueException
+                warn "Error parsing #{k}"
+                warn s
+                raise e
               end
               conn.user_version = v
             end
           end
-        end 
-        sql["stmts"].each do |k, v| 
-          begin
-            conn.stmts[k.to_sym] = conn.prepare(v)
-          rescue Exception => e
-            STDERR.puts "Error parsing #{k}"
-            STDERR.puts v
-            raise e               
-          end
+        end
+        sql["stmts"].each do |k, v|
+          conn.stmts[k.to_sym] = conn.prepare(v)
+        rescue Exception => e # standard:disable Lint/RescueException
+          warn "Error parsing #{k}"
+          warn v
+          raise e
         end
       end
       conn
     end
-        
   end
-      
-end  
+end
 
 Process.singleton_class.prepend(Litesupport::Forkable)
-

data/lib/litestack/railtie.rb

@@ -7,4 +7,4 @@ module Litestack
       app.config.active_record.sqlite3_production_warning = false
     end
   end
-end
+end

data/lib/litestack/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Litestack
-  VERSION = "0.4.1"
-end       
+  VERSION = "0.4.3"
+end

data/lib/litestack.rb

@@ -13,14 +13,16 @@ require_relative "./litestack/litecable"
 # conditionally load integration with other libraries
 require_relative "./sequel/adapters/litedb" if defined? Sequel
 require_relative "./active_record/connection_adapters/litedb_adapter" if defined? ActiveRecord
-require_relative "./railties/rails/commands/dbconsole" if defined? Rails && defined? ActiveRecord
+require_relative "./railties/rails/commands/dbconsole" if defined?(Rails) && defined?(ActiveRecord)
 require_relative "./active_support/cache/litecache" if defined? ActiveSupport
 require_relative "./active_job/queue_adapters/litejob_adapter" if defined? ActiveJob
 require_relative "./action_cable/subscription_adapter/litecable" if defined? ActionCable
 require_relative "./litestack/railtie" if defined? Rails::Railtie
 
 module Litestack
-  class NotImplementedError < Exception; end
-  class TimeoutError < Exception; end
-  class DeadlockError < Exception; end
+  class NotImplementedError < RuntimeError; end
+
+  class TimeoutError < RuntimeError; end
+
+  class DeadlockError < RuntimeError; end
 end

data/lib/railties/rails/commands/dbconsole.rb

@@ -1,6 +1,5 @@
 module Rails
   class DBConsole
-  
     def start
       ENV["RAILS_ENV"] ||= @options[:environment] || environment
       config = db_config.configuration_hash
@@ -28,18 +27,18 @@ module Rails
 
         args << db_config.database
 
-        find_cmd_and_exec(["mysql", "mysql5"], *args)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec(["mysql", "mysql5"], *args)
 
       when /^postgres|^postgis/
-        ENV["PGUSER"]         = config[:username] if config[:username]
-        ENV["PGHOST"]         = config[:host] if config[:host]
-        ENV["PGPORT"]         = config[:port].to_s if config[:port]
-        ENV["PGPASSWORD"]     = config[:password].to_s if config[:password] && @options[:include_password]
-        ENV["PGSSLMODE"]      = config[:sslmode].to_s if config[:sslmode]
-        ENV["PGSSLCERT"]      = config[:sslcert].to_s if config[:sslcert]
-        ENV["PGSSLKEY"]       = config[:sslkey].to_s if config[:sslkey]
-        ENV["PGSSLROOTCERT"]  = config[:sslrootcert].to_s if config[:sslrootcert]
-        find_cmd_and_exec("psql", db_config.database)
+        ENV["PGUSER"] = config[:username] if config[:username]
+        ENV["PGHOST"] = config[:host] if config[:host]
+        ENV["PGPORT"] = config[:port].to_s if config[:port]
+        ENV["PGPASSWORD"] = config[:password].to_s if config[:password] && @options[:include_password]
+        ENV["PGSSLMODE"] = config[:sslmode].to_s if config[:sslmode]
+        ENV["PGSSLCERT"] = config[:sslcert].to_s if config[:sslcert]
+        ENV["PGSSLKEY"] = config[:sslkey].to_s if config[:sslkey]
+        ENV["PGSSLROOTCERT"] = config[:sslrootcert].to_s if config[:sslrootcert]
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("psql", db_config.database)
 
       when "sqlite3", "litedb"
         args = []
@@ -48,8 +47,7 @@ module Rails
         args << "-header" if @options[:header]
         args << File.expand_path(db_config.database, Rails.respond_to?(:root) ? Rails.root : nil)
 
-        find_cmd_and_exec("sqlite3", *args)
-
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlite3", *args)
 
       when "oracle", "oracle_enhanced"
         logon = ""
@@ -60,14 +58,14 @@ module Rails
           logon << "@#{db_config.database}" if db_config.database
         end
 
-        find_cmd_and_exec("sqlplus", logon)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlplus", logon)
 
       when "sqlserver"
         args = []
 
-        args += ["-d", "#{db_config.database}"] if db_config.database
-        args += ["-U", "#{config[:username]}"] if config[:username]
-        args += ["-P", "#{config[:password]}"] if config[:password]
+        args += ["-d", db_config.database.to_s] if db_config.database
+        args += ["-U", config[:username].to_s] if config[:username]
+        args += ["-P", config[:password].to_s] if config[:password]
 
         if config[:host]
           host_arg = +"tcp:#{config[:host]}"
@@ -75,13 +73,11 @@ module Rails
           args += ["-S", host_arg]
         end
 
-        find_cmd_and_exec("sqlcmd", *args)
+        ActiveRecord::Base.connection.class.find_cmd_and_exec("sqlcmd", *args)
 
       else
         abort "Unknown command-line client for #{db_config.database}."
       end
     end
-                                                                                                                                                                                           
-
   end
 end

data/lib/sequel/adapters/litedb.rb

@@ -1,49 +1,44 @@
-require_relative '../../litestack/litedb'
-require 'sequel'
-require 'sequel/adapters/sqlite'
+require_relative "../../litestack/litedb"
+require "sequel"
+require "sequel/adapters/sqlite"
 
 module Sequel
   module Litedb
-  
-  	include SQLite
+    include SQLite
 
     LITEDB_TYPES = SQLITE_TYPES
-    
+
     class Database < Sequel::SQLite::Database
-      
       set_adapter_scheme :litedb
-      
+
       def connect(server)
-      
         Sequel.extension :fiber_concurrency if [:fiber, :polyphony].include? Litescheduler.backend
-      
+
         opts = server_opts(server)
-        opts[:database] = ':memory:' if blank_object?(opts[:database])
+        opts[:database] = ":memory:" if blank_object?(opts[:database])
         sqlite3_opts = {}
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::Litedb.new(opts[:database].to_s, sqlite3_opts)
 
         self.transaction_mode = :immediate
-        
-  	    if sqlite_version >= 104
+
+        if sqlite_version >= 104
           db.extended_result_codes = true
         end
-        
-        connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
-        
+
+        connection_pragmas.each { |s| log_connection_yield(s, db) { db.execute_batch(s) } }
+
         class << db
           attr_reader :prepared_statements
         end
-        
+
         db.instance_variable_set(:@prepared_statements, {})
         @raw_db = db
         db
       end
-
     end
-    
-    class Dataset < Sequel::SQLite::Dataset      
+
+    class Dataset < Sequel::SQLite::Dataset
     end
-    
   end
 end