lux-fw 0.1.17

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cf39a83b84a57cdc4523101a880a856a274723a
+  data.tar.gz: 850600181673ff261e0180dd862993060d153b26
+SHA512:
+  metadata.gz: d47ecd1b0aac507cb33613bcdb2b2aaa1d8ff11952a5ae8a2bd40d54c8c60108d3b176a7db79c2108bbcb2cf74e1aaf52bc7b3a54139e15f09c44eab454df864
+  data.tar.gz: 5eb42b08476252ea35d45d06f7cc40702f9626e8f26a44b155c815b65417030ca68ddb05b93d493c66ae650208b1ddb2c9a9038fdd81500cd5f2588e3434870d

data/.version

@@ -0,0 +1 @@
+0.1.17

data/bin/cli/am

@@ -0,0 +1,250 @@
+#!/usr/bin/env ruby
+
+ENV['DB_NAME'] = ARGV[0] if ARGV[0]
+
+require './config/application'
+
+class AutoMigrate
+  attr_accessor :fields
+
+  class << self
+    def table(table_name)
+      die "table [#{table_name}] not in plural -> expected [#{table_name.to_s.pluralize}]" unless table_name.to_s.pluralize == table_name.to_s
+      klass = table_name.to_s.classify
+      unless Object.const_defined?(klass)
+        puts "model #{klass} not defiend for table #{table_name}".red
+        exit
+      end
+
+      unless DB.table_exists?(table_name.to_s)
+        # http://sequel.jeremyevans.net/rdoc/files/doc/schema_modification_rdoc.html
+        DB.create_table table_name do
+          primary_key :id, Integer
+          index :id, :unique=>true
+        end
+      end
+
+      t = new(table_name)
+      yield(t)
+      t.fix_fields
+      t.update
+    end
+
+    def migrate(&block)
+      instance_eval(&block)
+    end
+
+    def enable_extension(name)
+      DB.run "CREATE EXTENSION IF NOT EXISTS #{name};"
+    end
+
+    def transaction_do text
+      begin
+        DB.run 'BEGIN; %s ;COMMIT;' % text
+      rescue
+        puts caller[1].red
+        puts text.yellow
+        raise $!
+      end
+    end
+  end
+
+  ###
+
+  def initialize(table_name)
+    @table_name = table_name
+    @fields = {}
+  end
+
+  def log_run(what)
+    puts " #{what.green}"
+    self.class.transaction_do what
+  end
+
+  def fix_fields
+    for vals in @fields.values
+      type = vals[0]
+      opts = vals[1]
+
+      opts[:limit] ||= 255 if type == :string
+      opts[:default] ||= false if type == :boolean
+
+      opts[:null] = true unless opts[:null].class.name == 'FalseClass'
+      opts[:array] ||= false
+      opts[:unique] ||= false
+      opts[:default] = [] if opts[:array]
+    end
+  end
+
+  def get_db_column_type(field)
+    type, opts = @fields[field]
+    db_type = type
+    db_type = :varchar if type == :string
+    db_type = Time if type == :datetime
+    if opts[:array]
+      db_type = "#{db_type}(#{opts[:limit]})" if type == :string
+      db_type = "#{db_type}[]"
+    else
+      db_type = "varchar(#{opts[:limit]})" if opts[:limit]
+    end
+    db_type
+  end
+
+  def update
+    begin
+      obj = @table_name.to_s.classify.constantize
+      o = obj.new
+    rescue
+      puts "Object #{@table_name.to_s.classify.red} does not exist, yet table #{@table_name.to_s.red} exists!"
+      # puts $!.message
+      return
+    end
+
+    # remove extra fields
+    existing_fields = o.attributes.keys - ['id']
+    for field in (existing_fields - @fields.keys.map(&:to_s))
+      print "Remove colum #{@table_name}.#{field} (y/N): ".blue
+      if STDIN.gets.chomp.downcase.index('y')
+        DB.drop_column @table_name, field
+        puts " drop_column #{field}".green
+      end
+    end
+
+    puts "Table #{@table_name.to_s.yellow}, #{@fields.keys.length} fields"
+
+    for field, opts_in in @fields
+      type = opts_in[0]
+      opts = opts_in[1]
+
+      db_type = get_db_column_type(field)
+
+      # create missing columns
+      unless obj.columns.index(field.to_sym)
+        DB.add_column @table_name, field, db_type, opts
+
+        if opts[:array]
+          default = type == :string ? "ARRAY[]::character varying[]" : "ARRAY[]::integer[]"
+
+          self.class.transaction_do "ALTER TABLE #{@table_name} ALTER COLUMN #{field} SET DEFAULT #{default};"
+        end
+
+        puts " add_column #{field}, #{db_type}, #{opts.to_json}".green
+        next
+      end
+
+      if current = obj.db_schema[field.to_sym]
+        # limit changed
+
+        # if we have type set as array and in db it is not array, fix that
+        if opts[:array] && !current[:db_type].include?('[]')
+
+          self.class.transaction_do %[
+            alter table #{@table_name} alter #{field} drop default;
+            alter table #{@table_name} alter #{field} type #{current[:db_type]}[] using array[#{field}];
+            alter table #{@table_name} alter #{field} set default '{}';
+          ]
+
+          puts " Coverted #{@table_name}.#{field} to array type".green
+        end
+
+        # if we have array but scema says no array
+        if !opts[:array] && current[:db_type].include?('[]')
+          m = current[:type] == :integer ? "#{field}[0]" : "array_to_string(#{field}, ',')"
+
+          self.class.transaction_do %[
+            alter table #{@table_name} alter #{field} drop default;
+            alter table #{@table_name} alter #{field} type #{current[:db_type].sub('[]','')} using #{m};
+          ]
+
+          puts " Coverted #{@table_name}.#{field}[] to non array type".red
+        end
+
+        # ap "#{@table_name}, #{field}, #{db_type}, #{current[:max_length]}, #{opts[:limit]}" if field == 'description'
+        if type == :string && current[:max_length] != opts[:limit]
+          self.class.transaction_do "ALTER TABLE #{@table_name} ALTER COLUMN #{field} TYPE varchar(#{opts[:limit]});"
+          puts " #{field} limit, #{current[:max_length]}-> #{opts[:limit]}".green
+        end
+
+        if type == :text && current[:max_length]
+          self.class.transaction_do "ALTER TABLE #{@table_name} ALTER COLUMN #{field} SET DATA TYPE text"
+          puts " #{field} limit from  #{current[:max_length]} to no limit (text type)".green
+        end
+
+        # null true or false
+        if current[:allow_null] != opts[:null]
+          to_run = " #{field} #{opts[:null] ? 'DROP' : 'SET'} NOT NULL"
+          log_run "ALTER TABLE #{@table_name} ALTER COLUMN #{to_run}"
+        end
+
+        # field default changed
+        if current[:default].to_s != opts[:default].to_s
+          # skip for arrays
+          next if opts[:array]
+          next if current[:default].to_s.index('{}') and opts[:default] == []
+          next if current[:default].to_s.starts_with?("'#{opts[:default]}':")
+
+          if opts[:default].to_s.blank?
+            log_run "ALTER TABLE #{@table_name} ALTER COLUMN #{field} drop default"
+          else
+            log_run "ALTER TABLE #{@table_name} ALTER COLUMN #{field} SET DEFAULT '#{opts[:default]}'; update #{@table_name} set #{field}='#{opts[:default]}' where #{field} is null;"
+          end
+        end
+
+        if opts[:index]
+          add_index(field)
+        end
+      end
+    end
+
+  end
+
+  def add_index(field)
+    type = @table_name.to_s.classify.constantize.new.db_schema[field][:db_type] rescue nil
+    # puts "#{field.to_s.yellow} (#{type})"
+
+    begin
+      if type.index('[]')
+        DB.run %[CREATE INDEX #{@table_name}_#{field}_gin_index on "#{@table_name}" USING GIN ("#{field}");]
+        puts " * added array GIN index on #{field}".green
+      else
+        DB.add_index(@table_name, field)
+        puts " * added index on #{field}".green
+      end
+    rescue; end
+  end
+
+  def rename(field_old, field_new)
+    existing_fields = @table_name.to_s.classify.constantize.new.attributes.keys.map(&:to_sym)
+    if existing_fields.index(field_old) && ! existing_fields.index(field_new)
+      DB.rename_column(@table_name, field_old, field_new)
+      puts " * renamed #{@table_name}.#{field_old} to #{@table_name}.#{field_new}"
+      puts ' * please run auto migration again'
+      exit
+    end
+  end
+
+  def method_missing(type, *args)
+    name = args[0]
+    opts = args[1] || {}
+    if [:string, :integer, :text, :boolean, :datetime, :date, :jsonb].index(type)
+      @fields[name] = [type, opts]
+    elsif [:decimal].index(type)
+      opts[:precision] ||= 8
+      opts[:scale] ||= 2
+      @fields[name] = [:decimal, opts]
+    elsif type == :timestamps
+      opts[:null] ||= false
+      @fields[:created_at] = [:datetime, opts]
+      @fields[:created_by] = [:integer, opts.merge(index: true)]
+      @fields[:updated_at] = [:datetime, opts]
+      @fields[:updated_by] = [:integer, opts]
+    elsif type == :polymorphic
+      @fields["#{name}_id".to_sym]   = [:integer, opts.merge(index: true) ]
+      @fields["#{name}_type".to_sym] = [:string, opts.merge(limit: 100, index: "#{name}_id")]
+    else
+      puts "Unknown #{type.to_s.red}"
+    end
+  end
+end
+
+require './config/schema.rb'

data/bin/cli/assets

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+if ARGV[0] == 'help'
+  puts 'lux assets rm gzip s3://assets'
+  puts ' rm        - remove local cached folder for assets'
+  puts ' gzip      - gzip files (for nginx)'
+  puts ' s3://path - copy files to bucket (must be last argument)'
+  exit
+end
+
+if ARGV.include?('rm')
+  system 'rm -rf ./tmp/assets'
+  system 'rm -rf ./public/assets'
+end
+
+require './config/application'
+
+assets = Dir['./app/assets/*/index.*'].map { |el| el.sub('./app/assets/','') }
+
+Lux.config.assets_precompile = true
+
+speed = Lux.speed do
+  # tpool is not showing compile errors
+  # tpool(assets) do |file|
+  for file in assets
+    asset = MiniAsset.create file
+    asset.compile ARGV
+    puts "Generated #{file.green} -> #{asset.production_file}"
+  end
+end
+
+puts "Asset precomlile done in #{speed}"
+
+if ARGV.last && ARGV.last[0,5] == 's3://'
+  puts 'Copy to %s'.green % ARGV.last
+  system 'aws s3 sync ./public %s --cache-control "max-age=31536000, no-transform, public"' % ARGV.last
+end

data/bin/cli/console

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+ENV['LUX_VERBOSE'] ||= 'true'
+
+load_start = Time.now
+
+require 'awesome_print'
+require 'clipboard'
+require './config/application'
+
+if File.exist?('./config/console.rb')
+  puts '* loading ./config/console.rb'
+  require './config/console'
+else
+  puts '* ./config/console.rb not found'
+end
+
+Lux::Config.live_require_check! if Lux.config(:auto_code_reload)
+
+puts Lux::Config.show_load_speed load_start
+
+class Object
+  def cp data
+    data = JSON.pretty_generate(data.to_hash) if data.respond_to?(:to_hash)
+    Clipboard.copy data
+    'copied'
+  end
+end
+
+begin
+  require 'pry'
+
+  # AwesomePrint.pry!
+  # nice object dump in console
+  Pry.print = proc { |output, data|
+    out = if data.is_a?(Hash)
+      data.class.to_s+"\n"+JSON.pretty_generate(data).gsub(/"(\w+)":/) { '"%s":' % $1.yellow }
+    else
+      data.ai
+    end
+
+    output.puts out
+  }
+
+  Pry
+rescue LoadError
+  puts 'pry not found, starting irb'.red
+  require 'irb'
+  IRB
+end.start

data/bin/cli/dev

@@ -0,0 +1 @@
+LuxCli.run "rerun -p '**/*.{rb,ru}' 'puma -p %s'" % @port

data/bin/cli/eval

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require './config/application'
+
+puts '* loading ./config/console.rb' if File.exist?('./config/console.rb')
+
+command = ARGV.join('; ')
+
+puts 'Command : %s' % command.light_blue
+
+data = eval command
+puts '-'
+puts 'Class   : %s' % data.class
+puts '-'
+ap data

data/bin/cli/exceptions

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'colorize'
+
+ERROR_FOLDER = './log/exceptions'
+
+case ARGV[0]
+  when 'help'
+    puts ' lux exceptions        - show all exceptions'
+    puts ' lux exceptions clear  - to clear error folder'
+    puts ' lux exceptions NUMBER - to show error on specific number'
+    exit
+  when 'clear'
+    LuxCli.run 'rm -rf "%s"' % ERROR_FOLDER
+    puts '%s removed' % ERROR_FOLDER
+    exit
+  else
+end
+
+show = ARGV[0] ? ARGV[0].to_i : nil
+
+error_folders = Dir['%s/*' % ERROR_FOLDER].sort_by { |x| File.mtime(x) }
+
+if error_folders.length == 0
+  puts 'Nothing found in %s'.blue % ERROR_FOLDER
+  exit
+end
+
+cnt = 0
+
+puts 'Add error number as last argument to show full erros'.blue
+
+error_folders.each do |error_folder|
+  cnt += 1
+  next if show && show != cnt
+
+  print '%s. %s - ' % [cnt.to_s.rjust(2), error_folder.split('/').last.yellow]
+  file = Dir['%s/*.txt' % error_folder].sort_by{ |f| File.mtime(f) }.first
+  next unless file
+
+  last_update = (Time.now - File.mtime(file)).to_i
+
+  if last_update < 60
+    print '%s sec ago - ' % last_update.to_s.blue
+  elsif last_update < 60*60
+    print '%s mins ago - ' % (last_update/60).to_i.to_s.blue
+  elsif last_update < 60*60*24
+    print '%s hours ago - ' % (last_update/(60*60)).to_i.to_s.blue
+  else
+    print '%s days ago - ' % (last_update/(60*60*24)).to_i.to_s.blue
+  end
+
+  puts file.split('/').last
+
+  if show
+    puts "\n" + File.read(file)
+    exit
+  end
+
+  first_line = File.read(file).split("\n").first
+  puts '    %s' % first_line
+end

data/bin/cli/generate

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+# use {{object}} and {{objects}} and {{object.classify}}  as template
+
+require 'optparse'
+require 'colorize'
+require 'fileutils'
+require 'sequel'
+require 'pp'
+
+Sequel.extension :inflector
+
+unless ARGV[0]
+  puts "./generate [object singular]".red
+  exit
+end
+
+template_dir = 'config/templates'
+exit puts "Lux::Template dir #{template_dir} is not accessible" unless Dir.exists?(template_dir)
+
+tpl_desc = {
+  p:'api',
+  m:'model',
+  a:'admin',
+  c:'cell',
+  v:'view'
+}
+
+@object  = ARGV[0]
+@objects = @object.pluralize
+
+puts "Singular  : #{@object.yellow}"
+puts "Plural    : #{@objects.yellow}"
+
+def parse_vars(data)
+  object  = @object
+  objects = @objects
+  klass   = @object.classify
+
+  data.gsub(/\{\{([^\}]+)\}\}/) { eval $1 }
+end
+
+# get all files
+templates = {}
+for el in Dir["./#{template_dir}/*.*"].map{ |file| file.split('/').last }
+  begin
+    data = parse_vars(File.read("#{template_dir}/#{el}"))
+  rescue
+    puts '-'
+    puts "File error: #{el.red}: #{$!.message}"
+    exit
+  end
+  type = el[0,1]
+
+  path = el.split('|', 2)[1]
+  path = parse_vars(path).gsub('#','/')
+
+  templates[type] ||= []
+  templates[type].push [path, data]
+end
+
+# # puts  "Lux::Templates : #{templates.keys.sort.map{ |el| tpl_desc[el.to_sym] ? tpl_desc[el.to_sym].sub(el, el.upcase.yellow) : el.yellow }.join(', ')}"
+puts  "Lux::Templates : #{templates.keys.map{ |el| "#{tpl_desc[el.to_sym]}(#{el.yellow})" }.join(', ')}"
+print "Execute   : "
+
+parse_templates = STDIN.gets.chomp
+
+for type in templates.keys
+  next unless parse_templates.index(type)
+  for el in templates[type]
+    file, data = *el
+    if File.exists?(file)
+      print 'exists'.yellow.rjust(20)
+    else
+      FileUtils.mkdir_p(file.sub(/\/[^\/]+$/,'')) rescue false
+      File.open(file, 'w') { |f| f.write(data) }
+      print 'created'.green.rjust(20)
+    end
+    puts ": #{file}"
+  end
+end
+

