litestack 0.4.1 → 0.4.2

data/bench/bench_jobs_rails.rb

@@ -1,39 +1,45 @@
-require './bench'
+require "./bench"
 
-count = ARGV[0].to_i rescue 1000
+count = begin
+  ARGV[0].to_i
+rescue
+  1000
+end
 env = ARGV[1] || "t"
-delay = ARGV[2].to_f rescue 0
-
+_delay = begin
+  ARGV[2].to_f
+rescue
+  0
+end
 
-#ActiveJob::Base.logger = Logger.new(IO::NULL)
+# ActiveJob::Base.logger = Logger.new(IO::NULL)
 
-require './rails_job.rb'
+require "./rails_job"
 
 RailsJob.queue_adapter = :sidekiq
 t = Time.now.to_f
-puts "Make sure sidekiq is started with -c ./rails_job.rb"     
-bench("enqueuing sidekiq jobs", count) do 
+puts "Make sure sidekiq is started with -c ./rails_job.rb"
+bench("enqueuing sidekiq jobs", count) do
   RailsJob.perform_later(count, t)
 end
 
 puts "Don't forget to check the sidekiq log for processing time conclusion"
 
-
 # Litejob bench
 ###############
 
 if env == "a" # threaded
-  require 'async/scheduler'
+  require "async/scheduler"
   Fiber.set_scheduler Async::Scheduler.new
   ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
 end
 
-require_relative '../lib/active_job/queue_adapters/litejob_adapter'
+require_relative "../lib/active_job/queue_adapters/litejob_adapter"
 puts Litescheduler.backend
 
 RailsJob.queue_adapter = :litejob
 t = Time.now.to_f
-bench("enqueuing litejobs", count) do 
+bench("enqueuing litejobs", count) do
   RailsJob.perform_later(count, t)
 end
 

data/bench/bench_jobs_raw.rb

@@ -1,15 +1,23 @@
-require './bench'
+require "./bench"
 
-count = ARGV[0].to_i rescue 1000
+count = begin
+  ARGV[0].to_i
+rescue
+  1000
+end
 env = ARGV[1] || "t"
-delay = ARGV[2].to_f rescue 0
+delay = begin
+  ARGV[2].to_f
+rescue
+  0
+end
 
 # Sidekiq bench
 ###############
-require './skjob.rb'
+require "./skjob"
 
 t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-puts "make sure sidekiq is started with skjob.rb as the job"     
+puts "make sure sidekiq is started with skjob.rb as the job"
 bench("enqueuing sidekiq jobs", count) do |i|
   SidekiqJob.perform_async(count, t, delay)
 end
@@ -20,15 +28,15 @@ puts "Don't forget to check the sidekiq log for processing time conclusion"
 ###############
 
 if env == "t" # threaded
-  # do nothing 
+  # do nothing
 elsif env == "a" # async
-  require 'async/scheduler'
+  require "async/scheduler"
   Fiber.set_scheduler Async::Scheduler.new
 end
 
-require './uljob.rb'
+require "./uljob"
 
-STDERR.puts "litejob started in #{Litescheduler.backend} environmnet"
+warn "litejob started in #{Litescheduler.backend} environment"
 
 t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 bench("enqueuing litejobs", count) do |i|
@@ -40,4 +48,3 @@ puts "Please wait for the benchmark to finish .."
 Fiber.scheduler.run if env == "a"
 
 sleep
-

data/bench/bench_queue.rb

@@ -1,16 +1,14 @@
-require './bench'
-require_relative '../lib/litestack'
+require "./bench"
+require_relative "../lib/litestack"
 
 count = 1000
 
-q = Litequeue.new({path: '../db/queue.db' })
+q = Litequeue.new({path: "../db/queue.db"})
 
 bench("Litequeue enqueue", count) do |i|
   q.push i.to_s
 end
 
 bench("Litequeue dequeue", count) do |i|
-  q.pop  
+  q.pop
 end
-
-

data/bench/rails_job.rb

@@ -1,18 +1,16 @@
-require 'active_job'
+require "active_job"
 
 class RailsJob < ActiveJob::Base
-  
   queue_as :default
 
   @@count = 0
-  
+
   def perform(count, time)
-    #sleep 1
-    @@count += 1 
-    if @@count == count  
+    # sleep 1
+    @@count += 1
+    if @@count == count
       puts "[litejob] Finished in #{Time.now.to_f - time} seconds (#{count / (Time.now.to_f - time)} jps)"
       @@count = 0
     end
   end
