lux-fw 0.1.17

data/lib/lux/rescue_from/rescue_from.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# rescue from errors
+#
+# in some class
+# Lux::RescueFrom.define(self) -> defines rescue_from method in class
+#
+# to add
+# rescue_from(UnauthorizedError) { ... }
+#
+# and to resolve in the end
+# @@rescue_from_ivar.call { main }
+
+class Lux::RescueFrom
+
+  class << self
+    def define(klass)
+      ClassAttributes.define klass, :rescue_from_hash
+
+      klass.class_eval %[
+        @@rescue_from_ivar = Lux::RescueFrom.new
+        def self.rescue_from(name, &block)
+          @@rescue_from_ivar.add(name, &block)
+        end
+      ]
+    end
+  end
+
+  ###
+
+  def initialize
+    @rescues = {}
+  end
+
+  def add(name, &block)
+    die ":#{name} is not allowed rescue name, only allowed are :default and :allways" if name.is_symbol? && ![:default, :allways].index(name)
+    @rescues[name.to_s] = block
+  end
+
+  def call
+    begin
+      yield
+    rescue Exception => e
+      raise e unless Lux.page
+
+      return if Lux.page.body && Lux.page.status
+
+      if proc = @rescues[e.class.to_s]
+        proc.call(e.message)
+      elsif @rescues['default'] # catch them all
+        @rescues['default'].call(e.message)
+      else
+        raise e
+      end
+
+      @rescues['allways'].call(e.message) if @rescues['allways']
+
+      Lux.page.status e.class
+    end
+  end
+end