data/bin/cli/get

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require './config/application'
+
+ap Lux ARGV[0] || '/'

data/bin/cli/nginx

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+command = ARGV[0]
+
+@local_conf = './config/nginx.conf'
+@nginx_conf = '/etc/nginx/sites-enabled/%s.conf' % Dir.pwd.split('/').last
+
+def build_conf
+  conf = File.read(@local_conf) rescue LuxCli.die('Local conf %s not found' % @local_conf)
+
+  LuxCli.die('$ROOT not found in config') unless conf.include?('$ROOT')
+
+  conf.gsub('$ROOT', Dir.pwd)
+end
+
+case command
+  when 'show'
+    puts build_conf
+  when 'install'
+    File.write './tmp/nginx.conf', build_conf
+    puts '# run this manualy'
+    puts
+    puts 'sudo cp ./tmp/nginx.conf %s && sudo nginx -t' % @nginx_conf
+  else
+    puts ' show      # show rendered config'
+    puts ' install   # install config/nginx.conf to %s' % @nginx_conf
+end
+

data/bin/cli/production

@@ -0,0 +1 @@
+LuxCli.run "puma -p %s -e production" % @port

data/bin/cli/routes

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+ENV['LUX_PRINT_ROUTES'] = 'true'
+
+require 'awesome_print'
+require './config/application'
+
+path = ARGV[0] || '/print-routes'
+
+puts 'Routes for test route %s' % path.green
+
+Lux path

