lux-fw 0.5.36 → 0.6.2

data/plugins/api/lib/response.rb

@@ -1,85 +0,0 @@
-class Lux::Api::Response
-  def self.error text
-    response = new
-    response.error text
-    response.render
-  end
-
-  ###
-
-  attr_accessor :data
-  attr_accessor :message
-
-  def initialize
-    @meta = {}.h_wia
-  end
-
-  def status num=nil
-    meta 'http_status', num.to_i if num && !@meta['http_status']
-    @meta['http_status']
-  end
-
-  def meta key, value
-    value = value.to_i if key == :status
-    @meta[key.to_s] = value
-  end
-
-  def error key, data=nil
-    unless data
-      data = key
-      key  = :base
-    end
-
-    key = key.to_s
-
-    @errors ||= {}
-    @errors[key] ||= []
-    @errors[key].push data unless @errors[key].include?(data)
-  end
-
-  def errors?
-    !!@errors
-  end
-
-  def message what
-    @message = what
-  end
-
-  def redirect url
-    @meta['location'] = url
-  end
-
-  def event name, opts={}
-    @meta['event'] ||= []
-    @meta['event'].push([name, opts])
-  end
-
-  def render
-    output = {}
-
-    if @errors
-      status 400
-
-      errors = @errors.inject({}) { |t, (k, v)| t[k] = v.join(', '); t }
-      base   = errors.values.uniq
-
-      errors.delete('base')
-
-      output[:error]          ||= {}
-      output[:error][:messages] = base
-      output[:error][:hash]     = errors if errors.keys.first
-    end
-
-    output[:data]    = @data    if @data.present?
-    output[:meta]    = @meta    if @meta.present?
-    output[:message] = @message if @message.present?
-
-    output
-  end
-  alias :to_hash :render
-
-  def write
-    Lux.current.response.status status
-    Lux.current.response.body render
-  end
-end

data/plugins/db/README.md

@@ -1,29 +0,0 @@
-### Create Sequel plugin
-
-```
-module Sequel::Plugins::LuxHelp
-
-  module ClassMethods
-    def bla
-      model # => refrence to model
-    end
-  end
-
-  module InstanceMethods
-
-  end
-
-  module DatasetMethods
-
-  end
-
-end
-
-Sequel::Model.plugin :lux_help
-```
-
-Default scope: http://stackoverflow.com/questions/11669880/default-scope-in-sequel
-
-### init
-
-If init.rb is defined it will be called, else all files will be loaded.

data/plugins/db/auto_migrate/auto_migrate.rb

