lux-fw 0.5.36 → 0.6.2

data/lib/lux/view/lib/cell_helpers.rb

@@ -1,29 +0,0 @@
-# make cell available in helpers
-
-require_relative 'helper_modules'
-
-class ViewCell < Lux::View::Cell
-end
-
-HtmlHelper.class_eval do
-  def cell name=nil, vars={}
-    if name
-      ViewCell.get(name, self, vars)
-    else
-      return @cell_base ||= ViewCell::Loader.new(self)
-    end
-  end
-end
-
-# make cell available in controllers
-Lux::Controller.class_eval do
-  def cell name=nil
-    name = if name
-      name.to_s.classify
-    else
-      self.class.to_s.split('::').last.sub('Controller')
-    end
-
-    name.constantize.new(self, vars)
-  end
-end

data/lib/lux/view/view.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-require 'thread'
-
-class Lux::View
-  @@template_cache = {}
-
-  class << self
-    def render_with_layout layout, template, helper={}
-      part_data = new(template, helper).render_part
-      new(layout, helper).render_part { part_data }
-    end
-
-    def render_part template, helper={}
-      new(template, helper).render_part
-    end
-  end
-
-  def initialize template, context={}
-    template           = template.sub(/^[^\w]+/, '')
-    @original_template = template
-
-    @helper = if context.class == Hash
-      # create helper class if only hash given
-      Lux::View::Helper.new(context)
-    else
-      context
-    end
-
-    mutex = Mutex.new
-
-    # if auto_code_reload is on then clear only once per request
-    if Lux.config(:auto_code_reload) && !Thread.current[:lux][:template_cache]
-      Thread.current[:lux][:template_cache] = true
-      mutex.synchronize { @@template_cache = {} }
-    end
-
-    if ref = @@template_cache[template]
-      @tilt, @template = *ref
-      return
-    end
-
-    for dir in ['./app/views']
-      for ext in Tilt.default_mapping.template_map.keys
-        next if @template
-        test = "#{dir}/#{template}.#{ext}"
-        @template = test if File.exists?(test)
-      end
-    end
-
-    unless @template
-      err  = caller.reject{ |l| l =~ %r{(/lux/|/gems/)} }.map{ |l| el=l.to_s.split(Lux.root.to_s); el[1] || l }.join("\n")
-      msg  = %[Lux::View "#{template}.{erb,haml}" not found]
-      msg += %[\n\n#{err}] if Lux.config(:dump_errors)
-
-      Lux.error msg
-    end
-
-    begin
-      mutex.synchronize do
-        # @tilt = Tilt.new(@template, ugly:true, escape_html: false)
-        @tilt = Tilt.new(@template, escape_html: false)
-        @@template_cache[template] = [@tilt, @template]
-      end
-    rescue
-      Lux.error("#{$!.message}\n\nTemplate: #{@template}")
-    end
-  end
-
-  def render_part
-    # global thread safe reference pointer to last temaplte rendered
-    # we nned this for inline template render
-
-    Thread.current[:lux][:last_template_path] = @template.sub('/app/views','').sub(/\/[^\/]+$/,'').sub(/^\./,'')
-    Lux.current.files_in_use @template
-
-    data = nil
-
-    speed = Lux.speed do
-      begin
-        data = @tilt.render(@helper) do
-          yield if block_given?
-        end
-      rescue => e
-        data = Lux::Error.inline %[Lux::View #{@template} render error], e
-      end
-    end
-
-    Lux.log " app/views/#{@template.split('app/views/').last}, #{speed}"
-
-    data
-  end
-
-end
-
-

data/lib/overload/it.rb

@@ -1,29 +0,0 @@
-# class Array
-#   def it
-#     @_it
-#   end
-
-#   # list.xeach { it.foo }
-#   def xeach &block
-#     each do |_|
-#       @_it = _
-#       instance_eval &block
-#     end
-#   end
-
-#   # list.xmap { it * 2 }
-#   def xmap &block
-#     map do |_|
-#       @_it = _
-#       instance_eval &block
-#     end
-#   end
-
-#   # list.xselect { it.class != Module }
-#   def xselect &block
-#     select do |_|
-#       @_it = _
-#       instance_eval &block
-#     end
-#   end
-# end

data/plugins/api/README.md

@@ -1,49 +0,0 @@
-## Lux::Api
-
-Default class for writing APIs
-
-### General rules
-
-* defines Lux::Api, ApplicationApi and ModelApi
-  * ApplicationApi - defines decorator and default rescue for output messages
-  * ModelApi - defines create, read, update and delete methods
-    * checks every action via Policy.can?(current_user, action, model)
-      ``` Policy.can?(Lux.current.var.user, :update?, @note) ```
-      checks if current user can update defined model
-  * you shuld modify and inherit from ApplicationApi or ModelApi
-
-* you can use before and after filters
-* attributes that are requested and checked via "param :name" are available as @_name
-
-
-### Example
-
-```
-class BlogApi < ModelApi
-
-  name  'List all blogs'
-  desc  'will list all blogs'
-  def index
-    Blog.order(:id).select(:id, :name).page
-  end
-
-  name  'Show single blog by id'
-  param :id, Integer
-  def show
-    Blog.find(@_id)
-  end
-
-end
-```
-
-### Rescues
-
-Define API rescue handler
-
-```
-ApplicationApi.on_error do |e|
-  key = SimpleException.log(e)
-  response.meta :error_key, key
-  response.meta :error_class, e.class
-end
-```

data/plugins/api/api.rb

@@ -1,153 +0,0 @@
-# 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
-  attr_accessor :message, :response
-
-  class_callback :before
-  class_callback :after
-
-  class << self
-    # public mount method for router
-    def call path, opts={}
-      if path.is_a?(Symbol)
-        # TestApi.call(:foo, email: '...')
-        new.call path, opts
-      else
-        # Lux::Api.call([:user, :profile], email: '...' )
-        return error 'Unsupported API call' if !path[1] || path[3]
-
-        if path[2]
-          opts[:_id] = path[1]
-          path[1] = path[2]
-        end
-
-        run path[0], path[1], opts
-      end
-    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
-          return 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 error "API #{klass} not found"
-      end
-
-      klass.new.call(action.to_sym, params)
-    end
-
-    def error message
-      Lux::Api::Response.error message
-    end
-  end
-
-  ###
-
-  def call action, params={}
-    begin
-      rescued_call action, params
-    rescue Lux::Api::Error => e
-      response.error e.message if e.message.to_s != 'false'
-    rescue => e
-      on_error(e)
-    end
-
-    puts response.render.pretty_generate if Lux.config(:log_to_stdout)
-
-    response.render
-  end
-
-  # internal method for running actions
-  # UserApi.new.call(:login, { email:'', pass:'' })
-  def rescued_call action, params={}
-    @response   = Lux::Api::Response.new
-    @params     = params
-    @action     = action
-    @class_name = self.class.to_s.sub(/Api$/,'')
-
-    error("Protected action call") if [:call, :rescued_call, :params, :error].index action
-    error("Action #{action} not found in #{self.class.to_s}") unless respond_to? action
-
-    # load default object
-    if @params[:_id]
-      eval "@object = @#{@class_name.underscore} = #{@class_name}[@params[:_id].to_i]"
-      @params.delete(:_id)
-    end
-
-    @method_attr = self.class.method_attr[action] || {}
-
-    return if response.errors?
-
-    # execte api call and verify params if possible
-    Object.class_callback :before, self
-    response.data = send(action) unless response.errors?
-    Object.class_callback :after, self unless response.errors?
-  end
-
-  def params
-    @params
-  end
-
-  def error what=nil
-    raise Lux::Api::Error.new(what || 'false')
-  end
-
-  def message what
-    response.message = what
-  end
-
-  def current
-    Lux.current
-  end
-
-  # default after block, can be overloaded
-  def after
-    return unless Lux.current
-
-    response.meta :ip, Lux.current.request.ip
-    response.meta :user, Lux.current.var.user ? Lux.current.var.user.email : nil
-    response.meta :http_status, Lux.current.response.status(200)
-  end
-
-  def on_error error
-    response.meta :error_key, Lux.error.log(error)
-    response.meta :error_class, error.class.to_s
-    response.error error.message
-  end
-
-end
-
-ApplicationApi ||= Class.new Lux::Api
-
-
-
-

data/plugins/api/lib/attr.rb

@@ -1,31 +0,0 @@
-# - in ApplicationApi, class level
-# api_attr :secure_token do |name|
-#   error 'User session required' unless User.current
-#   error 'Secure token not found' unless params[:secure_token]
-#   error 'Invalid secure token' if User.current.secure_token(name) != params.delete(:secure_token)
-# end
-
-# - in object api, instance level
-# secure_token :delete
-# def delete_me
-#   'ok'
-# end
-
-class ApplicationApi
-  API_ATTR ||= {}
-
-  def self.api_attr name, &block
-    method_attr name
-
-    API_ATTR[name] = block
-  end
-
-  ## api_attr check
-  before do
-    for method_attr_name, block in API_ATTR
-      for data in @method_attr[method_attr_name].or([])
-        instance_exec data, &block
-      end
-    end
-  end
-end

data/plugins/api/lib/dsl.rb

@@ -1,52 +0,0 @@
-class ApplicationApi
-  # 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
-
-  # helper for standard definition of parametars
-  # param :o_id
-  # param :o_id, Integer
-  # param :o_id, Integer, req: false
-  # param :o_id, req: false
-  method_attr :param do |field, type=String, opts={}|
-    opts = type.is_a?(Hash) ? type : opts.merge(type: type)
-    opts[:name] = field
-    opts[:req]  = true if opts[:req].nil?
-    opts[:type] ||= String
-    opts
-  end
-
-  # helper for standard definition of name
-  method_attr :name
-
-  # helper for standard definition of description
-  method_attr :data
-
-  ###
-
-  before do
-    if @method_attr[:param]
-      local  = @method_attr[: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.current
-
-        Lux.current.response.status 400
-        error errors.values.to_sentence
-      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
-  end
-
-end

data/plugins/api/lib/error.rb

@@ -1,3 +0,0 @@
-class Lux::Api::Error < StandardError
-
-end

data/plugins/api/lib/model_api.rb

@@ -1,203 +0,0 @@
-class Sequel::Model
-  module InstanceMethods
-    def same_as_last_field_value data
-      data = data.join('-') if data.is_array?
-      data = '' if data.is_hash?
-      data
-    end
-
-    def same_as_last?
-      @last = self.class.xorder('id desc').first
-      return unless @last
-
-      return if respond_to?(:name) && name != @last[:name]
-
-      new_o = self.to_h
-      new_o.delete :created_at
-      new_o.delete :updated_at
-      new_o.delete :id
-
-      old_o = new_o.keys.inject({}) do |t, key|
-        t[key] = @last.send(key)
-
-        new_o[key] = same_as_last_field_value new_o[key]
-        t[key]     = same_as_last_field_value t[key]
-
-        t
-      end
-
-      if new_o.to_s.length == old_o.to_s.length
-        raise "#{self.class} is the copy of the last one created."
-      end
-    end
-  end
-end
-
-###
-
-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
-
-    attributes
-  end
-
-  def create
-    @object = @class_name.constantize.new
-
-    for k, v in @params
-      v = nil if v.blank?
-      @object.send("#{k}=", v) if @object.respond_to?(k.to_sym)
-    end
-
-    @object.same_as_last? rescue error($!.message)
-
-    can? :create, @object
-    @object.save if @object.valid?
-    return if report_errros_if_any @object
-
-    if @object.id
-      message '%s created' % @class_name.capitalize
-    else
-      error 'object not created, error unknown'
-    end
-
-    add_response_object_path
-
-    attributes
-  end
-
-  def update
-    error "Object not found" unless @object
-
-    for k,v in @params
-      m = "#{k}=".to_sym
-      v = nil if v.blank?
-      @object.send(m, v) if @object.respond_to?(m)
-    end
-
-    can? :update, @object
-
-    @object.updated_at = Time.now.utc if @object.respond_to?(:updated_at)
-    @object.save if @object.valid?
-
-    report_errros_if_any @object
-
-    response.message '%s updated' % @class_name
-
-    add_response_object_path
-
-    attributes
-  end
-
-  # if you put active boolean field to objects, then they will be unactivated on destroy
-  def destroy force: false
-    error "Object not found" unless @object
-    can? :delete, @object
-
-    if !force && @object.respond_to?(:is_active)
-      @object.update is_active: false
-
-      message 'Object deleted (exists in trashcan)'
-    elsif !force && @object.respond_to?(:active)
-      @object.update active: false
-
-      message 'Object deleted (exists in trashcan)'
-    else
-      @object.destroy
-      message '%s deleted' % @object.class.name
-    end
-
-    report_errros_if_any @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
-
-    response.message = 'Object raised from the dead.'
-  end
-
-  private
-
-  def report_errros_if_any obj
-    return if obj.errors.count == 0
-
-    for k, v in obj.errors
-      desc = v.join(', ')
-
-      response.error k, desc
-    end
-
-    error
-  end
-
-  def can? action, object=nil
-    object ||= @object
-    object.can?(action) do |err|
-      msg  = 'No %s permission for %s' % [action.to_s.sub('?',''), Lux.current.var.user ? Lux.current.var.user.email : :guests]
-      msg += ' on %s' % object.class.name if object
-      error msg
-    end
-  end
-
-  def add_response_object_path
-    begin
-      if @object.respond_to?(:path)
-        response.meta :path, @object.path
-        response.meta :string_id, @object.id.string_id
-      end
-    rescue
-      nil
-    end
-  end
-
-  def attributes
-    @object.attributes.pluck(:id, :name, :email)
-  end
-
-end