lux-fw 0.1.35 → 0.2.1

data/lib/plugins/db_helpers/arrays_and_tags.rb

@@ -1,23 +0,0 @@
-module Sequel::Plugins::LuxArrays
-  module ClassMethods
-  end
-
-  module DatasetMethods
-    # def tagged_with(tag=nil, field=:tags)
-    #   return self unless tag
-    #   where("? = any (#{field})", tag)
-    # end
-
-    # 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
-  end
-
-end
-
-Sequel::Model.plugin :lux_arrays

data/lib/plugins/db_helpers/before_save.rb

@@ -1,44 +0,0 @@
-module Sequel::Plugins::LuxBeforeSave
-  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
-
-    def before_save
-      # basic security
-      self[:created_at] = Time.now.utc if ! self[:id] && respond_to?(:created_at)
-      self[:updated_at] = Time.now.utc if respond_to?(:updated_at)
-
-      if respond_to?(:created_by) || respond_to?(:updated_by)
-        errors.add(:base, 'You have to be registered to save data') unless User.current
-      end
-
-      for f in [:created_by, :updated_by]
-        if respond_to?(f) && !self[:id] && !self[f]
-          raise UnauthorizedError, "Current user not defined, can't set :#{f} on #{self.class}" unless User.current
-          self[f] = User.current.id
-        end
-      end
-
-      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/lib/plugins/db_helpers/cached_find_by.rb

@@ -1,45 +0,0 @@
-# module Sequel::Plugins::LuxCachedFindBy
-
-#   module ClassMethods
-
-#     @@cached_find_by ||= {}
-#     @@cache_all_for  ||= {}
-
-#     def find id
-#       return nil if id.blank?
-#       key = "#{self}/#{id}"
-#       Lux.cache.thread(key) { where(id:id).first }
-#     end
-
-#     def find_by what
-#       where(what).first
-#     end
-
-#     ###
-
-#     # in top of the class, defines cache to be run in memory
-#     # cache_all_for 10.minutes
-#     def cache_all_for duration
-#       @@cache_all_for[self.to_s] = duration
-#     end
-
-#     # City.cached_find_by(120, code: nav.root)
-#     def cached_find_by duration, opts
-#       key   = opts.keys.first
-#       value = opts.values.first
-#       time  = Time.now.to_i
-
-#       @@cached_find_by[self.to_s] = nil if @@cached_find_by[self.to_s] && (@@cached_find_by[self.to_s][0] + duration) < time
-#       @@cached_find_by[self.to_s] ||= [time, all]
-
-#       for el in @@cached_find_by[self.to_s][1]
-#         return el.dup if el[key] == value
-#       end
-
-#       nil
-#     end
-
-#   end
-# end
-
-# Sequel::Model.plugin :lux_cached_find_by

data/lib/plugins/db_helpers/class_and_instance.rb

@@ -1,120 +0,0 @@
-# http://ricostacruz.com/cheatsheets/sequel.html
-# http://sequel.jeremyevans.net/rdoc/files/doc/model_plugins_rdoc.html
-
-module Sequel::Plugins::LuxClassAndInstance
-
-  module ClassMethods
-    [:desc, :asc, :pluck, :ids].each do |m|
-      Sequel::Plugins.def_dataset_methods self, m
-    end
-
-    def find id
-      return nil if id.blank?
-      key = "#{self}/#{id}"
-      Lux.cache.thread(key) { where(id:id).first }
-    end
-
-    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 where_or_new filter
-      where(filter).first || new(filter)
-    end
-
-    def where_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
-      save
-    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
-    def desc
-      reverse :id
-    end
-
-    def asc
-      order :id
-    end
-
-    def pluck field
-      select_map field
-    end
-
-    def ids
-      select(:id).map(&:id)
-    end
-  end
-end
-
-Sequel::Model.plugin :lux_class_and_instance

