lux-fw 0.1.17

data/lib/overload/hash_wia.rb

@@ -0,0 +1,282 @@
+# 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
+

data/lib/overload/inflections.rb

@@ -0,0 +1,199 @@
+# # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/inflector/methods.rb
+
+# class String
+#   def pluralize(locale = :en)
+#     word = self
+#     apply_inflections(word, inflections(locale).plurals)
+#   end
+
+#   def singularize(locale = :en)
+#     word = self
+#     apply_inflections(word, inflections(locale).singulars)
+#   end
+
+#   def camelize(uppercase_first_letter = true)
+#     term = self
+#     string = term.to_s
+#     if uppercase_first_letter
+#       string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
+#     else
+#       string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+#     end
+#     string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
+#     string.gsub!("/".freeze, "::".freeze)
+#     string
+#   end
+
+#   def underscore
+#     camel_cased_word = self
+#     return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
+#     word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
+#     word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+#     word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+#     word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+#     word.tr!("-".freeze, "_".freeze)
+#     word.downcase!
+#     word
+#   end
+
+#   def humanize(options = {})
+#     result = self.to_s.dup
+
+#     inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+
+#     result.sub!(/\A_+/, "".freeze)
+#     result.sub!(/_id\z/, "".freeze)
+#     result.tr!("_".freeze, " ".freeze)
+
+#     result.gsub!(/([a-z\d]*)/i) do |match|
+#       "#{inflections.acronyms[match] || match.downcase}"
+#     end
+
+#     if options.fetch(:capitalize, true)
+#       result.sub!(/\A\w/) { |match| match.upcase }
+#     end
+
+#     result
+#   end
+
+#   def upcase_first
+#     string = self
+#     string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+#   end
+
+#   def titleize
+#     word = self
+#     humanize(underscore(word)).gsub(/\b(?<!['’`])[a-z]/) { |match| match.capitalize }
+#   end
+
+#   def tableize
+#     class_name = self
+#     pluralize(underscore(class_name))
+#   end
+
+#   def classify
+#     table_name = self.dup
+#     table_name.to_s.sub(/.*\./, "").freeze.singularize.camelize
+#   end
+
+#   def dasherize
+#     underscored_word = self
+#     underscored_word.tr("_".freeze, "-".freeze)
+#   end
+
+#   def demodulize()
+#     path = self.to_s
+#     if i = path.rindex("::")
+#       path[(i + 2)..-1]
+#     else
+#       path
+#     end
+#   end
+
+#   def deconstantize
+#     path = self.to_s
+#     path.to_s[0, path.rindex("::") || 0] # implementation based on the one in facets' Module#spacename
+#   end
+
+#   def foreign_key(separate_class_name_and_id_with_underscore = true)
+#     class_name = self
+#     underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
+#   end
+
+#   def constantize
+#     camel_cased_word = self
+#     names = camel_cased_word.split("::".freeze)
+
+#     # Trigger a built-in NameError exception including the ill-formed constant in the message.
+#     Object.const_get(camel_cased_word) if names.blank?
+
+#     # Remove the first blank element in case of '::ClassName' notation.
+#     names.shift if names.size > 1 && names.first.blank?
+
+#     names.inject(Object) do |constant, name|
+#       if constant == Object
+#         constant.const_get(name)
+#       else
+#         candidate = constant.const_get(name)
+#         next candidate if constant.const_defined?(name, false)
+#         next candidate unless Object.const_defined?(name)
+
+#         # Go down the ancestors to check if it is owned directly. The check
+#         # stops when we reach Object or the end of ancestors tree.
+#         constant = constant.ancestors.inject do |const, ancestor|
+#           break const    if ancestor == Object
+#           break ancestor if ancestor.const_defined?(name, false)
+#           const
+#         end
+
+#         # owner is in Object, so raise
+#         constant.const_get(name, false)
+#       end
+#     end
+#   end
+
+#   def safe_constantize
+#     camel_cased_word = self
+#     constantize(camel_cased_word)
+#   rescue NameError => e
+#     raise if e.name && !(camel_cased_word.to_s.split("::").include?(e.name.to_s) ||
+#       e.name.to_s == camel_cased_word.to_s)
+#   rescue ArgumentError => e
+#     raise unless /not missing constant #{const_regexp(camel_cased_word)}!$/.match?(e.message)
+#   end
+
+#   def ordinal
+#     number = self
+#     abs_number = number.to_i.abs
+
+#     if (11..13).include?(abs_number % 100)
+#       "th"
+#     else
+#       case abs_number % 10
+#       when 1; "st"
+#       when 2; "nd"
+#       when 3; "rd"
+#         else    "th"
+#       end
+#     end
+#   end
+
+#   def ordinalize
+#     number = self
+#     "#{number}#{ordinal(number)}"
+#   end
+
+#   private
+
+#     # Mounts a regular expression, returned as a string to ease interpolation,
+#     # that will match part by part the given constant.
+#     #
+#     #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
+#     #   const_regexp("::")            # => "::"
+#     def const_regexp(camel_cased_word) #:nodoc:
+#       parts = camel_cased_word.split("::".freeze)
+
+#       return Regexp.escape(camel_cased_word) if parts.blank?
+
+#       last = parts.pop
+
+#       parts.reverse.inject(last) do |acc, part|
+#         part.blank? ? acc : "#{part}(::#{acc})?"
+#       end
+#     end
+
+#     # Applies inflection rules for +singularize+ and +pluralize+.
+#     #
+#     #  apply_inflections('post', inflections.plurals)    # => "posts"
+#     #  apply_inflections('posts', inflections.singulars) # => "post"
+#     def apply_inflections(word, rules)
+#       result = word.to_s.dup
+
+#       if word.blank? || inflections.uncountables.uncountable?(result)
+#         result
+#       else
+#         rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
+#         result
+#       end
+#     end
+# end