-
 end

data/bench/skjob.rb

@@ -1,14 +1,14 @@
-require 'sidekiq'
+require "sidekiq"
 
 class SidekiqJob
   include Sidekiq::Job
   @@count = 0
   def perform(count, time, sleep_interval = nil)
-    sleep sleep_interval if sleep_interval  
+    sleep sleep_interval if sleep_interval
     @@count += 1
-    if @@count == count  
+    if @@count == count
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      STDERR.puts "Sidekiq finished in #{now - time} seconds (#{count / (now - time)} jps)"
+      warn "Sidekiq finished in #{now - time} seconds (#{count / (now - time)} jps)"
       @@count = 0
     end
   end

data/bench/uljob.rb

@@ -1,16 +1,16 @@
-require './bench'
-require '../lib/litestack/litejob'
+require "./bench"
+require "../lib/litestack/litejob"
 
 class MyJob
   include Litejob
   @@count = 0
-  #self.queue = :default
+  # self.queue = :default
   def perform(count, time, sleep_interval = nil)
-    sleep sleep_interval if sleep_interval  
+    sleep sleep_interval if sleep_interval
     @@count += 1
-    if @@count == count  
+    if @@count == count
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      STDERR.puts "Litejob finished in #{now - time} seconds (#{count / (now - time)} jps)"
+      warn "Litejob finished in #{now - time} seconds (#{count / (now - time)} jps)"
     end
   end
 end

data/lib/action_cable/subscription_adapter/litecable.rb

@@ -1,26 +1,23 @@
 # frozen_stringe_literal: true
 
-require_relative '../../litestack/litecable'
+require_relative "../../litestack/litecable"
 
 module ActionCable
   module SubscriptionAdapter
-    class Litecable < ::Litecable# :nodoc:
-
+    class Litecable < ::Litecable # :nodoc:
       attr_reader :logger, :server
-      
+
       prepend ChannelPrefix
 
-      def initialize(server, logger=nil)
+      def initialize(server, logger = nil)
         @server = server
         @logger = server.logger
         super({config_path: "./config/litecable.yml"})
       end
-            
+
       def shutdown
         close
       end
-    
     end
   end
 end
-

data/lib/active_job/queue_adapters/litejob_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../litestack/litejob.rb'
+require_relative "../../litestack/litejob"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/access"
 require "active_job"
@@ -12,13 +12,12 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :litejob
     class LitejobAdapter
-          
-      def initialize(options={})
+      def initialize(options = {})
         # we currently don't honour individual options per job class
         # possible in the future?
         # Job.options = DEFAULT_OPTIONS.merge(options)
       end
-    
+
       def enqueue(job) # :nodoc:
         Job.queue = job.queue_name
         Job.perform_async(job.serialize)
@@ -30,14 +29,13 @@ module ActiveJob
       end
 
       class Job # :nodoc:
-        
         DEFAULT_OPTIONS = {
           config_path: "./config/litejob.yml",
-          logger: nil, # Rails performs its logging already
-        }      
+          logger: nil # Rails performs its logging already
+        }
 
         include ::Litejob
-  
+
         def perform(job_data)
           Base.execute job_data
         end

data/lib/active_record/connection_adapters/litedb_adapter.rb

@@ -1,54 +1,47 @@
-require_relative '../../litestack/litedb'
-require 'active_record'
-require 'active_record/connection_adapters/sqlite3_adapter'
-require 'active_record/tasks/sqlite_database_tasks'
+require_relative "../../litestack/litedb"
+require "active_record"
+require "active_record/connection_adapters/sqlite3_adapter"
+require "active_record/tasks/sqlite_database_tasks"
 
 module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def litedb_connection(config)
+      config = config.symbolize_keys
 
-	module ConnectionHandling # :nodoc:
-
-		def litedb_connection(config)
-
-			config = config.symbolize_keys
-
-			# Require database.
-			unless config[:database]
-				raise ArgumentError, "No database file specified. Missing argument: database"
-			end
-
-			# Allow database path relative to Rails.root, but only if the database
-			# path is not the special path that tells sqlite to build a database only
-			# in memory.
-			if ":memory:" != config[:database] && !config[:database].to_s.start_with?("file:")
-				config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
-				dirname = File.dirname(config[:database])
-				Dir.mkdir(dirname) unless File.directory?(dirname)
-			end
-
-			db = ::Litedb.new(
-				config[:database].to_s,
-				config.merge(results_as_hash: true)
-			)
+      # Require database.
+      unless config[:database]
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      end
 