data/bin/cli/server

@@ -0,0 +1 @@
+LuxCli.run "LUX_VERBOSE=true puma -p %s" % @port

data/bin/cli/stat

@@ -0,0 +1 @@
+LuxCli.run 'goaccess -ca -f /var/log/nginx/access.log -a > public/goaccess.html'

data/bin/forever

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+# better? -> https://github.com/bluepill-rb/bluepill
+
+# ~/forever/forever.txt
+# test:  /Users/dux/.rvm/rubies/ruby-2.3.1/bin/ruby /Users/dux/dev/lux-fw/raumdog.com/test.rb
+# test2: /Users/dux/.rvm/rubies/ruby-2.3.1/bin/ruby /Users/dux/dev/lux-fw/raumdog.com/test2.rb
+
+# creates ~/forever/logs and ~/forever/pids
+# keeps logs in size
+
+# 1 1 * * * bash -l -c 'ruby /User/adsad/../forever'
+
+require 'colorize'
+require 'fileutils'
+
+@root = File.expand_path('~/forever')
+@max_file_size_in_mb = 1
+
+def die(data)
+  puts data.red
+  exit
+end
+
+def demonize(id, script)
+  size = @max_file_size_in_mb * 1_000_000
+
+  # rotate big files
+  for log_file in ["#{@root}/logs/#{id}.log", "#{@root}/logs/#{id}.err"]
+    if File.size?(log_file).to_i > (size * 3)
+      puts "truncate #{log_file} to #{size}".yellow
+      data = File.read(log_file)
+      data = data[data.length - size, size]
+      File.open(log_file, 'w') { |f| f.write(data) }
+    end
+  end
+
+  pid_file = "#{@root}/pids/#{id}.pid"
+  pid = File.read(pid_file).chomp rescue nil
+
+  env_id = "FOREVER_ID=#{id}_END"
+
+  if pid && `ps aux | grep #{env_id} | grep #{pid}`.index(script)
+    puts "exists #{id.ljust(15)} pid #{pid}".green
+  else
+    print "starting #{id.ljust(15)} pid ".yellow
+    `nohup #{script} #{env_id} >> #{@root}/logs/#{id}.log 2>> #{@root}/logs/#{id}.err < /dev/null & echo $! > #{pid_file}`
+    puts File.read(pid_file)
+  end
+end
+
+file = "#{@root}/forever.txt"
+die "~/forever/forever.txt not present (#{file})" unless File.exist?(file)
+
+FileUtils.mkdir_p "#{@root}/logs"
+FileUtils.mkdir_p "#{@root}/pids"
+
+apps = File.read(file).to_s.split("\n")
+
+for line in apps
+  next if line[0,1] == '#'
+  id, script = line.split(/\s*:\s*/, 2)
+  next unless script
+  demonize id, script
+end

