lux-fw 0.5.36 → 0.6.2

data/lib/overload/hash.rb

@@ -1,82 +1,21 @@
-# frozen_string_literal: true
-
-require_relative '../common/free_struct'
-
 class Hash
-  def h
-    Hashie::Mash.new(self)
-  end
-
-  def h_wia
-    HashWithIndifferentAccess.new(self)
-  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
-
-      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?
     self.keys.count == 0
   end
 
   def to_query namespace=nil
-    self.keys.sort.map { |k|
+    keys = self.keys.sort
+
+    return unless keys.first
+
+    '?' + keys.map do |k|
       name = namespace ? "#{namespace}[#{k}]" : k
       "#{name}=#{CGI::escape(self[k].to_s)}"
-    }.join('&')
+    end.join('&')
   end
 
-  def data_attributes
-    self.keys.sort.map{ |k| 'data-%s="%s"' % [k, self[k].to_s.gsub('"', '"')]}.join(' ')
+  def to_attributes
+    self.keys.sort.map{ |k| '%s="%s"' % [k, self[k].to_s.gsub('"', '"')]}.join(' ')
   end
 
   def pluck *args
@@ -84,31 +23,15 @@ class Hash
     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
+  def stringify_keys
+    transform_keys { |key| key.to_s }
   end
 
   def symbolize_keys
-    transform_keys{ |key| key.to_sym rescue key }
-  end
-
-  def symbolize_keys!
-    transform_keys!{ |key| key.to_sym rescue key }
+    transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
   end
 
+  # Returns hash with only selected keys
   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) }
@@ -124,8 +47,75 @@ class Hash
     omit
   end
 
-  def pretty_generate
-    JSON.pretty_generate(self).gsub(/"([\w\-]+)":/) { %["#{$1.yellow}":] }
+  # Returns a hash that includes everything but the given keys.
+  #    hash = { a: true, b: false, c: nil}
+  #    hash.except(:c) # => { a: true, b: false}
+  #    hash # => { a: true, b: false, c: nil}
+  #
+  # This is useful for limiting a set of parameters to everything but a few known toggles:
+  #    @person.update(params[:person].except(:admin))
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Hash#except in place, modifying current hash
+  def except!(*keys)
+    keys.each { |key| delete(key.to_s); delete(key.to_sym)  }
+    self
+  end
+
+  def remove_empty covert_to_s = false
+    self.keys.inject({}) do |t, el|
+      v = self[el]
+      t[covert_to_s ? el.to_s : el] = v if el.present? && v.present?
+      t
+    end
+  end
+
+  def to_js opts = {}
+    data = opts[:empty] ? self : remove_empty
+    data = data.to_json.gsub(/"(\w+)":/, "\\1:")
+    data = data.gsub(/",(\w)/, '", \1') unless opts[:narrow]
+    data
+  end
+
+  def transform_keys &block
+    if block
+      Hash.new.tap do |result|
+        for key, value in self
+          value = value.transform_keys(&block) if value.is_a?(Hash)
+          result[block.call(key)] = value
+        end
+      end
+    else
+      enum_for(:transform_keys)
+    end
+  end
+
+  # clean empty values from hash, deep
+  def deep_compact value = nil
+    value ||= self
+
+    res_hash = value.map do |key, value|
+      value = deep_compact(value) if value.is_a?(Hash)
+
+      # we need to remove '0' because that is what empty checkbox inserts, but it is nil
+      value = nil if [{}, [], '0'].include?(value)
+      value = nil if value.blank?
+      [key, value]
+    end
+
+    res_hash.to_h.compact
+  end
+
+  def self.deep_compact value
+    (value || {}).deep_compact
+  end
+
+  def html_safe key
+    if data = self[key]
+      self[key] = data.html_safe
+    end
   end
 end
 

data/lib/overload/integer.rb

@@ -12,4 +12,19 @@ class Integer
   def dotted
     self.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1.').reverse
   end
+
+  def to_filesize
+    base = 1024
+    out = lambda do
+      {
+        'B'  => base,
+        'KB' => base * base,
+        'MB' => base * base * base,
+        'GB' => base * base * base * base,
+        'TB' => base * base * base * base * base
+      }.each_pair { |e, s| return "#{(self.to_f / (s / base)).round(1)} #{e}" if self < s }
+    end.call
+
+    out.sub('.0 B', ' B')
+  end
 end

data/lib/overload/json.rb

@@ -0,0 +1,26 @@
+module LuxJson
+  # to json smart - pretty in dev
+  def to_jsons
+    Lux.env.screen_log? ? to_jsonp : to_json
+  end
+
+  # to json pretty
+  def to_jsonp colorize_keys = false
+    out = JSON.pretty_generate(self)
+    colorize_keys ? out.gsub(/(\n\s|)"([\w\-]+)":/) { '%s"%s":' % [$1, $2.yellow] } : out
+  end
+
+  # to json compact (for javascript)
+  def to_jsonc
+    to_json.gsub(/"(\w+)":/, '\1:')
+  end
+end
+
+class Hash
+  include LuxJson
+end
+
+class Array
+  include LuxJson
+end
+

data/lib/overload/nil.rb

@@ -1,13 +1,9 @@
 class NilClass
-  def empty?
-    true
-  end
-
-  def present?
-    false
-  end
-
   def dup
     nil
   end
+
+  def is? klass
+    true
+  end
 end

data/lib/overload/object.rb

@@ -1,34 +1,55 @@
 class Object
+  LUX_AUTO_LOAD ||= {}
 
-  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] }
+  def self.const_missing klass, path=nil
+    unless LUX_AUTO_LOAD.keys.first
+      for file in `find ./app -type f -name '*.rb'`.split($/)
+        klass_file = file.split('/').last.sub('.rb', '').classify
+        LUX_AUTO_LOAD[klass_file] ||= [false, file]
+      end
+    end
 