-			ConnectionAdapters::LitedbAdapter.new(db, logger, nil, config)
-			
-		rescue Errno::ENOENT => error
-			if error.message.include?("No such file or directory")
-				raise ActiveRecord::NoDatabaseError
-			else
-				raise
-			end
-		end
-	end
+      # Allow database path relative to Rails.root, but only if the database
+      # path is not the special path that tells sqlite to build a database only
+      # in memory.
+      if config[:database] != ":memory:" && !config[:database].to_s.start_with?("file:")
+        config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
+        dirname = File.dirname(config[:database])
+        Dir.mkdir(dirname) unless File.directory?(dirname)
+      end
 
-	module ConnectionAdapters # :nodoc:
+      db = ::Litedb.new(
+        config[:database].to_s,
+        config.merge(results_as_hash: true)
+      )
+
+      ConnectionAdapters::LitedbAdapter.new(db, logger, nil, config)
+    rescue Errno::ENOENT => error
+      if error.message.include?("No such file or directory")
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
+    end
+  end
 
-		class LitedbAdapter < SQLite3Adapter
+  module ConnectionAdapters # :nodoc:
+    class LitedbAdapter < SQLite3Adapter
+      ADAPTER_NAME = "litedb"
 
-		  ADAPTER_NAME = "litedb"
-  
       class << self
-        
         def dbconsole(config, options = {})
           args = []
 
@@ -58,45 +51,42 @@ module ActiveRecord
 
           find_cmd_and_exec("sqlite3", *args)
         end
-        		
       end
 
-		  NATIVE_DATABASE_TYPES = {
-			  primary_key:  "integer PRIMARY KEY NOT NULL",
-			  string:       { name: "text" },
-			  text:         { name: "text" },
-			  integer:      { name: "integer" },
-			  float:        { name: "real" },
-			  decimal:      { name: "real" },
-			  datetime:     { name: "text" },
-			  time:         { name: "integer" },
-			  date:         { name: "text" },
-			  binary:       { name: "blob" },
-			  boolean:      { name: "integer" },
-			  json:         { name: "text" },
-                          unixtime:     { name: "integer" }
-		  }
-		  
-		  private
-		  
-	      def connect
-            @raw_connection = ::Litedb.new(
-              @config[:database].to_s,
-              @config.merge(results_as_hash: true)
-            )
-            configure_connection
-        end
-		end
+      NATIVE_DATABASE_TYPES = {
+        primary_key: "integer PRIMARY KEY NOT NULL",
+        string: {name: "text"},
+        text: {name: "text"},
+        integer: {name: "integer"},
+        float: {name: "real"},
+        decimal: {name: "real"},
+        datetime: {name: "text"},
+        time: {name: "integer"},
+        date: {name: "text"},
+        binary: {name: "blob"},
+        boolean: {name: "integer"},
+        json: {name: "text"},
+        unixtime: {name: "integer"}
+      }
+
+      private
+
+      def connect
+        @raw_connection = ::Litedb.new(
+          @config[:database].to_s,
+          @config.merge(results_as_hash: true)
+        )
+        configure_connection
+      end
+    end
+  end
 
-	end
-	
   module Tasks # :nodoc:
     class LitedbDatabaseTasks < SQLiteDatabaseTasks # :nodoc:
     end
-    
+
     module DatabaseTasks
       register_task(/litedb/, "ActiveRecord::Tasks::LitedbDatabaseTasks")
-
     end
-	end
+  end
 end

data/lib/active_support/cache/litecache.rb

@@ -3,23 +3,21 @@ require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/numeric/time"
 require "active_support/cache"
-require_relative '../../litestack'
-
+require_relative "../../litestack/litecache"
 
 module ActiveSupport
   module Cache
     class Litecache < Store
-
       prepend Strategy::LocalCache
-		  
+
       def self.supports_cache_versioning?
         true
       end
 
-      def initialize(options={})
+      def initialize(options = {})
         super
         @options[:return_full_record] = true
-      	@cache = ::Litecache.new(@options) # reachout to the outer litecache class
+        @cache = ::Litecache.new(@options) # reachout to the outer litecache class
       end
 
       def increment(key, amount = 1, options = nil)
@@ -27,39 +25,39 @@ module ActiveSupport
         options = merged_options(options)
         # todo: fix me
         # this is currently a hack to avoid dealing with Rails cache encoding and decoding
