lux-fw 0.1.17

data/bin/lux

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+if File.exists?('lux-fw.gemspec')
+  puts 'Cant run in lux folder'
+  exit
+end
+
+require 'colorize'
+require 'optparse'
+require 'awesome_print'
+require 'dotenv'
+
+module LuxCli
+  extend self
+
+  def run what
+    puts what.green
+    system what
+  end
+
+  def die text
+    puts text.red
+    exit
+  end
+end
+
+Dotenv.load
+
+@port     = 3000
+lux_root = File.expand_path '../..', __FILE__
+
+puts 'Lux (%s, v%s)' % [lux_root, File.read('%s/.version' % lux_root)] unless ARGV[0]
+
+ARGV.options do |opts|
+  opts.on("-e", "--environment=val", "RACK_ENV enviroment", String) do |v|
+    v = 'production'  if v[0,1] == 'p'
+    v = 'development'  if v[0,1] == 'd'
+    ENV['RACK_ENV'] = v if v
+  end
+  opts.on("-p", "--port=val", "port (3000)", String) do |v|
+    @port = v.to_i
+  end
+end.parse!
+
+commands = {}
+commands['am']         = 'auto migrate'
+commands['assets']     = 'precompile assets and genereate mainifest.json'
+commands['console']    = 'Lux console'
+commands['dev']        = 'dev on port 3000 with hot reload on code change'
+commands['eval']       = 'eval code or file'
+commands['exceptions'] = 'show stored exceptions, last created first'
+commands['generate']   = 'generates models and views based on templates'
+commands['get']        = 'get local URL'
+# commands['job_que']    = 'process job que with loaded enviroment'
+commands['nginx']      = 'parse and install config/nginx.conf'
+commands['production'] = 'run puma in production mode'
+commands['routes']     = 'list routes'
+commands['server']     = 'run puma development server'
+commands['stat']       = 'goaccess stat to public/goaccess.html'
+
+command = ARGV.shift
+
+if command
+  for c in commands
+    command = c[0] if c[0] if c[0].start_with?(command)
+  end
+
+  if commands[command]
+    path = '%s/bin/cli/%s' % [lux_root, command]
+    load path
+  else
+    LuxCli.die "Can't find command [%s]" % command
+  end
+else
+  puts "\nCommands:"
+  for c in commands
+    # puts "  #{c[0].sub(/(\w)/,'[\\1]').ljust(15)} # #{c[1]}"
+    puts "  #{c[0].ljust(15)} # #{c[1]}"
+  end
+
+  puts "\nExamples:"
+  puts '  lux c           # lux console'
+  puts '  lux g user      # lux generate user users'
+  puts ''
+  exit
+end
+

data/bin/txt/nginx.conf

@@ -0,0 +1,29 @@
+worker_processes  1;
+
+events {
+  worker_connections  1024;
+}
+
+server {
+  listen 80;  #default deferred;
+  server_name .color-mont.com;
+  root        /home/deployer/apps/app/public;
+  error_log   /home/deployer/apps/app/log/nginx-error.log;
+
+  passenger_enabled on;
+  passenger_friendly_error_pages on;
+
+  location = /favicon.ico {
+    log_not_found off;
+    access_log    off;
+  }
+
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+  client_max_body_size 1G;
+  keepalive_timeout 20;
+}

data/bin/txt/siege-and-puma.txt

@@ -0,0 +1,3 @@
+puma -w 5 -t 2:2 -p 3000 -e production --preload
+
+siege -c 200 -t 10s -q --log=./siege.log http://profile.lvh.me:3000/en

data/lib/common/base32.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Base32
+
+  class Chunk
+    def initialize(bytes)
+      @table = "abcdefghijklmnopqrstuvwxyz234567"
+      @bytes = bytes
+    end
+
+    def decode
+      bytes = @bytes.take_while {|c| c != 61} # strip padding
+      n = (bytes.length * 5.0 / 8.0).floor
+      p = bytes.length < 8 ? 5 - (n * 8) % 5 : 0
+      c = bytes.inject(0) {|m,o| (m << 5) + @table.index(o.chr)} >> p
+      (0..n-1).to_a.reverse.collect {|i| ((c >> i * 8) & 0xff).chr} # bla
+    end
+
+    def encode
+      n = (@bytes.length * 8.0 / 5.0).ceil
+      p = n < 8 ? 5 - (@bytes.length * 8) % 5 : 0
+      c = @bytes.inject(0) {|m,o| (m << 8) + o} << p
+      [(0..n-1).to_a.reverse.collect {|i| @table[(c >> i * 5) & 0x1f].chr},
+       ("=" * (8-n))]
+    end
+  end
+
+  class << self
+    def chunks(str, size)
+      result = []
+      bytes = str.bytes
+      while bytes.any? do
+        result << Chunk.new(bytes.take(size))
+        bytes = bytes.drop(size)
+      end
+      result
+    end
+
+    def encode(str)
+      chunks(str, 5).collect(&:encode).flatten.join.sub(/=+$/,'')
+    end
+
+    def decode(str)
+      chunks(str, 8).collect(&:decode).flatten.join
+    end
+  end
+end

