lux-fw 0.1.17

data/lib/common/url.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# u = Url.new('https://www.YouTube.com/watch?t=1260&v=cOFSX6nezEY')
+# u.delete :t
+# u.hash '160s'
+# u.to_s -> 'https://com.youtube.www/watch?v=cOFSX6nezEY#160s'
+
+require 'cgi'
+
+class Url
+
+  attr_accessor :proto, :host, :port
+
+  class << self
+    def current
+      new Lux.page.request.url
+    end
+
+    def force_locale loc
+      u = current
+      u.locale loc
+      u.relative
+    end
+
+    def subdomain name,  in_path=nil
+      b = current.subdomain(name)
+      b.path in_path if in_path
+      b.url
+    end
+
+    def qs name, value=nil
+      current.qs(name, value).relative
+    end
+
+    # for search
+    # Url.prepare_qs(:q) -> /foo?bar=1&q=
+    def prepare_qs name
+      url = current.qs(name).relative
+      url += url.index('?') ? '&' : '?'
+      "#{url}#{name}="
+    end
+
+    def escape str=nil
+      CGI::escape(str.to_s)
+    end
+
+    def unescape str=nil
+      CGI::unescape(str.to_s)
+    end
+  end
+
+  ###
+
+  def initialize url
+    if url =~ /:/
+      @elms = url.split '/', 4
+    else
+      @elms = [url]
+      @elms.unshift '',''
+    end
+
+    domain_and_port = @elms[2].split(':')
+    @domain_parts = domain_and_port[0].to_s.split('.').reverse.map(&:downcase)
+
+    @qs = {}
+    path_with_qs = @elms[3].to_s.split(/\?|#/)
+    path_with_qs[1].split('&').map do |el|
+      parts = el.split('=')
+      @qs[parts[0]] = Url.unescape parts[1]
+    end if path_with_qs[1]
+
+    @path = path_with_qs[0] || '/'
+    @proto = @elms[0].split(':').first.downcase
+    @port = domain_and_port[1] ? domain_and_port[1].to_i : 80
+  end
+
+  def domain what=nil
+    if what
+      @host = what
+      return self
+    end
+
+    @domain_parts.slice(0,2).reverse.join '.'
+  end
+
+  def subdomain name
+    if name
+      @domain_parts[2] = name
+      return self
+    end
+    @domain_parts.drop(2).reverse.join('.').or nil
+  end
+
+  def subdomain= name
+    @domain_parts[2] = name
+  end
+
+  def host
+    @domain_parts.reverse.join '.'
+  end
+
+  def host_with_port
+    %[#{proto}://#{host}#{port == 80 ? '' : ":#{port}"}]
+  end
+
+  def query
+    @query
+  end
+
+  def path val=nil
+    return '/'+@path+(@namespace ? ":#{@namespace}" : '') unless val
+
+    @path = val.sub(/^\//,'')
+    self
+  end
+
+  def delete *keys
+    keys.map{ |key| @qs.delete(key.to_s) }
+    self
+  end
+
+  def hash val
+    @hash = "##{val}"
+  end
+
+  def qs name, value=nil
+    if value
+      @qs[name.to_s] = value
+    elsif name
+      @qs.delete(name.to_s)
+    end
+    self
+  end
+
+  def namespace data
+    @namespace = data.to_s
+    self
+  end
+
+  def locale what
+    elms = @path.split('/')
+    if elms[0] && Locale.all.index(elms[0].to_s)
+      elms[0] = what
+    else
+      elms.unshift what
+    end
+    @path = elms.join('/')
+    self
+  end
+
+  def qs_val
+    ret = []
+    if @qs.keys.length > 0
+      ret.push '?' + @qs.keys.sort.map{ |key| "#{key}=#{Url.escape(@qs[key].to_s)}" }.join('&')
+    end
+    ret.join('')
+  end
+
+  def url
+    [host_with_port, path, qs_val, @hash].join('')
+  end
+
+  def relative
+    [path, qs_val, @hash].join('').sub('//','/')
+  end
+
+  def to_s
+    domain.length > 0 ? url : local_url
+  end
+
+end

data/lib/lux/api/api.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+# 2xx - Success            4xx / 5xx - Error     3xx - Redirection
+# 200 OK                   400 Bad Request       301 Moved
+# 201 Created              401 Unauthorized      302 Found
+# 203 Partial Information  402 Payment Required  304 Not Modified
+# 204 No response          403 Forbidden
+# 404 Not Found
+# 500 Internal Server Error
+# 503 Service Unavailable
+
+class Lux::Api
+
+  BeforeAndAfter.define self, :before, :after
+
+  Lux::RescueFrom.define(self)
+
+  class << self
+    # public mount method for router
+    def call path
+      return 'Unsupported API call' if !path[1] || path[3]
+
+      opts = Lux.page.params # Lux.page.request.post? ? Rack::Utils.parse_nested_query(Lux.page.request.body.read).h : Lux.page.params
+
+      if path[2]
+        opts[:_id] = path[1]
+        path[1] = path[2]
+      end
+
+      Lux.page.body run(path[0], path[1], opts)
+    end
+
+    # public method for running actions on global class
+    # use as Lux::Api.run 'users', 'show', { email:'rejotl@gmail.com' }
+    # safe create api class and fix params
+    def run klass, action, params={}
+      params.delete_if{ |el| [:captures, :splat].index(el.to_sym) }
+
+      action = action.to_s.sub(/[^\w_]/,'')
+
+      class_name = klass.to_s.classify
+
+      if params[class_name.underscore]
+        begin
+          params.merge! params.delete(class_name.underscore)
+        rescue
+          error "#{$!.message}. Domain value is probably not hash, invalid parameter #{class_name.underscore}"
+        end
+      end
+
+      for k,v in params
+        params[k] = params[k].gsub('<','&lt;').gsub('>','&gt;').gsub(/\A^\s+|\s+\z/,'') if v.kind_of?(String)
+      end
+
+      begin
+        klass = (klass.singularize.camelize+'Api').constantize
+      rescue
+        return Lux.page.body({ error:"API #{klass} not found" })
+      end
+
+      klass.new.call(action.to_sym, params)
+    end
+
+  end
+
+  def call(action, params={})
+    @@rescue_from_ivar.call do
+      rescued_call(action, params)
+      BeforeAndAfter.execute(self, :after)
+    end
+
+    @response
+  end
+
+  # internal method for running actions
+  # UserApi.new.call(:login, { email:'', pass:'' })
+  def rescued_call(action, params={})
+    raise ForbidenError, "Protected action call" if [:call, :rescued_call, :params, :error].index action
+    raise NotFoundError, "Action #{action} not found in #{self.class.to_s}" unless respond_to? action
+
+    @response = {}
+    @message  = nil
+    @params   = params
+    @class_name = self.class.to_s.sub(/Api$/,'')
+
+    # load default object
+    if @params[:_id]
+      eval "@object = @#{@class_name.underscore} = #{@class_name}[@params[:_id].to_i]"
+      @params.delete(:_id)
+      @response[:path] = @object.path rescue nil if @object
+    end
+
+    # execte api call and verify params if possible
+    BeforeAndAfter.execute(self, :before)
+
+    return unless check_params_and_mock_instance_variables action
+
+    api_data = send(action)
+    format_response!(api_data)
+  end
+
+  def params
+    @params
+  end
+
+  def error(what)
+    raise StandardError, what
+  end
+
+  def format_response!(api_data=nil)
+    if api_data
+      # api_data = instance_eval(&res) if api_data.kind_of?(Proc)
+      api_data = api_data.all.map{ |el| el.attributes } if api_data.class.name == 'ActiveRecord::Relation'
+
+      # sequel array of objects returned
+      if api_data.kind_of?(Array) && api_data[0] && api_data[0].respond_to?(:columns)
+        api_data = api_data.map(&:to_h)
+      end
+
+      # object given
+      if api_data.respond_to?(:attributes)
+        @response[:path] = api_data.path if api_data.id && api_data.respond_to?(:path)
+        api_data = api_data.attributes.reject{ |f| ['updated_by', 'updated_at', 'created_by', 'created_at'].index(f) }
+      end
+
+      @response[:data] = api_data
+      @response[:message] = @message.to_s unless @message.nil?
+      # @response[:message] = api_data if !@message && api_data.kind_of?(String)
+
+      # if we define _redirect then we will be redirected to exact page
+      # useful for file uploads
+      if @params[:_redirect]
+        if @response[:error]
+          Lux.page.flash.error @response[:error]
+        elsif @response[:message]
+          Lux.page.flash.info @response[:message]
+        end
+        Lux.page.redirect(@params[:_redirect])
+      end
+    end
+
+    ap @response if Lux.config.debug_api_response
+  end
+
+  def message(what)
+    @message = what
+  end
+
+end
+

data/lib/lux/api/lib/application_api.rb

@@ -0,0 +1,19 @@
+class ApplicationApi < Lux::Api
+
+  # called at the end of response
+  def decorate_response!(data=nil)
+    @response = data if data
+    if Lux.page
+      @response[:ip] = Lux.page.request.ip
+      @response[:user] = Lux.page.var.user ? Lux.page.var.user.email : nil
+      @response[:http_status] = Lux.page.status(200)
+      @response[:error] ||= 'Bad request' if Lux.page.status != 200
+    end
+    @response
+  end
+
+  def after
+    decorate_response!
+  end
+
+end

data/lib/lux/api/lib/doc_builder.rb

@@ -0,0 +1,18 @@
+class Lux::Api
+  class << self
+    # list all availabe actions in a class
+    def actions
+      instance_level_actions = UserApi.instance_methods - Object.instance_methods - [:sinatra, :instance_run, :params]
+      @@actions[self.to_s].keys + instance_level_actions
+    end
+
+    # get details about action
+    def action_details(name)
+      @@actions[self.to_s][name] ||= {}
+      details = @@actions[self.to_s][name].reject { |key| [:proc].index(key) }
+      details[:name] ||= "#{name.to_s} action"
+      details[:action] ||= name
+      details.h
+    end
+  end
+end

data/lib/lux/api/lib/dsl.rb

@@ -0,0 +1,73 @@
+class Lux::Api
+
+  # name   'Show user data'
+  # param  :email, type: :email, req: false
+  # param  :pass
+  # def show
+  #   @user = User.where(email:@_email).first
+  #   @user.slice(:id, :name, :avatar, :email)
+  # end
+
+  class << self
+    @@actions ||= {}
+
+    def method_added(m)
+      ClassMethodParams.add_method self, m
+    end
+
+    # helper for standard definition of parametars
+    # param :o_id
+    # param :o_id, Integer
+    # param :o_id, Integer, req: false
+    # param :o_id, req: false
+    def param(field, type=String, opts={})
+      opts = type.is_a?(Hash) ? type : opts.merge(type: type)
+      opts[:name] = field
+      opts[:req]  = opts[:req].class.name == 'FalseClass' ? false : true
+      opts[:type] ||= String
+
+      ClassMethodParams.add_param self, :param, opts
+    end
+
+    # helper for standard definition of name
+    def name(name)
+      ClassMethodParams.add_param self, :name, name
+    end
+
+    # helper for standard definition of description
+    def description(data)
+      ClassMethodParams.add_param self, :description, name
+    end
+  end
+
+  ###
+
+  def check_params_and_mock_instance_variables action
+    opts = ClassMethodParams.params self.class, action
+
+    if opts && opts[:param]
+      local = opts[:param].inject({}) { |h, el| o=el.dup; h[o.delete(:name)] = o; h }
+
+      rules = Typero.new local
+      errors = rules.validate(@params)
+
+      if errors.keys.length > 0
+        raise ArgumentError.new(errors.values.to_sentence) unless Lux.page
+
+        Lux.page.status(400)
+        @response[:error] = errors.values.to_sentence
+        @response[:errors] = errors
+        return false
+      end
+
+      # define local prefixed @_ variables
+      for key in local.keys.map(&:to_s)
+        value = params[key]
+        eval "@_#{key.downcase.gsub(/[^\w]/,'_')} = value" if key.length < 15 && value.present? && key =~ /^[\w]+$/
+      end
+    end
+
+    true
+  end
+
+end

data/lib/lux/api/lib/model_api.rb

@@ -0,0 +1,145 @@
+class ModelApi < ApplicationApi
+
+  class << self
+    def toggle_ids name
+      self.class_eval %[
+        param :#{name}_id, Integer
+        def toggle_#{name}
+          message toggle!(@object, :#{name}_ids, @_#{name}_id) ? 'added' : 'removed'
+        end
+      ]
+    end
+  end
+
+  # toggles value in postgre array field
+  def toggle!(object, field, value)
+    object[field] ||= []
+
+    if object[field].include?(value)
+      object[field] -= [value]
+      object.save
+      false
+    else
+      object[field] += [value]
+      object.save
+      true
+    end
+  end
+
+  ###
+
+  def index
+    raise 'No index method defiend'
+  end
+
+  def show
+    error "Object not found" unless @object
+
+    can? :read, @object
+    @object.attributes
+  end
+
+  def create
+    @object = @class_name.constantize.new
+
+    @last = @class_name.constantize.my.last rescue @class_name.constantize.last
+    if @last && @last[:name].present? && @last[:name] == @params[:name]
+      error "#{@class_name} is same as last one created."
+    end
+
+    for k,v in @params
+      @object.send("#{k}=", v) if @object.respond_to?(k.to_sym)
+    end
+
+    can? :create, @object
+    @object.save if @object.valid?
+    return if report_errros_if_any @object
+
+    if @object.id
+      @message = "#{@class_name.capitalize} created"
+    else
+      error 'object not created, error unknown'
+    end
+
+    @response[:path] = (@object.path rescue nil)
+
+    @object.attributes
+  end
+
+  def update
+    error "Object not found" unless @object
+
+    for k,v in @params
+      @object.send("#{k}=", v) if @object.respond_to?(k.to_sym)
+    end
+
+    can? :update, @object
+    @object.save if @object.valid?
+    report_errros_if_any @object
+    @message = "#{@class_name} updated"
+    @response[:path] = (@object.path rescue nil)
+    @object.attributes
+  end
+
+  # if you put active boolean field to objects, then they will be unactivated on destroy
+  def destroy
+    error "Object not found" unless @object
+    can? :delete, @object
+
+    if @object.respond_to?(:is_active)
+      @object.update is_active: false
+      @message = 'Object deleted (exists in trashcan)'
+    elsif @object.respond_to?(:active)
+      @object.update active: false
+      @message = 'Object deleted (exists in trashcan)'
+    else
+      @object.destroy
+      @message = "#{@object.class.name} deleted"
+    end
+    report_errros_if_any @object
+    @object.attributes
+  end
+
+  def undelete
+    error "Object not found" unless @object
+    can? :create, @object
+
+    if @object.respond_to?(:is_active)
+      @object.update :is_active=>true
+    elsif @object.respond_to?(:active)
+      @object.update :active=>true
+    else
+      error "No is_active, can't undelete"
+    end
+
+    @message = 'Object raised from the dead.'
+  end
+
+  def report_errros_if_any(obj)
+    @response[:object] = obj.class.to_s.tableize.singularize
+    @response[:objects] = obj.class.to_s.tableize
+
+    if obj.errors.count > 0
+      @response[:error] = ''
+      @response[:errors] = {}
+      for k,v in obj.errors
+        desc = v.join(', ')
+        desc = "#{k} #{desc}" if desc.starts_with?('is ')
+        @response[:errors][k] = desc
+        @response[:error] += ', ' unless @response[:error].blank?
+        @response[:error] += desc
+      end
+      Lux.page.status(400)
+      return true
+    end
+    false
+  end
+
+  def can?(action, object)
+    ModelPolicy.can?(action: action, model: object, user: Lux.page.var.user) do |err|
+      msg  = 'No %s permission for %s' % [action.to_s.sub('?',''), Lux.page.var.user ? Lux.page.var.user.email : :guests]
+      msg += ' on %s' % object.class.name if object
+      error msg
+    end
+  end
+end

data/lib/lux/api/lib/rescue.rb

@@ -0,0 +1,18 @@
+Lux::Api.class_eval do
+
+  rescue_from(:default) do |msg|
+    Lux.page.status $!.class
+
+    data =  { error:msg }
+
+    if Lux.dev? && $!.class != StandardError
+      data[:backtrace] = $!.backtrace.reject{ |el| el.index('/gems/') }.map{ |el| el.sub(Lux.root.to_s, '') }
+      ap data[:backtrace]
+    end
+
+    ApplicationApi.new.decorate_response!(data)
+
+    Lux.page.body data
+  end
+
+end

data/lib/lux/cache/cache.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Lux::Cache
+  extend self
+
+  def server= obj
+    @@server = obj
+  end
+
+  # cache data in current thread
+  def thread key
+    data = Lux.thread[:cache][key]
+    return data if data
+    Lux.thread[:cache][key] = yield
+  end
+
+  def read key
+    return nil if (Lux.page.no_cache? rescue false)
+    @@server.get(key)
+  end
+  alias :get :read
+
+  def read_multi *args
+    @@server.get_multi(*args)
+  end
+  alias :get_multi :read_multi
+
+  def write key, data, ttl=nil
+    ttl = ttl.to_i if ttl
+    @@server.set(key, data, ttl)
+  end
+  alias :set :write
+
+  def delete key, data=nil
+    @@server.delete(key)
+  end
+
+  def fetch key, ttl=nil, log=true
+    ttl = ttl.to_i if ttl
+    @@server.delete key if Lux.page && Lux.page.no_cache?
+
+    Lux.log " Cache.fetch.get #{key} (ttl: #{ttl.or(:nil)})" if log
+    data = @@server.fetch key, ttl do
+      data = yield
+      Lux.log " Cache.fetch.SET #{key} len:#{data.to_s.length}" if log
+      data
+    end
+
+    data
+  end
+
+  def is_available?
+    set('lux-test', 9)
+    get('lux-test') == 9
+  end
+
+  def generate_key *data
+    keys = []
+    for el in [data].flatten
+      if el.respond_to?(:updated_at)
+        keys.push el.updated_at
+      elsif el.respond_to?(:created_at)
+        keys.push el.created_at
+      else
+        keys.push el.to_s
+      end
+    end
+    key = keys.join('-')
+    key.length < 30 ? key : Crypt.md5(key)
+  end
+end

data/lib/lux/cache/lib/memcached.rb

@@ -0,0 +1,3 @@
+# use this in app config
+# Lux.config.cache  = Dalli::Client.new('localhost:11211', { :namespace=>Digest::MD5.hexdigest(__FILE__)[0,4], :compress => true,  :expires_in => 1.hour })
+# directly connect memcached

data/lib/lux/cache/lib/null.rb

@@ -0,0 +1,23 @@
+module Lux::Cache::NullCache
+  extend self
+
+  def set(key, data, ttl=nil)
+    data
+  end
+
+  def get(key)
+    nil
+  end
+
+  def fetch(key, ttl=nil)
+    yield
+  end
+
+  def delete(key)
+    nil
+  end
+
+  def get_multi(*args)
+    {}
+  end
+end