lux-fw 0.1.17

data/lib/plugins/assets/assets_plug.rb

@@ -0,0 +1,26 @@
+# plug :local_assets
+# /compiled_asset/www/js/pjax.coffee
+# /raw_asset/www/js/pjax.coffee
+class Lux::Controller
+  def lux_assets_plug
+
+    # only allow clear in dev
+    if Lux.page.no_cache?
+      puts '* Clearing assets from ./tmp/assets'
+      `rm -rf ./tmp/assets`
+    end
+
+    path = nav.path.join('/')
+
+    if nav.root == 'compiled_asset'
+      asset = MiniAsset.create(path)
+      page.content_type asset.content_type
+      page.body asset.compiled_data
+    elsif nav.root == 'raw_asset'
+      Lux.error "You can watch raw files only in development" unless Lux.dev?
+
+      file = Lux.root.join('app/assets/%s' % path)
+      body file.exist? ? file.read : "error: File not found"
+    end
+  end
+end

data/lib/plugins/assets/helper_module_adapter.rb

@@ -0,0 +1,49 @@
+# export to all templates
+# = asset 'www/index.scss'
+# = asset 'www/index.coffee'
+module DefaultHelper
+  def asset_include path
+    raise ArgumentError.new("Path can't be empty") if path.empty?
+
+    url = if path.starts_with?('/') || path.include?('//')
+      path
+    else
+      '/compiled_asset/%s' % path
+    end
+
+    ext = url.split('?').first.split('.').last
+
+    if ['coffee', 'js'].include?(ext)
+      %[<script src="#{url}"></script>]
+    else
+      %[<link rel="stylesheet" href="#{url}" />]
+    end
+  end
+
+  # builds full asset path based on resource extension
+  # asset('main/index.coffee')
+  # will render 'app/assets/main/index.coffee' as http://aset.path/assets/main-index-md5hash.js
+  def asset file, dev_file=nil
+    # return second link if it is defined and we are in dev mode
+    return asset_include dev_file if dev_file && Lux.dev?
+
+    # return internet links
+    return asset_include file if file.starts_with?('/') || file.starts_with?('http')
+
+    # return asset link in production or faile unless able
+    unless Lux.config(:compile_assets)
+      mfile = MiniAsset.manifest['files'][file]
+      raise 'Compiled asset link for "%s" not found in manifest.json' % file if mfile.empty?
+      return asset_include Lux.config.assets_root.to_s + mfile
+    end
+
+    # try to create list of incuded files and show every one of them
+    data = []
+    asset = MiniAsset.create file
+    for file in asset.files
+      data.push asset_include file
+    end
+
+    data.join($/)
+  end
+end

data/lib/plugins/assets/init.rb

@@ -0,0 +1,4 @@
+require 'open3'
+
+['./tmp', './public', './public/assets', './tmp/assets'].each { |d| `mkdir #{d}` unless Dir.exist?(d) }
+

data/lib/plugins/db_helpers/array_and_hstore.rb

@@ -0,0 +1,64 @@
+# inits and saves postgre
+#   string and integer arrays
+#   hstore as hash with indifferent access to keys
+
+module Sequel::Plugins::LuxArrayAndHstore
+  module ClassMethods
+  end
+
+  module DatasetMethods
+  end
+
+  module InstanceMethods
+    # set right values on
+    def after_initialize
+      db_schema.each do |field, schema|
+        type = schema[:db_type]
+        if type.include?('[]') && !self[field].is_a?(Array)
+          self[field] = self[field].to_s.gsub(/^\{|\}$/, '').split(',')
+          self[field] = self[field].map(&:to_i) if schema[:type] == :integer
+        elsif type == 'jsonb'
+          self[field] ||= {}
+          self[field] = HashWithIndifferentAccess.new(JSON.load(self[field]) || {})
+        end
+      end
+    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_array_and_hstore

data/lib/plugins/db_helpers/arrays_and_tags.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,120 @@
+# 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

@@ -0,0 +1,101 @@
+# 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,95 @@
+# @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

data/lib/plugins/db_helpers/localize_plugin.rb

@@ -0,0 +1,57 @@
+module Sequel::Plugins::LuxLocalize
+  module ClassMethods
+    # in any modal
+    # localize :name
+    # to make :name multilang
+    # and to create :name_en, :name_de, ...
+    def localize(name)
+      unless db_schema[name]
+        puts "Field [:#{name}] does not exist in #{self.to_s}".red
+      end
+
+      unless (db_schema[name][:db_type] rescue nil) == 'jsonb'
+        puts "Field [:#{name}] in #{self.to_s} is not of type [jsonb]".red
+      end
+
+      class_eval %[
+        def #{name}(locale=nil)
+          field = self[:#{name}]
+          field ||= {}
+          locale ||= Locale.current
+          return field[locale] if field[locale] && !field[locale].start_with?('?')
+          val = field[Locale::DEFAULT].to_s
+          Lux.dev? ? '?'+val : val
+        end
+
+        def #{name}=(value)
+          self[:#{name}] ||= {} # if self[:#{name}].class.to_s != 'Hash'
+          self[:#{name}][Locale.current] = value
+        end
+      ]
+
+      for lang in Locale.all
+        class_eval %[
+          def #{name}_#{lang}
+            #{name}('#{lang}')
+          end
+
+          def #{name}_#{lang}=(value)
+            value = nil if value.start_with?('?')
+            self[:#{name}] ||= {}
+            self[:#{name}]['#{lang}'] = value
+          end
+        ]
+      end
+    end
+  end
+
+  module InstanceMethods
+
+  end
+
+  def DatasetMethods
+
+  end
+end
+
+Sequel::Model.plugin :lux_localize

data/lib/plugins/db_helpers/primary_keys.rb

@@ -0,0 +1,36 @@
+# 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