lux-fw 0.2.3 → 0.5.32

data/bin/lux

@@ -1,16 +1,26 @@
 #!/usr/bin/env ruby
+# -*- mode: ruby -*-
 
 if File.exists?('lux-fw.gemspec')
   puts 'Cant run in lux folder'
   exit
 end
 
+require 'thor'
 require 'colorize'
 require 'optparse'
 require 'awesome_print'
 require 'dotenv'
 
-module LuxCli
+Dotenv.load
+
+LUX_ROOT = File.expand_path '../..', __FILE__
+
+puts 'Lux (%s, v%s)' % [LUX_ROOT, File.read('%s/.version' % LUX_ROOT)] unless ARGV[0]
+
+###
+
+module Cli
   extend self
 
   def run what
@@ -22,76 +32,25 @@ module LuxCli
     puts text.red
     exit
   end
+
+  def info text
+    puts '* %s' % text.magenta
+  end
 end
 
-Dotenv.load
+###
 
-@port     = 3000
-lux_root = File.expand_path '../..', __FILE__
+trap("SIGINT") { Cli.die 'ctrl+c exit' }
 
-if Dir.exists?('.git')
-  test_root = `bundle show lux-fw`.chomp
-  lux_root  = test_root if test_root.include?('lux')
-end
+LuxCli = Class.new Thor
 
-puts 'Lux (%s, v%s)' % [lux_root, File.read('%s/.version' % lux_root)] unless ARGV[0]
+Dir['%s/bin/cli/*.rb' % LUX_ROOT].each { |it| load it }
 
-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
-  opts.on("-f", "--flags=val", "CRSL", String) do |v|
-    @flags = v
-  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['nginx']      = 'parse and install config/nginx.conf'
-commands['production'] = 'run puma in production mode'
-commands['routes']     = 'list routes'
-commands['render']     = 'render single page'
-commands['server']     = 'run puma development server'
-commands['systemd']    = 'parse and install config/systemd.conf'
-commands['stat']       = 'goaccess stat to public/goaccess.html'
-# commands['job_que']    = 'process job que with loaded enviroment'
-
-command = ARGV.shift
-
-if command
-  for c in commands
-    command = c[0] if c[0] if c[0].start_with?(command)
-  end
+LuxCli.start ARGV
 
-  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
+rakes = Dir['./Rakefile*'] + Dir['./rakefile*']
 
-  puts "\nExamples:"
-  puts '  lux c           # lux console'
-  puts '  lux g user      # lux generate user users'
-  puts ''
-  exit
+if !ARGV[0] && rakes[0]
+  puts 'Or use one of rake tasks'
+  puts '  ' + `rake -T`.gsub($/, "\n  ")
 end
-

data/lib/common/class_attributes.rb

@@ -1,75 +1,51 @@
-# frozen_string_literal: true
+# Defines class variable
 
-# ClassAttributes.define klass, :layout, 'default_value_optional'
-# klass.layout -> get value
-# klass.layout = value -> set value
+def Object.class_attribute name, default=nil, &block
+  raise ArgumentError.new('name must be symbol') unless name.is_a?(Symbol)
+
+  ivar = "@cattr_#{name}"
+  instance_variable_set ivar, block || default
+
+  define_singleton_method('%s=' % name) { |arg| send(name, arg) }
+  define_singleton_method(name) do |arg=:_undefined|
+    # define and set if argument given
+    if arg != :_undefined
+      instance_variable_set ivar, arg
+      return arg
+    end
+
+    # find value and return
+    ancestors.each do |klass|
+      if klass.instance_variable_defined?(ivar)
+        value = klass.instance_variable_get ivar
+        return value.is_a?(Proc) ? instance_exec(&value) : value
+      end
+    end
+  end
+end
 
 # class A
-#   ClassAttributes.define self, :layout, 'default'
+#   class_attribute :layout, 'default'
+#   class_attribute(:time) { Time.now }
 # end
+
 # class B < A
-#   layout 'l B'
+#   layout 'main'
 # end
+
 # class C < B
+#   time '11:55'
 # end
-# puts A.layout # default
-# puts B.layout # l B
-# puts C.layout # l B
 
