lux-fw 0.5.36 → 0.6.2

data/lib/overload/string.rb

@@ -1,22 +1,53 @@
 class String
   def constantize
-    Object.const_get('::'+self)
+    Object.const_get('::' + self)
+  end
+
+  # 'User'.constantize? # User
+  # 'UserFoo'.constantize? # nil
+  def constantize?
+    Object.const_defined?('::' + self) ? constantize : nil
+  end
+
+  # prepare data for storage write, to make it safe to dump on screen without unescape
+  def html_escape display = false
+    # .gsub('<', '&lt;').gsub('>', '&gt;')
+    # .gsub("'", '&#39').gsub('"', '&#34')
+    self
+      .gsub('<', display ? '&lt;' : '#LT;')
+      .gsub(/\A^\s+|\s+\z/,'')
+  end
+
+  # restore original before storage read
+  def html_unsafe full = false
+    if full
+      self
+        .gsub('#LT;', '<')
+        .gsub('$LT;', '<')
+        .gsub('&lt;', '<')
+        .gsub('&gt;', '>')
+        .gsub('&#39', "'")
+        .gsub('&#34', '"')
+    else
+      self.gsub('#LT;', '<')
+    end
   end
 
-  # simple markdown
-  def as_html
-    self.gsub($/, '<br />')
+  # export html without scripts and styles
+  def html_safe full = false
+    html_unsafe(full)
+      .gsub(/<(\/?script)/i,'&lt;\1')
+      .gsub(/<(\/?style)/i,'&lt;\1')
   end
 
-  # convert escaped strings, remove scritpts
-  def to_html opts={}
-    value = self.gsub(/&lt;/, '<').gsub(/&gt;/, '>').gsub(/&amp;/,'&')
-    value = value.gsub(/<script/,'&lt;script') unless opts[:script]
-    value = value.gsub(/<link/,'&lt;link') unless opts[:link]
-    value
+  # simple markdown
+  def as_html
+    self
+      .gsub($/, '<br />')
+      .gsub(/(https?:\/\/[^\s<]+)/) { %[<a href="#{$1}">#{$1.trim(40)}</a>] }
   end
 
-  def trim(len)
+  def trim len
     return self if self.length<len
     data = self.dup[0,len]+'&hellip;'
     data
@@ -26,10 +57,24 @@ class String
     self[0,1]
   end
 
+  def last num = 1
+    len = self.length
+    self[len-num, len]
+  end
+
+  # https://github.com/rgrove/sanitize
   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 quick_sanitize
+    out = self.gsub('<!--{tag}-->', '')
+    out = out.gsub(/\sstyle="([^"]+)"/) do
+      $1.start_with?('text-align:') ? $1 : ''
+    end
+    out
+  end
+
   def wrap node_name, opts={}
     return self unless node_name
     opts.tag(node_name, self)
@@ -39,23 +84,24 @@ class String
     self.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '?')
   end
 
-  def parse_erb
-    self.gsub(/<%=([^%]+)%>/) { eval $1; }
+  def parse_erb scope = nil
+    ERB.new(self).result(scope || binding)
   end
 
   def parameterize
-    self.downcase.gsub(/[^\w]+/,'-')
-  end
-
-  def to_url
     str_from = 'šđč枊ĐČĆŽäÄéeöÖüüÜß'
     str_to   = 'sdcczSDCCZaAeeoOuuUs'
-    str      = self.downcase.gsub(/\s+/,'-').tr(str_from, str_to)
-    # self.downcase.gsub(/\s+/,'-').tr(str_from, str_to).gsub(/[^\w\-]/,'')
-    str.sub(/\.$/, '').gsub('&',' and ').gsub('.',' dot ').parameterize.gsub('-dot-','.').downcase[0, 50].sub(/[\.\-]$/,'')
+
+    self
+      .tr(str_from, str_to)
+      .sub(/^[^\w+]/, '')
+      .sub(/[^\w+]$/, '')
+      .downcase
+      .gsub(/[^\w+]+/,'-')[0, 50]
   end
+  alias :to_url :parameterize
 
-  def css_to_hash
+  def qs_to_hash
     self.split('&').inject({}) do |h,line|
       el = line.split('=', 2)
       h[el[0]] = el[1]
@@ -67,17 +113,21 @@ class String
     self.split(/\s*,\s*/)
   end
 