-        #@cache.transaction(:immediate) do
-          if value = read(key, options)
-            value = value.to_i + amount
-            write(key, value, options)
-          end
-        #end
+        # @cache.transaction(:immediate) do
+        if (value = read(key, options))
+          value = value.to_i + amount
+          write(key, value, options)
+        end
+        # end
       end
 
       def decrement(key, amount = 1, options = nil)
         options = merged_options(options)
         increment(key, -1 * amount, options[:expires_in])
       end
-      
+
       def prune(limit = nil, time = nil)
         @cache.prune(limit)
       end
 
       def cleanup(limit = nil, time = nil)
         @cache.prune(limit)
-      end 
+      end
 
-      def clear(options = nil)
-      	@cache.clear
+      def clear
+        @cache.clear
       end
-      
+
       def count
         @cache.count
       end
-      
+
       def size
         @cache.size
       end
-      
+
       def max_size
         @cache.max_size
       end
@@ -70,33 +68,32 @@ module ActiveSupport
 
       private
 
-        # Read an entry from the cache.
-        def read_entry(key, **options)
-          deserialize_entry(@cache.get(key))
-        end
+      # Read an entry from the cache.
+      def read_entry(key, **options)
+        deserialize_entry(@cache.get(key))
+      end
 
-        # Write an entry to the cache.
-        def write_entry(key, entry, **options)
-          write_serialized_entry(key, serialize_entry(entry, **options), **options)
-        end
+      # Write an entry to the cache.
+      def write_entry(key, entry, **options)
+        write_serialized_entry(key, serialize_entry(entry, **options), **options)
+      end
 
-        def write_serialized_entry(key, payload, **options)
-          expires_in = options[:expires_in].to_i
-          if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
-            expires_in += 5.minutes
-          end
-          if options[:unless_exist]
-            @cache.set_unless_exists(key, payload, expires_in)
-          else
-            @cache.set(key, payload, expires_in)
-          end
+      def write_serialized_entry(key, payload, **options)
+        expires_in = options[:expires_in].to_i
+        if options[:race_condition_ttl] && expires_in > 0 && !options[:raw]
+          expires_in += 5.minutes
         end
-
-        # Delete an entry from the cache.
-        def delete_entry(key, **options)
-          return @cache.delete(key)
+        if options[:unless_exist]
+          @cache.set_unless_exists(key, payload, expires_in)
+        else
+          @cache.set(key, payload, expires_in)
         end
+      end
 
+      # Delete an entry from the cache.
+      def delete_entry(key, **options)
+        @cache.delete(key)
+      end
     end
   end
 end

data/lib/generators/litestack/install/install_generator.rb

@@ -27,9 +27,9 @@ class Litestack::InstallGenerator < Rails::Generators::Base
   def modify_gitignore
     append_file ".gitignore", <<~TEXT
 
-    # Ignore default Litestack SQLite databases.
-    /db/**/*.sqlite3
-    /db/**/*.sqlite3-*
+      # Ignore default Litestack SQLite databases.
+      /db/**/*.sqlite3
+      /db/**/*.sqlite3-*
     TEXT
   end
 end

data/lib/generators/litestack/install/templates/database.yml

@@ -7,6 +7,9 @@
 # `Litesupport.root.join("data.sqlite3")` stores
 # application data in the path `./db/#{Rails.env}/data.sqlite3`
 #
+# `Litesupport.root(env).join(path)` stores 
+# application data in the path `./db/#{env}/#{path}`
+#
 # idle_timeout should be set to zero, to avoid recycling sqlite connections
 # and losing the page cache
 # 
@@ -14,16 +17,17 @@ default: &default
   adapter: litedb
   pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>
   idle_timeout: 0
-  database: <%= Litesupport.root.join("data.sqlite3") %>
 
 development:
   <<: *default
+  database: <%= Litesupport.root("development").join("data.sqlite3") %>
 
 # Warning: The database defined as "test" will be erased and
 # re-generated from your development database when you run "rake".
 # Do not set this db to the same as development or production.
 test:
   <<: *default
+  database: <%= Litesupport.root("test").join("data.sqlite3") %>
 
 # Warning: Make sure your production database path is on a persistent
 # volume, otherwise your application data could be deleted between deploys.
@@ -32,3 +36,5 @@ test:
 # `LITESTACK_DATA_PATH` environment variable.
 production:
   <<: *default
+  database: <%= Litesupport.root("production").join("data.sqlite3") %>
+