convert rake task arguments to a standard hash.
497369
def rake_input(rake_arg)
      params = {}
      rake_arg.each do |key, val| 
        params[key] = val
      end
      # by default, use human logging if a logger is enabled.
      params[:logger] = Logger.new(STDOUT) unless params.key?(:logger)
      params[:log_format] = :human unless params.key?(:log_format)
      
      return params
    end
485220
def argshash(self, args, kwargs):
        ""
        a = repr(args)
        b = repr(sorted((repr(k), repr(v)) for k, v in kwargs.items()))
        return a + b
530368
def hash(self, val):
        """"""

        if not isinstance(val, bytes):
            raise _TypeError("val", "bytes", val)

        rv = self.compute(val)

        if not isinstance(val, bytes):
            raise _TypeError("val", "bytes", rv)

        return rv
231312
function argHashToArray(hash)
{
	var keys = Object.keys(hash);
	var result = [];
	for (var i = 0; i < keys.length; i++)
	{
		result[parseInt(keys[i], 10)] = hash[keys[i]];
	}
	return result;
}
114127
def serialized_task(self, task: Task) -> Tuple[str, str]:
        
        return f"{task.hash}.json", task.json
533089
def parent_task(name)
      task name do
        Rake::Task
          .tasks
          .select { |t| t.name =~ /^#{name}:/ }
          .sort_by(&:name)
          .each(&:execute)
      end
    end
12156
def cli_hash(list_of_kv):
    """"""
    ev_obj = {}
    for extra_var in list_of_kv:
        ev_list = extra_var.split('=')
        key = ev_list[0]
        val = '='.join(ev_list[1:])  # b64 and other side effects
        ev_obj[key] = val

    return ev_obj
117588
def setup_rake_dependencies(task, multitask = nil)
      dependencies.reverse_each do |d|
        begin
          bb = ALL_BUILDING_BLOCKS[d]
          raise "Error: tried to add the dependencies of \"#{d}\" to \"#{@name}\" but such a building block could not be found!" unless bb

          if multitask and bb.pre_step
            multitask.prerequisites.unshift(bb.get_task_name)
          else
            task.prerequisites.unshift(bb.get_task_name)
          end
        rescue ExitHelperException
          raise
        rescue Exception => e
          Printer.printError e.message
          ExitHelper.exit(1)
        end
      end

      task
    end
102006
def to_hash
      {
        :repository   => repository.name,
        :model        => model.name,
        :fields       => fields,
        :links        => links,
        :conditions   => conditions,
        :offset       => offset,
        :limit        => limit,
        :order        => order,
        :unique       => unique?,
        :add_reversed => add_reversed?,
        :reload       => reload?,
      }
    end
1231331
def to_hash
      stringified_params = Hash[parameters.map { |key, val| [key.to_s, val] }]
      base_hash.merge(stringified_params)
    end
183709
def define # :nodoc:

      actual_name = Hash === name ? name.keys.first : name
      unless ::Rake.application.last_comment
        desc "Run JShint"
      end
      task name do
        unless js_file_list.empty?
          result = Jshintrb::report(js_file_list, @options, @globals, STDERR)
          if result.size > 0
            abort("JSHint check failed") if fail_on_error
          end
        end
      end

      self
    end
1339511
def to_hash
      VALID_ATTRIBUTES.reduce({}) { |acc, k| acc[k] = send(k); acc }
    end
509546
def normalize_hash(hash)
      new_hash = {}

      hash.each do |key,value|
        new_hash[key.to_sym] = normalize(value)
      end

      return new_hash
    end
93391
def to_hash
        h = {}
        keys.each { |k| h[ k ] = self.fetch( k ) }
        h
    end
34539
def api_hash(replace = nil)
      self.replace = replace unless replace.nil?
      {
        url:          href,
        description:  description,
        extended:     extended,
        tags:         tag.join(" "),
        replace:      replace,
        shared:       shared,
        toread:       toread
      }.select { |key, value| ! value.nil? }
    end
1190274
def to_hash
      ret = {}
      self.each_pair do |k, v|
        ret[k] = v.to_hash()
      end
      ret
    end
124743
def to_hash
      _new_hash= {}
      each do |key, value|
        _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
      end
      Hash.new(default).merge!(_new_hash)
    end