litestack 0.3.0 → 0.4.2

data/lib/litestack/litesearch.rb

@@ -0,0 +1,34 @@
+module Litesearch
+  class Index; end
+
+  class Schema; end
+end
+
+require_relative "./litesearch/index"
+require_relative "./litesearch/model"
+
+module Litesearch
+  def litesearch_index_cache
+    @litesearch_index_cache ||= {}
+  end
+
+  def search_index(name)
+    # normalize the index name
+    # find the index in the db cache
+    name = name.to_s.downcase.to_sym
+    index = litesearch_index_cache[name]
+    # if the index is in the cache and no block is given then return it
+    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
+    index = if block_given?
+      Index.new(self, name) do |schema|
+        yield schema
+        schema.name(name)
+      end
+    else
+      Index.new(self, name)
+    end
+    litesearch_index_cache[name] = index
+  end
+end

data/lib/litestack/litesupport.rb

@@ -1,20 +1,16 @@
 # 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"
 
-module Litesupport
+require_relative "./litescheduler"
 
+module Litesupport
   class Error < StandardError; end
-  
-  def self.max_contexts
-    return 50 if scheduler == :fiber || scheduler == :polyphony
-    5    
-  end
 
   # Detect the Rack or Rails environment.
   def self.detect_environment
@@ -33,88 +29,10 @@ module Litesupport
     @environment ||= detect_environment
   end
 
-  # cache the scheduler we are running in
-  # it is an error to change the scheduler for a process
-  # or for a child forked from that process
-  def self.scheduler
-    @scehduler ||= detect_scheduler
-  end
-
-  # identify which scheduler we are running in
-  # we currently support :fiber, :polyphony, :iodine & :threaded
-  # in the future we might want to expand to other schedulers
-  def self.detect_scheduler
-    return :fiber if Fiber.scheduler 
-    return :polyphony if defined? Polyphony
-    return :iodine if defined? Iodine
-    return :threaded # fall back for all other schedulers
-  end
-  
-  # spawn a new execution context
-  def self.spawn(&block)
-    if self.scheduler == :fiber
-      Fiber.schedule(&block)
-    elsif self.scheduler == :polyphony
-      spin(&block)
-    elsif self.scheduler == :threaded or self.scheduler == :iodine
-      Thread.new(&block)
-    end
-    # we should never reach here
-  end
-
-  def self.context
-    if scheduler == :fiber || scheduler == :poylphony
-      Fiber.current.storage
-    else
-      Thread.current
-    end
-  end
-  
-  def self.current_context
-    if scheduler == :fiber || scheduler == :poylphony
-      Fiber.current
-    else
-      Thread.current
-    end
-  end
-  
-  # switch the execution context to allow others to run
-  def self.switch
-    if self.scheduler == :fiber
-      Fiber.scheduler.yield
-      true
-    elsif self.scheduler == :polyphony
-      Fiber.current.schedule
-      Thread.current.switch_fiber
-      true
-    else
-      #Thread.pass
-      false
-    end   
-  end
-  
-  # mutex initialization
-  def self.mutex
-    # a single mutex per process (is that ok?)
-    @@mutex ||= Mutex.new
-  end
-  
-  # bold assumption, we will only synchronize threaded code!
-  # If some code explicitly wants to synchronize a fiber
-  # they must send (true) as a parameter to this method
-  # else it is a no-op for fibers
-  def self.synchronize(fiber_sync = false, &block)
-    if self.scheduler == :fiber or self.scheduler == :polyphony
-      yield # do nothing, just run the block as is
-    else
-      self.mutex.synchronize(&block)
-    end
-  end
-  
   # common db object options
   def self.create_db(path)
     db = SQLite3::Database.new(path)
-    db.busy_handler{ switch || sleep(0.0001) }
+    db.busy_handler { Litescheduler.switch || sleep(0.0001) }
     db.journal_mode = "WAL"
     db.instance_variable_set(:@stmts, {})
     class << db
@@ -124,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
@@ -138,7 +56,7 @@ module Litesupport
       "."
     end
 
-    Pathname.new(path).join(Litesupport.environment)
+    Pathname.new(path).join(env)
   end
 
   def self.ensure_root_volume(path)
@@ -147,125 +65,106 @@ module Litesupport
   end
 
   class Mutex
-  
     def initialize
       @mutex = Thread::Mutex.new
     end
-    
+
     def synchronize(&block)
-      if Litesupport.scheduler == :threaded || Litesupport.scheduler == :iodine
-        @mutex.synchronize{ block.call }
+      if Litescheduler.backend == :threaded || Litescheduler.backend == :iodine
+        @mutex.synchronize { block.call }
       else
         block.call
       end
     end
-  
   end
-   
+
   class Pool
-  
     def initialize(count, &block)
       @count = count
       @block = block
-      @resources = []
+      @resources = Thread::Queue.new
       @mutex = Litesupport::Mutex.new
       @count.times do
-        resource = @mutex.synchronize{ block.call }
-        @resources << [resource, :free]
+        resource = @mutex.synchronize { block.call }
+        @resources << resource
       end
     end
-    
+
     def acquire
-      # check for pid changes
-      acquired = false
       result = nil
-      while !acquired do
-        @mutex.synchronize do
-          if resource = @resources.find{|r| r[1] == :free }
-            resource[1] = :busy
-            begin
-              result = yield resource[0]
-            rescue Exception => e
-              raise e
-            ensure
-              resource[1] = :free
-              acquired = true
-            end
-          end
-        end
-        sleep 0.001 unless acquired
+      resource = @resources.pop
+      begin
+        result = yield resource
+      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?(Litesupport.scheduler)
-        ForkListener.listeners.each{|l| l.call }
+      if Process.pid != ppid && [:threaded, :iodine].include?(Litescheduler.backend)
+        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)
@@ -276,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]
@@ -287,51 +194,50 @@ module Litesupport
       @options.merge!(config)
       @options.merge!(options) # make sure options passed to initialize trump everything else
     end
-    
+
     def setup
       @conn = create_pooled_connection
       @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}  
+      Litesupport::Pool.new(1) { create_connection }
     end
 
     # common db object options
     def create_connection(path_to_sql_file = nil)
       conn = SQLite3::Database.new(@options[:path])
-      conn.busy_handler{ Litesupport.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
@@ -344,38 +250,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.3.0"
-end       
+  VERSION = "0.4.2"
+end

data/lib/litestack.rb

@@ -2,6 +2,7 @@
 
 # load core classes
 require_relative "./litestack/version"
+require_relative "./litestack/litescheduler"
 require_relative "./litestack/litesupport"
 require_relative "./litestack/litemetric"
 require_relative "./litestack/litedb"
@@ -12,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
@@ -31,14 +30,14 @@ module Rails
         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]
+        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)
 
       when "sqlite3", "litedb"
@@ -50,7 +49,6 @@ module Rails
 
         find_cmd_and_exec("sqlite3", *args)
 
-
       when "oracle", "oracle_enhanced"
         logon = ""
 
@@ -65,9 +63,9 @@ module Rails
       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]}"
@@ -81,7 +79,5 @@ module Rails
         abort "Unknown command-line client for #{db_config.database}."
       end
     end
-                                                                                                                                                                                           
-
   end
 end

data/lib/sequel/adapters/litedb.rb

@@ -1,48 +1,44 @@
-require_relative '../../litestack/litedb'
-require 'sequel'
-require 'sequel/adapters/sqlite'
-#require 'shared/litedb'
+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? Litesupport.scheduler
-      
+        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