-# class User
-#   ClassAttributes.define_in_current_thread self, :current
+# for func in [:layout, :time]
+#   for klass in [A, B, C]
+#     puts "> %s = %s" % ["#{klass}.#{func}".ljust(8), klass.send(func)]
+#   end
 # 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.define_singleton_method('%s=' % name) { |*args| send name, *args}
-    klass.define_singleton_method(name) do |*args|
-      root = ::ClassAttributes::CA_DEFAULTS[name]
-
-      # set and return if argument defined
-      return root[to_s] = args[0] if args.length > 0
-
-      # find value and return
-      ancestors.map(&:to_s).each do |el|
-        value = root[el]
-        if value || el == 'Object'
-          value = instance_exec(&value) if value.is_a?(Proc)
-          return value
-        end
-      end
-    end
-  end
-
-  # defines class variable in current lux thread
-  # User.current = @user
-  # def current klass, name
-  #   klass.class.send(:define_method, name) do |*args|
-  #     Thread.current[:lux] ||= {}
-  #     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
-
-class Object
-  def class_attribute name, default=nil, &block
-    ClassAttributes.define self, name, default, &block
-  end
-end
+# # > A.layout = default
+# # > B.layout = main
+# # > C.layout = main
+# # > A.time   = 2018-10-28 18:07:33 +0100
+# # > B.time   = 2018-10-28 18:07:33 +0100
+# # > C.time   = 11:55

data/lib/common/class_callbacks.rb

@@ -1,64 +1,47 @@
-# frozen_string_literal: true
+# Rails style callbacks
 
-# in some class
-# ClassCallbacks.define self, :before, :after
-#
-# then to execute
-# instance_object = SomeClass.new
-# ClassCallbacks.execute(instance_object, :before)
-#
+# for controllers, execute from AppController to MainController
+# class_callback :before
 # before do
-#   ...
+#    ...
 # 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 ClassCallbacks
-  extend self
-
-  @@methods  = {}
-  @@pointers = {}
-
-  def add klass, unique_id, action, method
-    klass = klass.to_s
-    key   = Crypt.sha1(unique_id)
-
-    @@pointers[key] = method
-
-    @@methods[klass] ||= {}
-    @@methods[klass][action] ||= []
-    @@methods[klass][action].tap { |it| it.push(key) unless it.include?(key) }
+# before :method_name
+# instance = new
+# instance.class_callback :before,
+# instance.class_callback :before, arg
+
+class Object
+  def class_callback name, arg=nil
+    Object.class_callback name, self, arg
   end
 
-  def execute instance_object, action, object=nil
-    object ? instance_object.send(action, object) : instance_object.send(action)
+  def self.class_callback name, context=nil, arg=nil
+    ivar = "@ccallbacks_#{name}"
 
-    # execute for self and parents
-    instance_object.class.ancestors.reverse.map(&:to_s).each do |name|
-      next if     name == 'Object'
-      next unless actions = @@methods.dig(name, action)
+    unless context
+      define_singleton_method(name) do |method_name=nil, &block|
+        ref = caller[0].split(':in ').first
 
-      for el in actions.map { |o| @@pointers[o] }
-        if el.kind_of?(Symbol)
-          object ? instance_object.send(el, object) : instance_object.send(el)
-        else
-          object ? instance_object.instance_exec(object, &el) : instance_object.instance_exec(&el)
-        end
+        self.instance_variable_set(ivar, {}) unless instance_variable_defined?(ivar)
+        self.instance_variable_get(ivar)[ref] = method_name || block
       end
-    end
-  end
 
