static int l_revprop_list (lua_State *L) { const char *url = luaL_checkstring (L, 1); svn_opt_revision_t revision; if (lua_gettop (L) < 2 || lua_isnil (L, 2)) { revision.kind = get_revision_kind (url); } else { revision.kind = svn_opt_revision_number; revision.value.number = lua_tointeger (L, 2); } apr_pool_t *pool; svn_error_t *err; svn_client_ctx_t *ctx; init_function (&ctx, &pool, L); url = svn_path_canonicalize (url, pool); apr_hash_t *entries; apr_hash_index_t *hi; void *val; const void *key; svn_revnum_t rev; err = svn_client_revprop_list (&entries, url, &revision, &rev, ctx, pool); IF_ERROR_RETURN (err, pool, L); lua_newtable (L); for (hi = apr_hash_first (pool, entries); hi; hi = apr_hash_next (hi)) { const char *pname; svn_string_t *pval; apr_hash_this (hi, &key, NULL, &val); pname = key; pval = (svn_string_t *) val; if (svn_prop_needs_translation (pname)) { err = svn_subst_translate_string (&pval, pval, APR_LOCALE_CHARSET, pool); IF_ERROR_RETURN (err, pool, L); } err = svn_cmdline_cstring_from_utf8 (&pname, pname, pool); IF_ERROR_RETURN (err, pool, L); lua_pushstring (L, pval->data); lua_setfield (L, -2, pname); } svn_pool_destroy (pool); return 1; }
static int l_revprop_set (lua_State *L) { apr_pool_t *pool; svn_error_t *err; svn_client_ctx_t *ctx; svn_opt_revision_t revision; svn_revnum_t rev; const char *url = luaL_checkstring (L, 1); const char *propname = luaL_checkstring (L, 2); const char *propval = lua_isnil (L, 3) ? NULL : luaL_checkstring (L, 3); const char *propname_utf8 = NULL; int itable = 5; svn_boolean_t force = FALSE; if (lua_gettop (L) < 4 || lua_isnil (L, 4)) { revision.kind = get_revision_kind (url); } else { revision.kind = svn_opt_revision_number; revision.value.number = lua_tointeger (L, 4); } if (lua_gettop (L) >= itable && lua_istable (L, itable)) { lua_getfield (L, itable, "force"); if (lua_isboolean (L, -1)) { force = lua_toboolean (L, -1); } } init_function (&ctx, &pool, L); url = svn_path_canonicalize (url, pool); err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool); IF_ERROR_RETURN (err, pool, L); if (propval != NULL) { svn_string_t *sstring = svn_string_create (propval, pool); if (svn_prop_needs_translation (propname_utf8)) { err = svn_subst_translate_string (&sstring, sstring, APR_LOCALE_CHARSET, pool); IF_ERROR_RETURN (err, pool, L); } err = svn_client_revprop_set (propname_utf8, sstring, url, &revision, &rev, force, ctx, pool); } else { err = svn_client_revprop_set (propname_utf8, NULL, url, &revision, &rev, force, ctx, pool); } IF_ERROR_RETURN (err, pool, L); svn_pool_destroy (pool); return 0; }
/* Get a lock comment, allocate it in POOL and store it in *COMMENT. */ static svn_error_t * get_comment(const char **comment, svn_client_ctx_t *ctx, svn_cl__opt_state_t *opt_state, apr_pool_t *pool) { svn_string_t *comment_string; if (opt_state->filedata) { /* Get it from the -F argument. */ if (strlen(opt_state->filedata->data) < opt_state->filedata->len) { /* A message containing a zero byte can't be represented as a C string. */ return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL, _("Lock comment contains a zero byte")); } comment_string = svn_string_create(opt_state->filedata->data, pool); } else if (opt_state->message) { /* Get if from the -m option. */ comment_string = svn_string_create(opt_state->message, pool); } else { *comment = NULL; return SVN_NO_ERROR; } /* Translate to UTF8/LF. */ SVN_ERR(svn_subst_translate_string(&comment_string, comment_string, opt_state->encoding, pool)); *comment = comment_string->data; return SVN_NO_ERROR; }
/* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__propset(apr_getopt_t *os, void *baton, apr_pool_t *pool) { svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state; svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx; const char *pname, *pname_utf8; svn_string_t *propval = NULL; svn_boolean_t propval_came_from_cmdline; apr_array_header_t *args, *targets; int i; /* PNAME and PROPVAL expected as first 2 arguments if filedata was NULL, else PNAME alone will precede the targets. Get a UTF-8 version of the name, too. */ SVN_ERR(svn_opt_parse_num_args(&args, os, opt_state->filedata ? 1 : 2, pool)); pname = APR_ARRAY_IDX(args, 0, const char *); SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool)); if (! svn_prop_name_is_valid(pname_utf8)) return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL, _("'%s' is not a valid Subversion property name"), pname_utf8); /* Get the PROPVAL from either an external file, or from the command line. */ if (opt_state->filedata) { propval = svn_string_create_from_buf(opt_state->filedata, pool); propval_came_from_cmdline = FALSE; } else { propval = svn_string_create(APR_ARRAY_IDX(args, 1, const char *), pool); propval_came_from_cmdline = TRUE; } /* We only want special Subversion property values to be in UTF-8 and LF line endings. All other propvals are taken literally. */ if (svn_prop_needs_translation(pname_utf8)) SVN_ERR(svn_subst_translate_string(&propval, propval, opt_state->encoding, pool)); else if (opt_state->encoding) return svn_error_create (SVN_ERR_UNSUPPORTED_FEATURE, NULL, _("--encoding option applies only to textual" " Subversion-controlled properties")); /* Suck up all the remaining arguments into a targets array */ SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os, opt_state->targets, ctx, pool)); if (! opt_state->quiet) svn_cl__get_notifier(&ctx->notify_func2, &ctx->notify_baton2, FALSE, FALSE, FALSE, pool); /* Implicit "." is okay for revision properties; it just helps us find the right repository. */ if (opt_state->revprop) svn_opt_push_implicit_dot_target(targets, pool); SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool)); if (opt_state->revprop) /* operate on a revprop */ { svn_revnum_t rev; const char *URL; SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets, &URL, pool)); /* Let libsvn_client do the real work. */ SVN_ERR(svn_client_revprop_set2(pname_utf8, propval, NULL, URL, &(opt_state->start_revision), &rev, opt_state->force, ctx, pool)); } else if (opt_state->start_revision.kind != svn_opt_revision_unspecified) { return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL, _("Cannot specify revision for setting versioned property '%s'"), pname); } else /* operate on a normal, versioned property (not a revprop) */ { apr_pool_t *subpool = svn_pool_create(pool); if (opt_state->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; /* The customary implicit dot rule has been prone to user error * here. People would do intuitive things like * * $ svn propset svn:executable script * * and then be surprised to get an error like: * * svn: Illegal target for the requested operation * svn: Cannot set svn:executable on a directory () * * So we don't do the implicit dot thing anymore. A * target * must always be explicitly provided when setting a versioned * property. See * * http://subversion.tigris.org/issues/show_bug.cgi?id=924 * * for more details. */ if (targets->nelts == 0) { if (propval_came_from_cmdline) { return svn_error_createf (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target required ('%s' interpreted as prop value)"), propval->data); } else { return svn_error_create (SVN_ERR_CL_INSUFFICIENT_ARGS, NULL, _("Explicit target argument required")); } } for (i = 0; i < targets->nelts; i++) { const char *target = APR_ARRAY_IDX(targets, i, const char *); svn_commit_info_t *commit_info; svn_pool_clear(subpool); SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton)); SVN_ERR(svn_cl__try(svn_client_propset3 (&commit_info, pname_utf8, propval, target, opt_state->depth, opt_state->force, SVN_INVALID_REVNUM, opt_state->changelists, NULL, ctx, subpool), NULL, opt_state->quiet, SVN_ERR_UNVERSIONED_RESOURCE, SVN_ERR_ENTRY_NOT_FOUND, SVN_NO_ERROR)); if (! opt_state->quiet) svn_cl__check_boolean_prop_val(pname_utf8, propval->data, subpool); } svn_pool_destroy(subpool); } return SVN_NO_ERROR; }