+  def attribute_safe
+    self.gsub('"', '').gsub("'", '')
+  end
+
+  def db_safe
+    self.gsub(/[^0-9a-zA-Z_]/, '')
+  end
+
   def starts_with? prefix
     prefix.respond_to?(:to_str) && self[0, prefix.length] == prefix
   end
 
   def ends_with? suffix
+    return true if suffix == self
     suffix.is_a?(String) && self[-suffix.length, suffix.length] == suffix && self != suffix
-   end
-
-  def last(num=1)
-    len = self.length
-    self[len-num, len]
   end
 
   def span_green
@@ -94,10 +144,33 @@ class String
   end
 
   def escape
-    CGI::escape self
+    CGI::escape(self).gsub('+', '%20')
   end
 
   def unescape
     CGI::unescape self
   end
+
+  def sha1
+    Digest::SHA1.hexdigest self
+  end
+
+  def md5
+    Digest::MD5.hexdigest self
+  end
+
+  def extract_scripts! list: false
+    scripts = []
+    self.gsub!(/<script\b[^>]*>(.*?)<\/script>/im) { scripts.push $1; '' }
+    list ? scripts : scripts.map{ "<script>#{_1}</script>"}.join($/)
+  end
+
+  def to_slug len = 80
+    self.downcase.gsub(/[^\w]+/, '_').gsub(/_+/, '-').sub(/\-$/, '')[0, len]
+  end
+
+  def remove_tags
+    self.gsub(/<[^>]+>/, '')
+  end
+
 end

data/lib/overload/thread_simple.rb

@@ -0,0 +1,100 @@
+# https://gist.github.com/dux/466507a5e86cadd2c4714381a1f06cf4
+
+class Thread::Simple
+  # Thread::Simple.run do |t|
+  #   for foo in bar
+  #     t.add { ... }
+  #   end
+  # end
+  def self.run **args
+    ts = new
+    yield ts
+    ts.run
+  end
+
+  ###
+
+  attr_accessor :que, :size, :named
+
+  def initialize size: 5, sleep: 0.05
+    @sync     = Mutex.new
+    @sleep    = sleep
+    @size     = size
+    @que      = []
+    @threds   = []
+    @name_val = {}
+  end
+
+  def add name = nil, &block
+    @sync.synchronize do
+      if name
+        @que << proc { @name_val[name] = block.call }
+      else
+        @que << block
+      end
+    end
+  end
+
+  def run endless: false
+    @endless = endless
+
+    @size.times do
+      @threds << Thread.new do
+        task = nil
+
+        while active?
+          @sync.synchronize { task = @que.pop }
+          task.call if task
+          sleep @sleep
+        end
+      end
+    end
+
+    unless @endless
+      @threds.each(&:join)
+    end
+  end
+
+  def stop
+    @endless = false
+  end
+
+  def [] name
+    @name_val[name]
+  end
+
+  private
+
+  def active?
+    @endless || @que.first
+  end
+end
+
+###
+
+# pool = Thread::Simple.new
+
+# 1.upto(20) do |i|
+#   pool.add i do
+#     print '.'
+#     time = rand
+#     sleep time
+#     'Integer: %s (%s - %s)' % [i, pool.que.size, time]
+#   end
+# end
+
+# Thread.new do
+#   sleep 5
+#   pool.stop
+# end
+
+# pool.run endless: true
+
+# puts
+
+# for key in pool.named.keys.sort
+#   puts '%s -> %s' % [key, pool.named[key]]
+# end
+
+# puts
+# puts pool[10]

data/lib/overload/time.rb

@@ -1,10 +1,30 @@
 module TimeOptions
-  def short
-    strftime("%Y-%m-%d")
+  def short use_default = false
+    # lang = Lux.current.request.env['HTTP_ACCEPT_LANGUAGE'] rescue 'en'
+    default_format = '%Y-%m-%d'
+    date_format    = Lux.current.var[:date_format].or(Lux.config[:date_format] || default_format)
+    date_format    = default_format if use_default
+    date_format    = date_format.sub('yyyy', '%Y').sub('mm', '%m').sub('dd', '%d')
+
+    current.strftime date_format
+  end
+
+  def long use_default=false
+    current.strftime("#{short(use_default)} %H:%M")
   end
 