data/bin/job_que

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+check = `ps ax | grep ruby`.split("\n").select{ |line| line.index($0) }
+check.select! { |line| !line.index("#{Process.pid} ") }
+
+if check.length > 0
+  puts "Lux job_que allready running"
+  puts check
+  exit
+end
+
+eval File.read './lux/loader.rb'
+Lux.delay.run!
+
+# require 'pathname'
+# pid_file = Pathname.new("./tmp/job_que.pid")
+
+# if pid_file.exist?
+#   pid = pid_file.read
+#   proc = `ps -p #{pid} -o comm=`
+#   if proc.to_s.length > 1
+#     puts "Lux job_que allready running, pid: #{pid}"
+#     system "ps ax | grep #{pid} | grep ruby"
+#     exit
+#   end
+# end
+
+# pid_file.write(Process.pid)
+# Kernel.at_exit { pid_file.delete }
+
+
+# Lux.config.redis_server = Redis::Queue.new('__test', 'bp__test', :redis => Redis.new)
+# Lux.delay.server = :memory
+# Lux.delay.server = :redis
+# Lux.delay.push("puts '123 abc > mem'.red")
+# Lux.delay.push("puts '123 abc > redis'.red")
+# Lux.delay.push(Mailer.confirm_email('rejotl@gmail.com'), :deliver)
+# Mailer.confirm_email('rejotl@gmail.com').deliver_later
+# Lux.delay.run!