lux-fw 0.2.3 → 0.5.32

data/plugins/db/helpers/find_precache.rb

@@ -0,0 +1,31 @@
+# @list = LinkedUser
+#   .order(Sequel.desc(:updated_at))
+#   .where(user_id: user.id)
+#   .limit(20)
+#   .all
+#   .precache(:job_id)
+#   .precache(:org_id)
+
+class Sequel::Model
+  module ClassMethods
+    # find will cache all finds in a scope
+    def find id
+      return nil if id.blank?
+      Lux.current.cache("#{self}/#{id}") { where(id:id).first }
+    end
+  end
+end
+
+class Array
+  # we have to call all on set and then precache
+  def precache field, klass=nil
+    list = self.map(&field).uniq.sort
+    klass ||= field.to_s.sub(/_ids?$/, '').classify.constantize
+
+    for el in klass.where(id: list).all
+      Lux.current.cache("#{klass}/#{el.id}") { el.dup }
+    end
+
+    self
+  end
+end

data/plugins/db/helpers/link_objects.rb

@@ -0,0 +1,84 @@
+# @notes.preload(:bucket)
+
+# class Array
+#   def preload(name)
+#     field = "#{name.to_s.singularize}_id".to_sym
+#     ids = self.map{ |o| o[field] }.uniq
+#     buckets = name.to_s.classify.constantize.where(id:ids).to_a
+
+#     for o in self
+#       o.send "#{name}=", buckets.select{ |el| o.id==el.id }[0]
+#     end
+#   end
+# end
+
+class Sequel::Model
+  module ClassMethods
+
+    # Object.genders
+    # @object.gender
+    def link name, opts={}
+      name_s = name.to_s.singularize
+      name_p = name.to_s.pluralize
+
+      raise 'Please use enums plugin' if opts[:collection]
+
+      klass = opts[:class] ? opts[:class].to_s : name.to_s.singularize.classify
+
+      # link :country, class: Country -> many_to_one :country
+      if name.to_s == name_s
+        class_eval %[
+          def #{name_s}
+            @#{name_s}_cached ||= #{klass}.find(#{name_s}_id)
+          end
+          def #{name_s}=(object)
+            @#{name_s}_cached = object
+          end
+        ]
+
+      # link :cities
+      # postgre integer array, has to be in form #{name.singularize}_ids
+      # city_ids = [1,2,4]
+      # cities -> [<City:1>, <City:2>, <City:4>]
+      elsif db_schema["#{name_s}_ids".to_sym]
+        # puts "* #{to_s}.link :#{name} -> inline #{name_s}_ids".yellow
+        class_eval %[
+          def #{name_p}
+            return [] if #{name_s}_ids.blank?
+            ids = #{name_s}_ids.uniq
+
+            if !ids.first
+              []
+            elsif !ids[1]
+              [#{klass}.find(ids.first)]
+            else
+              #{klass}.where(Sequel.lit('id in ('+ids.join(',')+')')).all
+            end
+          end
+        ]
+
+      # link :countries -> one_to_many :countries
+      else
+        # one_to_many name, opts
+        field = "#{to_s.tableize.singularize}_id"
+
+        if klass.constantize.db_schema[field.to_sym]
+          comm = "#{klass}.where(#{field}:id).default"
+        else
+          # we have a link table
+          cname = klass[0,1] > to_s[0,1] ? "#{to_s}#{klass}" : "#{klass}#{to_s}"
+          comm  = "#{klass}.xwhere('id in (select #{klass.tableize.singularize}_id from #{cname.tableize} where #{to_s.tableize.singularize}_id=?)', id)"
+          puts "* #{to_s}.link :#{name} -> #{comm}"
+        end
+
+        class_eval %[
+          def #{name_p}
+            #{comm}
+          end
+        ]
+      end
+    end
+  end
+end
+
+

data/plugins/db/helpers/schema_checks.rb

@@ -0,0 +1,83 @@
+# inits and saves postgre
+#   string and integer arrays
+#   hstore as hash with indifferent access to keys
+
+module Sequel::Plugins::LuxInitAndSaveSchemaCheck
+  module ClassMethods
+  end
+
+  module DatasetMethods
+  end
+
+  module InstanceMethods
+    def validate
+      for field in columns
+        schema = db_schema[field]
+
+        # alert, no trim on to big field length
+        if schema[:max_length] && self[field] && self[field].length > schema[:max_length]
+          msg = 'Field "%s" max length is %s, got %d' % [field, schema[:max_length], self[field].length]
+          errors.add(field, msg)
+        end
+      end
+
+      super
+    end
+
+    # set right values on
+    def after_initialize
+      new_vals = {}
+      # DB.extension :connection_validator, :pg_array, :pg_json
+      db_schema.each do |field, schema|
+        type = schema[:db_type]
+
+        if type.include?('[]') && ![Array, Sequel::Postgres::PGArray].include?(self[field].class)
+          data = self[field].to_s.gsub(/^\{|\}$/, '').split(',')
+          data = data.map(&:to_i) if schema[:type] == :integer
+          self[field] = data
+        elsif type == 'jsonb' && self[field].class != Sequel::Postgres::JSONBHash
+          self[field] = HashWithIndifferentAccess.new(JSON.load(self[field]) || {})
+        end
+      end
+
+      super
+    end
+
+    def before_save
+      @_array_hash_cache_fields = {}
+
+      db_schema.each do |field, schema|
+        if schema[:db_type].include?('[]')
+          @_array_hash_cache_fields[field] = self[field].dup
+
+          data = self[field].to_a
+          data = data.map(&:to_i) if schema[:type] == :integer
+
+          db_data = data.to_json
+          db_data[0,1] = '{'
+          db_data[-1,1] = '}'
+          self[field] = db_data
+        elsif ['json', 'jsonb'].index(schema[:db_type])
+          @_array_hash_cache_fields[field] = self[field].dup
+
+          # we use this to convert symbols in keys to strings
+          self[field] = JSON.load(self[field].to_json).to_json
+        elsif schema[:db_type] == 'boolean'
+          self[field] = false if self[field] == 0
+          self[field] = true  if self[field] == 1
+        end
+      end
+
+      super
+    end
+
+    def after_save
+      @_array_hash_cache_fields.each { |k, v| self[k] = v }
+
+      super
+    end
+  end
+
+end
+
+Sequel::Model.plugin :lux_init_and_save_schema_check

data/plugins/db/helpers/typero_adapter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'typero'
+
+module Sequel::Plugins::TyperoAttributes
+  module ClassMethods
+    def attributes(&block)
+      self.instance_variable_set :@typero, Typero.new(&block)
+    end
+
+    def typero
+      self.instance_variable_get :@typero
+    end
+  end
+
+  module InstanceMethods
+    # calling typero! on any object will validate all fields
+    def typero! field_name=nil
+      typero = self.class.typero || return
+
+      typero.validate(self) do |name, err|
+        errors.add(name, err) unless (errors.on(name) || []).include?(err)
+      end
+
+      # this are rules unique to database, so we check them here
+      typero.rules.each do |field, rule|
+        # check uniqe fields
+        if rule[:uniq]
+          id    = self[:id] || 0
+          value = self[field]
+
+          # we only check if field is changed
+          if value.present? && column_changed?(field) && self.class.xwhere('LOWER(%s)=LOWER(?) and id<>?' % field, value, id).first
+            error = rule[:uniq].class == TrueClass ? %[Value '"#{value}"' for #{field} allready exists] : rule[:uniq]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+
+        # check protected fields
+        if rule[:protected] && self[:id]
+          if column_changed?(field)
+            error = rule[:protected].class == TrueClass ? "value once defined can't be overwritten." : rule[:protected]
+            errors.add(field, error) unless (errors.on(field) || []).include?(error)
+          end
+        end
+      end
+
+      # check single field if single field given
+      if field_name
+        raise ArgumentError.new 'Field :%s not found in %s' % [field_name, self] unless self[field_name]
+        return unless errors.on(field_name)
+
+        errors.on(field_name).join(', ')
+      end
+
+      true
+    end
+
+    def validate
+      typero!
+      super
+    end
+  end
+
+  module DatasetMethods
+
+  end
+end
+
+Sequel::Model.plugin :typero_attributes
+

data/plugins/db/logger/config.rb

@@ -0,0 +1,22 @@
+# Logs DB queries in console
+# to active just load the file
+if Lux.config(:log_to_stdout)
+  logger = Logger.new(STDOUT)
+
+  logger.formatter = proc { |severity, datetime, progname, msg|
+    elms = msg.split(/\(|s\)\s/, 3)
+    time = (elms[1].to_f * 1000).round(1)
+
+    if c = Thread.current[:db_q]
+      if c && c[:last] != msg
+        c[:last] = msg
+        c[:time] += elms[1].to_f
+        c[:cnt]  += 1
+
+        Lux.log " #{c[:cnt].to_s.rjust(2)}. #{time} : #{elms[2].to_s.cyan}\n"
+      end
+    end
+  }
+
+  DB.loggers << logger
+end

data/plugins/db/logger/lux_response_adapter.rb

@@ -0,0 +1,10 @@
+Lux.app do
+  before do
+    Thread.current[:db_q] = { time: 0.0, cnt: 0 }
+  end
+
+  after do
+    next unless Thread.current[:db_q]
+    Lux.log " #{Thread.current[:db_q][:cnt]} DB queries, #{(Thread.current[:db_q][:time]*1000).round(1)} ms" if Thread.current[:db_q][:cnt] > 0
+  end
+end

data/plugins/db/paginate/helper.rb

@@ -0,0 +1,32 @@
+module HtmlHelper
+
+  def paginate list
+    return unless list.respond_to?(:paginate_next)
+    return nil if list.paginate_page == 1 && !list.paginate_next
+
+    ret = ['<div class="paginate"><div>']
+
+    if list.paginate_page > 1
+      url = Url.current
+      list.paginate_page == 1 ? url.delete(list.paginate_param) : url.qs(list.paginate_param, list.paginate_page-1)
+      ret.push %[<a href="#{url.relative}">&larr;</a>]
+    else
+      ret.push %[<span>&larr;</span>]
+    end
+
+    ret.push %[<i>#{list.paginate_page == 1 ? '&bull;' : list.paginate_page}</i>]
+
+    if list.paginate_next
+      url = Url.current
+      url.qs(list.paginate_param, list.paginate_page+1)
+      ret.push %[<a href="#{url.relative}">&rarr;</a>]
+    else
+      ret.push %[<span>&rarr;</span>]
+    end
+
+    ret.push '</div></div>'
+    ret.join('')
+  end
+
+end
+

data/plugins/db/paginate/sequel_adapter.rb

@@ -0,0 +1,23 @@
+module Sequel::Plugins::LuxSimplePaginate
+  module DatasetMethods
+    def page size: 20, param: :page, page: nil, count: nil
+      page = (page || Lux.current.request.params[param]).to_i
+      page = 1 if page < 1
+
+      # ret = paginate(page, size).all
+      ret = offset((page-1) * size).limit(size+1).all
+
+      has_next = ret.length == size + 1
+      ret.pop if has_next
+
+      ret.define_singleton_method(:paginate_param) do; param ;end
+      ret.define_singleton_method(:paginate_page)  do; page; end
+      ret.define_singleton_method(:paginate_next)  do; has_next; end
+
+      ret
+    end
+  end
+end
+
+Sequel::Model.db.extension :pagination
+Sequel::Model.plugin :lux_simple_paginate

data/plugins/exceptions/simple_exception.rb

@@ -0,0 +1,64 @@
+module SimpleException
+  extend self
+
+  ERROR_FOLDER ||= './log/exceptions'
+
+  def log exception
+    return if Lux.env         == 'test'
+    # return if exception.class == LocalRaiseError
+    return unless Lux.current
+
+    history = exception.backtrace || []
+    history = history
+      .map{ |el| el.sub(Lux.root.to_s, '') }
+      .join("\n")
+
+    data = '%s in %s (user: %s)' % [exception.class, Lux.current.request.url, (Lux.current.var.user.email rescue 'guest')]
+    data = [data, exception.message, history].join("\n\n")
+    key  = Digest::SHA1.hexdigest history
+
+    folder = Lux.root.join('log/exceptions').to_s
+    Dir.mkdir(folder) unless Dir.exists?(folder)
+
+    File.write("#{folder}/#{key}.txt", data)
+
+    key
+  end
+
+  def list
+    error_files = Dir['%s/*.txt' % ERROR_FOLDER].sort_by { |x| File.mtime(x) }.reverse
+
+    error_files.map do |file|
+      last_update = (Time.now - File.mtime(file)).to_i
+
+      age = if last_update < 60
+        '%s sec ago' % last_update
+      elsif last_update < 60*60
+        '%s mins ago' % (last_update/60).to_i
+      elsif last_update < 60*60*24
+        '%s hours ago' % (last_update/(60*60)).to_i
+      else
+        '%s days ago' % (last_update/(60*60*24)).to_i
+      end
+
+      {
+        file: file,
+        last_update: last_update,
+        desc: File.read(file).split("\n").first,
+        code: file.split('/').last.split('.').first,
+        age: age
+      }
+    end
+  end
+
+  def get code
+    for el in list
+      return el if el[:code] == code
+    end
+  end
+
+  def clear
+    system 'rm -rf "%s"' % ERROR_FOLDER
+  end
+end
+

data/plugins/favicon/favicon.rb

@@ -0,0 +1,10 @@
+favicon = Lux.root.join('./public/favicon.png')
+
+die './public/favicon.png not found' unless favicon.exist?
+
+favicon = favicon.read
+
+Lux.app.before do
+  response.send_file('favicon.png', inline: true, content: favicon) if
+    ['/favicon.ico', '/apple-touch-icon.png'].include?(request.path.downcase)
+end

data/plugins/html/html_form.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+# = form Lux.current.var.user do |f|
+#   = f.hidden :company_id
+#   = f.row :name
+#   = f.row :counrty_id, :as=>:country
+#   .custom= f.input :email
+#   = f.submit 'Save'
+
+Lux.plugin 'api'
+
+ApplicationApi.before do
+  name = '[protected]:'
+  params.each do |k,v|
+    params[k] = Crypt.decrypt(v.split(name, 2)[1]) if v.is_a?(String) && v.starts_with?(name)
+  end
+end
+
+class HtmlForm
+  def initialize target, opts={}
+    opts[:method]   = 'get' if opts.delete(:get)
+    opts[:method] ||= 'get' unless @target
+    opts[:method] ||= 'post'
+    opts[:method]   = opts[:method].upcase
+
+    opts[:id] ||= 'form-%s' % Lux.current.uid
+
+    @target = target
+    @opts   = opts
+    @before = []     # add stuff to the begining of the form block
+
+    if @target.respond_to?(:update)
+      @object = @target
+      @opts['data-model'] = @object.class.to_s.underscore.singularize
+    end
+
+    before
+
+    @opts[:action] = @target if @target
+  end
+
+  # render full form, accepts block
+  def render
+    data  = @before.join('')
+    data += yield self
+    data = form data
+
+    @opts.tag(:form, data)
+  end
+
+  # run stuff after block initialize
+  def before
+    true
+  end
+
+  # hidden filed
+  def hidden name, opts={}
+    fname  = @object.class.name.tableize.singularize rescue nil
+
+    if name.respond_to?(:update)
+      oname = name.class.name.tableize.singularize
+      if @object && @object.respond_to?("#{oname}_id") # grp
+        Lux::Current::EncryptParams.hidden_input "#{fname}[#{oname}_id]", name.id
+      else
+        [
+          Lux::Current::EncryptParams.hidden_input("#{fname}[model_id]", name.id),
+          Lux::Current::EncryptParams.hidden_input("#{fname}[model_type]", name.class.name),
+        ].join('')
+      end
+    else
+      opts[:value] ||= @object[name] if @object && name.is_a?(Symbol)
+      name = '%s[%s]' % [fname, name] if fname && name.is_a?(Symbol)
+
+      if opts[:value].present?
+        Lux::Current::EncryptParams.hidden_input(name, opts[:value])
+      else
+        ''
+      end
+    end
+  end
+
+  # standard input linked to HtmlInput class
+  def input name, opts={}
+    @name          = name
+    opts[:id]    ||= Lux.current.uid
+    opts[:value] ||= Lux.current.request.params[name] if @opts[:method] == 'GET'
+    input_object   = HtmlInput.new(@object)
+    data           = input_object.render(name, opts)
+    @type          = input_object.type
+    data
+  end
+
+  # submit button
+  def submit name=nil
+    name ||= 'Submit'
+    %[<li><button type="submit">#{name}</button></li>]
+  end
+
+  # render simple row
+  def row name, opts={}
+    node  = input(name, opts)
+    label = %[<label for="#{opts[:id]}">#{opts[:label] || name.to_s.humanize}</label>]
+    %[<li class="as-#{opts[:as]}">#{label}#{node}<span class="error"></span></li>]
+  end
+
+  private
+
+  def form data
+    @opts[:class]  = 'ul-form'
+    %[<ul>#{data}</ul>]
+  end
+
+  def encrypt data
+    return unless data
+    '[protected]:%s' % Crypt.encrypt(data)
+  end
+end
+

data/plugins/html/html_input.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# input = HtmlInput.new(User.first)
+# input.render :email
+
+class HtmlInput
+  attr_accessor :type
+
+  def self.register name, &block
+    define_method "as_#{name}", &block
+  end
+
+  ###
+
+  def initialize(obj=nil, opts={})
+    @object  = obj
+    @globals = opts.dup
+  end
+
+  # if type is written in parameter :as=> use this helper function
+  def render(name, opts={})
+    if name.is_hash?
+      opts = name
+      name  = :null
+    end
+
+    opts  = opts_prepare name, opts.dup
+    @type = opts.delete(:as) || :text
+    send("as_#{@type}") rescue Lux::Error.inline("as_#{@type} (HtmlInput)")
+  end
+
+  private
+
+  # exports @name and @opts globals
+  def opts_prepare name, opts={}
+
+    opts[:as] ||= lambda do
+      return :select if opts[:collection]
+
+      data_type = @object[name].class.name rescue 'String'
+
+      if ['TrueClass','FalseClass'].index(data_type)
+        :checkbox
+      else
+        :string
+      end
+    end.call
+
+    # experimental, figure out collection unless defined
+    if name =~ /_id$/ && opts[:as] == :select && !opts[:collection]
+      class_name = name.to_s.split('_id')[0].capitalize
+      opts[:collection] = eval "#{class_name}.order('name').all"
+    end
+
+    opts[:as]    ||= :select if opts[:collection]
+    opts[:id]    ||= Lux.current.uid
+    opts[:value] ||= @object.send(name) if @object
+    opts[:value]   = opts[:default] if opts[:value].blank?
+    opts[:name]    = name.kind_of?(Symbol) && @object ? "#{@object.class.name.underscore}[#{name}]" : name
+
+    # convert decimal numbers to float
+    opts[:value] = opts[:value].to_f if opts[:value].class == BigDecimal
+
+    @label = opts.delete :label
+    @wrap  = opts.delete(:wrap) || @globals[:wrap]
+    @name  = name
+    @opts  = opts
+  end
+
+  def prepare_collection data
+    ret = []
+
+    if data.is_hash?
+      # { id: {name:'Foo'} } : { id: 'Foo' }
+      for id, name in data
+        name = name[:name] if name.is_hash?
+        ret.push [id.to_s, name]
+      end
+    else
+      for el in data
+        if data[0].respond_to?(:select_name)
+          ret.push [el.id.to_s, el.select_name]
+        elsif data[0].respond_to?(:name)
+          ret.push [el.id.to_s, el.name]
+        elsif data[0].kind_of?(Array)
+          ret.push [el[0].to_s, el[1]]
+        elsif data.is_hash?
+          ret.push el
+        else
+          ret.push [el.to_s, el]
+        end
+      end
+    end
+
+    ret
+  end
+
+end