lux-fw 0.1.35 → 0.2.1

data/lib/common/{before_and_after.rb → class_callbacks.rb}

@@ -1,35 +1,26 @@
 # frozen_string_literal: true
 
 # in some class
-#   def self.before(proc=nil, &block)
-#     BeforeAndAfter.add(self, caller[0], :before, proc || block)
-#   end
-# or
-#   BeforeAndAfter.define self, :before, :after
+# ClassCallbacks.define self, :before, :after
 #
 # then to execute
 # instance_object = SomeClass.new
-# BeforeAndAfter.execute(instance_object, :before)
-# or
+# ClassCallbacks.execute(instance_object, :before)
+#
 # before do
 #   ...
 # end
-# or
-# def before
-#   super
-#   ...
-# end
 #
 # logic is very simple, keep all pointers to all blocks in one class, resolve and execute as needed
 # we keep methods and ponters in different hashes to allow hot reload while development
 
-module BeforeAndAfter
+module ClassCallbacks
   extend self
 
   @@methods  = {}
   @@pointers = {}
 
-  def add(klass, unique_id, action, method)
+  def add klass, unique_id, action, method
     key = Crypt.md5(unique_id)
     @@pointers[key] = method
     @@methods[klass.to_s] ||= {}
@@ -37,8 +28,8 @@ module BeforeAndAfter
     @@methods[klass.to_s][action].push(key) unless @@methods[klass.to_s][action].index(key)
   end
 
-  def execute(instance_object, action)
-    instance_object.send(action)
+  def execute instance_object, action, object=nil
+    object ? instance_object.send(action, object) : instance_object.send(action)
 
     # execute for self and parent
     for name in instance_object.class.ancestors.reverse.map(&:to_s)
@@ -47,9 +38,9 @@ module BeforeAndAfter
       if @@methods[name] && @@methods[name][action]
         for el in @@methods[name][action].map { |o| @@pointers[o] }
           if el.kind_of?(Symbol)
-            instance_object.send(el)
+            object ? instance_object.send(el, object) : instance_object.send(el)
           else
-            instance_object.instance_exec &el
+            object ? instance_object.instance_exec(object, &el) : instance_object.instance_exec(&el)
           end
         end
       end