@@ -1,268 +0,0 @@
-# https://github.com/jeremyevans/sequel/blob/master/doc/schema_modification.rdoc
-
-class AutoMigrate
-  attr_accessor :fields
-
-  class << self
-    def table table_name, opts={}
-      die "Table [#{table_name}] not in plural -> expected [#{table_name.to_s.pluralize}]" unless table_name.to_s.pluralize == table_name.to_s
-
-      die 'Table name "%s" is not permited' % table_name if [:categories].include?(table_name)
-
-      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, opts
-      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 %s;' % 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, opts={}
-    @fields     = {}
-    @opts       = opts
-    @table_name = table_name
-
-    klass = @table_name.to_s.classify
-
-    Object.send(:remove_const, klass) if Object.const_defined?(klass)
-
-    eval %[class ::%s < Sequel::Model; end;] % klass
-    @object = klass.constantize.new
-  end
-
-  def transaction_do text
-    self.class.transaction_do text
-  end
-
-  def log_run what
-    puts ' %s' % 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 = '%s(%s)' % [db_type, opts[:limit]] if type == :string
-      db_type = '%s[]' % db_type
-    else
-      db_type = 'varchar(%s)' % opts[:limit] if opts[:limit]
-    end
-
-    db_type
-  end
-
-  def update
-    puts "Table #{@table_name.to_s.yellow}, #{@fields.keys.length} fields"
-
-    # remove extra fields
-    if @opts[:drop].class != FalseClass
-      for field in (@object.columns - @fields.keys - [:id])
-        print "Remove colum #{@table_name}.#{field} (y/N): ".light_blue
-        if STDIN.gets.chomp.downcase.index('y')
-          DB.drop_column @table_name, field
-          puts " drop_column #{field}".green
-        end
-      end
-    end
-
-    # loop trough defined fileds in schema
-    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 @object.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[]"
-          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 = @object.db_schema[field]
-        # unhandled db schema changes will not happen
-        # ---
-        # field   - field name
-        # current - current db_schema
-        # type    - new proposed type in schema
-        # opts    - new proposed types
-
-        # if we have type set as array and in db it is not array, fix that
-        if opts[:array]
-          # covert to array unless is array
-          if !current[:db_type].include?('[]')
-            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
-          elsif !current[:default]
-            # force default for array to be present
-            default = type == :string ? "ARRAY[]::character varying[]" : "ARRAY[]::integer[]"
-            transaction_do %[alter table #{@table_name} alter #{field} set default #{default};]
-          end
-        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}, ',')"
-
-          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
-
-        # if varchar limit size has changed
-        if type == :string && !opts[:array] && current[:max_length] != opts[:limit]
-          transaction_do "ALTER TABLE #{@table_name} ALTER COLUMN #{field} TYPE varchar(#{opts[:limit]});"
-          puts " #{field} limit, #{current[:max_length]}-> #{opts[:limit]}".green
-        end
-
-        # covert from varchar to text
-        if type == :text && current[:max_length]
-          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
-
-        # covert string to date
-        if current[:type] == :string && [:date, :datetime].include?(type)
-          log_run "ALTER TABLE #{@table_name} ALTER COLUMN #{field} TYPE #{type.to_s.upcase} using #{field}::#{type};"
-        end
-
-        #ap [current, field, type, opts] if current[:type] == :string && @table_name == :informators
-
-        # 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
-
-    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.columns
-
-    if existing_fields.index(field_old.to_sym) && ! existing_fields.index(field_new.to_sym)
-      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, :geography].index(type)
-      @fields[name.to_sym] = [type, opts]
-    elsif type == :decimal
-      opts[:precision] ||= 8
-      opts[:scale] ||= 2
-      @fields[name.to_sym] = [:decimal, opts]
-    elsif type == :timestamps
-      opts[:null] ||= false
-      @fields[:created_at] = [:datetime, opts]
-      @fields[:created_by] = [:integer, opts]
-      @fields[:updated_at] = [:datetime, opts]
-      @fields[:updated_by] = [:integer, opts]
-    elsif type == :polymorphic
-      name ||= :model
-      @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

data/plugins/db/auto_migrate/db.rake

@@ -1,15 +0,0 @@
-namespace :db do
-  desc 'Automigrate schema'
-  task am: :env do
-
-    # Sequel extension and plugin test
-    DB.run %[DROP TABLE IF EXISTS lux_tests;]
-    DB.run %[CREATE TABLE lux_tests (int_array integer[] default '{}', text_array text[] default '{}');]
-    class LuxTest < Sequel::Model; end;
-    LuxTest.new.save
-    die('"DB.extension :pg_array" not loaded') unless LuxTest.first.int_array.class == Sequel::Postgres::PGArray
-    DB.run %[DROP TABLE IF EXISTS lux_tests;]
-
-    require './config/schema.rb'
-  end
-end

data/plugins/db/helpers/array_search.rb

@@ -1,27 +0,0 @@
-Sequel::Model.dataset_module do
-  # only postgree
-  # Bucket.can.all_tags -> can_tags mora biti zadnji
-  def all_tags field=:tags, *args
-    sqlq = sql.split(' FROM ')[1]
-    sqlq = "select lower(unnest(#{field})) as tag FROM " + sqlq
-    sqlq = "select tag as name, count(tag) as cnt from (#{sqlq}) as tags group by tag order by cnt desc"
-    DB.fetch(sqlq).map(&:h).or([])
-  end
-
-  # were users.id in (select unnest(user_ids) from doors)
-  # def where_unnested klass
-  #   target_table = klass.to_s.tableize
-  #   where("#{table_name}.id in (select unnest(#{table_name.singularize}_ids) from #{target_table})")
-  # end
-  # assumes field name is tags
-  def where_any data, field
-    return self unless data.present?
-
-    if data.is_a?(Array)
-      xwhere data.map { |v| "#{v}=any(#{field})" }.join(' or ')
-    else
-      xwhere('?=any(%s)' % field, data)
-    end
-  end
-end
-

data/plugins/db/helpers/before_save_filters.rb