data/lib/lux/template/template.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Lux::Template
+  @@template_cache = {}
+
+  class << self
+    def render_with_layout template, opts={}, helper=nil
+      new(template, opts, helper).render_with_layout
+    end
+
+    def render_part template, opts={}, helper=nil
+      new(template, opts, helper).render_part
+    end
+  end
+
+  def initialize template, opts={}, helper=nil
+    template = template.sub(/^[^\w]+/, '')
+    @original_template = template
+    @opts   = opts
+    @helper = helper
+
+    mutex = Mutex.new
+
+    if Lux.config(:auto_code_reload) && !Lux.thread[:template_cache]
+      Lux.thread[: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 ['haml', 'erb']
+        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")
+      Lux.error %[Lux::Template "#{template}.{erb,haml}" not found\n\n#{err}]
+      raise
+    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
+    base_class = @helper ? @helper.to_s : @template.split('/')[3]
+    base_class = nil if base_class.index('.')
+    base_class ||= Module.new
+
+    # global thread safe reference pointer to last temaplte rendered
+    # we nned this for inline template render
+    Lux.thread[:last_template_path] = @template.sub('/app/views','').sub(/\/[^\/]+$/,'').sub(/^\./,'')
+
+    Lux.page.files_in_use.push @template
+
+    helper = Lux::Helper.for(base_class, @opts)
+    data = nil
+    speed = Lux.speed do
+      data = Lux::Error.try %[Lux::Template "#{@template}" render error] do
+        @tilt.render(helper) do
+          yield if block_given?
+        end
+      end
+    end
+
+    Lux.log " #{@template.split('app/views/').last}, #{speed}"
+
+    data
+  end
+
+  def render_with_layout
+    @part_data = render_part
+    layout_path = "#{@original_template.split('/')[0]}/layout"
+    Lux::Template.new(layout_path, @opts).render_part do
+      @part_data
+    end
+  end
+
+end
+
+

data/lib/lux-fw.rb

@@ -0,0 +1,48 @@
+# Gem.loaded_specs['lux-fw'].runtime_dependencies.each do |dep|
+#   require case dep.name
+#     when 'sequel_pg';    'sequel'
+#     when 'hamlit-block'; 'hamlit/block'
+#     else dep.name
+#   end
+# end
+
+require 'awesome_print'
+require 'as-duration'
+require 'colorize'
+require 'jwt'
+require 'fast_blank'
+require 'hamlit'
+require 'hamlit/block'
+require 'hashie'
+require 'rack'
+require 'sequel'
+
+require_relative './overload/object'
+
+die 'Lux error: RACK_ENV is not defined' unless ENV['RACK_ENV']
+die "Unsupported RACK_ENV [#{ENV['RACK_ENV']}]" unless ['production', 'development', 'test'].index(ENV['RACK_ENV'])
+
+Encoding.default_internal = Encoding.default_external = 'utf-8'
+
+Sequel.extension :inflector, :string_date_time
+Sequel::Model.plugin :after_initialize, :def_dataset_method
+Sequel.database_timezone = :utc
+
+# load basic lux libs
+require_relative './lux/lux'
+
+# load all lux libs
+[:overload, :common, :vendor, :lux].each do |f|
+  Lux::Config.require_all Lux.fw_root.join('./lib/%s' % f)
+end
+
+# load Tilt parsers
+Tilt.register Tilt::ERBTemplate,  'erb'
+Tilt.register Hamlit::Block::Template, 'haml'
+
+# ensure we are not loading lux in lux folder
+if Lux.root != Lux.fw_root
+  # create folders if needed
+  ['./log', './tmp'].each { |d| `mkdir #{d}` unless Dir.exist?(d) }
+end
+

data/lib/overload/array.rb

@@ -0,0 +1,52 @@
+class Array
+
+  def to_csv
+    ret = []
+    for row in self
+    	add = []
+    	for el in row
+    		add << '"'+el.to_s.gsub(/\s+/,' ').gsub(/"/,"''")+'"'
+	    end
+	    ret.push(add.join(';'))
+    end
+    ret.join("\n")
+  end
+
+  def wrap(name, opts={})
+    map{ |el| opts.tag(name, opts) }
+  end
+
+  def last=(what)
+    self[self.length-1] = what
+  end
+
+  def to_sentence(opts={})
+    opts[:words_connector]     ||= ', '
+    opts[:two_words_connector] ||= ' and '
+    opts[:last_word_connector] ||= ', and '
+
+    len = self.length
+
+    return '' if len == 0
+    return self[0] if len == 1
+    return self.join(opts[:two_words_connector]) if len == 2
+
+    last_word = self.pop
+
+    self.join(opts[:words_connector]) + opts[:last_word_connector] + last_word
+  end
+
+  # toggle element in array and return true when added
+  def toggle(element)
+    self.uniq!
+    self.compact!
+    if self.include?(element)
+      self.delete(element)
+      false
+    else
+      self.push(element)
+      true
+    end
+  end
+
+end

data/lib/overload/blank.rb

@@ -0,0 +1,62 @@
+# partialy extracted from
+# https://github.com/rails/rails/blob/5-0-stable/activesupport/lib/active_support/core_ext/object/blank.rb
+
+class Object
+  def blank?
+    !self
+  end
+
+  def empty?
+    blank?
+  end
+
+  def present?
+    !blank?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  def blank?
+    self.length == 0
+  end
+end
+
+class Hash
+  def blank?
+    self.keys.length == 0
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end
+
+class Time
+  def blank?
+    false
+  end
+end
+
+class String
+  # gem 'fast_blank'
+end

data/lib/overload/date.rb

@@ -0,0 +1,58 @@
+module TimeOptions
+  def short
+    strftime("%Y-%m-%d")
+  end
+
+  def long
+    strftime("%Y-%m-%d %H:%M")
+  end
+end
+
+class Time
+  include TimeOptions
+
+  class << self
+
+    # humanize_seconds(61)   -> 1min 1sec
+    # humanize_seconds(1111) -> 18min 31sec
+    def humanize_seconds(secs)
+      return '-' unless secs
+      secs = secs.to_i
+      [[60, :sec], [60, :min], [24, :hrs], [356, :days], [1000, :years]].map{ |count, name|
+        if secs > 0
+          secs, n = secs.divmod(count)
+          "#{n.to_i}#{name}"
+        end
+      }.compact.reverse.slice(0,2).join(' ')
+    end
+
+    def ago(start_time, end_time=nil)
+      end_time ||= Time.now
+      time_diff = end_time.to_i - start_time.to_i
+
+      in_past = time_diff > 0 ? true : false
+      time_diff = time_diff.abs
+
+      d_minutes = (time_diff / 60).round rescue 0
+      d_hours   = (time_diff / (60 * 60)).round rescue 0
+      d_days    = (time_diff / (60*60 * 24)).round rescue 0
+      d_months  = (time_diff / (60*60*24 * 30)).round rescue 0
+      d_years   = (time_diff / (60*60*24*30 * 12)).round rescue 0
+
+      return (in_past ? 'few sec ago' : 'in few seconds') if time_diff < 10
+      return (in_past ? 'less than min ago' : 'in less then a minute') if time_diff < 60
+
+      template = in_past ? '%s ago' : 'in %s'
+
+      return template % d_minutes.pluralize('min') if d_minutes < 60
+      return template % d_hours.pluralize('hour') if d_hours < 24
+      return template % d_days.pluralize('day') if d_days < 31
+      return template % d_months.pluralize('month') if d_months < 12
+      return template % d_years.pluralize('year')
+    end
+  end
+end
+
+class DateTime
+  include TimeOptions
+end

data/lib/overload/file.rb

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

data/lib/overload/hash.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+class Hash
+  def h
+    Hashie::Mash.new(self)
+  end
+
+  def h_wia
+    HashWithIndifferentAccess.new(self)
+  end
+
+	def tag node=nil, text=nil
+		opts = ''
+		self.each do |k,v|
+      opts += ' '+k.to_s.gsub(/_/,'-')+'="'+v.to_s.gsub(/"/,'"')+'"' if v.present?
+    end
+
+    return opts unless node
+
+    text = yield opts if block_given?
+    text ||= '' unless ['input', 'img', 'meta', 'link', 'hr', 'br'].include?(node.to_s)
+    text ? %{<#{node}#{opts}>#{text}</#{node}>} : %{<#{node}#{opts} />}
+	end
+
+  def to_struct name=nil
+    name ||= ToStructGeneric
+    Struct.new(name, *keys).new(*values)
+  end
+
+  def blank?
+    self.keys.count == 0
+  end
+
+  def to_query namespace=nil
+    self.keys.sort.map { |k|
+      name = namespace ? "#{namespace}[#{k}]" : k
+      "#{name}=#{CGI::escape(self[k].to_s)}"
+    }.join('&')
+  end
+
+  def pluck *args
+    string_args = args.map(&:to_s)
+    self.select{ |k,v| string_args.index(k.to_s) }
+  end
+
+  def transform_keys
+    return enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  def transform_keys!
+    return enum_for(:transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+
+  def slice *keys
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  def slice! *keys
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
+end
+