-  def long
-    strftime("%Y-%m-%d %H:%M")
+  def current
+    if respond_to?(:utc) && time_zone = Lux.current.var[:time_zone]
+      begin
+        tz = TZInfo::Timezone.get(time_zone)
+        tz.utc_to_local utc
+      rescue TZInfo::InvalidTimezoneIdentifier => e
+        Lux.logger(:time_zone).error '%s (%s)' % [e.message, time_zone]
+        self
+      end
+    else
+      self
+    end
   end
 end
 
@@ -12,44 +32,39 @@ class Time
   include TimeOptions
 
   class << self
-    # humanize_seconds(61)   -> 1min 1sec
-    # humanize_seconds(1111) -> 18min 31sec
-    def humanize_seconds secs
+    # prints proc speed of execution
+    # it will print first execution separate from the rest, used in cache testing
+    def speed num = 1
+      start = Time.now
+      yield
+      total = Time.now - start
+      puts 'Speed: %s sec for 1st run' % total.round(3)
+      if num > 1
+        start = Time.now
+        (num - 1).times { yield }
+        total = Time.now - start
+        puts 'Other %s runs speed: %s sec, avg -> %s' % [num, total.round(3), (total/num).round(3)]
+      end
+    end
+
+    # Precise ago
+    # Time.agop(61)   -> 1min 1sec
+    # Time.agop(1111) -> 18min 31sec
+    def agop secs, desc = nil
       return '-' unless secs
-      secs = secs.to_i
-      [[60, :sec], [60, :min], [24, :hrs], [356, :days], [1000, :years]].map{ |count, name|
+
+      [[60, :sec], [60, :min], [24, :hrs], [356, :days], [1000, :years]].map do |count, name|
         if secs > 0
           secs, n = secs.divmod(count)
           "#{n.to_i}#{name}"
         end
-      }.compact.reverse.slice(0,2).join(' ')
+      end.compact.reverse.slice(0,2).join(' ')
     end
 
-    def ago start_time, end_time=nil
-      start_time = Time.new(start_time.year, start_time.month, start_time.day) if start_time.class == Date
-
-      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')
+    # How long ago?
+    def ago start_time, end_time = nil
+      start = Time.parse start_time.to_s if [String, Date].include?(start_time.class)
+      TimeDifference.new(start || start_time, end_time, start_time.class).humanize
     end
 
     def monotonic
@@ -59,7 +74,7 @@ class Time
     # Generates a Time object from the given value.
     # Used by #expires and #last_modified.
     # extracted from Sinatra
-    def for(value)
+    def for value
       if value.is_a? Numeric
         Time.at value
       elsif value.respond_to? :to_s
@@ -67,8 +82,6 @@ class Time
       else
         value.to_time
       end
-    rescue ArgumentError => boom
-      raise boom
     rescue Exception
       raise ArgumentError, "unable to convert #{value.inspect} to a Time object"
     end
@@ -78,3 +91,12 @@ end
 class DateTime
   include TimeOptions
 end
+
+class Date
+  include TimeOptions
+
+  def to_i
+    Time.parse(to_s).to_i
+  end
+end
+

data/tasks/loader.rb

@@ -1,10 +1,17 @@
+require 'whirly'
+
+def invoke task, *args
+  puts task.light_black
+  Rake::Task[task].invoke(*args)
+end
+
 def run what
   puts what.yellow
   system what
 end
 
 def die what
-  puts '%s (%s)' % [what.red. caller[0]]
+  puts '%s (%s)' % [what.red, caller[0]]
   exit
 end
 
@@ -23,27 +30,33 @@ end
 ###
 
 task :env do
-  require './config/application'
+  require './config/env'
+end
+
+task :app do
+  require './config/app'
 end
 
 task :default do
-  puts '"rake -T" to show all tasks'
+  require 'lux-fw'
+  system Lux.fw_root.join('bin/lux').to_s
 end
 
 ###
 
 require 'bundler/setup'
-require 'dotenv'
 
-Dotenv.load
 Bundler.require :default, ENV.fetch('RACK_ENV')
 
 tasks  = []
 tasks += Dir['%s/tasks/*.rake' % Lux.fw_root]
 tasks += Dir['./lib/**/*.rake']
 
-for dir in Lux.plugin.loaded.map(&:folder)
+for dir in Lux.plugin.folders
   tasks += Dir['%s/**/*.rake' % dir]
 end
 
-tasks.each { |file| eval File.read file }
+tasks.each do |file|
+  load file
+end
+