@@ -1,32 +0,0 @@
-module Sequel::Plugins::LuxBeforeSave
-  module InstanceMethods
-    def before_save
-      # timestamps
-      self[:created_at] = Time.now.utc if !self[:id] && respond_to?(:created_at)
-      self[:updated_at] ||= Time.now.utc if respond_to?(:updated_at)
-
-      # return error if user needed and not defined
-      if !User.current && (respond_to?(:created_by) || respond_to?(:updated_by))
-        errors.add(:base, 'You have to be registered to save data')
-        return
-      end
-
-      # add timestamps
-      self[:created_by]   = User.current.id if respond_to?(:created_by) && !id
-      self[:updated_by] ||= User.current.id if respond_to?(:updated_by)
-
-      # delete cache key if defined
-      Lux.cache.delete(cache_key)
-
-      super
-    end
-
-    def before_destroy
-      Lux.cache.delete(cache_key)
-
-      super
-    end
-  end
-end
-
-Sequel::Model.plugin :lux_before_save

data/plugins/db/helpers/composite_primary_keys.rb

@@ -1,36 +0,0 @@
-# define composite key and check before save
-# class OrgUser < ApplicationModel
-#   primary_keys :org_id, :user_id
-# end
-
-module Sequel::Plugins::PrimaryKeys
-  module ClassMethods
-    def primary_keys(*args)
-      unless args[0]
-        return respond_to?(:_primary_keys) ? _primary_keys : [:id]
-      end
-
-      define_singleton_method(:_primary_keys) { args }
-    end
-  end
-
-  module InstanceMethods
-    def before_save
-      klass = self.class
-
-      if klass.respond_to?(:_primary_keys)
-        check = klass._primary_keys.inject(klass.dataset) do |record, field|
-          record = record.where(field =>send(field))
-        end
-
-        check = check.xwhere('id<>?', id) if self[:id]
-
-        raise StandardError, 'Record allredy exists (primary_keys check)' if check.first
-      end
-
-      super
-    end
-  end
-end
-
-Sequel::Model.plugin :primary_keys

data/plugins/db/helpers/core.rb

@@ -1,94 +0,0 @@
-# http://ricostacruz.com/cheatsheets/sequel.html
-# http://sequel.jeremyevans.net/rdoc/files/doc/model_plugins_rdoc.html
-
-class Sequel::Model
-  module ClassMethods
-    def find_by what
-      where(what).first
-    end
-
-    # active record like define scope
-    # http://sequel.jeremyevans.net/rdoc/classes/Sequel/Model/ClassMethods.html
-    def scope name, body=nil, &block
-      block ||= body
-      dataset_module{define_method(name, &block)}
-    end
-
-    # instance scope, same as scope but runs on instance
-    # iscope(:notes)   { Note.where(created_by:id) }
-    def iscope name, body=nil, &block
-      block ||= body
-      define_method(name, &block)
-    end
-
-    def first_or_new filter
-      where(filter).first || new(filter)
-    end
-
-    def first_or_create filter
-      where(filter).first || create(filter)
-    end
-  end
-
-  module InstanceMethods
-    def cache_key
-      "#{self.class}/#{id}"
-    end
-
-    def attributes
-      ret = {}
-      for el in columns
-        ret[el.to_s] = send(el.to_s) rescue '-'
-      end
-      ret
-    end
-
-    def touch
-      self[:updated_at] = Time.now.utc
-      save columns: [:updated_at]
-    end
-
-    def to_h
-      ret = {}
-      for el in self.keys
-        ret[el] = send el
-      end
-      ret
-    end
-
-    def creator
-      self[:created_by] ? User.find(self[:created_by]) : nil
-    end
-
-    def parent_model
-      model_type.constantize.find(model_id)
-    end
-
-    # has?(:name, "Name is not defined") -> errors.add("Name is not defined")
-    # has?(:name) -> false
-    def has?(*args)
-      if args[1] && args[1].kind_of?(String)
-        unless self[args[0]].present?
-          errors.add(args[0], args[1])
-          return false
-        end
-        return true
-      end
-      args.each { |el| return false unless self[el].present? }
-      true
-    end
-
-    def unique?(field)
-      select(field).xwhere('id<>?', id).count == 0
-    end
-
-    def save!
-      save
-    end
-  end
-
-  module DatasetMethods
-  end
-end
-
-