-  def define(klass, *args)
-    args.each do |action|
-      klass.class_eval %[
-        def #{action}(duck=nil)
+    else
+      list = context.respond_to?(:const_missing) ? context.ancestors : context.class.ancestors
+      list = list.slice 0, list.index(Object) if list.index(Object)
+
+      list.reverse.each do |klass|
+        if klass.instance_variable_defined?(ivar)
+          mlist = klass.instance_variable_get(ivar).values
+          mlist.each do |m|
+            if m.is_a?(Symbol)
+              context.send m
+            else
+              context.instance_exec arg, &m
+            end
+          end
         end
-
-        def self.#{action}(proc=nil, &block)
-          ClassCallbacks.add(self, caller[0], :#{action}, proc || block)
-        end
-      ]
+      end
     end
   end
 end

data/lib/common/crypt.rb

@@ -15,7 +15,7 @@ module Crypt
   ALGORITHM = 'HS512'
 
   def secret
-    ENV.fetch('SECRET') { puts '* Warn: ENV SECRET not set'; 'foo' }
+    ENV.fetch('SECRET') { Lux.config.secret } || die('Lux.config.secret not set')
   end
 
   def base64 str
@@ -44,22 +44,24 @@ module Crypt
 
   # Crypt.encrypt('secret')
   # Crypt.encrypt('secret', ttl:1.hour, password:'pa$$w0rd')
-  def encrypt(data, opts={})
-    opts = opts.to_opts!(:ttl, :password)
+  def encrypt data, opts={}
+    opts          = opts.to_opts(:ttl, :password)
+    payload       = { data:data }
+    payload[:ttl] = Time.now.to_i + opts.ttl.to_i if opts.ttl
 
-    payload = { data:data }
-    payload[:ttl] = Time.now.to_i + opts.ttl if opts.ttl
     JWT.encode payload, secret+opts.password.to_s, ALGORITHM
   end
 
   # Crypt.decrypt('secret')
   # Crypt.decrypt('secret', password:'pa$$w0rd')
-  def decrypt(token, opts={})
-    opts = opts.to_opts!(:password)
+  def decrypt token, opts={}
+    opts = opts.to_opts(:password, :ttl)
 
     token_data = JWT.decode token, secret+opts.password.to_s, true, { :algorithm => ALGORITHM }
     data = token_data[0]
-    raise "Crypted data expired before #{Time.now.to_i - data.ttl} seconds" if data['ttl'] && data['ttl'] < Time.now.to_i
+
+    raise "Crypted data expired before #{Time.now.to_i - data['ttl']} seconds" if data['ttl'] && data['ttl'] < Time.now.to_i
+
     data['data']
   end
 

data/lib/common/free_struct.rb

@@ -0,0 +1,42 @@
+# Convert hash to object with methods
+#   o = FreeStruct.new name: 'a'
+#   o.name   -> 'a'
+#   o[:name] -> 'a'
+#   o.name = 'b'
+#   o.name 'b'
+#   o.name -> 'b'
+#   o.name = nil
+#   o.name -> nil
+#   o.title -> raises error
+
+class FreeStruct
+  def initialize hash
+    @keys = hash.keys
+
+    hash.each do |key, value|
+      ivar = "@#{key}"
+
+      instance_variable_set ivar, value
+
+      define_singleton_method(key) do
+        instance_variable_get ivar
+      end
+
+      define_singleton_method "#{key}=" do |val|
+        instance_variable_set ivar, val
+      end
+    end
+  end
+
+  def [] key
+    send key
+  end
+
+  def to_h
+    @keys.inject({}) do |out, key|
+      out[key] = send(key)
+      out
+    end
+  end
+end
+

data/lib/common/hash_with_indifferent_access.rb

@@ -44,7 +44,7 @@ class HashWithIndifferentAccess
   end
 
   def dig *args
-    list = args.map{ |it| it.class == Symbol ? it.to_s : it }
+    list = args.map{ |it| it.is_a?(Symbol) ? it.to_s : it }
     @data.dig *list
   end
 

data/lib/common/html_tag_builder.rb

@@ -3,6 +3,7 @@
 #     n.li do |n|
 #       n.i '.arrow'
 #       n.span num
+#       n.id
 #     end
 #   end
 # end
@@ -17,8 +18,15 @@ class HtmlTagBuilder
     # tag :div, { 'class'=>'iform' } do
     def tag name=nil, opts={}, data=nil
       # covert tag.a '.foo.bar' to class names
-      if opts.class == String && opts[0,1] == '.'
-        opts = { class: opts.sub('.', '').gsub('.', ' ') }
+      # covert tag.a '#id' to id names
+      if opts.is_a?(String)
+        case opts[0,1]
+          when '.'
+            opts = { class: opts.sub('.', '').gsub('.', ' ') }
+          when '#'
+            opts = { id: opts.sub('#', '') }
+          end
+        else
       end
 
       # fix data and opts unless opts is Hash
@@ -50,6 +58,12 @@ class HtmlTagBuilder
       text ||= '' unless ['input', 'img', 'meta', 'link', 'hr', 'br'].include?(node.to_s)
       text ? %{<#{node}#{opts}>#{text}</#{node}>} : %{<#{node}#{opts} />}
     end
+
+    # tag.div(class: 'klasa') do -> tag.('klasa') do
+    def call class_name, &block
+      tag(:div, { class: class_name }, &block)
+    end
+
   end
 
   ###
@@ -60,6 +74,16 @@ class HtmlTagBuilder
     @data = []
   end
 
+  # push data to stack
+  def push data
+    @data.push data
+  end
+
+  # n.div(class: 'klasa') do -> n.('klasa') do
+  def call class_name, &block
+    @data.push self.class.tag(:div, { class: class_name }, &block)
+  end
+
   # forward to class
   def method_missing tag_name, *args, &block
     @data.push self.class.tag(tag_name, args[0], args[1], &block)

data/lib/common/url.rb

@@ -30,14 +30,14 @@ class Url
       b.url
     end
 
-    def qs name, value=nil
+    def qs name, value
       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 = current.delete(name).relative
       url += url.index('?') ? '&' : '?'
       "#{url}#{name}="
     end
@@ -54,26 +54,28 @@ class Url
   ###
 
   def initialize url
-    if url =~ /:/
-      @elms = url.split '/', 4
-    else
-      @elms = [url]
-      @elms.unshift '',''
+    url, qs_part = url.split('?', 2)
+
+    @qs = qs_part.to_s.split('&').inject({}) do |qs, el|
+      parts = el.split('=', 2)
+      qs[parts[0]] = Url.unescape parts[1]
+      qs
     end
 
-    domain_and_port = @elms[2].split(':')
-    @domain_parts = domain_and_port[0].to_s.split('.').reverse.map(&:downcase)
+    if url =~ %r{://}
+      @proto, _, @domain, @path = url.split '/', 4
+
+      @proto = @proto.sub(':', '')
 
-    @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]
+      @domain, @port = @domain.split(':', 2)
+      @port = nil if @port == '80' || @port.blank?
+
+      @domain_parts = @domain.split('.').reverse.map(&:downcase)
+    else
+      @path = url.to_s.sub(%r{^/}, '')
+    end
 
-    @path = path_with_qs[0] || '/'
-    @proto = @elms[0].split(':').first.downcase
-    @port = domain_and_port[1] ? domain_and_port[1].to_i : 80
+    @path = '' if @path.blank?
   end
 
   def domain what=nil
@@ -85,11 +87,12 @@ class Url
     @domain_parts.slice(0,2).reverse.join '.'
   end
 
-  def subdomain name
+  def subdomain name=nil
     if name
       @domain_parts[2] = name
       return self
     end
+
     @domain_parts.drop(2).reverse.join('.').or nil
   end
 
@@ -101,19 +104,17 @@ class Url
     @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
+    if val
+      @path = val.sub /^\//, ''
+      return self
+    else
+      '/' + @path
+    end
   end
 
   def delete *keys
@@ -125,13 +126,13 @@ class Url
     @hash = "##{val}"
   end
 
-  def qs name, value=nil
-    if value
+  def qs name, value=:_nil
+    if value != :_nil
       @qs[name.to_s] = value
+      self
     elsif name
-      @qs.delete(name.to_s)
+      @qs[name.to_s]
     end
-    self
   end
 
   def namespace data
@@ -141,21 +142,16 @@ class Url
 
   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('')
+    self
   end
 
   def url
@@ -167,7 +163,29 @@ class Url
   end
 
   def to_s
-    domain.length > 0 ? url : local_url
+    @domain ? url : relative
+  end
+
+  def [] key
+    @qs[key.to_s]
+  end
+
+  def []= key, value
+    @qs[key.to_s] = value
+  end
+
+  private
+
+  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 host_with_port
+    %[#{proto}://#{host}#{@port.present? ? ":#{@port}" : ''}]
   end
 
 end