lux-fw 0.1.17

data/lib/lux/cache/lib/ram.rb

@@ -0,0 +1,38 @@
+module Lux::Cache::RamCache
+  extend self
+
+  @@lock = Mutex.new
+  @@ram_cache = {}
+  @@ttl_cache = {}
+
+  def set(key, data, ttl=nil)
+    @@lock.synchronize do
+      @@ttl_cache[key] = Time.now.to_i + ttl if ttl
+      @@ram_cache[key] = data
+    end
+  end
+
+  def get(key)
+    if ttl_check = @@ttl_cache[key]
+      return nil if ttl_check < Time.now.to_i
+    end
+
+    @@ram_cache[key]
+  end
+
+  def fetch(key, ttl=nil)
+    data = get key
+    return data if data
+    set(key, yield, ttl)
+  end
+
+  def delete(key)
+    @@lock.synchronize do
+      @@ram_cache.delete(key)
+    end
+  end
+
+  def get_multi(*args)
+    @@ram_cache.select{ |k,v| args.index(k) }
+  end
+end

data/lib/lux/cell/cell.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+# Cells can be called in few ways
+# Cell.call path
+# Cell.action action_name, path
+# Cell.new.action_name *args
+
+class Lux::Cell
+  # define maser layout
+  # string is template, symbol is metod pointer and lambda is lambda
+  ClassAttributes.define self, :layout
+
+  # define helper contest, by defult derived from class name
+  ClassAttributes.define self, :helper
+
+  # before and after any action filter, ignored in cells, after is called just before render
+  BeforeAndAfter.define self, :before, :before_action, :before_render, :after
+
+  class << self
+    # class call method, should not be overridden
+    def call
+      Lux.page.files_in_use.push "app/cells/#{self.to_s.underscore}.rb"
+
+      cell = new
+      cell.filter :before
+      cell.call
+
+      return if Lux.page.body
+
+      # we want to exec filter after the call
+      cell.filter :before_action
+    end
+
+    # create mock function, to enable template rendering
+    # mock :index, :login
+    def mock *args
+      for el in args
+        # class_eval %[def #{el}(*args); true; end]
+        define_method el do
+          true
+        end
+      end
+    end
+
+    # simple shortcut allows direct call to action, bypasing call
+    def action name, object=nil
+      object.present? ? new.action(name, object) : new.action(name)
+    end
+
+    # for use in helpers, mostly
+    # renders only cell without layout
+    # = cell :tag_list, object
+    def cell name, *args
+      c = new
+      c.instance_variable_set '@cell_action', name
+      c.instance_variable_set '@no_render', true
+      c.send name, *args
+      c.render_part
+    end
+  end
+
+  ### INSTANCE METHODS
+
+  def initialize
+    # before and after should be exected only once
+    @executed_filters = {}
+    @base_template = self.class.to_s.index('::') ? self.class.to_s.sub(/Cell$/,'').underscore : self.class.to_s.sub(/Cell$/,'').downcase
+  end
+
+  # default call method, should be overitten
+  # expects arguments as flat array
+  # usually called by router
+  def call
+    action(:index)
+  end
+
+  def filter fiter_name
+    return if @executed_filters[fiter_name]
+    @executed_filters[fiter_name] = true
+
+    BeforeAndAfter.execute(self, fiter_name)
+  end
+
+  # action(:show, 2)
+  # action(:select', ['users'])
+  def action method_name, *args
+    raise ArgumentError.new('Cell action called with blank action name argument') if method_name.blank?
+
+    # maybe before filter rendered page
+    return if Lux.page.body
+
+    method_name = method_name.to_s.gsub('-', '_').gsub(/[^\w]/, '')
+
+    Lux.log " #{self.class.to_s}(:#{method_name})".blue
+    Lux.page.files_in_use.push "app/cells/#{self.class.to_s.underscore}.rb"
+
+    @cell_action = method_name
+
+    unless respond_to? method_name
+      raise NotFoundError.new('Method %s not found' % method_name) unless Lux.verbose?
+
+      list = methods - Lux::Cell.instance_methods
+      err = [%[No instance method "#{method_name}" found in class "#{self.class.to_s}"]]
+      err.push ["Expected so see def show(id) ..."] if method_name == 'show!'
+      err.push %[You have defined \n- #{(list).join("\n- ")}]
+      return Lux.error(err.join("\n\n"))
+    end
+
+    filter :before
+    return if Lux.page.body
+
+    filter :before_action
+    return if Lux.page.body
+
+    send method_name, *args
+    filter :after
+
+    return if Lux.page.body
+    render
+  end
+
+  # render :show, id
+  # render :index
+  # render 'main/root/index'
+  # render :profile,  name:'Dux'
+  # render text: 'ok'
+  def render name=nil, opts={}
+    return if Lux.page.body
+    return if @no_render
+
+    filter :before_render
+
+    if name.is_hash?
+      opts = name
+      name = nil
+    end
+
+    opts[:template] = name if name
+
+    # etag and cache string are same things, one is client based, other one is server based
+    if opts[:cache]
+      opts[:cache] = Lux.cache.generate_key(opts[:cache] )
+      opts[:etag] ||= opts[:cache]
+    end
+
+    return if opts[:etag] && Lux.page.etag(opts[:etag])
+
+    if opts[:cache]
+      data = Lux.cache.get(opts[:cache])
+      return Lux.page.body(data) if data
+    end
+
+    render_resolve_body(opts)
+    Lux.cache.set(opts[:cache], Lux.page.body) if opts[:cache]
+  end
+
+  # renders template to string
+  def render_part
+    Lux::Template.render_part("#{@base_template}/#{@cell_action}", instance_variables_hash, namespace)
+  end
+
+  def render_to_string name=nil, opts={}
+    opts[:set_page_body] = false
+    render name, opts
+  end
+
+  def send_file
+
+  end
+
+  private
+    # called be render
+    def render_resolve_body opts
+      # resolve basic types
+      if opts[:text]
+        Lux.page.content_type = 'text/plain'
+        return Lux.page.body(opts[:text])
+      elsif opts[:html]
+        Lux.page.content_type = 'text/html'
+        return Lux.page.body(opts[:html])
+      elsif opts[:json]
+        Lux.page.content_type = 'application/json'
+        return Lux.page.body(opts[:json])
+      end
+
+      ivh = instance_variables_hash
+
+      # resolve page data, without template
+      page_data = opts[:data] || Proc.new do
+        if template = opts.delete(:template)
+          template = template.to_s
+          template = "#{@base_template}/#{template}" unless template.starts_with?('/')
+        else
+          template = "#{@base_template}/#{@cell_action}"
+        end
+
+        Lux::Template.render_part(template, ivh, self.class.helper)
+      end.call
+
+      # resolve data with layout
+      layout = opts.delete(:layout)
+      layout = nil if layout.class == TrueClass
+      layout = false if @layout.class == FalseClass
+      if layout.class != FalseClass
+        layout_define = self.class.layout
+        layout = case layout_define
+          when String
+            layout = layout_define
+          when Symbol
+            send(layout_define)
+          when Proc
+            layout_define.call
+          else
+            "#{@base_template.split('/')[0]}/layout"
+        end
+
+        page_data = Lux::Template.new(layout, instance_variables_hash, self.class.helper).render_part do
+          page_data
+        end
+      end
+
+      Lux.page.body(page_data) unless opts[:set_page_body].is_false?
+      page_data
+    end
+
+    # helper functions
+    def page
+      Lux.page
+    end
+
+    def params
+      Lux.page.params
+    end
+
+    def nav
+      Lux.page.nav
+    end
+
+    def request
+      Lux.page.request
+    end
+
+    def redirect where, flash={}
+      Lux.page.redirect where, flash
+    end
+
+    def session
+      Lux.page.session
+    end
+
+    def namespace
+      @base_template.split('/')[0].to_sym
+    end
+
+    def helper(ns=nil)
+      Lux::Helper.for(ns || namespace)
+    end
+
+end
+

data/lib/lux/config/config.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# $LOADED_FEATURES.select{ |f| f.index('/app/') || f.index('/lux/') }
+
+module Lux::Config
+  extend self
+
+  LIVE_RELOAD ||= {}
+
+  # if we have errors in module loading, try to load them one more time
+  @module_error = []
+
+  # requires all files recrusive in, with spart sort
+  def require_all(files)
+    files = files.to_s
+    files += '/*' unless files.include?('*')
+
+    file_errors = []
+    glob = `echo #{files} #{files}/* #{files}/*/*  #{files}/*/*/* #{files}/*/*/*/* |tr ' ' '\n' | grep .rb`.split("\n")
+    glob.reject! { |file| file =~ /_\d+\.rb$/ }
+
+    glob.select{ |o| o.index('.rb') }.map{ |o| o.split('.rb')[0]}.each do |ruby_file|
+      require ruby_file rescue file_errors.push(ruby_file)
+    end
+
+    file_errors.each { |klass|
+      @klass = klass
+       require klass
+     }
+  rescue
+    puts "* double load error: require_all #{files}\n  #{@klass}.rb\n  #{$!.message}".red
+    raise $!
+  end
+
+  # load specific plugin
+  def plugin(name)
+    files = Dir['%s/lib/plugins/%s/*.rb' % [Lux.fw_root, name]]
+    die('Plugin "%s" load error, no plugin' % name) if files.length == 0
+    for file in files
+      require file
+    end
+    # Lux.log "* plugin :#{name}"
+  end
+
+  # preview config in development
+  def show_config
+    for k,v in Lux.config
+      next if v.kind_of?(Hash)
+      puts "* config :#{k} = #{v.kind_of?(Hash) ? '{...}' : v}"
+    end
+  end
+
+  # check all files and reload if needed
+  def live_require_check!
+    if LIVE_RELOAD.blank?
+      root = Lux.root.to_s
+      for file in $LOADED_FEATURES.select{ |f| f.index(root) || f.index('/lux/') }
+        LIVE_RELOAD[file] = File.mtime(file).to_i
+      end
+    end
+
+    for file, mtime in LIVE_RELOAD
+      new_file_mtime = File.mtime(file).to_i
+
+      next if mtime == new_file_mtime
+      LIVE_RELOAD[file] = new_file_mtime
+      Lux.log " Reloaded: .#{file.split(Lux.root.to_s).last.red}"
+      load file
+    end
+    true
+  end
+
+  def show_load_speed(load_start)
+    speed = ((Time.now - load_start)*1000).round.to_s.sub(/(\d)(\d{3})$/,'\1s \2')+'ms'
+    ram   = `ps -o rss -p #{$$}`.chomp.split("\n").last.to_i / 1000
+    opts  = []
+    opts.push Lux.verbose? ? 'verbose'.yellow : 'non-verbose'.green
+    opts.push Lux.config(:auto_code_reload) ? 'code-reload'.yellow : 'no-code-reload'.green
+
+    "* #{'Lux'.blue} loaded #{Lux.env('RACK_ENV').green} (#{opts.join(', ')}) mode in #{speed.to_s.white}, uses #{ram.to_s.white} MB RAM with total of #{Gem.loaded_specs.keys.length.to_s.white} gems in spec"
+  end
+end
+
+class Object
+  def reload!
+    Lux::Config.live_require_check!
+  end
+end

data/lib/lux/controller/controller.rb

@@ -0,0 +1,185 @@
+class Lux::Controller
+
+  LUX_PRINT_ROUTES = !!ENV['LUX_PRINT_ROUTES'] unless defined?(LUX_PRINT_ROUTES)
+
+  # define common http methods as constants
+  [:get, :head, :post, :delete, :put, :patch].map(&:to_s).map(&:upcase).each { |m| eval "#{m} ||= '#{m}'" }
+
+  # rescue from errors
+  Lux::RescueFrom.define(self)
+
+  # this is needed for Rescuce actions to work without Lux prefix
+  define_singleton_method(:page) { Lux.page }
+
+  ###
+
+  def debug
+    { :@locale=>@locale, :@nav=>nav, :@subdomain=>@subdomain, :@domain=>@domain }
+  end
+
+  def body?
+    Lux.page.body ? true : false
+  end
+
+  def body data
+    Lux.page.body(data)
+  end
+
+  def page
+    Lux.page
+  end
+
+  def nav
+    Lux.page.nav
+  end
+
+  def params
+    Lux.page.params
+  end
+
+  def redirect where, msgs={}
+    Lux.page.redirect where, msgs
+  end
+
+  def request
+    Lux.page.request
+  end
+
+  # gets only root
+  def root opts
+    if LUX_PRINT_ROUTES
+      @route_target = opts
+      print_route
+    end
+
+    call opts unless nav.root
+  end
+
+  ### plug and default prepares
+
+  def plug(name, &block)
+    return if body?
+    m = "#{name}_plug".to_sym
+    return Lux.error(%[Method "#{m}" not defined in Lux::Controller]) unless respond_to?(m)
+    send(m, &block)
+  end
+
+  def rescued_main
+    if respond_to?(:main)
+      @@rescue_from_ivar.call { main }
+    else
+      Lux.error %[No instance method "main" in Lux::Controller defiend]
+    end
+  end
+
+  def print_route
+    route = case @route
+      when Regexp
+        @route.to_s.ljust(20).red
+      when Symbol
+        ('/%s' % @route).ljust(20).green
+      when nil
+        '/'.ljust(20).green
+      else
+        @route.to_s.ljust(20).blue
+    end
+
+    route_target = case @route_target
+      when Symbol
+        ':%s' % @route_target
+      when Array
+        action = @route_target[1] == 'print-routes' ? @route : @route_target[1]
+        '%s.action("%s")' % [@route_target[0], action]
+      else
+        @route_target
+    end
+
+    puts '%s => %s (%s)' % [route, route_target.to_s.ljust(40), @route.class]
+  end
+
+  def route route_object
+    return if body?
+
+    if route_object.class == Hash
+      @route  = route_object.keys.first
+      @route_target = route_object.values.first
+    else
+      @route  = route_object
+    end
+
+    print_route if LUX_PRINT_ROUTES
+
+    return unless if @route.is_a?(String)
+      page.nav.to_s.start_with?(@route)
+    elsif @route.is_a?(Regexp)
+      page.nav.to_s =~ @route
+    else
+      nav.root == @route.to_s
+    end
+
+    @route_object = route_object
+
+    case @route_target
+      when Proc
+        @route_target.call
+      when Array
+         call @route_target[0], @route_target[1]
+      else
+        call @route_target
+    end
+  end
+  alias :match :route
+
+  def get object
+    return unless get?
+    route object
+  end
+
+  def post object
+    return unless post?
+    route object
+  end
+
+  def get?
+    Lux.page.request.request_method == 'GET'
+  end
+
+  def post?
+    Lux.page.request.request_method == 'POST'
+  end
+
+  # call :api_router
+  # call Main::UsersCell
+  # call Main::UsersCell, :index
+  # call 'main/orgs#show'
+  def call object=nil, action=nil
+    return true if body?
+
+    case object
+      when Symbol
+        return send(object)
+      when String
+        if object.include?('#')
+          object = object.split('#')
+          object[0] = ('%s_cell' % object[0]).classify.constantize
+        else
+          object = ('%s_cell' % object).classify.constantize
+        end
+    end
+
+    object, action = object if object.is_a? Array
+
+    Lux.log ' %s %s # %s' % [object.to_s.blue, nav.path, @route_object]
+
+    if action
+      object.action action
+    else
+      object.call
+    end
+
+    Lux.error 'Lux cell "%s" called via route "%s" but page body is not set' % [object, @route] unless body?
+
+    true
+  end
+
+end

data/lib/lux/controller/lib/nav.rb

@@ -0,0 +1,77 @@
+# experiment for different nav in rooter
+
+class Lux::Controller::Nav
+
+  attr_reader :root, :path, :id, :full, :locale, :subdomain, :domain
+
+  # acepts path as a string
+  def initialize request
+    @path = request.path.split('/').slice(1, 100) || []
+    @root = @path.shift if @path.first
+
+    @subdomain = request.host.split('.')
+    @domain    = @subdomain.pop(2).join('.')
+    @domain    += ".#{@subdomain.pop}" if @domain.length < 6
+
+    build_full
+  end
+
+  def build_full
+    @full = '/%s/%s' % [@root, @path.join('/')]
+  end
+
+  def shift_to_root
+    @root.tap do
+      @root = @path.shift
+      build_full
+    end
+  end
+
+  # used to make admin.lvm.me/users to lvh.me/admin/users
+  def unshift name
+    @path.unshift @root
+    @root = name
+    build_full
+  end
+
+  def parse_locale
+    return false unless Locale.all.include?(@root)
+    Locale.current = shift_to_root
+    true
+  end
+
+  def shift
+    @path.shift
+  end
+
+  def first
+    @path.first
+  end
+
+  def second
+    @path[1]
+  end
+
+  def last
+    @path.last
+  end
+
+  def rest
+    @path.slice(1, @path.length-1)
+  end
+
+  def to_s
+    @full
+  end
+
+  # if sets @id to whatever function returns
+  # page.nav.id! { |id| StringBase.extract id }
+  def id! &block
+    @block = block if block
+
+    return unless first
+    @id = @block.call first
+    shift if @id
+    @id
+  end
+end

data/lib/lux/controller/lib/plugs.rb

@@ -0,0 +1,10 @@
+class Lux::Controller
+
+  def lux_static_files_plug
+    file = Lux::Page::StaticFile.new(Lux.page.request.path)
+    return false unless file.is_static_file?
+    file.read
+    true
+  end
+
+end

data/lib/lux/delayed_job/delayed_job.rb

@@ -0,0 +1,44 @@
+module Lux::DelayedJob
+  extend self
+
+  @@server = nil
+
+  def server=(name)
+    adapter = "Lux::DelayedJob::#{name.to_s.capitalize}"
+    @@server = adapter.constantize
+  rescue NameError
+    die('No adapter %s not found' % adapter)
+  end
+
+  def push(object, method_to_call=nil)
+    die "No DelayedJob server defined" unless @@server
+    @@server.push [object, method_to_call]
+  end
+
+  def pop
+    obj, method_to_call = @@server.pop
+    return unless obj
+    puts "JOB POP> #{obj.to_s}.#{method_to_call}".yellow
+    if method_to_call
+      begin
+        obj.send(method_to_call)
+      rescue
+        puts("Lux::DelayedJob.pop FAIL for :#{method_to_call} (#{$!.message})".red)
+      end
+    else
+      eval(obj)
+    end
+    true
+  end
+
+  def run!(seconds=2)
+    puts "JOB QUE> is running for #{@@server}".green
+    Thread.new do
+      while true
+        print '.'
+        true while Lux::DelayedJob.pop
+        sleep seconds
+      end
+    end.join
+  end
+end

data/lib/lux/delayed_job/lib/memory.rb

@@ -0,0 +1,14 @@
+module Lux::DelayedJob::Memory
+  extend self
+
+  @@JOBS = []
+
+  def push(data)
+    @@JOBS.push data
+    Thread.new { true while Lux::DelayedJob.pop }
+  end
+
+  def pop
+    @@JOBS.shift
+  end
+end