|
#
|
|
# Copyright 2014 Red Hat, Inc.
|
|
#
|
|
# This software is licensed to you under the GNU General Public
|
|
# License as published by the Free Software Foundation; either version
|
|
# 2 of the License (GPLv2) or (at your option) any later version.
|
|
# There is NO WARRANTY for this software, express or implied,
|
|
# including the implied warranties of MERCHANTABILITY,
|
|
# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
|
|
# have received a copy of GPLv2 along with this software; if not, see
|
|
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
|
|
|
|
module Katello
|
|
module Util
|
|
module Support
|
|
def self.deep_copy(object)
|
|
Marshal.load(Marshal.dump(object))
|
|
end
|
|
|
|
def self.time
|
|
a = Time.now
|
|
yield
|
|
Time.now - a
|
|
end
|
|
|
|
def self.scrub(params, &block_to_match)
|
|
params.keys.each do |key|
|
|
if params[key].is_a?(Hash)
|
|
scrub(params[key], &block_to_match)
|
|
elsif block_to_match.call(key, params[key])
|
|
params[key] = "[FILTERED]"
|
|
end
|
|
end
|
|
params
|
|
end
|
|
|
|
# Helper method to just convert
|
|
# a collection of objects to their
|
|
# string representation (mostly to be used internally)
|
|
def self.stringify(col)
|
|
col.collect{|c| c.to_s}
|
|
end
|
|
|
|
# Given a rules hash in the format
|
|
# {<attrib_name>: {<attrib_name> => ...}}
|
|
# the method will match the params attributes to provided
|
|
# rule and return a diff.
|
|
# Here are some of the examples
|
|
# rule -> {:units => [[:name, :version, :min_version, :max_version]]}
|
|
# will match -> {:units => [{:name = > "boo", :version => "2.0"},
|
|
# {:name = > "Foo", :min_version => "2.0"}]}
|
|
# rule -> {:units => [[:id]], :date_range => [:start, :end],
|
|
# :errata_type => {}, :severity => {}}
|
|
# will match -> {:units => [{:id => 100}],
|
|
# :date_range => {:start => "05/14/2011"}}
|
|
# Note of caution this merely shows differences in the structure
|
|
# of params vs rules. It doesnt validate anything.
|
|
# Look at SerializedParamsValidator method for its uses.
|
|
def self.diff_hash_params(rule, params)
|
|
params = params.with_indifferent_access
|
|
if rule.is_a?(Array)
|
|
return stringify(params.keys) - stringify(rule)
|
|
end
|
|
|
|
rule = rule.with_indifferent_access
|
|
diff_data = rule.keys.collect do |k|
|
|
if params[k]
|
|
if (params[k].is_a?(Array)) && (rule[k].first.is_a?(Array))
|
|
diffs = params[k].collect {|pk| diff_hash_params(rule[k].first, pk)}.flatten
|
|
diffs
|
|
elsif params[k].is_a?(Hash)
|
|
keys = stringify(params[k].keys) - stringify(rule[k])
|
|
if keys.empty?
|
|
nil
|
|
else
|
|
{k => keys}
|
|
end
|
|
end
|
|
end
|
|
end
|
|
diff_data = diff_data.compact.flatten
|
|
|
|
return diff_data unless diff_data.nil? || diff_data.empty?
|
|
stringify(params.keys) - stringify(rule.keys)
|
|
end
|
|
|
|
# We need this so that we can return
|
|
# empty search results on an invalid query
|
|
# Basically this is a empty array with a total
|
|
# method. We could ve user Tire::Result:Collection
|
|
# But that class is way more involved
|
|
def self.array_with_total(a = [])
|
|
def a.total
|
|
size
|
|
end
|
|
a
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|