-    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('')])
+    klass = klass.to_s if klass.class == Symbol
+    path  = LUX_AUTO_LOAD[klass]
+    error = %{Can't find and autoload module/class "%s"} % klass
 
-    # puts '* autoload: %s from %s' % [file, klass_file]
+    if path
+      if path[0]
+        raise NameError.new('%s, found file "%s" is not defineing it.' % [error, path[1]])
+      else
+        path[0] = true
+        require path[1].sub('.rb', '')
+        Object.const_get(klass)
+      end
+    else
+      raise NameError.new('%s. Scanned all files in ./app folder' % error)
+    end
+  end
 
-    require klass_file
+  ###
 
-    Object.const_get(klass)
+  # @foo.or(2)
+  def or _or = nil, &block
+    self.blank? || self == 0 ? (block ? block.call : _or) : self
   end
 
-  ###
+  def nil _or = nil, &block
+    self.nil? ? (block ? block.call : _or) : self
+  end
 
-  def or _or
-    self.blank? || self == 0 ? _or : self
+  def and &block
+    block.call(self) if self.present?
   end
 
-  def try *args
-    return nil if self.class == NilClass
-    self.send(*args)
+  def try *args, &block
+    if self.class == NilClass
+      nil
+    elsif block_given?
+      data = args.first.nil? ? self : self.send(*args)
+      yield data
+    else
+      self.send(*args)
+    end
   end
 
   def die desc=nil, exp_object=nil
@@ -39,7 +60,7 @@ class Object
     raise desc
   end
 
-  # this will capture plain Hash and HashWithIndifferentAccess
+  # this will capture plain Hash and Hash With Indifferent Access
   def is_hash?
     self.class.to_s.index('Hash') ? true : false
   end
@@ -57,7 +78,7 @@ class Object
   end
 
   def is_true?
-    self ? true :false
+    ['true', 'on', '1'].include?(to_s)
   end
 
   def is_numeric?
@@ -72,6 +93,17 @@ class Object
     self.class == TrueClass || self.class == FalseClass
   end
 
+  def is_a! klass, error = nil
+    ancestors.each { |kind| return true if kind == klass }
+
+    if error
+      message = error.class == String ? error : %[Expected "#{self}" to be of "#{klass}"]
+      raise ArgumentError.new(message)
+    else
+      false
+    end
+  end
+
   def andand func=nil
     if present?
       if block_given?
@@ -80,12 +112,47 @@ class Object
         func ? send(func) : self
       end
     else
-      block_given? || func ? nil : {}.h
+      block_given? || func ? nil : {}.to_hwia
     end
   end
 
   def instance_variables_hash
-    Hash[instance_variables.map { |name| [name, instance_variable_get(name)] } ]
+    vars = instance_variables - [:@current]
+    vars = vars.reject { |var| var[0,2] == '@_' }
+    Hash[vars.map { |name| [name, instance_variable_get(name)] }]
+  end
+
+  # value should be Float
+  # value.is! Float
+  def is! value = :_nil
+    if value == :_nil
+      if self.present?
+        self
+      else
+        raise ArgumentError.new('Expected not not empty value')
+      end
+    elsif value == self.class
+      self
+    else
+      if self.class == Class && self.superclass != Object
+        if self.ancestors.include?(value)
+          self
+        else
+          raise ArgumentError.new('There is no %s in %s ancestors in %s' % [value, self, caller[0]])
+        end
+      else
+        raise ArgumentError.new('Expected %s but got %s in %s' % [value, self.class, caller[0]])
+      end
+    end
+  end
+
+  # value can be nil but if defined should be Float
+  # value.is? Float
+  def is? value = nil
+    is! value
+    true
+  rescue ArgumentError
+    false
   end
 end
 

data/lib/overload/pathname.rb

@@ -0,0 +1,11 @@
+require 'fileutils'
+
+class Pathname
+  def touch
+    FileUtils.touch to_s
+  end
+
+  def write_p data
+    File.write_p to_s, data
+  end
+end

data/lib/overload/raise_variants.rb

@@ -1,33 +1,39 @@
-class LocalRaiseError < StandardError
-end
-
 class Object
   # raise object
   def r what
-    opath = what.class.ancestors
-    out   = opath.join("\n> ")
-
-    data = what.is_a?(Hash) ? JSON.pretty_generate(what) : what.ai(plain:true)
-    out = [data, out, ''].join("\n\n-\n\n")
-
-    # unique_methods = what.methods - what.class.ancestors[0].instance_methods
-    # raise unique_methods
+    if what.is_a?(Method)
+      rr [:source_location, what.source_location.join(':')]
+    else
+      rr what
+    end
 
-    raise LocalRaiseError.new out
+    what = what.respond_to?(:to_jsonp) ? what.to_jsonp : what.inspect
+    raise StandardError.new(what.nil? ? 'nil' : what)
   end
 
   # better console log dump
-  def rr what
-    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 ---']
+  def rr what, as_jsonp = false
+    klass = what.class
+    klass = '%s at %s' % [klass, what.source_location.join(':').sub(Lux.root.to_s, '.')] if klass == Method
+    from = caller[0].include?('raise_variants.rb') ? caller[1] : caller[0]
+    from = from.sub(Lux.root.to_s+'/', './').split(':in ').first
+    header = '--- START (%s) %s - %s ---' % [klass, from, Lux.current.request.url]
+    as_jsonp = true if ['HashWia', 'Hash'].include?(what.class.to_s)
+    if as_jsonp
+      puts header
+      puts what.to_jsonp
+      puts '--- END ---'
+    else
+      ap [header, what, '--- END ---']
+    end
   end
 
   # unique methods for object
   # includes methods from modules
-  def rm object
+  def r? object
     dump = []
 
-    dump.push ['Class', object.class]
+    dump.push 'Class: %s' % object.class
 
     instance_unique = object.methods - object.class.ancestors[0].instance_methods
     class_unique    = object.methods
@@ -36,31 +42,16 @@ class Object
       class_unique -= _.instance_methods
 
       if _.class != Module
-        dump.push ['Parent Class', _]
+        dump.push 'Parent Class: %s' % _
         break
       end
     end
 
     dump.push ['Instance uniqe', instance_unique.sort] if instance_unique[0]
-    dump.push ['Uniqe from parent', class_unique.sort]
+    dump.push ['Uniqe from parent', class_unique.sort.join(', ')]
     dump.push ['Uniqe from parent simple', object.class.instance_methods(false)]
 
-    r dump
-  end
-
-  def rr! what
-    print "\e[H\e[2J\e[3J" # clear osx screen :)
-    rr what
-  end
-
-  # 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
+    rr dump
   end
 end
 
@@ -74,4 +65,3 @@ method(:ap) rescue Proc.new do
     end
   end
 end.call
-