data/lib/plugins/db_helpers/dataset_plugin.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-class Sequel::Model
-
-  module ClassMethods
-    [:xselect, :xorder, :xfrom, :xwhere, :xlike, :last_updated, :qs_search, :for].each do |m|
-      Sequel::Plugins.def_dataset_methods self, m
-    end
-  end
-
-  module DatasetMethods
-    def xselect text
-      select Sequel.lit text
-    end
-
-    def xorder text
-      order Sequel.lit text
-    end
-
-    def xfrom text
-      from Sequel.lit text
-    end
-
-    def xwhere hash_or_string, *args
-      return where(Sequel.lit("coalesce(%s,'')!=''" % hash_or_string)) if hash_or_string.is_a?(Symbol)
-      return where(Sequel.lit(hash_or_string, *args))                  if hash_or_string.is_a?(String)
-
-      q = hash_or_string.select{ |k,v| v.present? && v != 0 }
-      q.keys.blank? ? self : where(q)
-    end
-
-    def xlike search, *args
-      unless search.blank?
-        search = search.gsub(/'/,"''").downcase
-        where_str = []
-
-        for str in search.split(/\s+/).select(&:present?)
-          and_str = []
-          str = "%#{str}%"
-
-          for el in args
-            if model.db_schema[el][:db_type] == 'jsonb'
-              like_sql = "CAST(#{el} -> '#{Locale.current}' as text) ilike '#{str}'"
-              if Locale::DEFAULT != Locale.current
-                and_str << "(#{like_sql}) or (CAST(#{el} -> '#{Locale::DEFAULT}' as text) ilike '#{str}')"
-              else
-                and_str << like_sql
-              end
-            else
-              and_str << "#{el}::text ilike '#{str}'"
-            end
-          end
-
-          where_str.push '('+and_str.join(' or ')+')'
-        end
-
-        return where(Sequel.lit(where_str.join(' and ')))
-      end
-      self
-    end
-
-    def last_updated
-      field = model.db_schema[:updated_at] ? :updated_at : :id
-      order(Sequel.desc(field)).first
-    end
-
-    # search in array of qs arguments
-    def qs_search *args
-      for el in args
-        dataset = where("#{el}=?", Lux.page.params[el]) if !Lux.page.params[el].blank? && model.db_schema[el]
-      end
-      dataset || self
-    end
-
-    def for obj
-      # column_names
-      field_name = "#{obj.class.name.underscore}_id".to_sym
-      n1         = model.to_s.underscore
-      n2         = obj.class.to_s.underscore
-
-      cname = n1[0] < n2[0] ? n1+'_'+n2.pluralize : n2+'_'+n1.pluralize
-
-      if (cname.classify.constantize rescue false)
-        where Sequel.lit 'id in (select %s_id from %s where %s_id=%i)' % [n1, cname, n2, obj.id]
-      elsif model.db_schema["#{n2}_ids".to_sym]
-        return where Sequel.lit '%i=any(%s_ids)' % [obj.id, n2]
-      elsif model.db_schema[field_name]
-        return where Sequel.lit '%s=%i' % [field_name, obj.id]
-      elsif model.db_schema[:model_type]
-        return where(:model_type=>obj.class.to_s, :model_id=>obj.id)
-      elsif obj.class.to_s == 'User'
-        if obj.respond_to?(field_name)
-          return where Sequel.lit '%s=?' % [field_name, obj.id]
-        end
-        return where Sequel.lit 'created_by=%i' % obj.id
-      else
-        r "Unknown link for #{obj.class} (probably missing db field)"
-      end
-    end
-  end
-end

data/lib/plugins/db_helpers/filter_wrappers.rb

@@ -1,21 +0,0 @@
-module Sequel::Plugins::FilterWrappers
-  module ClassMethods
-
-    def validate &block
-      define_method :validate do
-        block.call
-        super
-      end
-    end
-
-    def before_save &block
-      define_method :before_save do
-        block.call
-        super
-      end
-    end
-
-  end
-end
-
-Sequel::Model.plugin :filter_wrappers

data/lib/plugins/db_helpers/link_plugin.rb

@@ -1,95 +0,0 @@
-# @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
-
-module Sequel::Plugins::LuxLink
-  module ClassMethods
-
-    # link :genders, default:1, collection:[ [1, 'male'], [2, 'Female'] ]
-    # link :genders, collection: { 1=>'male', 2=>'Female' }
-    # Object.genders
-    # @object.gender
-    def link name, opts={}
-      name_s = name.to_s.singularize
-      name_p = name.to_s.pluralize
-
-      if opts[:collection]
-        field = opts[:field] || "#{name_s}_id"
-
-        class_eval %[
-          def #{to_s}.#{name_p}
-            #{opts[:collection].to_json}
-          end
-
-          def #{name_s}
-            val = self[:#{field}] || #{opts[:default] || 'nil'}
-            return unless val
-            for k, v in #{to_s}.#{name_p}
-              return v if k == val
-            end
-            nil
-          end
-        ]
-        return
-      end
-
-      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 new.respond_to?("#{name_s}_ids")
-        # 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.join(',')
-            #{klass}.where(Sequel.lit('id in ('+ids+')'))
-          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
-
-Sequel::Model.plugin :lux_link