data/lib/overload/integer.rb

@@ -0,0 +1,19 @@
+class Integer
+  def pluralize(desc)
+    if self == 0
+      "no #{desc.to_s.pluralize}"
+    elsif self == 1
+      "#{self} #{desc}"
+    else
+      "#{self} #{desc.to_s.pluralize}"
+    end
+  end
+
+  def dotted
+    data = self.to_s
+    while data.sub!(/(\d)(\d{3})$/, "\\1.\\2")
+      1
+    end
+    data
+  end
+end

data/lib/overload/module.rb

@@ -0,0 +1,10 @@
+class Module
+  # creates instance with module included and runs the code
+  # MainHelper.runtime_eval do
+  #   @session_city = City.first
+  #   header_top_menu
+  # end
+  def runtime_eval &block
+    Class.new.send(:include, self).new.instance_exec &block
+  end
+end

data/lib/overload/nil.rb

@@ -0,0 +1,8 @@
+class NilClass
+  def empty?
+    true
+  end
+  def present?
+    false
+  end
+end

data/lib/overload/object.rb

@@ -0,0 +1,77 @@
+class LocalRaiseError < StandardError
+end
+
+class Object
+  def r(what=nil)
+    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")
+
+    raise LocalRaiseError.new out
+  end
+
+  def instance_variables_hash
+    Hash[instance_variables.map { |name| [name, instance_variable_get(name)] } ]
+  end
+
+  def or(_or)
+    self.blank? || self == 0 ? _or : self
+  end
+
+  def try(*args)
+    return nil if self.class == NilClass
+    self.send(*args)
+  end
+
+  def die(desc=nil, exp_object=nil)
+    desc ||= 'died without desc'
+    desc = '%s: %s' % [exp_object.class, desc] if exp_object
+    raise desc
+  end
+
+  # this will capture plain Hash and HashWithIndifferentAccess
+  def is_hash?
+    self.class.to_s.index('Hash') ? true : false
+  end
+
+  def is_array?
+    self.class.to_s.index('Array') ? true : false
+  end
+
+  def is_string?
+    self.class.to_s == 'String' ? true : false
+  end
+
+  def is_false?
+    self.class.name == 'FalseClass' ? true : false
+  end
+
+  def is_true?
+    self ? true :false
+  end
+
+  def is_numeric?
+    Float(self) != nil rescue false
+  end
+
+  def is_symbol?
+    self.class.to_s == 'Symbol' ? true : false
+  end
+
+  def is_boolean?
+    self.class == TrueClass || self.class == FalseClass
+  end
+
+end
+
+# if we dont have awesome print in prodction, define mock
+method(:ap) rescue Proc.new do
+  class Object
+    def ap(*args)
+      puts args
+    end
+  end
+end.call
+

data/lib/overload/string.rb

@@ -0,0 +1,89 @@
+class String
+  # simple markdown
+  def as_html
+    ret = self
+    ret = ret.gsub(/([\w\.])\n(\w)/,"\\1<br/>\\2")
+    ret
+  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
+  end
+
+  def trim(len)
+    return self if self.length<len
+    data = self.dup[0,len]+'&hellip;'
+    data
+  end
+
+  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 tag(node_name, opts={})
+    opts.tag(node_name, self)
+  end
+
+  def wrap(node_name, opts={})
+    return self unless node_name
+    opts.tag(node_name, self)
+  end
+
+  def fix_ut8
+    self.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '?')
+  end
+
+  def parse_erb
+    self.gsub(/<%=([^%]+)%>/) { eval $1; }
+  end
+
+  def parameterize
+    self.downcase.gsub(/[^\w]+/,'-')
+  end
+
+  def to_url
+    # str_from = 'šđč枊ĐČĆŽäÄéeöÖüüÜß'
+    # str_to   = 'sdcczSDCCZaAeeoOuuUs'
+    # self.downcase.gsub(/\s+/,'-').tr(str_from, str_to).gsub(/[^\w\-]/,'')
+    self.gsub('&',' and ').gsub('.',' dot ').parameterize.gsub('-dot-','.').downcase[0, 50]
+  end
+
+  def css_to_hash
+    self.split('&').inject({}) do |h,line|
+      el = line.split('=', 2)
+      h[el[0]] = el[1]
+      h
+    end
+  end
+
+  def to_a
+    self.split(/\s*,\s*/)
+  end
+
+  def starts_with?(prefix)
+    prefix.respond_to?(:to_str) && self[0, prefix.length] == prefix
+  end
+
+  def last(num=1)
+    len = self.length
+    self[len-num, len]
+  end
+
+  def span_green
+    %[<span style="color: #080;">#{self}</span>]
+  end
+
+  def span_red
+    %[<span style="color: #800;">#{self}</span>]
+  end
+
+  def constantize
+    klass = self
+    obj = Object.const_get(klass)
+    obj.to_s == klass.sub(/^::/,'') ? obj : raise(NameError, 'Cant find class %s' % klass)
+  end
+end

data/lib/overload/string_inflections.rb

@@ -0,0 +1,7 @@
+# http://sequel.jeremyevans.net/rdoc/classes/Sequel/Inflections.html
+
+String.inflections do |inflect|
+  inflect.plural 'bonus', 'bonuses'
+  inflect.plural 'clothing', 'clothes'
+  inflect.plural 'people', 'people'
+end

data/lib/overload/struct.rb

@@ -0,0 +1,5 @@
+class Struct
+  def to_hash
+    Hash[*members.zip(values).flatten]
+  end
+end