data/lib/common/before_and_after.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+# in some class
+#   def self.before(proc=nil, &block)
+#     BeforeAndAfter.add(self, caller[0], :before, proc || block)
+#   end
+# or
+#   BeforeAndAfter.define self, :before, :after
+#
+# then to execute
+# instance_object = SomeClass.new
+# BeforeAndAfter.execute(instance_object, :before)
+# or
+# before do
+#   ...
+# end
+# or
+# def before
+#   super
+#   ...
+# end
+#
+# logic is very simple, keep all pointers to all blocks in one class, resolve and execute as needed
+# we keep methods and ponters in different hashes to allow hot reload while development
+
+module BeforeAndAfter
+  extend self
+
+  @@methods  = {}
+  @@pointers = {}
+
+  def add(klass, unique_id, action, method)
+    key = Crypt.md5(unique_id)
+    @@pointers[key] = method
+    @@methods[klass.to_s] ||= {}
+    @@methods[klass.to_s][action] ||= []
+    @@methods[klass.to_s][action].push(key) unless @@methods[klass.to_s][action].index(key)
+  end
+
+  def execute(instance_object, action)
+    instance_object.send(action)
+
+    # execute for self and parent
+    for name in instance_object.class.ancestors.reverse.map(&:to_s)
+      next if name == 'Object'
+
+      if @@methods[name] && @@methods[name][action]
+        for el in @@methods[name][action].map { |o| @@pointers[o] }
+          if el.kind_of?(Symbol)
+            instance_object.send(el)
+          else
+            instance_object.instance_exec &el
+          end
+        end
+      end
+    end
+  end
+
+  def define(klass, *args)
+    for action in args
+      klass.class_eval %[
+        def #{action}
+        end
+
+        def self.#{action}(proc=nil, opts={}, &block)
+          BeforeAndAfter.add(self, caller[0], :#{action}, proc || block)
+        end
+      ]
+    end
+  end
+end

data/lib/common/class_attributes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# ClassAttributes.define klass, :layout, 'default_value_optional'
+# klass.layout -> get value
+# klass.layout = value -> set value
+
+# class A
+#   ClassAttributes.define self, :layout, 'default'
+# end
+# class B < A
+#   layout 'l B'
+# end
+# class C < B
+# end
+# puts A.layout # default
+# puts B.layout # l B
+# puts C.layout # l B
+
+# class User
+#   ClassAttributes.define_in_current_thread self, :current
+# end
+
+# User.current = User.first
+
+module ClassAttributes
+  extend self
+
+  CA_DEFAULTS = {}
+
+  # defines class variable
+  def define klass, name, default=nil, &block
+    raise ArgumentError, 'name must be symbol' unless name.class == Symbol
+
+    default ||= block if block
+
+    ::ClassAttributes::CA_DEFAULTS[name] = { 'Object'=>default }
+
+    klass.class.send(:define_method, name) do |*args|
+      root = ::ClassAttributes::CA_DEFAULTS[name]
+
+      # set and return if argument defined
+      return root[self.to_s] = args[0] if args.length > 0
+
+      # find value and return
+      self.ancestors.map(&:to_s).each do |el|
+        value = root[el]
+        if value || el == 'Object'
+          value = self.instance_exec(&value) if value.is_a?(Proc)
+          return value
+        end
+      end
+    end
+  end
+
+  # defines class variable in current lux thread
+  def current klass, name
+    klass.class.send(:define_method, name) do |*args|
+      Thread.current[:lux]['%s-%s' % [klass, name]]
+    end
+
+    klass.class.send(:define_method, '%s=' % name) do |value|
+      Thread.current[:lux] ||= {}
+      Thread.current[:lux]['%s-%s' % [klass, name]] = value
+    end
+  end
+end

data/lib/common/class_method_params.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+# allows adding of params to methods
+# used in Lux::Api
+#
+#   param :model_id, type: :integer
+#   param :age, max: 120
+#   def show
+#   end
+
+# class ModelApi
+#   class << self
+#     def param *args
+#       ClassMethodParams.add_param self, args
+#     end
+
+#     def method_added(m)
+#       ClassMethodParams.add_method self, m
+#     end
+#   end
+
+#   ###
+
+#   param :id
+#   param :user_id, Integer
+#   param :model_id, type: :integer
+#   param :age, max: 120
+#   def show
+
+#   end
+
+# end
+
+# class UserApi < ModelApi
+
+#   param :name
+#   def edit
+
+#   end
+
+# end
+
+# ap ClassMethodParams.params
+# ap ClassMethodParams.params UserApi, :show
+# ap ClassMethodParams.all UserApi
+
+module ClassMethodParams
+  extend self
+
+  @params = {}
+  @cache  = {}
+
+  def add_param klass, param, args
+    @cache[klass.to_s] ||= {}
+    @cache[klass.to_s][param] ||= []
+    @cache[klass.to_s][param].push args
+  end
+
+  def add_method klass, m
+    k = klass.to_s
+    @params[k] ||= {}
+    @params[k][m] = @cache[k] ? @cache[k].dup : {}
+    @cache = {}
+  end
+
+  def all_params
+    @params
+  end
+
+  # return all params method in a class
+  def params klass, m
+    return @params unless m
+
+    klass.ancestors.map(&:to_s).each do |klass|
+      return if klass == 'Object'
+      data = @params[klass]
+      return data[m] if data && data[m]
+    end
+
+    nil
+  end
+
+  # return all methos and all parameters for all methods in a class
+  def all klass
+    data = {}
+    all_methods = klass.instance_methods - Object.instance_methods
+    all_methods.each do |m|
+      data[m] = ClassMethodParams.params(klass, m)
+    end
+    data
+  end
+
+end
+

data/lib/common/crypt.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# @author: Dino Reic
+# @description:
+#   module for easy and convenient access to frequently used crypt operations
+
+require 'openssl'
+require 'base64'
+require 'digest/md5'
+require 'securerandom'
+
+module Crypt
+  extend self
+
+  ALGORITHM = 'HS512'
+
+  def secret
+    Lux.env('SECRET')
+  end
+
+  def base64(str)
+    Base64.urlsafe_encode64(str)
+  end
+
+  def uid
+    SecureRandom.hex
+  end
+
+  def sha1(str)
+    Digest::SHA1.hexdigest(str.to_s + secret)
+  end
+
+  def md5(str)
+    Digest::MD5.hexdigest(str.to_s + secret)
+  end
+
+  def bc(str)
+    BCrypt::Password.create(str + secret)
+  end
+
+  # Crypt.encrypt('secret')
+  # Crypt.encrypt('secret', ttl:1.hour, password:'pa$$w0rd')
+  def encrypt(data, opts={})
+    diff = opts.keys - [:ttl, :password]
+    raise 'Unallowed key(s) found %s' % diff.join(', ') if diff.length > 0
+
+    payload = { data:data }
+    payload[:ttl] = Time.now.to_i + opts[:ttl] if opts[:ttl]
+    hmac_secret = "#{secret}#{opts.delete(:password)}"
+    JWT.encode payload, hmac_secret, ALGORITHM
+  end
+
+  # Crypt.decrypt('secret')
+  # Crypt.decrypt('secret', password:'pa$$w0rd')
+  def decrypt(token, opts={})
+    diff = opts.keys - [:password]
+    raise 'Unallowed key(s) found %s' % diff.join(', ') if diff.length > 0
+
+    hmac_secret = "#{secret}#{opts.delete(:password)}"
+    token_data = JWT.decode token, hmac_secret, true, { :algorithm => ALGORITHM }
+    data = token_data[0]
+    raise "Crpted data expired before #{Time.now.to_i - data['ttl']} seconds" if data['ttl'] && data['ttl'] < Time.now.to_i
+    data['data']
+  end
+
+end

data/lib/common/folder_model.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class FolderModel
+
+  class << self
+    def find(key)
+      new(key)
+    end
+
+    def all
+      Dir["db/#{self.to_s.tableize}/*.json"].map{|file| new file.split('/').last.sub('.json') }
+    end
+  end
+
+  ###
+
+  def [](key)
+    @data[key]
+  end
+
+  def []=(key, value)
+    @data[key] = value
+  end
+
+  def method_missing(name, *args)
+    func = name.to_s.split('=')[0].to_sym
+
+    if name.to_s.index('=')
+      @data[func] = args[0]
+    else
+      # raise "Field #{name} not found"
+      @data[func]
+    end
+  end
+
+  def save
+    @storage.write JSON.pretty_generate(@data)
+    @data
+  end
+  alias :save! :save
+
+  def initialize(key)
+    @key = key
+    @storage = Pathname.new("db/#{self.class.to_s.tableize}/#{key}.json")
+    @data = JSON.parse @storage.read
+    @data = @data.h
+  end
+
+end
+

data/lib/common/generic_model.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# class FooBar < GenericModel
+#
+#   values [1, 'LinkedIn'],
+#          [2, 'Facebook'],
+#          [3, 'Twitter'],
+#          [4, 'Google'],
+#          [5, 'Email'],
+#          [6, 'Mobile']
+#
+#   def ico
+#     %{<img src="/images/type/#{code}.png" style="width:16px; height:16px; vertical-align:middle; " />}
+#   end
+#
+# end
+
+class GenericModel
+
+  @@values = {}
+
+  class << self
+    def values(vals)
+      @@values[self.to_s] = []
+      vals.map { |el| add_value(el) }
+    end
+
+    def add_value(val)
+      o = new(val)
+      for key in val.keys
+        eval %[def o.#{key}; @_vals[:#{key}]; end]
+      end
+      @@values[self.to_s].push(o)
+    end
+
+    def find(id)
+      for el in all
+        return el if el.id == id
+      end
+      nil
+    end
+
+    def all
+      @@values[self.to_s]
+    end
+
+    def where(opts)
+      @@values[self.to_s].select{ |el| el[opts.keys[0]] == opts.values[0] }
+    end
+  end
+
+  ###
+
+  def initialize(vals)
+    @_vals = vals
+  end
+
+  def [](key)
+    @_vals[key]
+  end
+
+end

data/lib/common/policy.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# base caller
+# UserPolicy.new(model: @model, user: User.current).can?(:update) -> can current user update @user
+# ApplicationPolicy.new(user: Lux.page.var.user).can?(:admin_login?) -> can current user login to admin
+
+# block will capture error message and be triggered only if error is present
+# ApplicationPolicy.can?(:login) { |msg| http_error 401, "Err: #{msg}".red; return 'no access' }
+
+class Policy
+
+  def initialize hash
+    for k, v in hash
+      instance_variable_set "@#{k}", v
+    end
+  end
+
+  # pass block if you want to handle errors yourself
+  # return true if false if block is passed
+  def can? action, &block
+    @action = action.to_s.sub('?','') + '?'
+    @action = @action.to_sym
+
+    # pre check
+    raise RuntimeError, 'Method name not allowed' if %w(can).index(@action)
+    raise NoMethodError, %[Policy check "#{action}" not found in #{self.class}] unless respond_to?(@action)
+
+    call &block
+  end
+
+  # call has to be isolated because specific of error handling
+  def call &block
+    return true if before(@action)
+    return true if send(@action)
+    raise UnauthorizedError, 'Access disabled in policy'
+   rescue UnauthorizedError
+    error = $!.message
+    error += " - #{self.class}.#{@action}" if Lux.config(:show_server_errors)
+    raise UnauthorizedError, error unless block
+    block.call(error)
+    false
+  end
+
+  ###
+
+  def before action
+    false
+  end
+
+  def error message
+    raise UnauthorizedError, message
+  end
+
+end

data/lib/common/string_base.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module StringBase
+  extend self
+
+  KEYS = 'bcdghjklmnpqrstvwxyz'
+  MULTIPLIER = 99
+
+  def encode value
+    value = value * MULTIPLIER
+    ring = Hash[KEYS.chars.map.with_index.to_a.map(&:reverse)]
+    base = KEYS.length
+    result = []
+    until value == 0
+      result << ring[ value % base ]
+      value /= base
+    end
+    result.reverse.join
+  end
+
+  def decode string
+    ring = Hash[KEYS.chars.map.with_index.to_a]
+    base = KEYS.length
+    ret = string.reverse.chars.map.with_index.inject(0) do |sum,(char,i)|
+      sum + ring[char] * (base**i)
+    end
+    raise 'Invalid decode base' if ret%MULTIPLIER>0
+    ret/MULTIPLIER
+  end
+
+  # extract ID from url
+  def extract(url_part)
+    id_str = url_part.split('-').last
+    return nil unless id_str
+    StringBase.decode(id_str) rescue nil
+  end
+end
+
+class Integer
+  def string_id
+    StringBase.encode self
+  end
+end
+
+class String
+  def string_id
+    StringBase.decode self
+  end
+end