anchor.diff:  -spec(acls(acls()) ->
                string()).
   acls(ACLs) ->
  -    Col1Len = lists:foldl(fun(#bucket_acl_info{user_id = User} = _ACL, C1) ->
  -                                  UserStr = binary_to_list(User),
  -                                  Len = length(UserStr),
  -                                  case (Len > C1) of
  -                                      true  -> Len;
  -                                      false -> C1
  -                                  end
  -                          end, 14, ACLs),
  -    Col2Len = 24, % @todo to be calcurated
  +    Col_1_Len = lists:foldl(fun(#bucket_acl_info{user_id = User} = _ACL, C1) ->
  +                                    UserStr = binary_to_list(User),
  +                                    Len = length(UserStr),
  +                                    case (Len > C1) of
  +                                        true  -> Len;
  +                                        false -> C1
  +                                    end
  +                            end, 14, ACLs),
  +    Col_2_Len = 24, % @todo to be calcurated
       Header = lists:append(
  -               [string:left("access_key_id", Col1Len), " | ",
  -                string:left("permissions",   Col2Len), "\r\n",
  -                lists:duplicate(Col1Len, "-"), "-+-",
  -                lists:duplicate(Col2Len, "-"), "\r\n"]),
  +               [string:left("access_key_id", Col_1_Len), " | ",
  +                string:left("permissions",   Col_2_Len), "\r\n",
  +                lists:duplicate(Col_1_Len, "-"), "-+-",
  +                lists:duplicate(Col_2_Len, "-"), "\r\n"]),
   
       Fun = fun(#bucket_acl_info{user_id = User, permissions = Permissions} = _ACL, Acc) ->
                     UserStr = binary_to_list(User),
  
positive.code:                              case (Len4 > C4) of
                                   true  -> Len4;
                                   false -> C4
                               end
                              }
                      end, {Col1MinLen, Col2MinLen,
                            Col3MinLen, Col4MinLen}, Buckets),
      Col5Len = 26, %% created at
  
      Header = lists:append(
                 [
                  string:left("cluster id",  Col1Len), " | ",
                  string:left("bucket",      Col2Len), " | ",
                  string:left("owner",       Col3Len), " | ",
                  string:left("permissions", Col4Len), " | ",
                  string:left("created at",  Col5Len), "\r\n",
  
                  lists:duplicate(Col1Len, "-"), "-+-",
                  lists:duplicate(Col2Len, "-"), "-+-",
                  lists:duplicate(Col3Len, "-"), "-+-",
                  lists:duplicate(Col4Len, "-"), "-+-",
                  lists:duplicate(Col5Len, "-"), "\r\n"
                 ]),
  
      Fun = fun(#bucket_dto{name = Bucket,
                            owner = #user_credential{user_id= Owner},
                            acls  = Permissions1,
                            cluster_id = ClusterId,
                            created_at = Created1}, Acc) ->
                    ClusterIdStr = atom_to_list(ClusterId),
                    BucketStr = binary_to_list(Bucket),
                    OwnerStr  = binary_to_list(Owner),
                    PermissionsStr = leo_s3_bucket:aclinfo_to_str(Permissions1),
                    Created2  = case (Created1 > 0) of
                                    true  -> leo_date:date_format(Created1);
                                    false -> []
                                end,
  
                    Acc ++ io_lib:format("~s | ~s | ~s | ~s | ~s\r\n",
                                         [
                                          string:left(ClusterIdStr,   Col1Len),
                                          string:left(BucketStr,      Col2Len),
                                          string:left(OwnerStr,       Col3Len),
                                          string:left(PermissionsStr, Col4Len),
                                          Created2])
            end,
      lists:append([lists:foldl(Fun, Header, Buckets), "\r\n"]).
  
  
  %% @doc Format a bucket list
  %%
  -spec(bucket_by_access_key(list(#?BUCKET{})) ->
               string()).
  bucket_by_access_key(Buckets) ->
      Col1MinLen = 8,
      Col2MinLen = 12,
      {Col1Len, Col2Len} =
          lists:foldl(fun(#?BUCKET{name = Bucket,
                                   acls = Permissions}, {C1, C2}) ->
                              BucketStr = binary_to_list(Bucket),
  
negative.code:                                                                   "\r\n"]))
                                end,
                    Acc ++ io_lib:format(FormatStr,
                                         [string:left(UserStr, Col_1_Len)] ++ Permissions)
            end,
      lists:append([lists:foldl(Fun, Header, ACLs), "\r\n"]).
  
  