lux-fw 0.2.3 → 0.5.32

data/lib/overload/file.rb

@@ -1,11 +1,6 @@
 class File
   class << self
-    def write(name, data)
-      File.open(name, 'w') { |f| f.write(data) }
-      data
-    end
-
-    def change(name)
+    def change name
       data = File.read(name)
       data = yield data
       File.write(name, data)

data/lib/overload/hash.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../common/free_struct'
+
 class Hash
   def h
     Hashie::Mash.new(self)
@@ -9,13 +11,57 @@ class Hash
     HashWithIndifferentAccess.new(self)
   end
 
-	def tag node=nil, text=nil
-		HtmlTagBuilder.build self, node, text
-	end
+  # readonly hash with .to_h
+  def to_readonly name=nil
+    Class.new.tap do |c|
+      c.define_singleton_method(:to_h) do
+        m_list = methods(false) - [:to_h]
+        m_list.inject({}) do |h,m|
+          h[m] = send(m)
+          h[m] = h[m].to_h if h[m].class == Class
+          h
+        end
+      end
+
+      each do |k, v|
+        v = v.to_readonly if v.class == Hash
+        c.define_singleton_method(k) { v }
+      end
+    end
+  end
+
+  # {...}.to_opts :name, :age
+  # {...}.to_opts name: String, age: Integer
+  def to_opts *keys
+    if keys.first.is_a?(Hash)
+      # if given Hash check opt class types
+      keys.first.each do |key, target_class|
+        source = self[key]
+
+        if target_class && !source.nil? && !source.is_a?(target_class)
+          raise ArgumentError.new(%[Expected argument :#{key} to be of type "#{target_class}" not "#{source.class}"])
+        end
+      end
 
-  def to_struct name=nil
-    name ||= ToStructGeneric
-    Struct.new(name, *keys).new(*values)
+      keys = keys.first.keys
+    end
+
+    not_allowed = self.keys - keys
+    raise ArgumentError.new('Key :%s not allowed in option' % not_allowed.first) if not_allowed.first
+
+    FreeStruct.new keys.inject({}) { |total, key|
+      raise 'Hash key :%s is not allowed!' % key unless keys.include?(key)
+      total[key] = self[key]
+      total
+    }
+  end
+
+  def to_struct
+    to_opts *keys
+  end
+
+  def tag node=nil, text=nil
+    HtmlTagBuilder.build self, node, text
   end
 
   def blank?
@@ -29,6 +75,10 @@ class Hash
     }.join('&')
   end
 
+  def data_attributes
+    self.keys.sort.map{ |k| 'data-%s="%s"' % [k, self[k].to_s.gsub('"', '"')]}.join(' ')
+  end
+
   def pluck *args
     string_args = args.map(&:to_s)
     self.select{ |k,v| string_args.index(k.to_s) }
@@ -74,13 +124,6 @@ class Hash
     omit
   end
 
-  def to_opts! *keys
-    self.keys.each { |key| raise 'Hash key :%s is not allowed!' % key unless keys.include?(key) }
-
-    DynamicClass.new keys
-      .inject({}) { |_, key| _[key] = self[key]; _ }
-  end
-
   def pretty_generate
     JSON.pretty_generate(self).gsub(/"([\w\-]+)":/) { %["#{$1.yellow}":] }
   end

data/lib/overload/integer.rb

@@ -1,11 +1,11 @@
 class Integer
-  def pluralize(desc)
+  def pluralize desc
     if self == 0
       "no #{desc.to_s.pluralize}"
     elsif self == 1
       "#{self} #{desc}"
     else
-      "#{self} #{desc.to_s.pluralize}"
+      "#{self.dotted} #{desc.to_s.pluralize}"
     end
   end
 

data/lib/overload/it.rb

@@ -1,7 +1,10 @@
 # class Array
+#   def it
+#     @_it
+#   end
+
 #   # list.xeach { it.foo }
 #   def xeach &block
-#     define_singleton_method(:it) { @_it } unless respond_to?(:it)
 #     each do |_|
 #       @_it = _
 #       instance_eval &block
@@ -10,7 +13,6 @@
 
 #   # list.xmap { it * 2 }
 #   def xmap &block
-#     define_singleton_method(:it) { @_it } unless respond_to?(:it)
 #     map do |_|
 #       @_it = _
 #       instance_eval &block
@@ -19,11 +21,9 @@
 
 #   # list.xselect { it.class != Module }
 #   def xselect &block
-#     define_singleton_method(:it) { @_it } unless respond_to?(:it)
 #     select do |_|
 #       @_it = _
 #       instance_eval &block
 #     end
 #   end
-
 # end

data/lib/overload/object.rb

@@ -1,5 +1,27 @@
 class Object
 
+  def self.const_missing klass
+    file  = klass.to_s.tableize.singularize
+    paths = [
+      'models',
+      'lib',
+      'lib/vendor',
+      'vendor',
+      file.split('_').last.pluralize
+    ].map  { |it| './app/%s/%s.rb' % [it, file] }
+
+    klass_file = paths.find { |it| File.exist?(it) } or
+      raise NameError.new('Can not find and autoload class "%s", looked in %s' % [klass, paths.map{ |it| "\n#{it}" }.join('')])
+
+    # puts '* autoload: %s from %s' % [file, klass_file]
+
+    require klass_file
+
+    Object.const_get(klass)
+  end
+
+  ###
+
   def or _or
     self.blank? || self == 0 ? _or : self
   end
@@ -13,6 +35,7 @@ class Object
     desc ||= 'died without desc'
     desc = '%s: %s' % [exp_object.class, desc] if exp_object
     puts desc.red
+    puts caller.slice(0, 10)
     raise desc
   end
 
@@ -49,14 +72,20 @@ class Object
     self.class == TrueClass || self.class == FalseClass
   end
 
-end
-
-# if we dont have awesome print in prodction, define mock
-method(:ap) rescue Proc.new do
-  class Object
-    def ap(*args)
-      puts args
+  def andand func=nil
+    if present?
+      if block_given?
+        yield(self)
+      else
+        func ? send(func) : self
+      end
+    else
+      block_given? || func ? nil : {}.h
     end
   end
-end.call
+
+  def instance_variables_hash
+    Hash[instance_variables.map { |name| [name, instance_variable_get(name)] } ]
+  end
+end
 

data/lib/overload/{r.rb → raise_variants.rb}

@@ -18,7 +18,8 @@ class Object
 
   # better console log dump
   def rr what
-    ap ['--- START (%s) ---' % what.class, what, '--- END ---']
+    src = caller[0].sub(Lux.root.to_s+'/', '').sub(Lux.fw_root.to_s, 'lux-fw').split(':in `').first
+    ap ['--- START (%s) %s ---' % [what.class, src], what, '--- END ---']
   end
 
   # unique methods for object
@@ -52,7 +53,25 @@ class Object
     rr what
   end
 
-  def instance_variables_hash
-    Hash[instance_variables.map { |name| [name, instance_variable_get(name)] } ]
+  # show method info
+  # show User, :secure_hash
+  def rr? instance, m
+    el = instance.class.instance_method(m)
+    puts el.source_location.join(':').yellow
+    puts '-'
+    puts el.source if el.respond_to?(:source)
+    nil
   end
-end
+end
+
+###
+
+# if we dont have awesome print in prodction, define mock
+method(:ap) rescue Proc.new do
+  class Object
+    def ap(*args)
+      puts args
+    end
+  end
+end.call
+

data/lib/overload/string.rb

@@ -1,4 +1,8 @@
 class String
+  def constantize
+    Object.const_get('::'+self)
+  end
+
   # simple markdown
   def as_html
     self.gsub($/, '<br />')
@@ -18,15 +22,15 @@ class String
     data
   end
 
-  def sanitize
-    Sanitize.clean(self, :elements=>%w[span ul ol li b bold i italic u underline hr br p], :attributes=>{'span'=>['style']} )
+  def first
+    self[0,1]
   end
 
-  def tag(node_name, opts={})
-    opts.tag(node_name, self)
+  def sanitize
+    Sanitize.clean(self, :elements=>%w[span ul ol li b bold i italic u underline hr br p], :attributes=>{'span'=>['style']} )
   end
 
-  def wrap(node_name, opts={})
+  def wrap node_name, opts={}
     return self unless node_name
     opts.tag(node_name, self)
   end
@@ -63,10 +67,14 @@ class String
     self.split(/\s*,\s*/)
   end
 
-  def starts_with?(prefix)
+  def starts_with? prefix
     prefix.respond_to?(:to_str) && self[0, prefix.length] == prefix
   end
 
+  def ends_with? suffix
+    suffix.is_a?(String) && self[-suffix.length, suffix.length] == suffix && self != suffix
+   end
+
   def last(num=1)
     len = self.length
     self[len-num, len]
@@ -84,4 +92,12 @@ class String
   def decolorize
     self.gsub(/\[0;\d\d;\d\dm([^\[]*)\[0m/) { $1 }
   end
+
+  def escape
+    CGI::escape self
+  end
+
+  def unescape
+    CGI::unescape self
+  end
 end

data/misc/demo/app/cells/demo_cell.rb

@@ -0,0 +1,12 @@
+class DemoCell < ViewCell
+
+  def time
+    Time.now
+  end
+
+  def render time
+    @time = time.to_i
+    template :demo
+  end
+
+end

data/misc/demo/app/controllers/application_controller.rb

@@ -0,0 +1,7 @@
+class ApplicationContrller < Lux::Controller
+
+end
+
+class Main
+
+end

data/misc/demo/app/controllers/main/root_controller.rb

@@ -0,0 +1,9 @@
+class Main::RootController < ApplicationContrller
+
+  mock :about
+
+  def index
+    @title = 'Yay, you are on Lux'
+  end
+
+end

data/misc/demo/app/routes.rb

@@ -0,0 +1,5 @@
+Lux.app do
+  routes do
+    root 'main/root#index'
+  end
+end

data/misc/demo/config/application.rb

@@ -0,0 +1,14 @@
+require_relative 'environment'
+
+###
+
+Lux.config.secret     = 'secret'
+Lux.config.host       = 'http://localhost:3000'
+
+###
+
+Lux.require_all './app'
+
+###
+
+Lux.start

data/misc/demo/config/assets.rb

@@ -0,0 +1,6 @@
+asset :main do
+  css do
+    add 'css/main/*'
+    add './app/cells/**'
+  end
+end

data/misc/demo/config/environment.rb

@@ -0,0 +1,7 @@
+require 'bundler/setup'
+require 'dotenv'
+
+Dotenv.load
+
+Bundler.require :default, ENV.fetch('RACK_ENV')
+

data/misc/puma_auto_tune.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# Instantiate about one process per X MiB of available memory, scaling up to as
+# close to MAX_THREADS as possible while observing an upper bound based on the
+# number of virtual/logical CPUs. If there are fewer processes than
+# MAX_THREADS, add threads per process to reach MAX_THREADS.
+require 'etc'
+
+KB_PER_WORKER = 64 * 1_024 # average of peak PSS of single-threaded processes (watch smem -k)
+MIN_WORKERS = 2
+MAX_WORKERS_PER_VCPU = 1.25 # virtual/logical
+MIN_THREADS_PER_WORKER = 1
+MAX_THREADS = Integer(ENV['MAX_CONCURRENCY'] || 256)
+
+def meminfo arg
+  File.open('/proc/meminfo') do |f|
+    f.each_line do |line|
+      key, value = line.split(/:\s+/)
+      return value.split(/\s+/).first.to_i if key == arg
+    end
+  end
+
+  raise "Unable to find `#{arg}' in /proc/meminfo!"
+rescue
+  1_000_000
+end
+
+def auto_tune
+  avail_mem = meminfo('MemAvailable') * 0.8 - MAX_THREADS * 1_024
+
+  workers = [
+    [(1.0 * avail_mem / KB_PER_WORKER).floor, MIN_WORKERS].max,
+    (Etc.nprocessors * MAX_WORKERS_PER_VCPU).ceil
+  ].min
+
+  threads_per_worker = [
+    workers < MAX_THREADS ? (1.0 * MAX_THREADS / workers).ceil : -Float::INFINITY,
+    MIN_THREADS_PER_WORKER
+  ].max
+
+  [workers, threads_per_worker]
+end
+
+p auto_tune if $0 == __FILE__

data/misc/unicorn.rb

@@ -0,0 +1,37 @@
+# set path to application
+app_dir = File.expand_path("../..", __FILE__)
+working_directory app_dir
+
+# Set unicorn options
+worker_processes 10
+preload_app true
+timeout 20
+
+# Set up socket location
+listen "127.0.0.1:3000", :tcp_nopush => true
+listen "#{app_dir}/tmp/unicorn.sock", :backlog => 512
+
+# Logging
+stderr_path "#{app_dir}/log/unicorn.stderr.log"
+stdout_path "#{app_dir}/log/unicorn.stdout.log"
+
+# Set master PID location
+pid "#{app_dir}/tmp/unicorn.pid"
+
+worker_processes 5
+timeout 15
+
+preload_app true
+
+GC.respond_to?(:copy_on_write_friendly=) and GC.copy_on_write_friendly = true
+
+check_client_connection false
+
+before_exec do |server|
+end
+
+before_fork do |server, worker|
+end
+
+after_fork do |server, worker|
+end

data/{lib/lux → plugins}/api/api.rb

@@ -12,21 +12,26 @@
 class Lux::Api
   attr_accessor :message, :response
 
-  ClassCallbacks.define self, :before, :after, :on_error
+  class_callback :before
+  class_callback :after
 
   class << self
     # public mount method for router
-    def call path
-      return 'Unsupported API call' if !path[1] || path[3]
-
-      opts = Lux.current.params # Lux.current.request.post? ? Rack::Utils.parse_nested_query(Lux.current.request.body.read).h : Lux.current.params
+    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
 
-      if path[2]
-        opts[:_id] = path[1]
-        path[1] = path[2]
+        run path[0], path[1], opts
       end
-
-      Lux.current.response.body run(path[0], path[1], opts)
     end
 
     # public method for running actions on global class
@@ -43,7 +48,7 @@ class Lux::Api
         begin
           params.merge! params.delete(class_name.underscore)
         rescue
-          error "#{$!.message}. Domain value is probably not hash, invalid parameter #{class_name.underscore}"
+          return error "#{$!.message}. Domain value is probably not hash, invalid parameter #{class_name.underscore}"
         end
       end
 
@@ -54,11 +59,15 @@ class Lux::Api
       begin
         klass = (klass.singularize.camelize+'Api').constantize
       rescue
-        return Lux.current.response.body({ error:"API #{klass} not found" })
+        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
 
   ###
@@ -69,44 +78,39 @@ class Lux::Api
     rescue Lux::Api::Error => e
       response.error e.message if e.message.to_s != 'false'
     rescue => e
-      rr [e.message, e.backtrace] if Lux.config(:log_to_stdout)
-
-      ClassCallbacks.execute self, :on_error, e
-
-      response.error e.message
+      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={}
-    raise ForbidenError, "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
-
     @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
 
-    check_params_and_mock_instance_variables action
+    @method_attr = self.class.method_attr[action] || {}
 
     return if response.errors?
 
     # execte api call and verify params if possible
-    ClassCallbacks.execute(self, :before)
-
-    response.data = send(action)
-
-    ClassCallbacks.execute(self, :after)
-
-    puts response.render.pretty_generate if Lux.config.log_to_stdout
+    Object.class_callback :before, self
+    response.data = send(action) unless response.errors?
+    Object.class_callback :after, self unless response.errors?
   end
 
   def params
@@ -121,6 +125,10 @@ class Lux::Api
     response.message = what
   end
 
+  def current
+    Lux.current
+  end
+
   # default after block, can be overloaded
   def after
     return unless Lux.current
@@ -130,7 +138,16 @@ class Lux::Api
     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
+ApplicationApi ||= Class.new Lux::Api
+
+
+
 

data/plugins/api/lib/attr.rb

@@ -0,0 +1,31 @@
+# - 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/{lib/lux → plugins}/api/lib/dsl.rb

@@ -1,4 +1,4 @@
-class Lux::Api
+class ApplicationApi
   # name   'Show user data'
   # param  :email, type: :email, req: false
   # param  :pass
@@ -28,10 +28,7 @@ class Lux::Api
 
   ###
 
-  def check_params_and_mock_instance_variables action
-    @method_attr = self.class.method_attr[action] || {}
-
-    # params check if framework default
+  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
@@ -41,7 +38,7 @@ class Lux::Api
         raise ArgumentError.new(errors.values.to_sentence) unless Lux.current
 
         Lux.current.response.status 400
-        return response.error errors.values.to_sentence
+        error errors.values.to_sentence
       end
 
       # define local prefixed @_ variables