@@ -59,11 +50,11 @@ module BeforeAndAfter
   def define(klass, *args)
     for action in args
       klass.class_eval %[
-        def #{action}
+        def #{action}(duck=nil)
         end
 
-        def self.#{action}(proc=nil, opts={}, &block)
-          BeforeAndAfter.add(self, caller[0], :#{action}, proc || block)
+        def self.#{action}(proc=nil, &block)
+          ClassCallbacks.add(self, caller[0], :#{action}, proc || block)
         end
       ]
     end

data/lib/common/crypt.rb

@@ -15,10 +15,10 @@ module Crypt
   ALGORITHM = 'HS512'
 
   def secret
-    Lux.env('SECRET')
+    ENV.fetch('SECRET') { puts '* Warn: ENV SECRET not set'; 'foo' }
   end
 
-  def base64(str)
+  def base64 str
     Base64.urlsafe_encode64(str)
   end
 
@@ -26,16 +26,20 @@ module Crypt
     SecureRandom.hex
   end
 
-  def sha1(str)
+  def sha1 str
     Digest::SHA1.hexdigest(str.to_s + secret)
   end
 
-  def md5(str)
+  def md5 str
     Digest::MD5.hexdigest(str.to_s + secret)
   end
 
-  def bc(str)
-    BCrypt::Password.create(str + secret)
+  def bcrypt plain, check=nil
+    if check
+      BCrypt::Password.new(check) == [plain, secret].join('')
+    else
+      BCrypt::Password.create(plain + secret)
+    end
   end
 
   # Crypt.encrypt('secret')

data/lib/common/dynamic_class.rb

@@ -1,23 +1,28 @@
-# o = DynamicClass.new a: 'b'
-# o.a -> 'b'
-# o.b -> raises error
+# o = DynamicClass.new name: 'a'
+# o.name -> 'a'
+# o.name = 'b'
+# o.name 'b'
+# o.name -> 'b'
+# o.name = nil
+# o.name -> nil
+# o.title -> raises error
 class DynamicClass
   def initialize data, &block
     @data  = data
     @block = block if block
   end
 
-  def method_missing m, *args, &block
+  def method_missing m, arg=:_UNDEF
     key = m.to_s.sub('=','').to_sym
 
     unless @data.has_key?(key)
       raise ArgumentError.new('Key :%s not found in DynamicOptions' % key)
     end
 
-    if m.to_s.include?('=')
-      @data[key] = args[0]
-    else
+    if arg == :_UNDEF
       @data[key]
+    else
+      @data[key] = arg
     end
   end
 end

data/lib/common/generic_model.rb

@@ -20,12 +20,12 @@ class GenericModel
   @@values = {}
 
   class << self
-    def values(vals)
+    def values vals
       @@values[self.to_s] = []
       vals.map { |el| add_value(el) }
     end
 
-    def add_value(val)
+    def add_value val
       o = new(val)
       for key in val.keys
         eval %[def o.#{key}; @_vals[:#{key}]; end]
@@ -33,7 +33,7 @@ class GenericModel
       @@values[self.to_s].push(o)
     end
 
-    def find(id)
+    def find id
       for el in all
         return el if el.id == id
       end
@@ -44,18 +44,18 @@ class GenericModel
       @@values[self.to_s]
     end
 
-    def where(opts)
+    def where opts
       @@values[self.to_s].select{ |el| el[opts.keys[0]] == opts.values[0] }
     end
   end
 
   ###
 
-  def initialize(vals)
+  def initialize vals
     @_vals = vals
   end
 
-  def [](key)
+  def [] key
     @_vals[key]
   end
 

data/lib/common/hash_with_indifferent_access.rb

@@ -44,10 +44,15 @@ class HashWithIndifferentAccess
   end
 
   def dig *args
-    list = args.map{ |_| _.class == Symbol ? _.to_s : _ }
+    list = args.map{ |it| it.class == Symbol ? it.to_s : it }
     @data.dig *list
   end
 
+  def pluck *args
+    args = args.map(&:to_s)
+    @data.select { |k,v| args.include?(k) }
+  end
+
   def clear
     @data.keys.each { |key| @data.delete(key) }
   end
@@ -67,286 +72,3 @@ class HashWithIndifferentAccess
     value.is_a?(Hash) ? self.class.new(value) : value
   end
 end
-
-
-# exrtacted from Rails
-# class HashWithIndifferentAccess < Hash
-#   # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
-#   # this class.
-#   def extractable_options?
-#     true
-#   end
-
-#   def with_indifferent_access
-#     dup
-#   end
-
-#   def initialize(constructor = {})
-#     if constructor.respond_to?(:to_hash)
-#       super()
-#       update(constructor)
-
-#       hash = constructor.to_hash
-#       self.default = hash.default if hash.default
-#       self.default_proc = hash.default_proc if hash.default_proc
-#     else
-#       super(constructor)
-#     end
-#   end
-
-#   def default(*args)
-#     arg_key = args.first
-
-#     if include?(key = convert_key(arg_key))
-#       self[key]
-#     else
-#       super
-#     end
-#   end
-
-#   def self.[](*args)
-#     new.merge!(Hash[*args])
-#   end
-
-#   alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-#   alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-#   # Assigns a new value to the hash:
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash[:key] = 'value'
-#   #
-#   # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
-#   def []=(key, value)
-#     regular_writer(convert_key(key), convert_value(value, for: :assignment))
-#   end
-
-#   alias_method :store, :[]=
-
-#   # Updates the receiver in-place, merging in the hash passed as argument:
-#   #
-#   #   hash_1 = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash_1[:key] = 'value'
-#   #
-#   #   hash_2 = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash_2[:key] = 'New Value!'
-#   #
-#   #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-#   #
-#   # The argument can be either an
-#   # <tt>ActiveSupport::HashWithIndifferentAccess</tt> or a regular +Hash+.
-#   # In either case the merge respects the semantics of indifferent access.
-#   #
-#   # If the argument is a regular hash with keys +:key+ and +"key"+ only one
-#   # of the values end up in the receiver, but which one is unspecified.
-#   #
-#   # When given a block, the value for duplicated keys will be determined
-#   # by the result of invoking the block with the duplicated key, the value
-#   # in the receiver, and the value in +other_hash+. The rules for duplicated
-#   # keys follow the semantics of indifferent access:
-#   #
-#   #   hash_1[:key] = 10
-#   #   hash_2['key'] = 12
-#   #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-#   def update(other_hash)
-#     if other_hash.is_a? HashWithIndifferentAccess
-#       super(other_hash)
-#     else
-#       other_hash.to_hash.each_pair do |key, value|
-#         if block_given? && key?(key)
-#           value = yield(convert_key(key), self[key], value)
-#         end
-#         regular_writer(convert_key(key), convert_value(value))
-#       end
-#       self
-#     end
-#   end
-
-#   alias_method :merge!, :update
-
-#   # Checks the hash for a key matching the argument passed in:
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash['key'] = 'value'
-#   #   hash.key?(:key)  # => true
-#   #   hash.key?('key') # => true
-#   def key?(key)
-#     super(convert_key(key))
-#   end
-
-#   alias_method :include?, :key?
-#   alias_method :has_key?, :key?
-#   alias_method :member?, :key?
-
-#   # Same as <tt>Hash#[]</tt> where the key passed as argument can be
-#   # either a string or a symbol:
-#   #
-#   #   counters = ActiveSupport::HashWithIndifferentAccess.new
-#   #   counters[:foo] = 1
-#   #
-#   #   counters['foo'] # => 1
-#   #   counters[:foo]  # => 1
-#   #   counters[:zoo]  # => nil
-#   def [](key)
-#     super(convert_key(key))
-#   end
-
-#   # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-#   # either a string or a symbol:
-#   #
-#   #   counters = ActiveSupport::HashWithIndifferentAccess.new
-#   #   counters[:foo] = 1
-#   #
-#   #   counters.fetch('foo')          # => 1
-#   #   counters.fetch(:bar, 0)        # => 0
-#   #   counters.fetch(:bar) { |key| 0 } # => 0
-#   #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-#   def fetch(key, *extras)
-#     super(convert_key(key), *extras)
-#   end
-
-#   # Returns an array of the values at the specified indices:
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash[:a] = 'x'
-#   #   hash[:b] = 'y'
-#   #   hash.values_at('a', 'b') # => ["x", "y"]
-#   def values_at(*indices)
-#     indices.collect { |key| self[convert_key(key)] }
-#   end
-
-#   # Returns an array of the values at the specified indices, but also
-#   # raises an exception when one of the keys can't be found.
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash[:a] = 'x'
-#   #   hash[:b] = 'y'
-#   #   hash.fetch_values('a', 'b') # => ["x", "y"]
-#   #   hash.fetch_values('a', 'c') { |key| 'z' } # => ["x", "z"]
-#   #   hash.fetch_values('a', 'c') # => KeyError: key not found: "c"
-#   def fetch_values(*indices, &block)
-#     indices.collect { |key| fetch(key, &block) }
-#   end if Hash.method_defined?(:fetch_values)
-
-#   # Returns a shallow copy of the hash.
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new({ a: { b: 'b' } })
-#   #   dup  = hash.dup
-#   #   dup[:a][:c] = 'c'
-#   #
-#   #   hash[:a][:c] # => nil
-#   #   dup[:a][:c]  # => "c"
-#   def dup
-#     self.class.new(self).tap do |new_hash|
-#       set_defaults(new_hash)
-#     end
-#   end
-
-#   # This method has the same semantics of +update+, except it does not
-#   # modify the receiver but rather returns a new hash with indifferent
-#   # access with the result of the merge.
-#   def merge(hash, &block)
-#     dup.update(hash, &block)
-#   end
-
-#   # Like +merge+ but the other way around: Merges the receiver into the
-#   # argument and returns a new hash with indifferent access as result:
-#   #
-#   #   hash = ActiveSupport::HashWithIndifferentAccess.new
-#   #   hash['a'] = nil
-#   #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
-#   def reverse_merge(other_hash)
-#     super(self.class.new(other_hash))
-#   end
-#   alias_method :with_defaults, :reverse_merge
-
-#   # Same semantics as +reverse_merge+ but modifies the receiver in-place.
-#   def reverse_merge!(other_hash)
-#     replace(reverse_merge(other_hash))
-#   end
-#   alias_method :with_defaults!, :reverse_merge!
-
-#   # Replaces the contents of this hash with other_hash.
-#   #
-#   #   h = { "a" => 100, "b" => 200 }
-#   #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
-#   def replace(other_hash)
-#     super(self.class.new(other_hash))
-#   end
-
-#   # Removes the specified key from the hash.
-#   def delete(key)
-#     super(convert_key(key))
-#   end
-
-#   def stringify_keys!; self end
-#   def deep_stringify_keys!; self end
-#   def stringify_keys; dup end
-#   def deep_stringify_keys; dup end
-#   # undef :symbolize_keys!
-#   # undef :deep_symbolize_keys!
-#   def symbolize_keys; to_hash.symbolize_keys! end
-#   def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
-#   def to_options!; self end
-
-#   def select(*args, &block)
-#     return to_enum(:select) unless block_given?
-#     dup.tap { |hash| hash.select!(*args, &block) }
-#   end
-
-#   def reject(*args, &block)
-#     return to_enum(:reject) unless block_given?
-#     dup.tap { |hash| hash.reject!(*args, &block) }
-#   end
-
-#   def transform_values(*args, &block)
-#     return to_enum(:transform_values) unless block_given?
-#     dup.tap { |hash| hash.transform_values!(*args, &block) }
-#   end
-
-#   def compact
-#     dup.tap(&:compact!)
-#   end
-
-#   # Convert to a regular hash with string keys.
-#   def to_hash
-#     _new_hash = Hash.new
-#     set_defaults(_new_hash)
-
-#     each do |key, value|
-#       _new_hash[key] = convert_value(value, for: :to_hash)
-#     end
-#     _new_hash
-#   end
-
-#   private
-#     def convert_key(key) # :doc:
-#       key.kind_of?(Symbol) ? key.to_s : key
-#     end
-
-#     def convert_value(value, options = {}) # :doc:
-#       if value.is_a? Hash
-#         if options[:for] == :to_hash
-#           value.to_hash
-#         else
-#           value.class == Hash ? HashWithIndifferentAccess.new(value) : value
-#         end
-#       elsif value.is_a?(Array)
-#         if options[:for] != :assignment || value.frozen?
-#           value = value.dup
-#         end
-#         value.map! { |e| convert_value(e, options) }
-#       else
-#         value
-#       end
-#     end
-
-#     def set_defaults(target) # :doc:
-#       if default_proc
-#         target.default_proc = default_proc.dup
-#       else
-#         target.default = default
-#       end
-#     end
-# end
-