From a34a3b3aa52fa4b68430d34cddba66120efc5231 Mon Sep 17 00:00:00 2001 From: Slava Zanko Date: Sun, 31 Jul 2011 23:44:15 +0300 Subject: [PATCH] Added vfs_path_tokens_count() and vfs_path_tokens_get() functions ...for easy work with vfs_path_t tokens. Signed-off-by: Slava Zanko --- lib/vfs/path.c | 181 +++++++++++++++++++++++++++- lib/vfs/path.h | 2 + tests/lib/vfs/Makefile.am | 4 + tests/lib/vfs/path_manipulations.c | 238 +++++++++++++++++++++++++++++++++++++ 4 files changed, 420 insertions(+), 5 deletions(-) create mode 100644 tests/lib/vfs/path_manipulations.c diff --git a/lib/vfs/path.c b/lib/vfs/path.c index 69df114e2..746b85916 100644 --- a/lib/vfs/path.c +++ b/lib/vfs/path.c @@ -515,7 +515,8 @@ vfs_path_from_str_uri_parser (char *path) (element->encoding != NULL) ? str_crt_conv_from (element->encoding) : INVALID_CONV; vpath->path = g_list_prepend (vpath->path, element); - if (real_vfs_prefix_start > path && *(real_vfs_prefix_start) == PATH_SEP) + if ((real_vfs_prefix_start > path && *(real_vfs_prefix_start) == PATH_SEP) || + (real_vfs_prefix_start == path && *(real_vfs_prefix_start) != PATH_SEP)) *real_vfs_prefix_start = '\0'; else *(real_vfs_prefix_start + 1) = '\0'; @@ -536,6 +537,52 @@ vfs_path_from_str_uri_parser (char *path) } /* --------------------------------------------------------------------------------------------- */ +/** + * Add element's class info to result string (such as VFS name, host, encoding etc) + * This function used as helper only in vfs_path_tokens_get() function + * + * @param element current path element + * @param ret_tokens total tikens for return + * @param element_tokens accumulated element-only tokens + */ + +static void +vfs_path_tokens_add_class_info (vfs_path_element_t * element, GString * ret_tokens, + GString * element_tokens) +{ + if (((element->class->flags & VFSF_LOCAL) == 0 || ret_tokens->len > 0) + && element_tokens->len > 0) + { + char *url_str; + + if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP) + g_string_append_c (ret_tokens, PATH_SEP); + + g_string_append (ret_tokens, element->vfs_prefix); + g_string_append (ret_tokens, VFS_PATH_URL_DELIMITER); + + url_str = vfs_path_build_url_params_str (element); + if (*url_str != '\0') + { + g_string_append (ret_tokens, url_str); + g_string_append_c (ret_tokens, PATH_SEP); + } + + g_free (url_str); + } + if (element->encoding != NULL) + { + if (ret_tokens->len > 0 && ret_tokens->str[ret_tokens->len - 1] != PATH_SEP) + g_string_append (ret_tokens, PATH_SEP_STR); + g_string_append (ret_tokens, VFS_ENCODING_PREFIX); + g_string_append (ret_tokens, element->encoding); + g_string_append (ret_tokens, PATH_SEP_STR); + } + + g_string_append (ret_tokens, element_tokens->str); +} + +/* --------------------------------------------------------------------------------------------- */ /*** public functions ****************************************************************************/ /* --------------------------------------------------------------------------------------------- */ /** @@ -583,8 +630,8 @@ vfs_path_to_str_elements_count (const vfs_path_t * vpath, int elements_count) { char *url_str; - if (buffer->str[buffer->len - 1] != '/') - g_string_append_c (buffer, '/'); + if (buffer->len == 0 || buffer->str[buffer->len - 1] != PATH_SEP) + g_string_append_c (buffer, PATH_SEP); g_string_append (buffer, element->vfs_prefix); g_string_append (buffer, VFS_PATH_URL_DELIMITER); @@ -1038,8 +1085,10 @@ vfs_path_deserialize (const char *data, GError ** error) /* --------------------------------------------------------------------------------------------- */ /** * Build vfs_path_t object from arguments. - * - * return newly allocated vfs_path_t object + * + * @param ... path tokens, terminated by NULL + * + * @return newly allocated vfs_path_t object */ vfs_path_t * @@ -1061,6 +1110,14 @@ vfs_path_build_filename (const char *first_element, ...) } /* --------------------------------------------------------------------------------------------- */ +/** + * Append tokens to path object + * + * @param vpath path object + * @param ... NULL-terminated strings + * + * @return newly allocated path object + */ vfs_path_t * vfs_path_append_new (const vfs_path_t * vpath, const char *first_element, ...) @@ -1086,3 +1143,117 @@ vfs_path_append_new (const vfs_path_t * vpath, const char *first_element, ...) } /* --------------------------------------------------------------------------------------------- */ +/** + * get tockens count in path. + * + * @param vpath path object + * + * @return count of tokens + */ + +size_t +vfs_path_tokens_count (const vfs_path_t * vpath) +{ + size_t count_tokens = 0; + int element_index; + + if (vpath == NULL) + return 0; + + for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++) + { + vfs_path_element_t *element; + char **path_tokens, **iterator; + + element = vfs_path_get_by_index (vpath, element_index); + path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1); + + while (*iterator != NULL) + { + if (**iterator != '\0') + count_tokens++; + iterator++; + } + g_strfreev (path_tokens); + } + return count_tokens; +} + +/* --------------------------------------------------------------------------------------------- */ +/** + * Get subpath by tokens + * + * @param vpath path object + * @param start_position first token for got/ Started from 0. + * If negative, then position will be relative to end of path + * @param length count of tokens + * + * @return newly allocated string with path tokens separated by slash + */ + +char * +vfs_path_tokens_get (const vfs_path_t * vpath, ssize_t start_position, size_t length) +{ + GString *ret_tokens, *element_tokens; + int element_index; + size_t tokens_count = vfs_path_tokens_count (vpath); + + if (length == 0) + length = tokens_count; + + if (start_position < 0) + start_position = (ssize_t) tokens_count + start_position; + + if (start_position < 0) + return NULL; + + if (start_position >= (ssize_t) tokens_count) + return NULL; + + if (start_position + (ssize_t) length > (ssize_t) tokens_count) + length = tokens_count - start_position; + + ret_tokens = g_string_sized_new (32); + element_tokens = g_string_sized_new (32); + + for (element_index = 0; element_index < vfs_path_elements_count (vpath); element_index++) + { + vfs_path_element_t *element; + char **path_tokens, **iterator; + + g_string_assign (element_tokens, ""); + element = vfs_path_get_by_index (vpath, element_index); + path_tokens = iterator = g_strsplit (element->path, PATH_SEP_STR, -1); + + while (*iterator != NULL) + { + if (**iterator != '\0') + { + if (start_position == 0) + { + if (length == 0) + { + vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens); + g_string_free (element_tokens, TRUE); + g_strfreev (path_tokens); + return g_string_free (ret_tokens, FALSE); + } + length--; + if (element_tokens->len != 0) + g_string_append_c (element_tokens, PATH_SEP); + g_string_append (element_tokens, *iterator); + } + else + start_position--; + } + iterator++; + } + g_strfreev (path_tokens); + vfs_path_tokens_add_class_info (element, ret_tokens, element_tokens); + } + + g_string_free (element_tokens, TRUE); + return g_string_free (ret_tokens, !(start_position == 0 && length == 0)); +} + +/* --------------------------------------------------------------------------------------------- */ diff --git a/lib/vfs/path.h b/lib/vfs/path.h index a450c20db..a2266cd74 100644 --- a/lib/vfs/path.h +++ b/lib/vfs/path.h @@ -59,6 +59,8 @@ vfs_path_t *vfs_path_from_str (const char *path_str); vfs_path_t *vfs_path_from_str_flags (const char *path_str, vfs_path_flag_t flags); vfs_path_t *vfs_path_build_filename (const char *first_element, ...); vfs_path_t *vfs_path_append_new (const vfs_path_t *, const char *first_element, ...); +size_t vfs_path_tokens_count (const vfs_path_t *); +char *vfs_path_tokens_get (const vfs_path_t * vpath, ssize_t start_position, size_t length); vfs_path_element_t *vfs_path_get_by_index (const vfs_path_t * path, int element_index); vfs_path_element_t *vfs_path_element_clone (const vfs_path_element_t * element); diff --git a/tests/lib/vfs/Makefile.am b/tests/lib/vfs/Makefile.am index e64fbc035..e3e0bdce1 100644 --- a/tests/lib/vfs/Makefile.am +++ b/tests/lib/vfs/Makefile.am @@ -11,6 +11,7 @@ LIBS=@CHECK_LIBS@ \ TESTS = \ canonicalize_pathname \ current_dir \ + path_manipulations \ path_recode \ path_serialize \ tempdir \ @@ -28,6 +29,9 @@ canonicalize_pathname_SOURCES = \ current_dir_SOURCES = \ current_dir.c +path_manipulations_SOURCES = \ + path_manipulations.c + path_recode_SOURCES = \ path_recode.c diff --git a/tests/lib/vfs/path_manipulations.c b/tests/lib/vfs/path_manipulations.c new file mode 100644 index 000000000..74e5e9bb3 --- /dev/null +++ b/tests/lib/vfs/path_manipulations.c @@ -0,0 +1,238 @@ +/* lib/vfs - test vfs_path_t manipulation functions + + Copyright (C) 2011 Free Software Foundation, Inc. + + Written by: + Slava Zanko , 2011 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License + as published by the Free Software Foundation; either version 2 of + the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. +*/ + +#define TEST_SUITE_NAME "/lib/vfs" + +#include + +#include "lib/global.c" + +#ifndef HAVE_CHARSET +#define HAVE_CHARSET 1 +#endif + +#include "lib/charsets.h" + +#include "lib/strutil.h" +#include "lib/vfs/xdirentry.h" +#include "lib/vfs/path.h" + +#include "src/vfs/local/local.c" + + +struct vfs_s_subclass test_subclass1, test_subclass2, test_subclass3; +struct vfs_class vfs_test_ops1, vfs_test_ops2, vfs_test_ops3; + +static void +setup (void) +{ + + str_init_strings (NULL); + + vfs_init (); + init_localfs (); + vfs_setup_work_dir (); + + + test_subclass1.flags = VFS_S_REMOTE; + vfs_s_init_class (&vfs_test_ops1, &test_subclass1); + + vfs_test_ops1.name = "testfs1"; + vfs_test_ops1.flags = VFSF_NOLINKS; + vfs_test_ops1.prefix = "test1"; + vfs_register_class (&vfs_test_ops1); + + vfs_s_init_class (&vfs_test_ops2, &test_subclass2); + vfs_test_ops2.name = "testfs2"; + vfs_test_ops2.prefix = "test2"; + vfs_register_class (&vfs_test_ops2); + + vfs_s_init_class (&vfs_test_ops3, &test_subclass3); + vfs_test_ops3.name = "testfs3"; + vfs_test_ops3.prefix = "test3"; + vfs_test_ops3.flags = VFSF_LOCAL; + vfs_register_class (&vfs_test_ops3); + + mc_global.sysconfig_dir = (char *) TEST_SHARE_DIR; + load_codepages_list (); +} + +static void +teardown (void) +{ + free_codepages_list (); + + vfs_shut (); + str_uninit_strings (); +} + +/* --------------------------------------------------------------------------------------------- */ + +START_TEST (test_vfs_path_tokens_count) +{ + size_t tokens_count; + vfs_path_t *vpath; + + vpath = vfs_path_from_str ("/"); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 0, "actual: %zu; expected: 0\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str ("/path"); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 1, "actual: %zu; expected: 1\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str ("/path1/path2/path3"); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 3, "actual: %zu; expected: 3\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str_flags ("test3://path1/path2/path3/path4", VPF_NO_CANON); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 4, "actual: %zu; expected: 4\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str_flags ("path1/path2/path3", VPF_NO_CANON); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 3, "actual: %zu; expected: 3\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str ("/path1/path2/path3/"); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 3, "actual: %zu; expected: 3\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str ("/local/path/test1://user:pass@some.host:12345/bla-bla/some/path/"); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 5, "actual: %zu; expected: 5\n", tokens_count); + vfs_path_free (vpath); + + vpath = vfs_path_from_str ( + "/local/path/test1://user:pass@some.host:12345/bla-bla/some/path/test2://#enc:KOI8-R/bla-bla/some/path/test3://111/22/33" + ); + tokens_count = vfs_path_tokens_count(vpath); + fail_unless (tokens_count == 11, "actual: %zu; expected: 11\n", tokens_count); + vfs_path_free (vpath); +} +END_TEST + +/* --------------------------------------------------------------------------------------------- */ + +#define check_invalid_token_str(input, start, length) { \ + vpath = vfs_path_from_str (input); \ + path_tokens = vfs_path_tokens_get(vpath, start, length); \ + fail_unless (path_tokens == NULL, "path_tokens should be NULL!\n"); \ + g_free (path_tokens); \ + vfs_path_free (vpath); \ +} + +#define check_token_str(input, start, length, etalon) { \ + vpath = vfs_path_from_str_flags (input, VPF_NO_CANON); \ + path_tokens = vfs_path_tokens_get(vpath, start, length); \ + fail_unless (path_tokens != NULL, "path_tokens shouldn't equal to NULL!\n"); \ + if (path_tokens != NULL) \ + fail_unless (strcmp(path_tokens, etalon) == 0, "\nactual: '%s'\netalon: '%s'", path_tokens, etalon); \ + g_free (path_tokens); \ + vfs_path_free (vpath); \ +} + +START_TEST (test_vfs_path_tokens_get) +{ + vfs_path_t *vpath; + char *path_tokens; + + /* Invalid start position */ + check_invalid_token_str ("/" , 2, 1); + + /* Invalid negative position */ + check_invalid_token_str ("/path" , -3, 1); + + /* Count of tokens is zero. Count should be autocorrected */ + check_token_str ("/path", 0, 0, "path"); + + /* get 'path2/path3' by 1,2 */ + check_token_str ("/path1/path2/path3/path4", 1, 2, "path2/path3"); + + /* get 'path2/path3' by 1,2 from LOCAL VFS */ + check_token_str ("test3://path1/path2/path3/path4", 1, 2, "path2/path3"); + + /* get 'path2/path3' by 1,2 from LOCAL VFS with encoding */ + check_token_str ("test3://path1/path2/test3://#enc:KOI8-R/path3/path4", 1, 2, "path2/test3://#enc:KOI8-R/path3"); + + /* get 'path2/path3' by 1,2 with encoding */ + check_token_str ("#enc:KOI8-R/path1/path2/path3/path4", 1, 2, "#enc:KOI8-R/path2/path3"); + + /* get 'path2/path3' by 1,2 from non-LOCAL VFS */ + check_token_str ("test2://path1/path2/path3/path4", 1, 2, "test2://path2/path3"); + + /* get 'path2/path3' by 1,2 throught non-LOCAL VFS */ + check_token_str ("/path1/path2/test1://user:pass@some.host:12345/path3/path4", 1, 2, "path2/test1://user:pass@some.host:12345/path3"); + + /* get 'path2/path3' by 1,2 from LOCAL VFS */ + /* TODO: currently this test don't passed. Probably broken string URI parser */ +/* check_token_str ("test3://path1/path2/test2://test3://path3/path4", 1, 2, "path2/path3"); */ + + /* get 'path2/path3' by 1,2 where path2 it's LOCAL VFS */ + check_token_str ("test3://path1/path2/test2://path3/path4", 1, 2, "path2/test2://path3"); + + /* get 'path2/path3' by 1,2 where path3 it's LOCAL VFS */ + check_token_str ("test2://path1/path2/test3://path3/path4", 1, 2, "test2://path2/test3://path3"); + + /* get 'path4' by -1,1 */ + check_token_str ("/path1/path2/path3/path4", -1, 1, "path4"); + + /* get 'path2/path3/path4' by -3,0 */ + check_token_str ("/path1/path2/path3/path4", -3, 0, "path2/path3/path4"); + +} +END_TEST + +/* --------------------------------------------------------------------------------------------- */ + + +int +main (void) +{ + int number_failed; + + Suite *s = suite_create (TEST_SUITE_NAME); + TCase *tc_core = tcase_create ("Core"); + SRunner *sr; + + tcase_add_checked_fixture (tc_core, setup, teardown); + + /* Add new tests here: *************** */ + tcase_add_test (tc_core, test_vfs_path_tokens_count); + tcase_add_test (tc_core, test_vfs_path_tokens_get); + /* *********************************** */ + + suite_add_tcase (s, tc_core); + sr = srunner_create (s); + srunner_set_log (sr, "path_manipulations.log"); + srunner_run_all (sr, CK_NORMAL); + number_failed = srunner_ntests_failed (sr); + srunner_free (sr); + return (number_failed == 0) ? 0 : 1; +} + +/* --------------------------------------------------------------------------------------------- */ -- 2.11.4.GIT