diff options
47 files changed, 4100 insertions, 2043 deletions
@@ -32,8 +32,9 @@ Makefile.in /stamp-h1 .dirstamp /build-aux/* -!/build-aux/build-windows.sh !/build-aux/git-version-gen +!/build-aux/travis-build.sh +!/build-aux/travis-deploy.sh # installed .m4 files /m4/*.m4 @@ -43,8 +44,10 @@ Makefile.in /blogc*.[17] blogc*.html -# blogc +# binaries /blogc +/blogc-git-receiver +/blogc-runserver # tests /tests/check_content_parser @@ -66,3 +69,5 @@ blogc-*.rpm # git-version-gen /.version + +/build/ diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..15c4906 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,34 @@ +dist: trusty +sudo: required +language: c + +addons: + apt: + packages: + - libcmocka-dev + - libmagic-dev + - libevent-dev + - rpm + - valgrind + +compiler: + - clang + - gcc + +env: + - TARGET=valgrind + - TARGET=distcheck + - TARGET=dist-srpm + +matrix: + exclude: + - compiler: clang + env: TARGET=dist-srpm + +install: gem install ronn + +before_script: ./autogen.sh + +script: + - ./build-aux/travis-build.sh + - ./build-aux/travis-deploy.sh diff --git a/Makefile.am b/Makefile.am index 2c36543..5ebb3bd 100644 --- a/Makefile.am +++ b/Makefile.am @@ -4,15 +4,16 @@ ACLOCAL_AMFLAGS = -I m4 AM_DISTCHECK_CONFIGURE_FLAGS = \ --enable-tests \ - --enable-ronn \ + --disable-ronn \ --disable-valgrind \ + --enable-git-receiver \ + --enable-runserver \ $(NULL) ## File listings EXTRA_DIST = \ - build-aux/build-windows.sh \ build-aux/git-version-gen \ $(top_srcdir)/.version \ autogen.sh \ @@ -40,11 +41,12 @@ noinst_HEADERS = \ src/renderer.h \ src/source-parser.h \ src/template-parser.h \ - src/utils/utils.h \ + src/utils.h \ $(NULL) noinst_LTLIBRARIES = \ libblogc.la \ + libblogc_utils.la \ $(NULL) noinst_PROGRAMS = \ @@ -54,6 +56,18 @@ bin_PROGRAMS = \ blogc \ $(NULL) +if BUILD_GIT_RECEIVER +bin_PROGRAMS += \ + blogc-git-receiver \ + $(NULL) +endif + +if BUILD_RUNSERVER +bin_PROGRAMS += \ + blogc-runserver \ + $(NULL) +endif + check_PROGRAMS = \ $(NULL) @@ -68,10 +82,6 @@ libblogc_la_SOURCES = \ src/renderer.c \ src/source-parser.c \ src/template-parser.c \ - src/utils/mem.c \ - src/utils/slist.c \ - src/utils/strings.c \ - src/utils/trie.c \ $(NULL) libblogc_la_CFLAGS = \ @@ -84,8 +94,18 @@ libblogc_la_LIBADD = \ $(NULL) +libblogc_utils_la_SOURCES = \ + src/utils.c \ + $(NULL) + +libblogc_utils_la_CFLAGS = \ + $(AM_CFLAGS) \ + -I$(top_srcdir)/src \ + $(NULL) + + blogc_SOURCES = \ - src/main.c \ + src/blogc.c \ $(NULL) blogc_CFLAGS = \ @@ -95,23 +115,78 @@ blogc_CFLAGS = \ blogc_LDADD = \ libblogc.la \ + libblogc_utils.la \ + $(NULL) + + +if BUILD_GIT_RECEIVER +blogc_git_receiver_SOURCES = \ + src/blogc-git-receiver.c \ + $(NULL) + +blogc_git_receiver_CFLAGS = \ + $(AM_CFLAGS) \ + -I$(top_srcdir)/src \ $(NULL) +blogc_git_receiver_LDADD = \ + libblogc_utils.la \ + $(NULL) +endif + + +if BUILD_RUNSERVER +blogc_runserver_SOURCES = \ + src/blogc-runserver.c \ + $(NULL) + +blogc_runserver_CFLAGS = \ + $(AM_CFLAGS) \ + -I$(top_srcdir)/src \ + $(LIBEVENT_CFLAGS) \ + $(SQUAREBALL_CFLAGS) \ + $(NULL) + +blogc_runserver_LDADD = \ + $(LIBEVENT_LIBS) \ + $(MAGIC_LIBS) \ + libblogc_utils.la \ + $(NULL) +endif + ## Build rules: man pages EXTRA_DIST += \ man/blogc.1.ronn \ + man/blogc-git-receiver.1.ronn \ + man/blogc-runserver.1.ronn \ man/blogc-source.7.ronn \ man/blogc-template.7.ronn \ + man/blogc-pagination.7.ronn \ man/index.txt \ + blogc-git-receiver.1 \ + blogc-runserver.1 \ $(NULL) dist_man_MANS = \ blogc.1 \ blogc-source.7 \ blogc-template.7 \ + blogc-pagination.7 \ + $(NULL) + +if BUILD_GIT_RECEIVER +dist_man_MANS += \ + blogc-git-receiver.1 \ $(NULL) +endif + +if BUILD_RUNSERVER +dist_man_MANS += \ + blogc-runserver.1 \ + $(NULL) +endif MAINTAINERCLEANFILES += \ $(dist_man_MANS) \ @@ -125,7 +200,23 @@ blogc.1: man/blogc.1.ronn --pipe \ --organization "Rafael G. Martins" \ --manual "$(PACKAGE_NAME) Manual" \ - $< > $@ + $(top_srcdir)/man/blogc.1.ronn > blogc.1 + +blogc-git-receiver.1: man/blogc-git-receiver.1.ronn + $(AM_V_GEN)$(RONN) \ + --roff \ + --pipe \ + --organization "Rafael G. Martins" \ + --manual "$(PACKAGE_NAME) Manual" \ + $(top_srcdir)/man/blogc-git-receiver.1.ronn > blogc-git-receiver.1 + +blogc-runserver.1: man/blogc-runserver.1.ronn + $(AM_V_GEN)$(RONN) \ + --roff \ + --pipe \ + --organization "Rafael G. Martins" \ + --manual "$(PACKAGE_NAME) Manual" \ + $(top_srcdir)/man/blogc-runserver.1.ronn > blogc-runserver.1 blogc-source.7: man/blogc-source.7.ronn $(AM_V_GEN)$(RONN) \ @@ -133,7 +224,7 @@ blogc-source.7: man/blogc-source.7.ronn --pipe \ --organization "Rafael G. Martins" \ --manual "$(PACKAGE_NAME) Manual" \ - $< > $@ + $(top_srcdir)/man/blogc-source.7.ronn > blogc-source.7 blogc-template.7: man/blogc-template.7.ronn $(AM_V_GEN)$(RONN) \ @@ -141,19 +232,36 @@ blogc-template.7: man/blogc-template.7.ronn --pipe \ --organization "Rafael G. Martins" \ --manual "$(PACKAGE_NAME) Manual" \ - $< > $@ + $(top_srcdir)/man/blogc-template.7.ronn > blogc-template.7 + +blogc-pagination.7: man/blogc-pagination.7.ronn + $(AM_V_GEN)$(RONN) \ + --roff \ + --pipe \ + --organization "Rafael G. Martins" \ + --manual "$(PACKAGE_NAME) Manual" \ + $(top_srcdir)/man/blogc-pagination.7.ronn > blogc-pagination.7 else blogc.1: $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 +blogc-git-receiver.1: + $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 + +blogc-runserver.1: + $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 + blogc-source.7: $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 blogc-template.7: $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 +blogc-pagination.7: + $(AM_V_GEN)echo "error: ronn not found. failed to build man page: $@"; exit 1 + endif @@ -187,6 +295,7 @@ tests_check_error_LDFLAGS = \ tests_check_error_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_loader_SOURCES = \ @@ -206,6 +315,7 @@ tests_check_loader_LDFLAGS = \ tests_check_loader_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_content_parser_SOURCES = \ @@ -224,6 +334,7 @@ tests_check_content_parser_LDFLAGS = \ tests_check_content_parser_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_datetime_parser_SOURCES = \ @@ -241,6 +352,7 @@ tests_check_datetime_parser_LDFLAGS = \ tests_check_datetime_parser_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_renderer_SOURCES = \ @@ -258,6 +370,7 @@ tests_check_renderer_LDFLAGS = \ tests_check_renderer_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_source_parser_SOURCES = \ @@ -275,6 +388,7 @@ tests_check_source_parser_LDFLAGS = \ tests_check_source_parser_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_template_parser_SOURCES = \ @@ -292,6 +406,7 @@ tests_check_template_parser_LDFLAGS = \ tests_check_template_parser_LDADD = \ $(CMOCKA_LIBS) \ libblogc.la \ + libblogc_utils.la \ $(NULL) tests_check_utils_SOURCES = \ @@ -308,7 +423,7 @@ tests_check_utils_LDFLAGS = \ tests_check_utils_LDADD = \ $(CMOCKA_LIBS) \ - libblogc.la \ + libblogc_utils.la \ $(NULL) endif @@ -317,6 +432,17 @@ TESTS = \ $(check_PROGRAMS) +## Helpers: dist-srpm + +if USE_RPMBUILD +dist-srpm: blogc.spec dist-xz + $(RPMBUILD) \ + --define "_srcrpmdir $(top_builddir)" \ + --define "_sourcedir $(top_builddir)" \ + -bs blogc.spec +endif + + ## Helpers: git-version-gen $(top_srcdir)/.version: @@ -1,6 +1,6 @@ # blogc -[](https://semaphoreci.com/blogc/blogc) +[](https://travis-ci.org/blogc/blogc) A blog compiler. @@ -12,10 +12,12 @@ Clone the [Git repository](https://github.com/blogc/blogc) or grab the [latest r Inside the source directory, run the following commands: $ ./autogen.sh # if installing from git - $ ./configure + $ ./configure [--enable-git-receiver] [--enable-runserver] $ make # make install +The `./configure` options listed above will enable building of helper tools. To learn more about these tools, please read the man pages. + To create your first blog, please clone our example repository and adapt it to your needs: $ git clone https://github.com/blogc/blogc-example my-blog @@ -24,7 +26,7 @@ To create your first blog, please clone our example repository and adapt it to y $ git init $ git commit -am 'initial commit' -At this point you'll have an empty blog, that can be customized to suit your needs. You'll want to look at the 'post/' directory and edit your first post. Each new post, template or asset must be added to the Makefile. Please read it carefully. +At this point you'll have an empty blog, that can be customized to suit your needs. You'll want to look at the `content/post/` directory and edit your first post. Each new post, template or asset must be added to the `Makefile`. Please read it carefully. If some unexpected error happened, please [file an issue](https://github.com/blogc/blogc/issues/new). diff --git a/blogc.spec.in b/blogc.spec.in index 3d76ecb..534b5c1 100644 --- a/blogc.spec.in +++ b/blogc.spec.in @@ -1,43 +1,85 @@ -Name: @PACKAGE_NAME@ -Version: @PACKAGE_VERSION@ -Release: 1%{?dist} -License: BSD -Group: Applications/Text -Summary: A blog compiler -URL: @PACKAGE_URL@ -Source0: https://github.com/blogc/blogc/releases/download/v%{version}/blogc-%{version}.tar.xz - -#BuildRequires: -#Requires: +Name: @PACKAGE_NAME@ +Version: @RPM_VERSION@ +Release: 1%{?dist} +License: BSD +Group: Applications/Text +Summary: A blog compiler +URL: @PACKAGE_URL@ +Source0: https://github.com/blogc/blogc/releases/download/v@PACKAGE_VERSION@/blogc-@PACKAGE_VERSION@.tar.xz +BuildRequires: libevent-devel >= 2.0, file-devel %description blogc(1) is a blog compiler. It converts source files and templates into blog/website resources. +%package git-receiver +Summary: A simple login shell/git hook to deploy blogc websites +Group: System Environment/Shells +Requires: git, tar, make -%prep -%setup -q -n blogc-%{version} +%description git-receiver +blogc-git-receiver is a simple login shell/git hook to deploy blogc websites. + +%package runserver +Summary: A simple HTTP server to test blogc websites +Group: Development/Tools +Requires: libevent >= 2.0, file-libs + +%description runserver +blogc-runserver is a simple HTTP server to test blogc websites. +%prep +%setup -q -n @PACKAGE_NAME@-@PACKAGE_VERSION@ %build -%configure +%configure --enable-git-receiver --enable-runserver make %{?_smp_mflags} - %install rm -rf $RPM_BUILD_ROOT %make_install - %files -%{_mandir}/man*/blogc* +%{_mandir}/man*/blogc.* +%{_mandir}/man*/blogc-source.* +%{_mandir}/man*/blogc-template.* +%{_mandir}/man*/blogc-pagination.* %{_bindir}/blogc - %doc README.md %license LICENSE +%files git-receiver +%{_mandir}/man*/blogc-git-receiver.* +%{_bindir}/blogc-git-receiver +%license LICENSE + +%files runserver +%{_mandir}/man*/blogc-runserver.* +%{_bindir}/blogc-runserver +%license LICENSE %changelog +* Sat Apr 30 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.9.0-1 +- New release. Merged blogc-git-receiver and blogc-runserver. + +* Sun Apr 17 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.8.1-1 +- New release. + +* Wed Apr 6 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.8.0-1 +- New release. + +* Mon Feb 29 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.7.6-1 +- New release. Added new dependency. + +* Sun Feb 21 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.7.5-1 +- New release. + +* Sun Feb 21 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.7.4-1 +- New release. + +* Sat Feb 20 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.7.3-1 +- New release. + * Mon Jan 25 2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> 0.7.2-1 - New release. diff --git a/build-aux/build-windows.sh b/build-aux/build-windows.sh deleted file mode 100755 index bdecc8b..0000000 --- a/build-aux/build-windows.sh +++ /dev/null @@ -1,48 +0,0 @@ -#!/bin/bash - -# This script builds windows binaries, given a source tarball. -# It was designed to work on Fedora, and requires the following packages: -# -# mingw32-gcc mingw64-gcc zip -# -# This script must be called with the xz source tarball and the target version -# as arguments. - - -set -ex - -[[ $# -eq 2 ]] - - -build() { - local version=${2} - local arch=${3} - local build_dir="/tmp/blogc_build_${version}_${arch}" - local dest_dir="/tmp/blogc-${version}-w${arch}" - - rm -rf "${build_dir}" - mkdir -p "${build_dir}" - tar -xvf "${1}" -C "${build_dir}" - - pushd "${build_dir}/blogc-${version}" &> /dev/null - "mingw${arch}-configure" - make - popd &> /dev/null - - rm -rf "${dest_dir}" - mkdir -p "${dest_dir}" - cp "${build_dir}/blogc-${version}/.libs/blogc.exe" "${dest_dir}/" - cp "${build_dir}/blogc-${version}/LICENSE" "${dest_dir}/" - cp "${build_dir}/blogc-${version}/README.md" "${dest_dir}/" - - pushd "$(dirname ${dest_dir})" &> /dev/null - zip "$(basename ${dest_dir}).zip" "$(basename ${dest_dir})"/* - popd &> /dev/null - - mv "${dest_dir}.zip" . -} - - -for arch in 32 64; do - build "$1" "$2" "${arch}" -done diff --git a/build-aux/travis-build.sh b/build-aux/travis-build.sh new file mode 100755 index 0000000..53cf589 --- /dev/null +++ b/build-aux/travis-build.sh @@ -0,0 +1,21 @@ +#!/bin/bash + +set -ex + +rm -rf build +mkdir -p build + +pushd build > /dev/null + +../configure \ + CFLAGS="-Wall -g" \ + --enable-ronn \ + --disable-silent-rules \ + --enable-tests \ + --enable-valgrind \ + --enable-git-receiver \ + --enable-runserver + +popd > /dev/null + +make -C build "${TARGET}" diff --git a/build-aux/travis-deploy.sh b/build-aux/travis-deploy.sh new file mode 100755 index 0000000..51aac3e --- /dev/null +++ b/build-aux/travis-deploy.sh @@ -0,0 +1,67 @@ +#!/bin/bash + +set -e + +if [[ "x${TRAVIS_PULL_REQUEST}" != "xfalse" ]]; then + echo "This is a pull request. skipping deploy ..." + exit 0 +fi + +if [[ "x${TRAVIS_BRANCH}" != "xmaster" ]] && [[ "x${TRAVIS_TAG}" != xv* ]]; then + echo "This isn't master branch nor a valid tag. skipping deploy ..." + exit 0 +fi + +if [[ "x${CC}" != "xgcc" ]] || [[ "x${TARGET}" = "xvalgrind" ]]; then + echo "Invalid target for deploy. skipping ..." + exit 0 +fi + +if [[ ! -d build ]]; then + echo "Build directory not found." + exit 1 +fi + +if [[ "x${TARGET}" = "xdist-srpm" ]]; then + FILES=( build/*.src.rpm ) +else + FILES=( build/*.{*.tar.{gz,bz2,xz},zip} ) +fi + +TARNAME="$(grep PACKAGE_TARNAME build/config.h | cut -d\" -f2)" +VERSION="$(grep PACKAGE_VERSION build/config.h | cut -d\" -f2)" + +do_curl() { + curl \ + --silent \ + --ftp-create-dirs \ + --upload-file "${1}" \ + --user "${FTP_USER}:${FTP_PASSWORD}" \ + "ftp://${FTP_HOST}/public_html/${TARNAME}/${TARNAME}-${VERSION}/$(basename ${1})" +} + +echo " * Found files:" +for f in "${FILES[@]}"; do + echo " $(basename ${f})" +done +echo + +for f in "${FILES[@]}"; do + echo " * Processing file: $(basename ${f}):" + + echo -n " Generating SHA512 checksum ... " + pushd build > /dev/null + sha512sum "$(basename ${f})" > "$(basename ${f}).sha512" + popd > /dev/null + echo "done" + + echo -n " Uploading file ... " + do_curl "${f}" + echo "done" + + echo -n " Uploading SHA512 checksum ... " + do_curl "${f}.sha512" + echo "done" + + echo +done diff --git a/configure.ac b/configure.ac index bdb7c1e..0e36070 100644 --- a/configure.ac +++ b/configure.ac @@ -22,6 +22,30 @@ AS_IF([test "x$ac_cv_prog_cc_c99" = "xno"], [ PKG_PROG_PKG_CONFIG +AC_PROG_SED + +RPM_VERSION=`echo ${PACKAGE_VERSION} | sed "s/-/./g"` +AC_SUBST(RPM_VERSION) + +AC_ARG_ENABLE([rpmbuild], AS_HELP_STRING([--disable-rpmbuild], + [ignore presence of rpmbuild and disable srpm generation])) +AS_IF([test "x$enable_rpmbuild" != "xno"], [ + AC_PATH_PROG([rpmbuild], [rpmbuild]) + AS_IF([test "x$ac_cv_path_rpmbuild" = "x"], [ + have_rpmbuild=no + ], [ + have_rpmbuild=yes + ]) +]) +AS_IF([test "x$have_rpmbuild" = "xyes"], , [ + AS_IF([test "x$enable_rpmbuild" = "xyes"], [ + AC_MSG_ERROR([rpmbuild requested but not found]) + ]) +]) +AM_CONDITIONAL([USE_RPMBUILD], [test "x$ac_cv_path_rpmbuild" != "x"]) +RPMBUILD="$ac_cv_path_rpmbuild" +AC_SUBST(RPMBUILD) + AC_ARG_ENABLE([ronn], AS_HELP_STRING([--disable-ronn], [ignore presence of ronn and disable man pages generation])) AS_IF([test "x$enable_ronn" != "xno"], [ @@ -95,29 +119,67 @@ AS_IF([test "x$have_cmocka" = "xyes"], , [ ]) AM_CONDITIONAL([USE_CMOCKA], [test "x$have_cmocka" = "xyes"]) +GIT_RECEIVER="disabled" +AC_ARG_ENABLE([git-receiver], AS_HELP_STRING([--enable-git-receiver], + [build blogc-git-receiver tool])) +AS_IF([test "x$enable_git_receiver" = "xyes"], [ + AC_CHECK_HEADERS([sys/types.h sys/stat.h time.h libgen.h unistd.h errno.h dirent.h], [ + GIT_RECEIVER="enabled" + have_git_receiver=yes + ], [ + AC_MSG_ERROR([blogc-git-receiver tool requested but required headers not found]) + ]) +]) +AM_CONDITIONAL([BUILD_GIT_RECEIVER], [test "x$have_git_receiver" = "xyes"]) + +RUNSERVER="disabled" +AC_ARG_ENABLE([runserver], AS_HELP_STRING([--enable-runserver], + [build blogc-runserver tool])) +AS_IF([test "x$enable_runserver" = "xyes"], [ + AC_CHECK_HEADERS([signal.h stdarg.h fcntl.h unistd.h sys/stat.h sys/types.h],, [ + AC_MSG_ERROR([blogc-runserver tool requested but required headers not found]) + ]) + AC_CHECK_HEADERS([magic.h],, [ + AC_MSG_ERROR([blogc-runserver tool requested but libmagic headers not found]) + ]) + AC_CHECK_LIB(magic, [magic_open], [MAGIC_LIBS="-lmagic"], [ + AC_MSG_ERROR([blogc-runserver tool requested but libmagic library not found]) + ]) + AC_SUBST(MAGIC_LIBS) + PKG_CHECK_MODULES([LIBEVENT], [libevent >= 2.0]) + RUNSERVER="enabled" + have_runserver=yes +]) +AM_CONDITIONAL([BUILD_RUNSERVER], [test "x$have_runserver" = "xyes"]) + AC_CHECK_HEADERS([sys/types.h sys/stat.h time.h]) LT_LIB_M AC_CONFIG_FILES([ - Makefile - blogc.spec + Makefile + blogc.spec ]) + AC_OUTPUT AS_ECHO(" - ==== ${PACKAGE_STRING} ==== + ====== ${PACKAGE_STRING} ====== + + prefix: ${prefix} + exec_prefix: ${exec_prefix} + bindir: ${bindir} - prefix: ${prefix} - exec_prefix: ${exec_prefix} - bindir: ${bindir} + compiler: ${CC} + cflags: ${CFLAGS} + ldflags: ${LDFLAGS} - compiler: ${CC} - cflags: ${CFLAGS} - ldflags: ${LDFLAGS} + blogc-git-receiver: ${GIT_RECEIVER} + blogc-runserver: ${RUNSERVER} - tests: ${TESTS} + tests: ${TESTS} - ronn: ${RONN} - valgrind: ${VALGRIND} + ronn: ${RONN} + valgrind: ${VALGRIND} + rpmbuild: ${RPMBUILD} ") diff --git a/man/blogc-git-receiver.1.ronn b/man/blogc-git-receiver.1.ronn new file mode 100644 index 0000000..e26ed09 --- /dev/null +++ b/man/blogc-git-receiver.1.ronn @@ -0,0 +1,126 @@ +blogc-git-receiver(1) -- a simple login shell/git hook to deploy blogc websites +=============================================================================== + +## SYNOPSIS + +chsh -s $(command -v `blogc-git-receiver`) <user> + +## DESCRIPTION + +**blogc-git-receiver** provides a PaaS-like way to deploy blogc(1) websites. +When used as a login shell, it will accept git payloads, creating bare repositories +as needed, and installing a hook, that will take care of rebuilding the website each +time someone push something to the `master` branch. + +The git repository must provide a `Makefile` (or a `GNUMakefile`), that should +accept the `OUTPUT_DIR` variable, and install built files in the directory pointed +by this variable. + +`blogc-git-receiver` is part of `blogc` project, but isn't tied to blogc(1). Any +repository with `Makefile` that builds content and install it to `OUTPUT_DIR` +should works with `blogc-git-receiver`. + +## SETUP + +After creating an user (`blogc` for the examples), change its shell to +blogc-git-receiver(1): + + # chsh -s $(command -v blogc-git-receiver) blogc + +Now add ssh keys to `/home/blogc/.ssh/authorized_keys`. Every key in +`authorized_keys` will be allowed to push to the git repositories, and even +create new ones. + +Also, make sure to install all the dependencies required by the websites, +including a web server. `blogc-git-receiver` can't handle web server virtual hosts. + +To deploy a website (e.g. blogc example repository): + + $ git clone https://github.com/blogc/blogc-example.git + $ cd blogc-example + $ git remote add blogc blogc@${SERVER_IP}:blogs/blogc-example.git + $ git push blogc master + +This will deploy the example to the server, creating a symlink to the built content +in `/home/blogc/repos/blogs/blogc-example.git/htdocs`. This symlink should be used +as the document root for the web server virtual host. + +### Setup with SELinux enabled (Fedora) + +Supposing the usage of nginx as webserver, running as the `nginx` user: + + # dnf install -y nginx policycoreutils-python-utils + # useradd -m -s $(command -v blogc-git-receiver) blogc + # gpasswd -a nginx blogc + # chmod -R g+rx /home/blogc + # su -c "mkdir /home/blogc/{builds,repos}" -s /bin/sh blogc + # semanage fcontext -a -t httpd_sys_content_t "/home/blogc/(builds|repos)(/.*)?" + # restorecon -R -v /home/blogc + # systemctl restart nginx + +After running these commands, the machine is ready to be used. + +## REPOSITORY MIRRORING + +Users can rely on `blogc-git-receiver` to mirror repositories to a remote Git +repository (e.g. a free Bitbucket private repository). This feature just requires +adding a remote called `mirror` to the bare repository in the server. If such remote +exists, `blogc-git-receiver` will `git push --mirror` to it. + +Please note that the `blogc` user must be able to push to the remote repository, and +that any content manually pushed to the remote repository is overwritten by +`blogc-git-receiver`. + +Some reasonable ways to allow the `blogc` user to push to the remote repository are: + +- Create a password-less SSH key. The key *must* be password-less, because the push + is automatic, and remote git hooks can't be interactive. +- Create an oauth token in the hosting service (if it supports oauth authentication + in git, e.g. GitHub) and add it to the git URL. + +The mirroring feature wont't block a `git push`, it will just raise warnings. That +means that if an error happens when mirroring the repository, the deploy will still +succeed. Users should pay attention to the git hook logs, to avoid losing data +due to repositories not being mirrored. + +To add the `mirror` remote: + + # su -s /bin/bash - blogc + $ git remote add --mirror=push mirror $YOUR_GIT_MIRROR_URL + +### Caveats of repository mirroring with SSH + +The authentication must be done with a password-less SSH key created by the `blogc` +user. + +As the `git push --mirror` call is automated, users must disable SSH strict host +checking in SSH's `~/.ssh/config` file: + + Host bitbucket.org + StrictHostKeyChecking no + +The example uses `bitbucket.org` as remote host, that should be changed if needed. + +To change this file, users must login with `/bin/bash` or any other "real" shell, +as `root`: + + # su -s /bin/bash - blogc + +## ENVIRONMENT VARIABLES + +`blogc-git-receiver` will export an environment variable called `BLOGC_GIT_RECEIVER` +when calling `gmake` to build websites. This variable can be used to enable building +of content that should only be built when running in production environment, for +example. + +## BUGS + +Please report any issues to: <https://github.com/blogc/blogc> + +## AUTHOR + +Rafael G. Martins <<rafael@rafaelmartins.eng.br>> + +## SEE ALSO + +blogc(1), git(7), chsh(1), su(1), make(1) diff --git a/man/blogc-pagination.7.ronn b/man/blogc-pagination.7.ronn new file mode 100644 index 0000000..db40334 --- /dev/null +++ b/man/blogc-pagination.7.ronn @@ -0,0 +1,122 @@ +blogc-pagination(7) -- blogc's pagination support +================================================= + +## DESCRIPTION + +blogc(1) supports some basic pagination and post filtering, when running on +`listing` mode. Files are listed in the order that they are provided to +blogc(1) in the command line, no sorting is done. + +## PAGINATION PARAMETERS + +blogc(1) accepts some variables as `-D` options, that are used to filter the +files passed as arguments to it: + + * `FILTER_PER_PAGE`: + Integer, limits the maximum number of files to be listed. + + * `FILTER_PAGE`: + Integer, current page. If calling blogc(1) with 10 files, + `FILTER_PER_PAGE`=4 and `FILTER_PAGE`=3, it will return just the 2 last + files, skipping the first 2 pages with 4 files each one. + + * `FILTER_TAG`: + String, if defined, blogc(1) will only list files that declare a `TAGS` + variable, as a space-separated list of tags (tags can't have spaces, + obviously). See blogc-source(7) for details about how to define source + variables. The pagination filters will only act on the files with the + provided tag, instead of filtering the whole file set. + +## TEMPLATE VARIABLES + +blogc(1) will export some global blogc-template(7) variables, that can be used +to build links for next and previous page. + + * `CURRENT_PAGE`: + Integer, usually the same value of `FILTER_PAGE` pagination paramenter, if + defined, or 1. + + * `FIRST_PAGE`: + Integer, 1 if more than zero files were listed. + + * `LAST_PAGE`: + Integer, last page available if more than zero files were listed. + + * `PREVIOUS_PAGE`: + Integer, `CURRENT_PAGE` minus 1, if `CURRENT_PAGE` is bigger than 1. + + * `NEXT_PAGE`: + Integer, `CURRENT_PAGE` plus 1, if `LAST_PAGE` is bigger than `CURRENT_PAGE`. + +blogc(1) can output the value of the variables after evaluation, instead of +actually rendering the files, using the `-p` option. See blogc(1) for details. +This is useful to know the last page that needs to be built, using `-p LAST_PAGE`, +for example. + +### Date variables + +blogc(1) will also export some global blogc-template(7) variables related to +the `DATE` variable, as specified in blogc-source(7). + + * `DATE_FIRST`: + String, `DATE` variable from the first file in the listing. + * `DATE_LAST`: + String, `DATE` variable from the last file in the listing. + +These variables can be also formatted with `DATE_FORMAT` global blogc(1) parameter, +if provided, using `DATE_FIRST_FORMATTED` and `DATE_LAST_FORMATTED` global +template variables. + +### File name variables + +blogc(1) will also export some global blogc-template(7) variables related to +the `FILENAME` variable, as automatically exported by the source file parser, +see blogc-source(7) for details. + + * `FILENAME_FIRST`: + String, `FILENAME` variable from the first file in the listing. + * `FILENAME_LAST`: + String, `FILENAME` variable from the last file in the listing. + +## EXAMPLES + +### Source file with tags + + TITLE: My post + TAGS: foo bar baz + ----------------- + Post content + +This source file defines 3 tags: `foo`, `bar` and `baz`. + +### Template with pagination + + {% block listing_once %} + <ul class="pager"> + {% ifdef PREVIOUS_PAGE %} + <li class="previous"> + <a href="/page/{{ PREVIOUS_PAGE }}/">← Newer</a> + </li> + {% endif %} + {% ifdef NEXT_PAGE %} + <li class="next"> + <a href="/page/{{ NEXT_PAGE }}/">Older →</a> + </li> + {% endif %} + </ul> + {% endblock %} + +This example does not uses all the variables, but the concept is the same for +all of them. + +## BUGS + +Please report any issues to: <https://github.com/blogc/blogc> + +## AUTHOR + +Rafael G. Martins <<rafael@rafaelmartins.eng.br>> + +## SEE ALSO + +blogc(1), blogc-source(7), blogc-template(7) diff --git a/man/blogc-runserver.1.ronn b/man/blogc-runserver.1.ronn new file mode 100644 index 0000000..a306fbe --- /dev/null +++ b/man/blogc-runserver.1.ronn @@ -0,0 +1,48 @@ +blogc-runserver(1) -- a simple HTTP server to test blogc websites +================================================================= + +## SYNOPSIS + +`blogc-runserver` [`-t` <HOST>] [`-p` <PORT>] <DOCROOT><br> +`blogc-runserver` [`-h`|`-v`] + +## DESCRIPTION + +**blogc-runserver** is a simple HTTP server that makes it easy to test blogc websites. +Users just need to point it to the directory where the target files where built. It +comes with a few pre-defined rules, similar to production webservers, that allow users +to quickly test their websites without configuring a webserver. + +`blogc-runserver` is part of `blogc` project, but isn't tied to blogc(1). It may be +able to serve any website built by static site generators. + +## OPTIONS + + * `-t` <HOST>: + HTTP server listen address, defaults to `127.0.0.1`. + + * `-p` <PORT>: + HTTP server listen port, defaults to `8080`. + + * `-v`: + Show program name, version and exit. + + * `-h`: + Show help message and exit. + +## ARGUMENTS + + * <DOCROOT>: + HTTP server document root. + +## BUGS + +Please report any issues to: <https://github.com/blogc/blogc> + +## AUTHOR + +Rafael G. Martins <<rafael@rafaelmartins.eng.br>> + +## SEE ALSO + +blogc(1) diff --git a/man/blogc-source.7.ronn b/man/blogc-source.7.ronn index 7fa0796..b583d6e 100644 --- a/man/blogc-source.7.ronn +++ b/man/blogc-source.7.ronn @@ -45,6 +45,15 @@ You can omit seconds, minutes and hours if you want, they will be filled with The ``DATE_FORMAT`` variable should be passed to blogc(1) as a global variable. Its value must be a valid strptime(3) format. +The source parser will also automatically generate a variable called `FILENAME`, +that stores the name of the source file, without its extension. This is useful +for building permalinks in templates. This variable can't be overriden by an +explicit definition in source file. + +Another variable, `DESCRIPTION`, will be automatically created by the source +parser. Its content is the first line of the first paragraph of the content. +This variable can be overriden by an explicit definition in source file. + ## SOURCE CONTENT - BLOCK ELEMENTS ### Paragraphs @@ -203,18 +212,35 @@ Images are defined using the following syntax: This is an image:  +Whitespace characters and new lines are allowed between alt text and image URL: + + This is an image: ![This is the image alt text] + (picture.jpg) + ### Links Links are defined using the following syntax: To learn more about blogc, [click here](https://blogc.rgm.io). +Whitespace characters and new lines are allowed between link text and link URL: + + To learn more about blogc, [click here] + (https://blogc.rgm.io). + ### Image Links Links can be combined with images: [](https://blogc.rgm.io) +Whitespace characters and new lines are allowed between link text and link URL, +and between alt text and image URL: + + [![This is the image alt text] + (picture.jpg)] + (https://blogc.rgm.io) + ### Automatic Links Automatic link is defined with 2 '[' before and 2 ']' after the URL. @@ -226,6 +252,11 @@ Automatic link is defined with 2 '[' before and 2 ']' after the URL. Line breaks can be added after a paragraph line adding 2 or more white spaces to the end of the line. +### En dashes and Em dashes + +Sequences of 2 '-' characters are converted to an En dash HTML entity. +Sequences of 3 '-' characters are converted to an Em dash HTML entity. + ## BUGS diff --git a/man/blogc.1.ronn b/man/blogc.1.ronn index 7ee617f..baee026 100644 --- a/man/blogc.1.ronn +++ b/man/blogc.1.ronn @@ -44,7 +44,7 @@ designed to be used with make(1). * `-p` <KEY>: Show the value of a global configuration parameter right after the source parsing and exits. This is useful to get parameters for your `Makefile`, - like the last page when using pagination. + like the last page when using pagination, see blogc-pagination(7) for details. * `-t` <TEMPLATE>: Template file. It is a required option, if `blogc` needs to render something. @@ -93,4 +93,4 @@ Rafael G. Martins <<rafael@rafaelmartins.eng.br>> ## SEE ALSO -blogc-source(7), blogc-template(7), make(1), strptime(3) +blogc-source(7), blogc-template(7), blogc-pagination(7) make(1), strptime(3) diff --git a/man/index.txt b/man/index.txt index a85e2a0..4ca6e67 100644 --- a/man/index.txt +++ b/man/index.txt @@ -1,9 +1,15 @@ # manuals -blogc(1) blogc.1.ronn -blogc-source(7) blogc-source.7.ronn -blogc-template(7) blogc-template.7.ronn +blogc(1) blogc.1.ronn +blogc-git-receiver(1) blogc-git-receiver.1.ronn +blogc-runserver(1) blogc-runserver.1.ronn +blogc-source(7) blogc-source.7.ronn +blogc-template(7) blogc-template.7.ronn +blogc-pagination(7) blogc-pagination.7.ronn # external manuals -make(1) http://man.cx/make(1) -strcmp(3) http://man.cx/strcmp(3) -strptime(3) http://man.cx/strptime(3) +make(1) http://man.cx/make(1) +chsh(1) http://man.cx/chsh(1) +su(1) http://man.cx/su(1) +strcmp(3) http://man.cx/strcmp(3) +strptime(3) http://man.cx/strptime(3) +git(7) http://man.cx/git(7) diff --git a/src/blogc-git-receiver.c b/src/blogc-git-receiver.c new file mode 100644 index 0000000..ffeac61 --- /dev/null +++ b/src/blogc-git-receiver.c @@ -0,0 +1,502 @@ +/* + * blogc: A blog compiler. + * Copyright (C) 2015-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> + * + * This program can be distributed under the terms of the BSD License. + * See the file LICENSE. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif /* HAVE_CONFIG_H */ + +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <libgen.h> +#include <unistd.h> +#include <errno.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <dirent.h> +#include <time.h> + +#include "utils.h" + +#ifndef BUFFER_SIZE +#define BUFFER_SIZE 4096 +#endif + + +static unsigned int +cpu_count(void) +{ +#ifdef _SC_NPROCESSORS_ONLN + long num = sysconf(_SC_NPROCESSORS_ONLN); + if (num >= 1) + return (unsigned int) num; +#endif + return 1; +} + + +static void +rmdir_recursive(const char *dir) +{ + struct stat buf; + if (0 != stat(dir, &buf)) { + fprintf(stderr, "warning: failed to remove directory (%s): %s\n", dir, + strerror(errno)); + return; + } + if (!S_ISDIR(buf.st_mode)) { + fprintf(stderr, "error: trying to remove invalid directory: %s\n", dir); + exit(2); + } + DIR *d = opendir(dir); + if (d == NULL) { + fprintf(stderr, "error: failed to open directory: %s\n", + strerror(errno)); + exit(2); + } + struct dirent *e; + while (NULL != (e = readdir(d))) { + if ((0 == strcmp(e->d_name, ".")) || (0 == strcmp(e->d_name, ".."))) + continue; + char *f = sb_strdup_printf("%s/%s", dir, e->d_name); + if (0 != stat(f, &buf)) { + fprintf(stderr, "error: failed to stat directory entry (%s): %s\n", + e->d_name, strerror(errno)); + free(f); + exit(2); + } + if (S_ISDIR(buf.st_mode)) { + rmdir_recursive(f); + } + else if (0 != unlink(f)) { + fprintf(stderr, "error: failed to remove file (%s): %s\n", f, + strerror(errno)); + free(f); + exit(2); + } + free(f); + } + if (0 != closedir(d)) { + fprintf(stderr, "error: failed to close directory: %s\n", + strerror(errno)); + exit(2); + } + if (0 != rmdir(dir)) { + fprintf(stderr, "error: failed to remove directory: %s\n", + strerror(errno)); + exit(2); + } +} + + +static int +git_shell(int argc, char *argv[]) +{ + int rv = 0; + + char *repo = NULL; + char *command_orig = NULL; + char *command_name = NULL; + char command_new[BUFFER_SIZE]; + + bool exec_git = false; + + // validate git command + size_t len = strlen(argv[2]); + if (!((len > 17 && (0 == strncmp(argv[2], "git-receive-pack ", 17))) || + (len > 16 && (0 == strncmp(argv[2], "git-upload-pack ", 16))) || + (len > 19 && (0 == strncmp(argv[2], "git-upload-archive ", 19))))) + { + fprintf(stderr, "error: unsupported git command: %s\n", argv[2]); + rv = 1; + goto cleanup; + } + + // get shell path + char *self = getenv("SHELL"); + if (self == NULL) { + fprintf(stderr, "error: failed to find blogc-git-receiver path\n"); + rv = 1; + goto cleanup; + } + + // get home path + char *home = getenv("HOME"); + if (home == NULL) { + fprintf(stderr, "error: failed to find user home path\n"); + rv = 1; + goto cleanup; + } + + // get git repository + command_orig = sb_strdup(argv[2]); + char *p, *r; + for (p = command_orig; *p != ' ' && *p != '\0'; p++); + if (*p == ' ') + p++; + if (*p == '\'' || *p == '"') + p++; + if (*p == '/') + p++; + for (r = p; *p != '\'' && *p != '"' && *p != '\0'; p++); + if (*p == '\'' || *p == '"') + *p = '\0'; + if (*--p == '/') + *p = '\0'; + + repo = sb_strdup_printf("repos/%s", r); + + // check if repository is sane + if (0 == strlen(repo)) { + fprintf(stderr, "error: invalid repository\n"); + rv = 1; + goto cleanup; + } + + if (0 == strncmp(argv[2], "git-upload-", 11)) // no need to check len here + goto git_exec; + + if (0 != chdir(home)) { + fprintf(stderr, "error: failed to chdir (%s): %s\n", home, + strerror(errno)); + rv = 1; + goto cleanup; + } + + if (0 != access(repo, F_OK)) { + char *git_init_cmd = sb_strdup_printf( + "git init --bare \"%s\" > /dev/null", repo); + if (0 != system(git_init_cmd)) { + fprintf(stderr, "error: failed to create git repository: %s\n", + repo); + rv = 1; + free(git_init_cmd); + goto cleanup; + } + free(git_init_cmd); + } + + if (0 != chdir(repo)) { + fprintf(stderr, "error: failed to chdir (%s/%s): %s\n", home, repo, + strerror(errno)); + rv = 1; + goto cleanup; + } + + if (0 != access("hooks", F_OK)) { + // openwrt git package won't install git templates, then the git + // repositories created with it won't have the hooks/ directory. + if (0 != mkdir("hooks", 0777)) { // mkdir honors umask for us. + fprintf(stderr, "error: failed to create directory (%s/%s/hooks): " + "%s\n", home, repo, strerror(errno)); + rv = 1; + goto cleanup; + } + } + + if (0 != chdir("hooks")) { + fprintf(stderr, "error: failed to chdir (%s/%s/hooks): %s\n", home, + repo, strerror(errno)); + rv = 1; + goto cleanup; + } + + if (0 == access("pre-receive", F_OK)) { + if (0 != unlink("pre-receive")) { + fprintf(stderr, "error: failed to remove old symlink " + "(%s/%s/hooks/pre-receive): %s\n", home, repo, strerror(errno)); + rv = 1; + goto cleanup; + } + } + + if (0 != symlink(self, "pre-receive")) { + fprintf(stderr, "error: failed to create symlink " + "(%s/%s/hooks/pre-receive): %s\n", home, repo, strerror(errno)); + rv = 1; + goto cleanup; + } + + if (0 == access("post-receive", F_OK)) { + if (0 != unlink("post-receive")) { + fprintf(stderr, "error: failed to remove old symlink " + "(%s/%s/hooks/post-receive): %s\n", home, repo, strerror(errno)); + rv = 1; + goto cleanup; + } + } + + if (0 != symlink(self, "post-receive")) { + fprintf(stderr, "error: failed to create symlink " + "(%s/%s/hooks/post-receive): %s\n", home, repo, strerror(errno)); + rv = 1; + goto cleanup; + } + + if (0 != chdir(home)) { + fprintf(stderr, "error: failed to chdir (%s): %s\n", home, + strerror(errno)); + rv = 1; + goto cleanup; + } + +git_exec: + command_name = sb_strdup(argv[2]); + for (p = command_name; *p != ' ' && *p != '\0'; p++); + if (*p == ' ') + *p = '\0'; + + if (BUFFER_SIZE < (strlen(command_name) + strlen(repo) + 4)) { + fprintf(stderr, "error: git-shell command is too big\n"); + rv = 1; + goto cleanup; + } + + if (snprintf(command_new, BUFFER_SIZE, "%s '%s'", command_name, repo)) + exec_git = true; + +cleanup: + free(repo); + free(command_orig); + free(command_name); + + if (exec_git) { + execlp("git-shell", "git-shell", "-c", command_new, NULL); + + // execlp only returns on error, then something bad happened + fprintf(stderr, "error: failed to execute git-shell\n"); + rv = 1; + } + + return rv; +} + + +static int +git_post_receive_hook(int argc, char *argv[]) +{ + if (0 != system("git remote get-url --push mirror &> /dev/null")) + return 0; + + // at this point we know that we have a remote called mirror, we can just + // push to it. + if (0 != system("git push --mirror mirror")) + fprintf(stderr, "warning: failed push to git mirror\n"); + + return 0; +} + + +typedef enum { + START_OLD = 1, + OLD, + START_NEW, + NEW, + START_REF, + REF +} input_state_t; + + +static int +git_pre_receive_hook(int argc, char *argv[]) +{ + int c; + char buffer[BUFFER_SIZE]; + + input_state_t state = START_OLD; + size_t i = 0; + size_t start = 0; + + int rv = 0; + char *new = NULL; + char *master = NULL; + + while (EOF != (c = getc(stdin))) { + + buffer[i] = (char) c; + + switch (state) { + case START_OLD: + start = i; + state = OLD; + break; + case OLD: + if (c != ' ') + break; + // no need to store old + state = START_NEW; + break; + case START_NEW: + start = i; + state = NEW; + break; + case NEW: + if (c != ' ') + break; + state = START_REF; + new = strndup(buffer + start, i - start); + break; + case START_REF: + start = i; + state = REF; + break; + case REF: + if (c != '\n') + break; + state = START_OLD; + // we just care about a ref (refs/heads/master), everything + // else is disposable :) + if (!((i - start == 17) && + (0 == strncmp("refs/heads/master", buffer + start, 17)))) + { + free(new); + new = NULL; + break; + } + master = new; + break; + } + + if (++i >= BUFFER_SIZE) { + fprintf(stderr, "error: pre-receive hook payload is too big.\n"); + rv = 1; + goto cleanup2; + } + } + + if (master == NULL) { + fprintf(stderr, "warning: no reference to master branch found. " + "nothing to deploy.\n"); + goto cleanup2; + } + + char *repo_dir = NULL; + char *output_dir = NULL; + + if (NULL == getcwd(buffer, BUFFER_SIZE)) { + fprintf(stderr, "error: failed to get repository remote path: %s\n", + strerror(errno)); + rv = 1; + goto cleanup; + } + + repo_dir = sb_strdup(buffer); + + char dir[] = "/tmp/blogc_XXXXXX"; + if (NULL == mkdtemp(dir)) { + rv = 1; + goto cleanup; + } + + char *git_archive_cmd = sb_strdup_printf( + "git archive \"%s\" | tar -x -C \"%s\" -f -", master, dir); + if (0 != system(git_archive_cmd)) { + fprintf(stderr, "error: failed to extract git content to temporary " + "directory: %s\n", dir); + rv = 1; + free(git_archive_cmd); + goto cleanup; + } + free(git_archive_cmd); + + if (0 != chdir(dir)) { + fprintf(stderr, "error: failed to chdir (%s): %s\n", dir, + strerror(errno)); + rv = 1; + goto cleanup; + } + + if ((0 != access("Makefile", F_OK)) && (0 != access("GNUMakefile", F_OK))) { + fprintf(stderr, "warning: no makefile found. skipping ...\n"); + goto cleanup; + } + + char *home = getenv("HOME"); + if (home == NULL) { + fprintf(stderr, "error: failed to find user home path\n"); + rv = 1; + goto cleanup; + } + + unsigned long epoch = time(NULL); + output_dir = sb_strdup_printf("%s/builds/%s-%lu", home, master, epoch); + char *gmake_cmd = sb_strdup_printf( + "gmake -j%d OUTPUT_DIR=\"%s\" BLOGC_GIT_RECEIVER=1", + cpu_count(), output_dir); + fprintf(stdout, "running command: %s\n\n", gmake_cmd); + fflush(stdout); + if (0 != system(gmake_cmd)) { + fprintf(stderr, "error: failed to build website ...\n"); + rmdir_recursive(output_dir); + free(gmake_cmd); + rv = 1; + goto cleanup; + } + free(gmake_cmd); + + if (0 != chdir(repo_dir)) { + fprintf(stderr, "error: failed to chdir (%s): %s\n", repo_dir, + strerror(errno)); + rmdir_recursive(output_dir); + rv = 1; + goto cleanup; + } + + char *htdocs_sym = NULL; + ssize_t htdocs_sym_len = readlink("htdocs", buffer, BUFFER_SIZE); + if (0 < htdocs_sym_len) { + if (0 != unlink("htdocs")) { + fprintf(stderr, "error: failed to remove symlink (%s/htdocs): %s\n", + repo_dir, strerror(errno)); + rmdir_recursive(output_dir); + rv = 1; + goto cleanup; + } + buffer[htdocs_sym_len] = '\0'; + htdocs_sym = buffer; + } + + if (0 != symlink(output_dir, "htdocs")) { + fprintf(stderr, "error: failed to create symlink (%s/htdocs): %s\n", + repo_dir, strerror(errno)); + rmdir_recursive(output_dir); + rv = 1; + goto cleanup; + } + + if (htdocs_sym != NULL) + rmdir_recursive(htdocs_sym); + +cleanup: + free(output_dir); + rmdir_recursive(dir); + free(repo_dir); +cleanup2: + free(new); + return rv; +} + + +int +main(int argc, char *argv[]) +{ + if (argc > 0) { + if (0 == strcmp(basename(argv[0]), "pre-receive")) + return git_pre_receive_hook(argc, argv); + if (0 == strcmp(basename(argv[0]), "post-receive")) + return git_post_receive_hook(argc, argv); + } + + if (argc == 3 && (0 == strcmp(argv[1], "-c"))) + return git_shell(argc, argv); + + fprintf(stderr, "error: this is a special shell, go away!\n"); + return 1; +} diff --git a/src/blogc-runserver.c b/src/blogc-runserver.c new file mode 100644 index 0000000..81bd5f9 --- /dev/null +++ b/src/blogc-runserver.c @@ -0,0 +1,389 @@ +/* + * blogc: A blog compiler. + * Copyright (C) 2015-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> + * + * This program can be distributed under the terms of the BSD License. + * See the file LICENSE. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif /* HAVE_CONFIG_H */ + +#include <event2/event.h> +#include <event2/http.h> +#include <event2/buffer.h> +#include <event2/keyvalq_struct.h> +#include <magic.h> +#include <signal.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> + +#include "utils.h" + + +/** + * this mapping is used to declare "supported" file types, that are forced over + * whatever detected by libmagic, but we will still use the charset provided by + * libmagic anyway. it also helps detecting index files when the client asks + * for a directory. + */ +static const struct content_type_map { + const char *mimetype; + const char *extension; + const char *index; +} content_types[] = { + {"text/html", "html", "index.html"}, + {"text/html", "htm", "index.htm"}, + {"text/xml", "xml", "index.xml"}, + {"text/plain", "txt", "index.txt"}, + {"text/css", "css", NULL}, + {"application/javascript", "js", NULL}, + {NULL, NULL, NULL} +}; + + +static magic_t magic_all = NULL; +static magic_t magic_charset = NULL; + + +static const char* +get_extension(const char *filename) +{ + const char *ext = NULL; + unsigned int i; + for (i = strlen(filename); i > 0; i--) { + if (filename[i] == '.') { + ext = filename + i + 1; + break; + } + } + if (i == 0) + return NULL; + return ext; +} + + +static char* +guess_content_type(const char *filename, int fd) +{ + int newfd; + + // try "supported" types first, and just use libmagic for charset + const char *extension = get_extension(filename); + if (extension == NULL) + goto libmagic; + const char *supported = NULL; + for (unsigned int i = 0; content_types[i].extension != NULL; i++) + if (0 == strcmp(content_types[i].extension, extension)) + supported = content_types[i].mimetype; + if (supported != NULL) { + newfd = dup(fd); + if (-1 != newfd) { + const char* charset = magic_descriptor(magic_charset, newfd); + close(newfd); + if (charset != NULL) + return sb_strdup_printf("%s; charset=%s", supported, charset); + } + return sb_strdup(supported); + } + +libmagic: + + // fallback to use libmagic for everything + newfd = dup(fd); + if (-1 != newfd) { + const char* content_type = magic_descriptor(magic_all, newfd); + close(newfd); + if (content_type != NULL) + return sb_strdup(content_type); + } + return sb_strdup("application/octet-stream"); +} + + +static void +handler(struct evhttp_request *request, void *ptr) +{ + const char *root = ptr; + const char *uri = evhttp_request_get_uri(request); + + struct evhttp_uri *decoded_uri = evhttp_uri_parse(uri); + if (decoded_uri == NULL) { + evhttp_send_error(request, 400, "Bad request"); + return; + } + + const char *path = evhttp_uri_get_path(decoded_uri); + if (path == NULL) + path = "/"; + + char *decoded_path = evhttp_uridecode(path, 0, NULL); + if (decoded_path == NULL) { + evhttp_send_error(request, 400, "Bad request"); + goto point1; + } + + char *abs_path = sb_strdup_printf("%s/%s", root, decoded_path); + char *real_path = realpath(abs_path, NULL); + free(abs_path); + + if (real_path == NULL) { + evhttp_send_error(request, 404, "Not found"); + goto point2; + } + + char *real_root = realpath(root, NULL); + if (real_root == NULL) { + evhttp_send_error(request, 500, "Internal server error"); + goto point3; + } + + if (0 != strncmp(real_root, real_path, strlen(real_root))) { + evhttp_send_error(request, 404, "Not found"); + goto point4; + } + + struct stat st; + if (0 > stat(real_path, &st)) { + evhttp_send_error(request, 404, "Not found"); + goto point4; + } + + bool add_slash = false; + + if (S_ISDIR(st.st_mode)) { + char *found = NULL; + + for (unsigned int i = 0; content_types[i].mimetype != NULL; i++) { + if (content_types[i].index == NULL) + continue; + char *f = sb_strdup_printf("%s/%s", real_path, + content_types[i].index); + if (0 == access(f, F_OK)) { + found = sb_strdup(f); + break; + } + free(f); + } + + if (found == NULL) { + evhttp_send_error(request, 403, "Forbidden"); + goto point4; + } + + size_t path_len = strlen(path); + if (path_len > 0 && path[path_len - 1] != '/') + add_slash = true; + + free(real_path); + real_path = found; + } + + int fd; + if ((fd = open(real_path, O_RDONLY)) < 0) { + evhttp_send_error(request, 500, "Internal server error"); + goto point4; + } + + char *type = guess_content_type(real_path, fd); + + if (fstat(fd, &st) < 0) { + evhttp_send_error(request, 500, "Internal server error"); + goto point5; + } + + struct evkeyvalq *headers = evhttp_request_get_output_headers(request); + + if (add_slash) { + char *tmp = sb_strdup_printf("%s/", path); + evhttp_add_header(headers, "Location", tmp); + free(tmp); + // production webservers usually returns 301 in such cases, but 302 is + // better for development/testing. + evhttp_send_reply(request, 302, "Found", NULL); + goto point5; + } + + evhttp_add_header(headers, "Content-Type", type); + char *content_length = sb_strdup_printf("%zu", st.st_size); + evhttp_add_header(headers, "Content-Length", content_length); + free(content_length); + + struct evbuffer *evb = evbuffer_new(); + evbuffer_add_file(evb, fd, 0, st.st_size); + evhttp_send_reply(request, 200, "OK", evb); + +point5: + free(type); +point4: + free(real_root); +point3: + free(real_path); +point2: + free(decoded_path); +point1: + evhttp_uri_free(decoded_uri); +} + + +static int +runserver(const char *address, unsigned short port, const char *root) +{ + struct event_base *base = event_base_new(); + if (base == NULL) { + fprintf(stderr, "error: failed to initialize event base\n"); + return 1; + } + + struct evhttp *http = evhttp_new(base); + if (http == NULL) { + fprintf(stderr, "error: failed to initialize HTTP server\n"); + return 1; + } + + evhttp_set_gencb(http, handler, (char*) root); + + evhttp_set_allowed_methods(http, EVHTTP_REQ_GET | EVHTTP_REQ_HEAD); + + if (0 != evhttp_bind_socket(http, address, port)) { + fprintf(stderr, "error: failed to bind socket to %s:%d\n", address, + port); + return 1; + } + + fprintf(stderr, " * Running on http://%s:%d/\n", address, port); + + event_base_dispatch(base); + + return 0; +} + + +static void +print_help(void) +{ + printf( + "usage:\n" + " blogc-runserver [-h] [-v] [-t HOST] [-p PORT] DOCROOT\n" + " - A simple HTTP server to test blogc websites.\n" + "\n" + "positional arguments:\n" + " DOCROOT document root directory\n" + "\n" + "optional arguments:\n" + " -h show this help message and exit\n" + " -v show version and exit\n" + " -t HOST set server listen address (default: 127.0.0.1)\n" + " -p PORT set server listen port (default: 8080)\n"); +} + + +static void +print_usage(void) +{ + printf("usage: blogc-runserver [-h] [-v] [-t HOST] [-p PORT] DOCROOT\n"); +} + + +int +main(int argc, char **argv) +{ + signal(SIGPIPE, SIG_IGN); + + int rv = 0; + char *host = NULL; + char *docroot = NULL; + unsigned short port = 8080; + + unsigned int args = 0; + + for (unsigned int i = 1; i < argc; i++) { + if (argv[i][0] == '-') { + switch (argv[i][1]) { + case 'h': + print_help(); + goto cleanup; + case 'v': + printf("%s\n", PACKAGE_STRING); + goto cleanup; + case 't': + if (argv[i][2] != '\0') + host = sb_strdup(argv[i] + 2); + else + host = sb_strdup(argv[++i]); + break; + case 'p': + if (argv[i][2] != '\0') + port = strtoul(argv[i] + 2, NULL, 10); + else + port = strtoul(argv[++i], NULL, 10); + break; + default: + print_usage(); + fprintf(stderr, "blogc-runserver: error: invalid " + "argument: -%c\n", argv[i][1]); + rv = 2; + goto cleanup; + } + } + else { + if (args > 0) { + print_usage(); + fprintf(stderr, "blogc-runserver: error: only one positional " + "argument allowed\n"); + rv = 2; + goto cleanup; + } + args++; + docroot = sb_strdup(argv[i]); + } + } + + if (docroot == NULL) { + print_usage(); + fprintf(stderr, "blogc-runserver: error: document root directory " + "required\n"); + rv = 2; + goto cleanup; + } + + if (host == NULL) + host = sb_strdup("127.0.0.1"); + + magic_all = magic_open(MAGIC_MIME); + magic_charset = magic_open(MAGIC_MIME_ENCODING); + if (magic_all == NULL || magic_charset == NULL) { + fprintf(stderr, "error: failed to initialize libmagic\n"); + rv = 1; + goto cleanup; + } + + if ((0 != magic_load(magic_all, NULL)) || + (0 != magic_load(magic_charset, NULL))) + { + fprintf(stderr, "error: failed to load libmagic data\n"); + magic_close(magic_all); + magic_close(magic_charset); + rv = 1; + goto cleanup; + } + + rv = runserver(host, port, docroot); + + magic_close(magic_all); + magic_close(magic_charset); + +cleanup: + free(host); + free(docroot); + + return rv; +} @@ -24,12 +24,12 @@ #include <stdio.h> #include <string.h> -#include "utils/utils.h" #include "source-parser.h" #include "template-parser.h" #include "loader.h" #include "renderer.h" #include "error.h" +#include "utils.h" #ifndef PACKAGE_VERSION #define PACKAGE_VERSION "Unknown" @@ -71,7 +71,7 @@ blogc_print_usage(void) static void blogc_mkdir_recursive(const char *filename) { - char *fname = b_strdup(filename); + char *fname = sb_strdup(filename); for (char *tmp = fname; *tmp != '\0'; tmp++) { if (*tmp != '/' && *tmp != '\\') continue; @@ -117,9 +117,9 @@ main(int argc, char **argv) char *tmp = NULL; char **pieces = NULL; - b_slist_t *sources = NULL; - b_trie_t *config = b_trie_new(free); - b_trie_insert(config, "BLOGC_VERSION", b_strdup(PACKAGE_VERSION)); + sb_slist_t *sources = NULL; + sb_trie_t *config = sb_trie_new(free); + sb_trie_insert(config, "BLOGC_VERSION", sb_strdup(PACKAGE_VERSION)); for (unsigned int i = 1; i < argc; i++) { tmp = NULL; @@ -136,21 +136,21 @@ main(int argc, char **argv) break; case 't': if (argv[i][2] != '\0') - template = b_strdup(argv[i] + 2); + template = sb_strdup(argv[i] + 2); else if (i + 1 < argc) - template = b_strdup(argv[++i]); + template = sb_strdup(argv[++i]); break; case 'o': if (argv[i][2] != '\0') - output = b_strdup(argv[i] + 2); + output = sb_strdup(argv[i] + 2); else if (i + 1 < argc) - output = b_strdup(argv[++i]); + output = sb_strdup(argv[++i]); break; case 'p': if (argv[i][2] != '\0') - print = b_strdup(argv[i] + 2); + print = sb_strdup(argv[i] + 2); else if (i + 1 < argc) - print = b_strdup(argv[++i]); + print = sb_strdup(argv[++i]); break; case 'D': if (argv[i][2] != '\0') @@ -158,11 +158,11 @@ main(int argc, char **argv) else if (i + 1 < argc) tmp = argv[++i]; if (tmp != NULL) { - pieces = b_str_split(tmp, '=', 2); - if (b_strv_length(pieces) != 2) { + pieces = sb_str_split(tmp, '=', 2); + if (sb_strv_length(pieces) != 2) { fprintf(stderr, "blogc: error: invalid value for " "-D (must have an '='): %s\n", tmp); - b_strv_free(pieces); + sb_strv_free(pieces); rv = 2; goto cleanup; } @@ -173,13 +173,13 @@ main(int argc, char **argv) fprintf(stderr, "blogc: error: invalid value " "for -D (configuration key must be uppercase " "with '_'): %s\n", pieces[0]); - b_strv_free(pieces); + sb_strv_free(pieces); rv = 2; goto cleanup; } } - b_trie_insert(config, pieces[0], b_strdup(pieces[1])); - b_strv_free(pieces); + sb_trie_insert(config, pieces[0], sb_strdup(pieces[1])); + sb_strv_free(pieces); pieces = NULL; } break; @@ -192,17 +192,17 @@ main(int argc, char **argv) } } else - sources = b_slist_append(sources, b_strdup(argv[i])); + sources = sb_slist_append(sources, sb_strdup(argv[i])); } - if (!listing && b_slist_length(sources) == 0) { + if (!listing && sb_slist_length(sources) == 0) { blogc_print_usage(); fprintf(stderr, "blogc: error: one source file is required\n"); rv = 2; goto cleanup; } - if (!listing && b_slist_length(sources) > 1) { + if (!listing && sb_slist_length(sources) > 1) { blogc_print_usage(); fprintf(stderr, "blogc: error: only one source file should be provided, " "if running without '-l'\n"); @@ -212,14 +212,14 @@ main(int argc, char **argv) blogc_error_t *err = NULL; - b_slist_t *s = blogc_source_parse_from_files(config, sources, &err); + sb_slist_t *s = blogc_source_parse_from_files(config, sources, &err); if (err != NULL) { blogc_error_print(err); rv = 2; goto cleanup2; } - b_slist_t* l = blogc_template_parse_from_file(template, &err); + sb_slist_t* l = blogc_template_parse_from_file(template, &err); if (err != NULL) { blogc_error_print(err); rv = 2; @@ -227,7 +227,7 @@ main(int argc, char **argv) } if (print != NULL) { - const char *val = b_trie_lookup(config, print); + const char *val = sb_trie_lookup(config, print); if (val == NULL) { fprintf(stderr, "blogc: error: configuration variable not found: %s\n", print); @@ -273,13 +273,13 @@ cleanup4: cleanup3: blogc_template_free_stmts(l); cleanup2: - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); blogc_error_free(err); cleanup: - b_trie_free(config); + sb_trie_free(config); free(template); free(output); free(print); - b_slist_free_full(sources, free); + sb_slist_free_full(sources, free); return rv; } diff --git a/src/content-parser.c b/src/content-parser.c index 8dceb8b..0561d20 100644 --- a/src/content-parser.c +++ b/src/content-parser.c @@ -13,9 +13,9 @@ #include <stdbool.h> #include <string.h> -#include "utils/utils.h" #include "content-parser.h" #include "directives.h" +#include "utils.h" // this is a half ass implementation of a markdown-like syntax. bugs are // expected. feel free to improve the parser and add new features. @@ -26,7 +26,7 @@ blogc_slugify(const char *str) { if (str == NULL) return NULL; - char *new_str = b_strdup(str); + char *new_str = sb_strdup(str); int diff = 'a' - 'A'; // just to avoid magic numbers for (size_t i = 0; new_str[i] != '\0'; i++) { if (new_str[i] >= 'a' && new_str[i] <= 'z') @@ -47,32 +47,32 @@ blogc_htmlentities(const char *str) { if (str == NULL) return NULL; - b_string_t *rv = b_string_new(); + sb_string_t *rv = sb_string_new(); for (size_t i = 0; str[i] != '\0'; i++) { switch (str[i]) { case '&': - b_string_append(rv, "&"); + sb_string_append(rv, "&"); break; case '<': - b_string_append(rv, "<"); + sb_string_append(rv, "<"); break; case '>': - b_string_append(rv, ">"); + sb_string_append(rv, ">"); break; case '"': - b_string_append(rv, """); + sb_string_append(rv, """); break; case '\'': - b_string_append(rv, "'"); + sb_string_append(rv, "'"); break; case '/': - b_string_append(rv, "/"); + sb_string_append(rv, "/"); break; default: - b_string_append_c(rv, str[i]); + sb_string_append_c(rv, str[i]); } } - return b_string_free(rv, false); + return sb_string_free(rv, false); } @@ -139,7 +139,7 @@ blogc_content_parse_inline(const char *src) size_t start_state = 0; size_t end = 0; - b_string_t *rv = b_string_new(); + sb_string_t *rv = sb_string_new(); bool open_em_ast = false; bool open_strong_ast = false; @@ -165,7 +165,7 @@ blogc_content_parse_inline(const char *src) if (escape) { if (state == LINK_CLOSED) - b_string_append_c(rv, c); + sb_string_append_c(rv, c); current++; escape = false; continue; @@ -174,11 +174,21 @@ blogc_content_parse_inline(const char *src) if (c != ' ' && c != '\n' && c != '\r') spaces = 0; + if (state == LINK_TEXT_CLOSE && c != ' ' && c != '\n' && c != '\r' && + c != '(') + { + sb_string_append_c(rv, src[start_state]); + tmp = blogc_content_parse_inline(src + start_state + 1); + sb_string_append(rv, tmp); + // no need to free here, we will exit the loop! + break; + } + switch (c) { case '\\': if (state == LINK_CLOSED && (open_code || open_code_double)) { - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; } if (!escape) @@ -188,7 +198,7 @@ blogc_content_parse_inline(const char *src) case '*': case '_': if (state == LINK_CLOSED && (open_code || open_code_double)) { - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; } if (!is_last && src[current + 1] == c) { @@ -197,7 +207,7 @@ blogc_content_parse_inline(const char *src) (c == '_' && open_strong_und)) { if (state == LINK_CLOSED) - b_string_append(rv, "</strong>"); + sb_string_append(rv, "</strong>"); if (c == '*') open_strong_ast = false; else @@ -205,7 +215,7 @@ blogc_content_parse_inline(const char *src) break; } if (state == LINK_CLOSED) - b_string_append(rv, "<strong>"); + sb_string_append(rv, "<strong>"); if (c == '*') open_strong_ast = true; else @@ -214,7 +224,7 @@ blogc_content_parse_inline(const char *src) } if ((c == '*' && open_em_ast) || (c == '_' && open_em_und)) { if (state == LINK_CLOSED) - b_string_append(rv, "</em>"); + sb_string_append(rv, "</em>"); if (c == '*') open_em_ast = false; else @@ -222,7 +232,7 @@ blogc_content_parse_inline(const char *src) break; } if (state == LINK_CLOSED) - b_string_append(rv, "<em>"); + sb_string_append(rv, "<em>"); if (c == '*') open_em_ast = true; else @@ -233,22 +243,26 @@ blogc_content_parse_inline(const char *src) if (!is_last && src[current + 1] == c) { current++; if (state == LINK_CLOSED) - b_string_append_printf(rv, "<%scode>", + sb_string_append_printf(rv, "<%scode>", open_code_double ? "/" : ""); open_code_double = !open_code_double; break; } if (state == LINK_CLOSED) - b_string_append_printf(rv, "<%scode>", open_code ? "/" : ""); + sb_string_append_printf(rv, "<%scode>", open_code ? "/" : ""); open_code = !open_code; break; case '!': - if (state == LINK_CLOSED && (open_code || open_code_double)) { - b_string_append_c(rv, c); - break; - } if (state == LINK_CLOSED) { + if (open_code || open_code_double) { + sb_string_append_c(rv, c); + break; + } + if (!is_last && src[current + 1] != '[') { + sb_string_append_c(rv, c); + break; + } state = LINK_IMAGE; is_image = true; start_state = current; @@ -257,7 +271,7 @@ blogc_content_parse_inline(const char *src) case '[': if (state == LINK_CLOSED && (open_code || open_code_double)) { - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; } if (state == LINK_CLOSED || state == LINK_IMAGE) { @@ -287,8 +301,8 @@ blogc_content_parse_inline(const char *src) } if (state == LINK_AUTO_CLOSE) { state = LINK_CLOSED; - tmp = b_strndup(src + start, end - start); - b_string_append_printf(rv, "<a href=\"%s\">%s</a>", tmp, tmp); + tmp = sb_strndup(src + start, end - start); + sb_string_append_printf(rv, "<a href=\"%s\">%s</a>", tmp, tmp); end = 0; free(tmp); tmp = NULL; @@ -298,7 +312,7 @@ blogc_content_parse_inline(const char *src) if (state == LINK_TEXT) { if (open_bracket-- == 0) { state = LINK_TEXT_CLOSE; - tmp = b_strndup(src + start, current - start); + tmp = sb_strndup(src + start, current - start); tmp2 = blogc_content_parse_inline(tmp); free(tmp); tmp = NULL; @@ -306,7 +320,7 @@ blogc_content_parse_inline(const char *src) break; } if (state == LINK_CLOSED) - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; case '(': @@ -316,18 +330,18 @@ blogc_content_parse_inline(const char *src) break; } if (state == LINK_CLOSED) - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; case ')': if (state == LINK_URL) { state = LINK_CLOSED; - tmp = b_strndup(src + start, current - start); + tmp = sb_strndup(src + start, current - start); if (is_image) - b_string_append_printf(rv, "<img src=\"%s\" alt=\"%s\">", + sb_string_append_printf(rv, "<img src=\"%s\" alt=\"%s\">", tmp, tmp2); else - b_string_append_printf(rv, "<a href=\"%s\">%s</a>", + sb_string_append_printf(rv, "<a href=\"%s\">%s</a>", tmp, tmp2); free(tmp); tmp = NULL; @@ -337,13 +351,13 @@ blogc_content_parse_inline(const char *src) break; } if (state == LINK_CLOSED) - b_string_append_c(rv, c); + sb_string_append_c(rv, c); break; case ' ': if (state == LINK_CLOSED) { spaces++; - b_string_append_c(rv, c); + sb_string_append_c(rv, c); } if (!is_last) break; @@ -352,55 +366,74 @@ blogc_content_parse_inline(const char *src) case '\r': if (state == LINK_CLOSED) { if (spaces >= 2) { - b_string_append(rv, "<br />"); + sb_string_append(rv, "<br />"); spaces = 0; } if (c == '\n' || c == '\r') - b_string_append_c(rv, c); + sb_string_append_c(rv, c); + } + break; + + case '-': + if (state != LINK_CLOSED) + break; + if ((current < (src_len - 1) && src[current + 1] == '-') && + !(open_code || open_code_double)) + { + if (current < (src_len - 2) && src[current + 2] == '-') { + sb_string_append(rv, "—"); + current += 2; + } + else { + sb_string_append(rv, "–"); + current += 1; + } + } + else { + sb_string_append_c(rv, c); } break; case '&': if (state == LINK_CLOSED) - b_string_append(rv, "&"); + sb_string_append(rv, "&"); break; case '<': if (state == LINK_CLOSED) - b_string_append(rv, "<"); + sb_string_append(rv, "<"); break; case '>': if (state == LINK_CLOSED) - b_string_append(rv, ">"); + sb_string_append(rv, ">"); break; case '"': if (state == LINK_CLOSED) - b_string_append(rv, """); + sb_string_append(rv, """); break; case '\'': if (state == LINK_CLOSED) - b_string_append(rv, "'"); + sb_string_append(rv, "'"); break; case '/': if (state == LINK_CLOSED) - b_string_append(rv, "/"); + sb_string_append(rv, "/"); break; default: if (state == LINK_CLOSED) - b_string_append_c(rv, c); + sb_string_append_c(rv, c); } if (is_last && state != LINK_CLOSED) { - b_string_append_c(rv, src[start_state]); + sb_string_append_c(rv, src[start_state]); tmp = blogc_content_parse_inline(src + start_state + 1); - b_string_append(rv, tmp); - free(tmp); - tmp = NULL; + sb_string_append(rv, tmp); + // no need to free here, its the last iteration } current++; } @@ -408,7 +441,7 @@ blogc_content_parse_inline(const char *src) free(tmp); free(tmp2); - return b_string_free(rv, false); + return sb_string_free(rv, false); } @@ -440,7 +473,7 @@ blogc_is_ordered_list_item(const char *str, size_t prefix_len) char* -blogc_content_parse(const char *src, size_t *end_excerpt) +blogc_content_parse(const char *src, size_t *end_excerpt, char **description) { // src is always nul-terminated. size_t src_len = strlen(src); @@ -463,7 +496,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) char *directive_name = NULL; char *directive_argument = NULL; char *directive_key = NULL; - b_trie_t *directive_params = NULL; + sb_trie_t *directive_params = NULL; // this isn't empty because we need some reasonable default value in the // unlikely case that we need to print some line ending before evaluating @@ -473,11 +506,11 @@ blogc_content_parse(const char *src, size_t *end_excerpt) char d = '\0'; - b_slist_t *lines = NULL; - b_slist_t *lines2 = NULL; + sb_slist_t *lines = NULL; + sb_slist_t *lines2 = NULL; - b_string_t *rv = b_string_new(); - b_string_t *tmp_str = NULL; + sb_string_t *rv = sb_string_new(); + sb_string_t *tmp_str = NULL; blogc_content_parser_state_t state = CONTENT_START_LINE; @@ -607,14 +640,14 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); - tmp = b_strndup(src + start, end - start); + tmp = sb_strndup(src + start, end - start); parsed = blogc_content_parse_inline(tmp); slug = blogc_slugify(tmp); if (slug == NULL) - b_string_append_printf(rv, "<h%d>%s</h%d>%s", + sb_string_append_printf(rv, "<h%d>%s</h%d>%s", header_level, parsed, header_level, line_ending); else - b_string_append_printf(rv, "<h%d id=\"%s\">%s</h%d>%s", + sb_string_append_printf(rv, "<h%d id=\"%s\">%s</h%d>%s", header_level, slug, parsed, header_level, line_ending); free(slug); @@ -638,8 +671,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_HTML_END: if (c == '\n' || c == '\r' || is_last) { - tmp = b_strndup(src + start, end - start); - b_string_append_printf(rv, "%s%s", tmp, line_ending); + tmp = sb_strndup(src + start, end - start); + sb_string_append_printf(rv, "%s%s", tmp, line_ending); free(tmp); tmp = NULL; state = CONTENT_START_LINE; @@ -652,7 +685,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_BLOCKQUOTE: if (c == ' ' || c == '\t') break; - prefix = b_strndup(src + start, current - start); + prefix = sb_strndup(src + start, current - start); state = CONTENT_BLOCKQUOTE_START; break; @@ -660,16 +693,16 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); - tmp = b_strndup(src + start2, end - start2); - if (b_str_starts_with(tmp, prefix)) { - lines = b_slist_append(lines, b_strdup(tmp + strlen(prefix))); + tmp = sb_strndup(src + start2, end - start2); + if (sb_str_starts_with(tmp, prefix)) { + lines = sb_slist_append(lines, sb_strdup(tmp + strlen(prefix))); state = CONTENT_BLOCKQUOTE_END; } else { state = CONTENT_PARAGRAPH; free(prefix); prefix = NULL; - b_slist_free_full(lines, free); + sb_slist_free_full(lines, free); lines = NULL; if (is_last) { free(tmp); @@ -685,22 +718,18 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_BLOCKQUOTE_END: if (c == '\n' || c == '\r' || is_last) { - tmp_str = b_string_new(); - for (b_slist_t *l = lines; l != NULL; l = l->next) { - if (l->next == NULL) - b_string_append_printf(tmp_str, "%s", l->data); - else - b_string_append_printf(tmp_str, "%s%s", l->data, - line_ending); - } - tmp = blogc_content_parse(tmp_str->str, NULL); - b_string_append_printf(rv, "<blockquote>%s</blockquote>%s", + tmp_str = sb_string_new(); + for (sb_slist_t *l = lines; l != NULL; l = l->next) + sb_string_append_printf(tmp_str, "%s%s", l->data, + line_ending); + tmp = blogc_content_parse(tmp_str->str, NULL, description); + sb_string_append_printf(rv, "<blockquote>%s</blockquote>%s", tmp, line_ending); free(tmp); tmp = NULL; - b_string_free(tmp_str, true); + sb_string_free(tmp_str, true); tmp_str = NULL; - b_slist_free_full(lines, free); + sb_slist_free_full(lines, free); lines = NULL; free(prefix); prefix = NULL; @@ -716,7 +745,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_CODE: if (c == ' ' || c == '\t') break; - prefix = b_strndup(src + start, current - start); + prefix = sb_strndup(src + start, current - start); state = CONTENT_CODE_START; break; @@ -724,16 +753,16 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); - tmp = b_strndup(src + start2, end - start2); - if (b_str_starts_with(tmp, prefix)) { - lines = b_slist_append(lines, b_strdup(tmp + strlen(prefix))); + tmp = sb_strndup(src + start2, end - start2); + if (sb_str_starts_with(tmp, prefix)) { + lines = sb_slist_append(lines, sb_strdup(tmp + strlen(prefix))); state = CONTENT_CODE_END; } else { state = CONTENT_PARAGRAPH; free(prefix); prefix = NULL; - b_slist_free_full(lines, free); + sb_slist_free_full(lines, free); lines = NULL; free(tmp); tmp = NULL; @@ -749,18 +778,18 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_CODE_END: if (c == '\n' || c == '\r' || is_last) { - b_string_append(rv, "<pre><code>"); - for (b_slist_t *l = lines; l != NULL; l = l->next) { + sb_string_append(rv, "<pre><code>"); + for (sb_slist_t *l = lines; l != NULL; l = l->next) { char *tmp_line = blogc_htmlentities(l->data); if (l->next == NULL) - b_string_append_printf(rv, "%s", tmp_line); + sb_string_append_printf(rv, "%s", tmp_line); else - b_string_append_printf(rv, "%s%s", tmp_line, + sb_string_append_printf(rv, "%s%s", tmp_line, line_ending); free(tmp_line); } - b_string_append_printf(rv, "</code></pre>%s", line_ending); - b_slist_free_full(lines, free); + sb_string_append_printf(rv, "</code></pre>%s", line_ending); + sb_slist_free_full(lines, free); lines = NULL; free(prefix); prefix = NULL; @@ -782,7 +811,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) } if (c == ' ' || c == '\t') break; - prefix = b_strndup(src + start, current - start); + prefix = sb_strndup(src + start, current - start); state = CONTENT_UNORDERED_LIST_START; break; @@ -791,7 +820,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) break; } if (c == '\n' || c == '\r' || is_last) { - b_string_append_printf(rv, "<hr />%s", line_ending); + sb_string_append_printf(rv, "<hr />%s", line_ending); state = CONTENT_START_LINE; start = current; d = '\0'; @@ -804,30 +833,30 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); - tmp = b_strndup(src + start2, end - start2); - tmp2 = b_strdup_printf("%-*s", strlen(prefix), ""); - if (b_str_starts_with(tmp, prefix)) { + tmp = sb_strndup(src + start2, end - start2); + tmp2 = sb_strdup_printf("%-*s", strlen(prefix), ""); + if (sb_str_starts_with(tmp, prefix)) { if (lines2 != NULL) { - tmp_str = b_string_new(); - for (b_slist_t *l = lines2; l != NULL; l = l->next) { + tmp_str = sb_string_new(); + for (sb_slist_t *l = lines2; l != NULL; l = l->next) { if (l->next == NULL) - b_string_append_printf(tmp_str, "%s", l->data); + sb_string_append_printf(tmp_str, "%s", l->data); else - b_string_append_printf(tmp_str, "%s%s", l->data, + sb_string_append_printf(tmp_str, "%s%s", l->data, line_ending); } - b_slist_free_full(lines2, free); + sb_slist_free_full(lines2, free); lines2 = NULL; parsed = blogc_content_parse_inline(tmp_str->str); - b_string_free(tmp_str, true); - lines = b_slist_append(lines, b_strdup(parsed)); + sb_string_free(tmp_str, true); + lines = sb_slist_append(lines, sb_strdup(parsed)); free(parsed); parsed = NULL; } - lines2 = b_slist_append(lines2, b_strdup(tmp + strlen(prefix))); + lines2 = sb_slist_append(lines2, sb_strdup(tmp + strlen(prefix))); } - else if (b_str_starts_with(tmp, tmp2)) { - lines2 = b_slist_append(lines2, b_strdup(tmp + strlen(prefix))); + else if (sb_str_starts_with(tmp, tmp2)) { + lines2 = sb_slist_append(lines2, sb_strdup(tmp + strlen(prefix))); } else { state = CONTENT_PARAGRAPH_END; @@ -837,8 +866,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt) tmp2 = NULL; free(prefix); prefix = NULL; - b_slist_free_full(lines, free); - b_slist_free_full(lines2, free); + sb_slist_free_full(lines, free); + sb_slist_free_full(lines2, free); lines = NULL; if (is_last) continue; @@ -857,28 +886,28 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { if (lines2 != NULL) { // FIXME: avoid repeting the code below - tmp_str = b_string_new(); - for (b_slist_t *l = lines2; l != NULL; l = l->next) { + tmp_str = sb_string_new(); + for (sb_slist_t *l = lines2; l != NULL; l = l->next) { if (l->next == NULL) - b_string_append_printf(tmp_str, "%s", l->data); + sb_string_append_printf(tmp_str, "%s", l->data); else - b_string_append_printf(tmp_str, "%s%s", l->data, + sb_string_append_printf(tmp_str, "%s%s", l->data, line_ending); } - b_slist_free_full(lines2, free); + sb_slist_free_full(lines2, free); lines2 = NULL; parsed = blogc_content_parse_inline(tmp_str->str); - b_string_free(tmp_str, true); - lines = b_slist_append(lines, b_strdup(parsed)); + sb_string_free(tmp_str, true); + lines = sb_slist_append(lines, sb_strdup(parsed)); free(parsed); parsed = NULL; } - b_string_append_printf(rv, "<ul>%s", line_ending); - for (b_slist_t *l = lines; l != NULL; l = l->next) - b_string_append_printf(rv, "<li>%s</li>%s", l->data, + sb_string_append_printf(rv, "<ul>%s", line_ending); + for (sb_slist_t *l = lines; l != NULL; l = l->next) + sb_string_append_printf(rv, "<li>%s</li>%s", l->data, line_ending); - b_string_append_printf(rv, "</ul>%s", line_ending); - b_slist_free_full(lines, free); + sb_string_append_printf(rv, "</ul>%s", line_ending); + sb_slist_free_full(lines, free); lines = NULL; free(prefix); prefix = NULL; @@ -915,30 +944,30 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); - tmp = b_strndup(src + start2, end - start2); - tmp2 = b_strdup_printf("%-*s", prefix_len, ""); + tmp = sb_strndup(src + start2, end - start2); + tmp2 = sb_strdup_printf("%-*s", prefix_len, ""); if (blogc_is_ordered_list_item(tmp, prefix_len)) { if (lines2 != NULL) { - tmp_str = b_string_new(); - for (b_slist_t *l = lines2; l != NULL; l = l->next) { + tmp_str = sb_string_new(); + for (sb_slist_t *l = lines2; l != NULL; l = l->next) { if (l->next == NULL) - b_string_append_printf(tmp_str, "%s", l->data); + sb_string_append_printf(tmp_str, "%s", l->data); else - b_string_append_printf(tmp_str, "%s%s", l->data, + sb_string_append_printf(tmp_str, "%s%s", l->data, line_ending); } - b_slist_free_full(lines2, free); + sb_slist_free_full(lines2, free); lines2 = NULL; parsed = blogc_content_parse_inline(tmp_str->str); - b_string_free(tmp_str, true); - lines = b_slist_append(lines, b_strdup(parsed)); + sb_string_free(tmp_str, true); + lines = sb_slist_append(lines, sb_strdup(parsed)); free(parsed); parsed = NULL; } - lines2 = b_slist_append(lines2, b_strdup(tmp + prefix_len)); + lines2 = sb_slist_append(lines2, sb_strdup(tmp + prefix_len)); } - else if (b_str_starts_with(tmp, tmp2)) { - lines2 = b_slist_append(lines2, b_strdup(tmp + prefix_len)); + else if (sb_str_starts_with(tmp, tmp2)) { + lines2 = sb_slist_append(lines2, sb_strdup(tmp + prefix_len)); } else { state = CONTENT_PARAGRAPH_END; @@ -948,8 +977,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt) tmp2 = NULL; free(parsed); parsed = NULL; - b_slist_free_full(lines, free); - b_slist_free_full(lines2, free); + sb_slist_free_full(lines, free); + sb_slist_free_full(lines2, free); lines = NULL; if (is_last) continue; @@ -968,28 +997,28 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { if (lines2 != NULL) { // FIXME: avoid repeting the code below - tmp_str = b_string_new(); - for (b_slist_t *l = lines2; l != NULL; l = l->next) { + tmp_str = sb_string_new(); + for (sb_slist_t *l = lines2; l != NULL; l = l->next) { if (l->next == NULL) - b_string_append_printf(tmp_str, "%s", l->data); + sb_string_append_printf(tmp_str, "%s", l->data); else - b_string_append_printf(tmp_str, "%s%s", l->data, + sb_string_append_printf(tmp_str, "%s%s", l->data, line_ending); } - b_slist_free_full(lines2, free); + sb_slist_free_full(lines2, free); lines2 = NULL; parsed = blogc_content_parse_inline(tmp_str->str); - b_string_free(tmp_str, true); - lines = b_slist_append(lines, b_strdup(parsed)); + sb_string_free(tmp_str, true); + lines = sb_slist_append(lines, sb_strdup(parsed)); free(parsed); parsed = NULL; } - b_string_append_printf(rv, "<ol>%s", line_ending); - for (b_slist_t *l = lines; l != NULL; l = l->next) - b_string_append_printf(rv, "<li>%s</li>%s", l->data, + sb_string_append_printf(rv, "<ol>%s", line_ending); + for (sb_slist_t *l = lines; l != NULL; l = l->next) + sb_string_append_printf(rv, "<li>%s</li>%s", l->data, line_ending); - b_string_append_printf(rv, "</ol>%s", line_ending); - b_slist_free_full(lines, free); + sb_string_append_printf(rv, "</ol>%s", line_ending); + sb_slist_free_full(lines, free); lines = NULL; free(prefix); prefix = NULL; @@ -1033,7 +1062,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_DIRECTIVE_COLON: if (c == ':') { free(directive_name); - directive_name = b_strndup(src + start2, end - start2); + directive_name = sb_strndup(src + start2, end - start2); state = CONTENT_DIRECTIVE_ARGUMENT_START; if (is_last) { state = CONTENT_DIRECTIVE_PARAM_END; @@ -1077,7 +1106,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); free(directive_argument); - directive_argument = b_strndup(src + start2, end - start2); + directive_argument = sb_strndup(src + start2, end - start2); if (is_last) { state = CONTENT_DIRECTIVE_PARAM_END; continue; @@ -1098,7 +1127,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) state = CONTENT_DIRECTIVE_PARAM_END; continue; } - prefix = b_strndup(src + start2, current - start2); + prefix = sb_strndup(src + start2, current - start2); state = CONTENT_DIRECTIVE_PARAM_PREFIX; current--; break; @@ -1106,7 +1135,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) case CONTENT_DIRECTIVE_PARAM_PREFIX: if (c == ' ' || c == '\t') break; - if (c == ':' && b_str_starts_with(src + start2, prefix)) { + if (c == ':' && sb_str_starts_with(src + start2, prefix)) { state = CONTENT_DIRECTIVE_PARAM_KEY_START; break; } @@ -1137,7 +1166,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) break; if (c == ':') { free(directive_key); - directive_key = b_strndup(src + start2, current - start2); + directive_key = sb_strndup(src + start2, current - start2); state = CONTENT_DIRECTIVE_PARAM_VALUE_START; break; } @@ -1161,9 +1190,9 @@ blogc_content_parse(const char *src, size_t *end_excerpt) end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); if (directive_params == NULL) - directive_params = b_trie_new(free); - b_trie_insert(directive_params, directive_key, - b_strndup(src + start2, end - start2)); + directive_params = sb_trie_new(free); + sb_trie_insert(directive_params, directive_key, + sb_strndup(src + start2, end - start2)); free(directive_key); directive_key = NULL; if (!is_last) @@ -1176,7 +1205,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) if (c == '\n' || c == '\r' || is_last) { // FIXME: handle errors in the rest of the parser. blogc_error_t *err = NULL; - blogc_directive_ctx_t *ctx = b_malloc( + blogc_directive_ctx_t *ctx = sb_malloc( sizeof(blogc_directive_ctx_t)); ctx->name = directive_name; ctx->argument = directive_argument; @@ -1186,7 +1215,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) free(ctx); blogc_error_print(err); if (rv_d != NULL) - b_string_append(rv, rv_d); + sb_string_append(rv, rv_d); free(rv_d); state = CONTENT_START_LINE; start = current; @@ -1194,7 +1223,7 @@ blogc_content_parse(const char *src, size_t *end_excerpt) directive_name = NULL; free(directive_argument); directive_argument = NULL; - b_trie_free(directive_params); + sb_trie_free(directive_params); directive_params = NULL; free(prefix); prefix = NULL; @@ -1215,15 +1244,17 @@ blogc_content_parse(const char *src, size_t *end_excerpt) state = CONTENT_PARAGRAPH_END; end = is_last && c != '\n' && c != '\r' ? src_len : (real_end != 0 ? real_end : current); + if (description != NULL && *description == NULL) + *description = sb_strndup(src + start, end - start); } if (!is_last) break; case CONTENT_PARAGRAPH_END: if (c == '\n' || c == '\r' || is_last) { - tmp = b_strndup(src + start, end - start); + tmp = sb_strndup(src + start, end - start); parsed = blogc_content_parse_inline(tmp); - b_string_append_printf(rv, "<p>%s</p>%s", parsed, + sb_string_append_printf(rv, "<p>%s</p>%s", parsed, line_ending); free(parsed); parsed = NULL; @@ -1244,8 +1275,8 @@ blogc_content_parse(const char *src, size_t *end_excerpt) free(directive_name); free(directive_argument); free(directive_key); - b_trie_free(directive_params); + sb_trie_free(directive_params); free(prefix); - return b_string_free(rv, false); + return sb_string_free(rv, false); } diff --git a/src/content-parser.h b/src/content-parser.h index 6617bb4..148d5ed 100644 --- a/src/content-parser.h +++ b/src/content-parser.h @@ -16,6 +16,7 @@ char* blogc_slugify(const char *str); char* blogc_htmlentities(const char *str); char* blogc_content_parse_inline(const char *src); bool blogc_is_ordered_list_item(const char *str, size_t prefix_len); -char* blogc_content_parse(const char *src, size_t *end_excerpt); +char* blogc_content_parse(const char *src, size_t *end_excerpt, + char **description); #endif /* _CONTENT_PARSER_H */ diff --git a/src/datetime-parser.c b/src/datetime-parser.c index 8785a89..ad65ff7 100644 --- a/src/datetime-parser.c +++ b/src/datetime-parser.c @@ -17,8 +17,8 @@ #include <string.h> #include "error.h" -#include "utils/utils.h" #include "datetime-parser.h" +#include "utils.h" typedef enum { @@ -380,7 +380,7 @@ blogc_convert_datetime(const char *orig, const char *format, return NULL; } - return b_strdup(buf); + return sb_strdup(buf); #endif } diff --git a/src/directives.c b/src/directives.c index b538825..eb6166b 100644 --- a/src/directives.c +++ b/src/directives.c @@ -12,9 +12,9 @@ #include <string.h> -#include "utils/utils.h" #include "directives.h" #include "error.h" +#include "utils.h" const static blogc_directive_t registry[] = { @@ -48,11 +48,11 @@ blogc_directive_youtube(blogc_directive_ctx_t *ctx, blogc_error_t **err) return NULL; } - char *width = b_trie_lookup(ctx->params, "width"); - char *height = b_trie_lookup(ctx->params, "height"); + char *width = sb_trie_lookup(ctx->params, "width"); + char *height = sb_trie_lookup(ctx->params, "height"); // using default 16:9 sizes provided by youtube as of 2015-11-04 - return b_strdup_printf( + return sb_strdup_printf( "<iframe width=\"%s\" height=\"%s\" " "src=\"https://www.youtube.com/embed/%s\" frameborder=\"0\" " "allowfullscreen></iframe>%s", diff --git a/src/directives.h b/src/directives.h index dd27f03..0c6e35b 100644 --- a/src/directives.h +++ b/src/directives.h @@ -9,13 +9,13 @@ #ifndef _DIRECTIVES_H #define _DIRECTIVES_H -#include "utils/utils.h" +#include "utils.h" #include "error.h" typedef struct { const char *name; const char *argument; - b_trie_t *params; + sb_trie_t *params; const char *eol; } blogc_directive_ctx_t; diff --git a/src/error.c b/src/error.c index 59a85a3..3aea641 100644 --- a/src/error.c +++ b/src/error.c @@ -14,16 +14,16 @@ #include <stdlib.h> #include <stdarg.h> #include <string.h> -#include "utils/utils.h" #include "error.h" +#include "utils.h" blogc_error_t* blogc_error_new(blogc_error_type_t type, const char *msg) { - blogc_error_t *err = b_malloc(sizeof(blogc_error_t)); + blogc_error_t *err = sb_malloc(sizeof(blogc_error_t)); err->type = type; - err->msg = b_strdup(msg); + err->msg = sb_strdup(msg); return err; } @@ -33,7 +33,7 @@ blogc_error_new_printf(blogc_error_type_t type, const char *format, ...) { va_list ap; va_start(ap, format); - char *tmp = b_strdup_vprintf(format, ap); + char *tmp = sb_strdup_vprintf(format, ap); va_end(ap); blogc_error_t *rv = blogc_error_new(type, tmp); free(tmp); @@ -47,7 +47,7 @@ blogc_error_parser(blogc_error_type_t type, const char *src, size_t src_len, { va_list ap; va_start(ap, format); - char *msg = b_strdup_vprintf(format, ap); + char *msg = sb_strdup_vprintf(format, ap); va_end(ap); size_t lineno = 1; @@ -88,7 +88,7 @@ blogc_error_parser(blogc_error_type_t type, const char *src, size_t src_len, if (lineend <= linestart && src_len >= linestart) lineend = src_len; - char *line = b_strndup(src + linestart, lineend - linestart); + char *line = sb_strndup(src + linestart, lineend - linestart); blogc_error_t *rv = NULL; @@ -14,9 +14,9 @@ #include <stdarg.h> #include <stdio.h> #include <string.h> -#include "utils/utils.h" #include "file.h" #include "error.h" +#include "utils.h" // this would belong to loader.c, but we need it in a separated file to be // able to mock it when unit testing the loader functions. @@ -38,16 +38,16 @@ blogc_file_get_contents(const char *path, size_t *len, blogc_error_t **err) return NULL; } - b_string_t *str = b_string_new(); + sb_string_t *str = sb_string_new(); char buffer[BLOGC_FILE_CHUNK_SIZE]; while (!feof(fp)) { size_t read_len = fread(buffer, sizeof(char), BLOGC_FILE_CHUNK_SIZE, fp); *len += read_len; - b_string_append_len(str, buffer, read_len); + sb_string_append_len(str, buffer, read_len); } fclose(fp); - return b_string_free(str, false); + return sb_string_free(str, false); } diff --git a/src/loader.c b/src/loader.c index baa81fa..5ca0aac 100644 --- a/src/loader.c +++ b/src/loader.c @@ -14,12 +14,12 @@ #include <stdbool.h> #include <stdio.h> #include <string.h> -#include "utils/utils.h" #include "file.h" #include "source-parser.h" #include "template-parser.h" #include "loader.h" #include "error.h" +#include "utils.h" char* @@ -31,7 +31,7 @@ blogc_get_filename(const char *f) if (strlen(f) == 0) return NULL; - char *filename = b_strdup(f); + char *filename = sb_strdup(f); // keep a pointer to original string char *tmp = filename; @@ -52,14 +52,14 @@ blogc_get_filename(const char *f) } } - char *final_filename = b_strdup(tmp); + char *final_filename = sb_strdup(tmp); free(filename); return final_filename; } -b_slist_t* +sb_slist_t* blogc_template_parse_from_file(const char *f, blogc_error_t **err) { if (err == NULL || *err != NULL) @@ -68,13 +68,13 @@ blogc_template_parse_from_file(const char *f, blogc_error_t **err) char *s = blogc_file_get_contents(f, &len, err); if (s == NULL) return NULL; - b_slist_t *rv = blogc_template_parse(s, len, err); + sb_slist_t *rv = blogc_template_parse(s, len, err); free(s); return rv; } -b_trie_t* +sb_trie_t* blogc_source_parse_from_file(const char *f, blogc_error_t **err) { if (err == NULL || *err != NULL) @@ -83,13 +83,13 @@ blogc_source_parse_from_file(const char *f, blogc_error_t **err) char *s = blogc_file_get_contents(f, &len, err); if (s == NULL) return NULL; - b_trie_t *rv = blogc_source_parse(s, len, err); + sb_trie_t *rv = blogc_source_parse(s, len, err); // set FILENAME variable if (rv != NULL) { char *filename = blogc_get_filename(f); if (filename != NULL) - b_trie_insert(rv, "FILENAME", filename); + sb_trie_insert(rv, "FILENAME", filename); } free(s); @@ -97,16 +97,16 @@ blogc_source_parse_from_file(const char *f, blogc_error_t **err) } -b_slist_t* -blogc_source_parse_from_files(b_trie_t *conf, b_slist_t *l, blogc_error_t **err) +sb_slist_t* +blogc_source_parse_from_files(sb_trie_t *conf, sb_slist_t *l, blogc_error_t **err) { blogc_error_t *tmp_err = NULL; - b_slist_t *rv = NULL; + sb_slist_t *rv = NULL; unsigned int with_date = 0; - const char *filter_tag = b_trie_lookup(conf, "FILTER_TAG"); - const char *filter_page = b_trie_lookup(conf, "FILTER_PAGE"); - const char *filter_per_page = b_trie_lookup(conf, "FILTER_PER_PAGE"); + const char *filter_tag = sb_trie_lookup(conf, "FILTER_TAG"); + const char *filter_page = sb_trie_lookup(conf, "FILTER_PAGE"); + const char *filter_per_page = sb_trie_lookup(conf, "FILTER_PER_PAGE"); long page = strtol(filter_page != NULL ? filter_page : "", NULL, 10); if (page <= 0) @@ -121,27 +121,27 @@ blogc_source_parse_from_files(b_trie_t *conf, b_slist_t *l, blogc_error_t **err) unsigned int end = start + per_page; unsigned int counter = 0; - for (b_slist_t *tmp = l; tmp != NULL; tmp = tmp->next) { + for (sb_slist_t *tmp = l; tmp != NULL; tmp = tmp->next) { char *f = tmp->data; - b_trie_t *s = blogc_source_parse_from_file(f, &tmp_err); + sb_trie_t *s = blogc_source_parse_from_file(f, &tmp_err); if (s == NULL) { *err = blogc_error_new_printf(BLOGC_ERROR_LOADER, "An error occurred while parsing source file: %s\n\n%s", f, tmp_err->msg); blogc_error_free(tmp_err); tmp_err = NULL; - b_slist_free_full(rv, (b_free_func_t) b_trie_free); + sb_slist_free_full(rv, (sb_free_func_t) sb_trie_free); rv = NULL; break; } if (filter_tag != NULL) { - const char *tags_str = b_trie_lookup(s, "TAGS"); + const char *tags_str = sb_trie_lookup(s, "TAGS"); // if user wants to filter by tag and no tag is provided, skip it if (tags_str == NULL) { - b_trie_free(s); + sb_trie_free(s); continue; } - char **tags = b_str_split(tags_str, ' ', 0); + char **tags = sb_str_split(tags_str, ' ', 0); bool found = false; for (unsigned int i = 0; tags[i] != NULL; i++) { if (tags[i][0] == '\0') @@ -149,26 +149,26 @@ blogc_source_parse_from_files(b_trie_t *conf, b_slist_t *l, blogc_error_t **err) if (0 == strcmp(tags[i], filter_tag)) found = true; } - b_strv_free(tags); + sb_strv_free(tags); if (!found) { - b_trie_free(s); + sb_trie_free(s); continue; } } if (filter_page != NULL) { if (counter < start || counter >= end) { counter++; - b_trie_free(s); + sb_trie_free(s); continue; } counter++; } - if (b_trie_lookup(s, "DATE") != NULL) + if (sb_trie_lookup(s, "DATE") != NULL) with_date++; - rv = b_slist_append(rv, s); + rv = sb_slist_append(rv, s); } - if (with_date > 0 && with_date < b_slist_length(rv)) + if (with_date > 0 && with_date < sb_slist_length(rv)) // fatal error, maybe? blogc_fprintf(stderr, "blogc: warning: 'DATE' variable provided for at least one source " @@ -176,38 +176,38 @@ blogc_source_parse_from_files(b_trie_t *conf, b_slist_t *l, blogc_error_t **err) "wrong values for 'DATE_FIRST' and 'DATE_LAST' variables.\n"); bool first = true; - for (b_slist_t *tmp = rv; tmp != NULL; tmp = tmp->next) { - b_trie_t *s = tmp->data; + for (sb_slist_t *tmp = rv; tmp != NULL; tmp = tmp->next) { + sb_trie_t *s = tmp->data; if (first) { - const char *val = b_trie_lookup(s, "DATE"); + const char *val = sb_trie_lookup(s, "DATE"); if (val != NULL) - b_trie_insert(conf, "DATE_FIRST", b_strdup(val)); - val = b_trie_lookup(s, "FILENAME"); + sb_trie_insert(conf, "DATE_FIRST", sb_strdup(val)); + val = sb_trie_lookup(s, "FILENAME"); if (val != NULL) - b_trie_insert(conf, "FILENAME_FIRST", b_strdup(val)); + sb_trie_insert(conf, "FILENAME_FIRST", sb_strdup(val)); first = false; } if (tmp->next == NULL) { // last - const char *val = b_trie_lookup(s, "DATE"); + const char *val = sb_trie_lookup(s, "DATE"); if (val != NULL) - b_trie_insert(conf, "DATE_LAST", b_strdup(val)); - val = b_trie_lookup(s, "FILENAME"); + sb_trie_insert(conf, "DATE_LAST", sb_strdup(val)); + val = sb_trie_lookup(s, "FILENAME"); if (val != NULL) - b_trie_insert(conf, "FILENAME_LAST", b_strdup(val)); + sb_trie_insert(conf, "FILENAME_LAST", sb_strdup(val)); } } if (filter_page != NULL) { unsigned int last_page = ceilf(((float) counter) / per_page); - b_trie_insert(conf, "CURRENT_PAGE", b_strdup_printf("%ld", page)); + sb_trie_insert(conf, "CURRENT_PAGE", sb_strdup_printf("%ld", page)); if (page > 1) - b_trie_insert(conf, "PREVIOUS_PAGE", b_strdup_printf("%ld", page - 1)); + sb_trie_insert(conf, "PREVIOUS_PAGE", sb_strdup_printf("%ld", page - 1)); if (page < last_page) - b_trie_insert(conf, "NEXT_PAGE", b_strdup_printf("%ld", page + 1)); - if (b_slist_length(rv) > 0) - b_trie_insert(conf, "FIRST_PAGE", b_strdup("1")); + sb_trie_insert(conf, "NEXT_PAGE", sb_strdup_printf("%ld", page + 1)); + if (sb_slist_length(rv) > 0) + sb_trie_insert(conf, "FIRST_PAGE", sb_strdup("1")); if (last_page > 0) - b_trie_insert(conf, "LAST_PAGE", b_strdup_printf("%d", last_page)); + sb_trie_insert(conf, "LAST_PAGE", sb_strdup_printf("%d", last_page)); } return rv; diff --git a/src/loader.h b/src/loader.h index c432e20..32b58be 100644 --- a/src/loader.h +++ b/src/loader.h @@ -9,13 +9,13 @@ #ifndef _LOADER_H #define _LOADER_H -#include "utils/utils.h" #include "error.h" +#include "utils.h" char* blogc_get_filename(const char *f); -b_slist_t* blogc_template_parse_from_file(const char *f, blogc_error_t **err); -b_trie_t* blogc_source_parse_from_file(const char *f, blogc_error_t **err); -b_slist_t* blogc_source_parse_from_files(b_trie_t *conf, b_slist_t *l, +sb_slist_t* blogc_template_parse_from_file(const char *f, blogc_error_t **err); +sb_trie_t* blogc_source_parse_from_file(const char *f, blogc_error_t **err); +sb_slist_t* blogc_source_parse_from_files(sb_trie_t *conf, sb_slist_t *l, blogc_error_t **err); #endif /* _LOADER_H */ diff --git a/src/renderer.c b/src/renderer.c index 5e07b0c..5af3b8a 100644 --- a/src/renderer.c +++ b/src/renderer.c @@ -13,69 +13,69 @@ #include <stdbool.h> #include <stdio.h> #include <string.h> -#include "utils/utils.h" #include "datetime-parser.h" #include "error.h" #include "loader.h" #include "source-parser.h" #include "template-parser.h" #include "renderer.h" +#include "utils.h" const char* -blogc_get_variable(const char *name, b_trie_t *global, b_trie_t *local) +blogc_get_variable(const char *name, sb_trie_t *global, sb_trie_t *local) { const char *rv = NULL; if (local != NULL) { - rv = b_trie_lookup(local, name); + rv = sb_trie_lookup(local, name); if (rv != NULL) return rv; } if (global != NULL) - rv = b_trie_lookup(global, name); + rv = sb_trie_lookup(global, name); return rv; } char* -blogc_format_date(const char *date, b_trie_t *global, b_trie_t *local) +blogc_format_date(const char *date, sb_trie_t *global, sb_trie_t *local) { const char *date_format = blogc_get_variable("DATE_FORMAT", global, local); if (date == NULL) return NULL; if (date_format == NULL) - return b_strdup(date); + return sb_strdup(date); blogc_error_t *err = NULL; char *rv = blogc_convert_datetime(date, date_format, &err); if (err != NULL) { blogc_error_print(err); blogc_error_free(err); - return b_strdup(date); + return sb_strdup(date); } return rv; } char* -blogc_format_variable(const char *name, b_trie_t *global, b_trie_t *local, - b_slist_t *foreach_var) +blogc_format_variable(const char *name, sb_trie_t *global, sb_trie_t *local, + sb_slist_t *foreach_var) { if (0 == strcmp(name, "FOREACH_ITEM")) { if (foreach_var != NULL && foreach_var->data != NULL) { - return b_strdup(foreach_var->data); + return sb_strdup(foreach_var->data); } return NULL; } char *var = NULL; bool must_format = false; - if (b_str_ends_with(name, "_FORMATTED")) { - var = b_strndup(name, strlen(name) - 10); + if (sb_str_ends_with(name, "_FORMATTED")) { + var = sb_strndup(name, strlen(name) - 10); must_format = true; } if (var == NULL) - var = b_strdup(name); + var = sb_strdup(name); const char *value = blogc_get_variable(var, global, local); free(var); @@ -85,30 +85,30 @@ blogc_format_variable(const char *name, b_trie_t *global, b_trie_t *local, char *rv = NULL; if (must_format) { - if (b_str_starts_with(name, "DATE_")) { + if (sb_str_starts_with(name, "DATE_")) { rv = blogc_format_date(value, global, local); } } if (rv == NULL) - return b_strdup(value); + return sb_strdup(value); return rv; } -b_slist_t* -blogc_split_list_variable(const char *name, b_trie_t *global, b_trie_t *local) +sb_slist_t* +blogc_split_list_variable(const char *name, sb_trie_t *global, sb_trie_t *local) { const char *value = blogc_get_variable(name, global, local); if (value == NULL) return NULL; - b_slist_t *rv = NULL; + sb_slist_t *rv = NULL; - char **tmp = b_str_split(value, ' ', 0); + char **tmp = sb_str_split(value, ' ', 0); for (unsigned int i = 0; tmp[i] != NULL; i++) { if (tmp[i][0] != '\0') // ignore empty strings - rv = b_slist_append(rv, tmp[i]); + rv = sb_slist_append(rv, tmp[i]); else free(tmp[i]); } @@ -119,25 +119,25 @@ blogc_split_list_variable(const char *name, b_trie_t *global, b_trie_t *local) char* -blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing) +blogc_render(sb_slist_t *tmpl, sb_slist_t *sources, sb_trie_t *config, bool listing) { if (tmpl == NULL) return NULL; - b_slist_t *current_source = NULL; - b_slist_t *listing_start = NULL; + sb_slist_t *current_source = NULL; + sb_slist_t *listing_start = NULL; - b_string_t *str = b_string_new(); + sb_string_t *str = sb_string_new(); - b_trie_t *tmp_source = NULL; + sb_trie_t *tmp_source = NULL; char *config_value = NULL; char *defined = NULL; unsigned int if_count = 0; - b_slist_t *foreach_var = NULL; - b_slist_t *foreach_var_start = NULL; - b_slist_t *foreach_start = NULL; + sb_slist_t *foreach_var = NULL; + sb_slist_t *foreach_var_start = NULL; + sb_slist_t *foreach_start = NULL; bool if_not = false; bool inside_block = false; @@ -145,7 +145,7 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing int cmp = 0; - b_slist_t *tmp = tmpl; + sb_slist_t *tmp = tmpl; while (tmp != NULL) { blogc_template_stmt_t *stmt = tmp->data; @@ -153,7 +153,7 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing case BLOGC_TEMPLATE_CONTENT_STMT: if (stmt->value != NULL) - b_string_append(str, stmt->value); + sb_string_append(str, stmt->value); break; case BLOGC_TEMPLATE_BLOCK_STMT: @@ -210,7 +210,7 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing config_value = blogc_format_variable(stmt->value, config, inside_block ? tmp_source : NULL, foreach_var); if (config_value != NULL) { - b_string_append(str, config_value); + sb_string_append(str, config_value); free(config_value); config_value = NULL; break; @@ -252,7 +252,7 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing (stmt->value2[0] == '"') && (stmt->value2[strlen(stmt->value2) - 1] == '"')) { - defined2 = b_strndup(stmt->value2 + 1, + defined2 = sb_strndup(stmt->value2 + 1, strlen(stmt->value2) - 2); } else { @@ -354,7 +354,7 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing } } foreach_start = NULL; - b_slist_free_full(foreach_var_start, free); + sb_slist_free_full(foreach_var_start, free); foreach_var_start = NULL; break; } @@ -364,5 +364,5 @@ blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, bool listing // no need to free temporary variables here. the template parser makes sure // that templates are sane and statements are closed. - return b_string_free(str, false); + return sb_string_free(str, false); } diff --git a/src/renderer.h b/src/renderer.h index 15204e6..2982ee8 100644 --- a/src/renderer.h +++ b/src/renderer.h @@ -10,15 +10,15 @@ #define _RENDERER_H #include <stdbool.h> -#include "utils/utils.h" +#include "utils.h" -const char* blogc_get_variable(const char *name, b_trie_t *global, b_trie_t *local); -char* blogc_format_date(const char *date, b_trie_t *global, b_trie_t *local); -char* blogc_format_variable(const char *name, b_trie_t *global, b_trie_t *local, - b_slist_t *foreach_var); -b_slist_t* blogc_split_list_variable(const char *name, b_trie_t *global, - b_trie_t *local); -char* blogc_render(b_slist_t *tmpl, b_slist_t *sources, b_trie_t *config, +const char* blogc_get_variable(const char *name, sb_trie_t *global, sb_trie_t *local); +char* blogc_format_date(const char *date, sb_trie_t *global, sb_trie_t *local); +char* blogc_format_variable(const char *name, sb_trie_t *global, sb_trie_t *local, + sb_slist_t *foreach_var); +sb_slist_t* blogc_split_list_variable(const char *name, sb_trie_t *global, + sb_trie_t *local); +char* blogc_render(sb_slist_t *tmpl, sb_slist_t *sources, sb_trie_t *config, bool listing); #endif /* _RENDERER_H */ diff --git a/src/source-parser.c b/src/source-parser.c index 65fdd4e..f250bd3 100644 --- a/src/source-parser.c +++ b/src/source-parser.c @@ -13,10 +13,10 @@ #include <stdbool.h> #include <string.h> -#include "utils/utils.h" #include "content-parser.h" #include "source-parser.h" #include "error.h" +#include "utils.h" typedef enum { @@ -30,7 +30,7 @@ typedef enum { } blogc_source_parser_state_t; -b_trie_t* +sb_trie_t* blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) { if (err == NULL || *err != NULL) @@ -43,7 +43,7 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) char *key = NULL; char *tmp = NULL; char *content = NULL; - b_trie_t *rv = b_trie_new(free); + sb_trie_t *rv = sb_trie_new(free); blogc_source_parser_state_t state = SOURCE_START; @@ -73,7 +73,7 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) if ((c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_') break; if (c == ':') { - key = b_strndup(src + start, current - start); + key = sb_strndup(src + start, current - start); if (((current - start == 8) && (0 == strncmp("FILENAME", src + start, 8))) || ((current - start == 7) && @@ -122,8 +122,8 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) case SOURCE_CONFIG_VALUE: if (c == '\n' || c == '\r') { - tmp = b_strndup(src + start, current - start); - b_trie_insert(rv, key, b_strdup(b_str_strip(tmp))); + tmp = sb_strndup(src + start, current - start); + sb_trie_insert(rv, key, sb_strdup(sb_str_strip(tmp))); free(tmp); free(key); key = NULL; @@ -152,12 +152,24 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) case SOURCE_CONTENT: if (current == (src_len - 1)) { - tmp = b_strndup(src + start, src_len - start); - b_trie_insert(rv, "RAW_CONTENT", tmp); - content = blogc_content_parse(tmp, &end_excerpt); - b_trie_insert(rv, "CONTENT", content); - b_trie_insert(rv, "EXCERPT", end_excerpt == 0 ? - b_strdup(content) : b_strndup(content, end_excerpt)); + tmp = sb_strndup(src + start, src_len - start); + sb_trie_insert(rv, "RAW_CONTENT", tmp); + char *description = NULL; + content = blogc_content_parse(tmp, &end_excerpt, &description); + if (description != NULL) { + // do not override source-provided description. + if (NULL == sb_trie_lookup(rv, "DESCRIPTION")) { + // no need to free, because we are transfering memory + // ownership to the trie. + sb_trie_insert(rv, "DESCRIPTION", description); + } + else { + free(description); + } + } + sb_trie_insert(rv, "CONTENT", content); + sb_trie_insert(rv, "EXCERPT", end_excerpt == 0 ? + sb_strdup(content) : sb_strndup(content, end_excerpt)); } break; } @@ -168,7 +180,7 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) current++; } - if (*err == NULL && b_trie_size(rv) == 0) { + if (*err == NULL && sb_trie_size(rv) == 0) { // ok, nothing found in the config trie, but no error set either. // let's try to be nice with the users and provide some reasonable @@ -202,7 +214,7 @@ blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err) if (*err != NULL) { free(key); - b_trie_free(rv); + sb_trie_free(rv); return NULL; } diff --git a/src/source-parser.h b/src/source-parser.h index f359f9e..5cadf95 100644 --- a/src/source-parser.h +++ b/src/source-parser.h @@ -10,10 +10,10 @@ #define _SOURCE_PARSER_H #include <stdlib.h> -#include "utils/utils.h" #include "error.h" +#include "utils.h" -b_trie_t* blogc_source_parse(const char *src, size_t src_len, +sb_trie_t* blogc_source_parse(const char *src, size_t src_len, blogc_error_t **err); #endif /* _SOURCE_PARSER_H */ diff --git a/src/template-parser.c b/src/template-parser.c index 1d9046e..525f5f5 100644 --- a/src/template-parser.c +++ b/src/template-parser.c @@ -13,9 +13,9 @@ #include <stdbool.h> #include <string.h> -#include "utils/utils.h" #include "template-parser.h" #include "error.h" +#include "utils.h" typedef enum { @@ -52,7 +52,7 @@ typedef enum { } blogc_template_parser_block_state_t; -b_slist_t* +sb_slist_t* blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) { if (err == NULL || *err != NULL) @@ -71,7 +71,7 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) unsigned int if_count = 0; bool foreach_open = false; - b_slist_t *stmts = NULL; + sb_slist_t *stmts = NULL; blogc_template_stmt_t *stmt = NULL; /* @@ -100,21 +100,21 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) case TEMPLATE_START: if (last) { - stmt = b_malloc(sizeof(blogc_template_stmt_t)); + stmt = sb_malloc(sizeof(blogc_template_stmt_t)); stmt->type = type; if (lstrip_next) { - tmp = b_strndup(src + start, src_len - start); - stmt->value = b_strdup(b_str_lstrip(tmp)); + tmp = sb_strndup(src + start, src_len - start); + stmt->value = sb_strdup(sb_str_lstrip(tmp)); free(tmp); tmp = NULL; lstrip_next = false; } else { - stmt->value = b_strndup(src + start, src_len - start); + stmt->value = sb_strndup(src + start, src_len - start); } stmt->op = 0; stmt->value2 = NULL; - stmts = b_slist_append(stmts, stmt); + stmts = sb_slist_append(stmts, stmt); previous = stmt; stmt = NULL; } @@ -131,21 +131,21 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) else state = TEMPLATE_VARIABLE_START; if (end > start) { - stmt = b_malloc(sizeof(blogc_template_stmt_t)); + stmt = sb_malloc(sizeof(blogc_template_stmt_t)); stmt->type = type; if (lstrip_next) { - tmp = b_strndup(src + start, end - start); - stmt->value = b_strdup(b_str_lstrip(tmp)); + tmp = sb_strndup(src + start, end - start); + stmt->value = sb_strdup(sb_str_lstrip(tmp)); free(tmp); tmp = NULL; lstrip_next = false; } else { - stmt->value = b_strndup(src + start, end - start); + stmt->value = sb_strndup(src + start, end - start); } stmt->op = 0; stmt->value2 = NULL; - stmts = b_slist_append(stmts, stmt); + stmts = sb_slist_append(stmts, stmt); previous = stmt; stmt = NULL; } @@ -159,7 +159,7 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) if ((previous != NULL) && (previous->type == BLOGC_TEMPLATE_CONTENT_STMT)) { - previous->value = b_str_rstrip(previous->value); // does not need copy + previous->value = sb_str_rstrip(previous->value); // does not need copy } state = TEMPLATE_BLOCK_START; break; @@ -559,19 +559,19 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) op_start = 0; op_end = 0; } - stmt = b_malloc(sizeof(blogc_template_stmt_t)); + stmt = sb_malloc(sizeof(blogc_template_stmt_t)); stmt->type = type; stmt->value = NULL; stmt->op = tmp_op; stmt->value2 = NULL; if (end > start) - stmt->value = b_strndup(src + start, end - start); + stmt->value = sb_strndup(src + start, end - start); if (end2 > start2) { - stmt->value2 = b_strndup(src + start2, end2 - start2); + stmt->value2 = sb_strndup(src + start2, end2 - start2); start2 = 0; end2 = 0; } - stmts = b_slist_append(stmts, stmt); + stmts = sb_slist_append(stmts, stmt); previous = stmt; stmt = NULL; state = TEMPLATE_START; @@ -622,9 +622,9 @@ blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err) void -blogc_template_free_stmts(b_slist_t *stmts) +blogc_template_free_stmts(sb_slist_t *stmts) { - for (b_slist_t *tmp = stmts; tmp != NULL; tmp = tmp->next) { + for (sb_slist_t *tmp = stmts; tmp != NULL; tmp = tmp->next) { blogc_template_stmt_t *data = tmp->data; if (data == NULL) continue; @@ -632,5 +632,5 @@ blogc_template_free_stmts(b_slist_t *stmts) free(data->value2); free(data); } - b_slist_free(stmts); + sb_slist_free(stmts); } diff --git a/src/template-parser.h b/src/template-parser.h index 6cd2c80..a8b4e8b 100644 --- a/src/template-parser.h +++ b/src/template-parser.h @@ -9,8 +9,8 @@ #ifndef _TEMPLATE_PARSER_H #define _TEMPLATE_PARSER_H -#include "utils/utils.h" #include "error.h" +#include "utils.h" /* * note: whitespace cleaners are NOT added to ast. we fix strings right during @@ -44,8 +44,8 @@ typedef struct { blogc_template_stmt_operator_t op; } blogc_template_stmt_t; -b_slist_t* blogc_template_parse(const char *src, size_t src_len, +sb_slist_t* blogc_template_parse(const char *src, size_t src_len, blogc_error_t **err); -void blogc_template_free_stmts(b_slist_t *stmts); +void blogc_template_free_stmts(sb_slist_t *stmts); #endif /* _TEMPLATE_GRAMMAR_H */ diff --git a/src/utils.c b/src/utils.c new file mode 100644 index 0000000..855b503 --- /dev/null +++ b/src/utils.c @@ -0,0 +1,612 @@ +/* + * blogc: A blog compiler. + * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> + * + * This program can be distributed under the terms of the BSD License. + * See the file LICENSE. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif /* HAVE_CONFIG_H */ + +#define SB_STRING_CHUNK_SIZE 128 + +#include <ctype.h> +#include <string.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <stdio.h> + +#include "utils.h" + + +void* +sb_malloc(size_t size) +{ + // simple things simple! + void *rv = malloc(size); + if (rv == NULL) { + fprintf(stderr, "fatal: Failed to allocate memory!\n"); + abort(); + } + return rv; +} + + +void* +sb_realloc(void *ptr, size_t size) +{ + // simple things even simpler :P + void *rv = realloc(ptr, size); + if (rv == NULL && size != 0) { + fprintf(stderr, "fatal: Failed to reallocate memory!\n"); + free(ptr); + abort(); + } + return rv; +} + + +sb_slist_t* +sb_slist_append(sb_slist_t *l, void *data) +{ + sb_slist_t *node = sb_malloc(sizeof(sb_slist_t)); + node->data = data; + node->next = NULL; + if (l == NULL) { + l = node; + } + else { + sb_slist_t *tmp; + for (tmp = l; tmp->next != NULL; tmp = tmp->next); + tmp->next = node; + } + return l; +} + + +sb_slist_t* +sb_slist_prepend(sb_slist_t *l, void *data) +{ + sb_slist_t *node = sb_malloc(sizeof(sb_slist_t)); + node->data = data; + node->next = l; + l = node; + return l; +} + + +void +sb_slist_free_full(sb_slist_t *l, sb_free_func_t free_func) +{ + while (l != NULL) { + sb_slist_t *tmp = l->next; + if ((free_func != NULL) && (l->data != NULL)) + free_func(l->data); + free(l); + l = tmp; + } +} + + +void +sb_slist_free(sb_slist_t *l) +{ + sb_slist_free_full(l, NULL); +} + + +size_t +sb_slist_length(sb_slist_t *l) +{ + if (l == NULL) + return 0; + size_t i; + sb_slist_t *tmp; + for (tmp = l, i = 0; tmp != NULL; tmp = tmp->next, i++); + return i; +} + + +char* +sb_strdup(const char *s) +{ + if (s == NULL) + return NULL; + size_t l = strlen(s); + char *tmp = malloc(l + 1); + if (tmp == NULL) + return NULL; + memcpy(tmp, s, l + 1); + return tmp; +} + + +char* +sb_strndup(const char *s, size_t n) +{ + if (s == NULL) + return NULL; + size_t l = strnlen(s, n); + char *tmp = malloc(l + 1); + if (tmp == NULL) + return NULL; + memcpy(tmp, s, l); + tmp[l] = '\0'; + return tmp; +} + + +char* +sb_strdup_vprintf(const char *format, va_list ap) +{ + va_list ap2; + va_copy(ap2, ap); + int l = vsnprintf(NULL, 0, format, ap2); + va_end(ap2); + if (l < 0) + return NULL; + char *tmp = malloc(l + 1); + if (!tmp) + return NULL; + int l2 = vsnprintf(tmp, l + 1, format, ap); + if (l2 < 0) { + free(tmp); + return NULL; + } + return tmp; +} + + +char* +sb_strdup_printf(const char *format, ...) +{ + va_list ap; + va_start(ap, format); + char *tmp = sb_strdup_vprintf(format, ap); + va_end(ap); + return tmp; +} + + +bool +sb_str_starts_with(const char *str, const char *prefix) +{ + int str_l = strlen(str); + int str_lp = strlen(prefix); + if (str_lp > str_l) + return false; + return strncmp(str, prefix, str_lp) == 0; +} + + +bool +sb_str_ends_with(const char *str, const char *suffix) +{ + int str_l = strlen(str); + int str_ls = strlen(suffix); + if (str_ls > str_l) + return false; + return strcmp(str + str_l - str_ls, suffix) == 0; +} + + +char* +sb_str_lstrip(char *str) +{ + if (str == NULL) + return NULL; + int i; + size_t str_len = strlen(str); + for (i = 0; i < str_len; i++) { + if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') && + (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') && + (str[i] != '\v')) + { + str += i; + break; + } + if (i == str_len - 1) { + str += str_len; + break; + } + } + return str; +} + + +char* +sb_str_rstrip(char *str) +{ + if (str == NULL) + return NULL; + int i; + size_t str_len = strlen(str); + for (i = str_len - 1; i >= 0; i--) { + if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') && + (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') && + (str[i] != '\v')) + { + str[i + 1] = '\0'; + break; + } + if (i == 0) { + str[0] = '\0'; + break; + } + } + return str; +} + + +char* +sb_str_strip(char *str) +{ + return sb_str_lstrip(sb_str_rstrip(str)); +} + + +char** +sb_str_split(const char *str, char c, unsigned int max_pieces) +{ + if (str == NULL) + return NULL; + char **rv = sb_malloc(sizeof(char*)); + unsigned int i, start = 0, count = 0; + for (i = 0; i < strlen(str) + 1; i++) { + if (str[0] == '\0') + break; + if ((str[i] == c && (!max_pieces || count + 1 < max_pieces)) || str[i] == '\0') { + rv = sb_realloc(rv, (count + 1) * sizeof(char*)); + rv[count] = sb_malloc(i - start + 1); + memcpy(rv[count], str + start, i - start); + rv[count++][i - start] = '\0'; + start = i + 1; + } + } + rv = sb_realloc(rv, (count + 1) * sizeof(char*)); + rv[count] = NULL; + return rv; +} + + +char* +sb_str_replace(const char *str, const char search, const char *replace) +{ + char **pieces = sb_str_split(str, search, 0); + if (pieces == NULL) + return NULL; + char* rv = sb_strv_join(pieces, replace); + sb_strv_free(pieces); + if (rv == NULL) + return sb_strdup(str); + return rv; +} + + +void +sb_strv_free(char **strv) +{ + if (strv == NULL) + return; + for (size_t i = 0; strv[i] != NULL; i++) + free(strv[i]); + free(strv); +} + + +char* +sb_strv_join(char **strv, const char *separator) +{ + if (strv == NULL || separator == NULL) + return NULL; + sb_string_t *str = sb_string_new(); + for (size_t i = 0; strv[i] != NULL; i++) { + str = sb_string_append(str, strv[i]); + if (strv[i + 1] != NULL) + str = sb_string_append(str, separator); + } + return sb_string_free(str, false); +} + + +size_t +sb_strv_length(char **strv) +{ + if (strv == NULL) + return 0; + size_t i; + for (i = 0; strv[i] != NULL; i++); + return i; +} + + +sb_string_t* +sb_string_new(void) +{ + sb_string_t* rv = sb_malloc(sizeof(sb_string_t)); + rv->str = NULL; + rv->len = 0; + rv->allocated_len = 0; + + // initialize with empty string + rv = sb_string_append(rv, ""); + + return rv; +} + + +char* +sb_string_free(sb_string_t *str, bool free_str) +{ + if (str == NULL) + return NULL; + char *rv = NULL; + if (free_str) + free(str->str); + else + rv = str->str; + free(str); + return rv; +} + + +sb_string_t* +sb_string_dup(sb_string_t *str) +{ + if (str == NULL) + return NULL; + sb_string_t* new = sb_string_new(); + return sb_string_append_len(new, str->str, str->len); +} + + +sb_string_t* +sb_string_append_len(sb_string_t *str, const char *suffix, size_t len) +{ + if (str == NULL) + return NULL; + if (suffix == NULL) + return str; + size_t old_len = str->len; + str->len += len; + if (str->len + 1 > str->allocated_len) { + str->allocated_len = (((str->len + 1) / SB_STRING_CHUNK_SIZE) + 1) * SB_STRING_CHUNK_SIZE; + str->str = sb_realloc(str->str, str->allocated_len); + } + memcpy(str->str + old_len, suffix, len); + str->str[str->len] = '\0'; + return str; +} + + +sb_string_t* +sb_string_append(sb_string_t *str, const char *suffix) +{ + if (str == NULL) + return NULL; + const char *my_suffix = suffix == NULL ? "" : suffix; + return sb_string_append_len(str, my_suffix, strlen(my_suffix)); +} + + +sb_string_t* +sb_string_append_c(sb_string_t *str, char c) +{ + if (str == NULL) + return NULL; + size_t old_len = str->len; + str->len += 1; + if (str->len + 1 > str->allocated_len) { + str->allocated_len = (((str->len + 1) / SB_STRING_CHUNK_SIZE) + 1) * SB_STRING_CHUNK_SIZE; + str->str = sb_realloc(str->str, str->allocated_len); + } + str->str[old_len] = c; + str->str[str->len] = '\0'; + return str; +} + + +sb_string_t* +sb_string_append_printf(sb_string_t *str, const char *format, ...) +{ + if (str == NULL) + return NULL; + va_list ap; + va_start(ap, format); + char *tmp = sb_strdup_vprintf(format, ap); + va_end(ap); + str = sb_string_append(str, tmp); + free(tmp); + return str; +} + + +sb_trie_t* +sb_trie_new(sb_free_func_t free_func) +{ + sb_trie_t *trie = sb_malloc(sizeof(sb_trie_t)); + trie->root = NULL; + trie->free_func = free_func; + return trie; +} + + +static void +sb_trie_free_node(sb_trie_t *trie, sb_trie_node_t *node) +{ + if (trie == NULL || node == NULL) + return; + if (node->data != NULL && trie->free_func != NULL) + trie->free_func(node->data); + sb_trie_free_node(trie, node->next); + sb_trie_free_node(trie, node->child); + free(node); +} + + +void +sb_trie_free(sb_trie_t *trie) +{ + if (trie == NULL) + return; + sb_trie_free_node(trie, trie->root); + free(trie); +} + + +void +sb_trie_insert(sb_trie_t *trie, const char *key, void *data) +{ + if (trie == NULL || key == NULL || data == NULL) + return; + + sb_trie_node_t *parent = NULL; + sb_trie_node_t *previous; + sb_trie_node_t *current; + sb_trie_node_t *tmp; + + while (1) { + + if (trie->root == NULL || (parent != NULL && parent->child == NULL)) { + current = sb_malloc(sizeof(sb_trie_node_t)); + current->key = *key; + current->data = NULL; + current->next = NULL; + current->child = NULL; + if (trie->root == NULL) + trie->root = current; + else + parent->child = current; + parent = current; + goto clean; + } + + tmp = parent == NULL ? trie->root : parent->child; + previous = NULL; + + while (tmp != NULL && tmp->key != *key) { + previous = tmp; + tmp = tmp->next; + } + + parent = tmp; + + if (previous == NULL || parent != NULL) + goto clean; + + current = sb_malloc(sizeof(sb_trie_node_t)); + current->key = *key; + current->data = NULL; + current->next = NULL; + current->child = NULL; + previous->next = current; + parent = current; + +clean: + if (*key == '\0') { + if (parent->data != NULL && trie->free_func != NULL) + trie->free_func(parent->data); + parent->data = data; + break; + } + key++; + } +} + + +void* +sb_trie_lookup(sb_trie_t *trie, const char *key) +{ + if (trie == NULL || trie->root == NULL || key == NULL) + return NULL; + + sb_trie_node_t *parent = trie->root; + sb_trie_node_t *tmp; + while (1) { + for (tmp = parent; tmp != NULL; tmp = tmp->next) { + + if (tmp->key == *key) { + if (tmp->key == '\0') + return tmp->data; + parent = tmp->child; + break; + } + } + if (tmp == NULL) + return NULL; + + if (*key == '\0') + break; + key++; + } + return NULL; +} + + +static void +sb_trie_size_node(sb_trie_node_t *node, size_t *count) +{ + if (node == NULL || count == NULL) + return; + + if (node->key == '\0') + (*count)++; + + sb_trie_size_node(node->next, count); + sb_trie_size_node(node->child, count); +} + + +size_t +sb_trie_size(sb_trie_t *trie) +{ + if (trie == NULL) + return 0; + + size_t count = 0; + sb_trie_size_node(trie->root, &count); + return count; +} + + +static void +sb_trie_foreach_node(sb_trie_node_t *node, sb_string_t *str, + sb_trie_foreach_func_t func, void *user_data) +{ + if (node == NULL || str == NULL || func == NULL) + return; + + if (node->key == '\0') { + char *tmp = sb_string_free(str, false); + func(tmp, node->data, user_data); + free(tmp); + } + + if (node->child != NULL) { + sb_string_t *child = sb_string_dup(str); + child = sb_string_append_c(child, node->key); + sb_trie_foreach_node(node->child, child, func, user_data); + } + + if (node->next != NULL) + sb_trie_foreach_node(node->next, str, func, user_data); + + if (node->child != NULL && node->next == NULL) + sb_string_free(str, true); +} + + +void +sb_trie_foreach(sb_trie_t *trie, sb_trie_foreach_func_t func, + void *user_data) +{ + if (trie == NULL || trie->root == NULL || func == NULL) + return; + + sb_string_t *str = sb_string_new(); + sb_trie_foreach_node(trie->root, str, func, user_data); +} diff --git a/src/utils.h b/src/utils.h new file mode 100644 index 0000000..411295a --- /dev/null +++ b/src/utils.h @@ -0,0 +1,102 @@ +/* + * blogc: A blog compiler. + * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> + * + * This program can be distributed under the terms of the BSD License. + * See the file LICENSE. + */ + +#ifndef _UTILS_H +#define _UTILS_H + +#include <stddef.h> +#include <stdarg.h> +#include <stdbool.h> +#include <stdarg.h> +#include <stdlib.h> + + +// memory + +typedef void (*sb_free_func_t) (void *ptr); + +void* sb_malloc(size_t size); +void* sb_realloc(void *ptr, size_t size); + + +// slist + +typedef struct _sb_slist_t { + struct _sb_slist_t *next; + void *data; +} sb_slist_t; + +sb_slist_t* sb_slist_append(sb_slist_t *l, void *data); +sb_slist_t* sb_slist_prepend(sb_slist_t *l, void *data); +void sb_slist_free(sb_slist_t *l); +void sb_slist_free_full(sb_slist_t *l, sb_free_func_t free_func); +size_t sb_slist_length(sb_slist_t *l); + + +// strfuncs + +char* sb_strdup(const char *s); +char* sb_strndup(const char *s, size_t n); +char* sb_strdup_vprintf(const char *format, va_list ap); +char* sb_strdup_printf(const char *format, ...); +bool sb_str_starts_with(const char *str, const char *prefix); +bool sb_str_ends_with(const char *str, const char *suffix); +char* sb_str_lstrip(char *str); +char* sb_str_rstrip(char *str); +char* sb_str_strip(char *str); +char** sb_str_split(const char *str, char c, unsigned int max_pieces); +char* sb_str_replace(const char *str, const char search, const char *replace); +void sb_strv_free(char **strv); +char* sb_strv_join(char **strv, const char *separator); +size_t sb_strv_length(char **strv); + + +// string + +typedef struct { + char *str; + size_t len; + size_t allocated_len; +} sb_string_t; + +sb_string_t* sb_string_new(void); +char* sb_string_free(sb_string_t *str, bool free_str); +sb_string_t* sb_string_dup(sb_string_t *str); +sb_string_t* sb_string_append_len(sb_string_t *str, const char *suffix, size_t len); +sb_string_t* sb_string_append(sb_string_t *str, const char *suffix); +sb_string_t* sb_string_append_c(sb_string_t *str, char c); +sb_string_t* sb_string_append_printf(sb_string_t *str, const char *format, ...); + + +// trie + +typedef struct _sb_trie_node_t { + char key; + void *data; + struct _sb_trie_node_t *next, *child; +} sb_trie_node_t; + +struct _sb_trie_t { + sb_trie_node_t *root; + sb_free_func_t free_func; +}; + +typedef struct _sb_trie_t sb_trie_t; + +typedef void (*sb_trie_foreach_func_t)(const char *key, void *data, + void *user_data); + +sb_trie_t* sb_trie_new(sb_free_func_t free_func); +void sb_trie_free(sb_trie_t *trie); +void sb_trie_insert(sb_trie_t *trie, const char *key, void *data); +void* sb_trie_lookup(sb_trie_t *trie, const char *key); +size_t sb_trie_size(sb_trie_t *trie); +void sb_trie_foreach(sb_trie_t *trie, sb_trie_foreach_func_t func, + void *user_data); + +#endif /* _UTILS_H */ diff --git a/src/utils/mem.c b/src/utils/mem.c deleted file mode 100644 index 693d555..0000000 --- a/src/utils/mem.c +++ /dev/null @@ -1,42 +0,0 @@ -/* - * blogc: A blog compiler. - * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> - * - * This program can be distributed under the terms of the BSD License. - * See the file LICENSE. - */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif /* HAVE_CONFIG_H */ - -#include <stdlib.h> -#include <stdio.h> -#include "utils.h" - - -void* -b_malloc(size_t size) -{ - // simple things simple! - void *rv = malloc(size); - if (rv == NULL) { - fprintf(stderr, "fatal error: Failed to allocate memory!\n"); - exit(1); - } - return rv; -} - - -void* -b_realloc(void *ptr, size_t size) -{ - // simple things even simpler :P - void *rv = realloc(ptr, size); - if (rv == NULL && size != 0) { - fprintf(stderr, "fatal error: Failed to reallocate memory!\n"); - free(ptr); - exit(1); - } - return rv; -} diff --git a/src/utils/slist.c b/src/utils/slist.c deleted file mode 100644 index 9753aa7..0000000 --- a/src/utils/slist.c +++ /dev/null @@ -1,68 +0,0 @@ -/* - * blogc: A blog compiler. - * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> - * - * This program can be distributed under the terms of the BSD License. - * See the file LICENSE. - */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif /* HAVE_CONFIG_H */ - -#include <stdlib.h> -#include "utils.h" - - -b_slist_t* -b_slist_append(b_slist_t *l, void *data) -{ - b_slist_t *node = malloc(sizeof(b_slist_t)); - if (node == NULL) { - l = NULL; - return l; - } - node->data = data; - node->next = NULL; - if (l == NULL) - l = node; - else { - b_slist_t *tmp; - for (tmp = l; tmp->next != NULL; tmp = tmp->next); - tmp->next = node; - } - return l; -} - - -void -b_slist_free_full(b_slist_t *l, b_free_func_t free_func) -{ - while (l != NULL) { - b_slist_t *tmp = l->next; - free_func(l->data); - free(l); - l = tmp; - } -} - - -void -b_slist_free(b_slist_t *l) -{ - while (l != NULL) { - b_slist_t *tmp = l->next; - free(l); - l = tmp; - } -} - - -unsigned int -b_slist_length(b_slist_t *l) -{ - unsigned int i; - b_slist_t *tmp; - for (tmp = l, i = 0; tmp != NULL; tmp = tmp->next, i++); - return i; -} diff --git a/src/utils/strings.c b/src/utils/strings.c deleted file mode 100644 index 3151612..0000000 --- a/src/utils/strings.c +++ /dev/null @@ -1,314 +0,0 @@ -/* - * blogc: A blog compiler. - * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> - * - * This program can be distributed under the terms of the BSD License. - * See the file LICENSE. - */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif /* HAVE_CONFIG_H */ - -#include <ctype.h> -#include <string.h> -#include <stdarg.h> -#include <stdbool.h> -#include <stdio.h> -#include <stdlib.h> -#include "utils.h" - - -char* -b_strdup(const char *s) -{ - if (s == NULL) - return NULL; - size_t l = strlen(s); - char *tmp = malloc(l + 1); - if (tmp == NULL) - return NULL; - memcpy(tmp, s, l + 1); - return tmp; -} - - -char* -b_strndup(const char *s, size_t n) -{ - if (s == NULL) - return NULL; - size_t l = strnlen(s, n); - char *tmp = malloc(l + 1); - if (tmp == NULL) - return NULL; - memcpy(tmp, s, l); - tmp[l] = '\0'; - return tmp; -} - - -char* -b_strdup_vprintf(const char *format, va_list ap) -{ - va_list ap2; - va_copy(ap2, ap); - int l = vsnprintf(NULL, 0, format, ap2); - va_end(ap2); - if (l < 0) - return NULL; - char *tmp = malloc(l + 1); - if (!tmp) - return NULL; - int l2 = vsnprintf(tmp, l + 1, format, ap); - if (l2 < 0) { - free(tmp); - return NULL; - } - return tmp; -} - - -char* -b_strdup_printf(const char *format, ...) -{ - va_list ap; - va_start(ap, format); - char *tmp = b_strdup_vprintf(format, ap); - va_end(ap); - return tmp; -} - - -bool -b_str_starts_with(const char *str, const char *prefix) -{ - int str_l = strlen(str); - int str_lp = strlen(prefix); - if (str_lp > str_l) - return false; - return strncmp(str, prefix, str_lp) == 0; -} - - -bool -b_str_ends_with(const char *str, const char *suffix) -{ - int str_l = strlen(str); - int str_ls = strlen(suffix); - if (str_ls > str_l) - return false; - return strcmp(str + str_l - str_ls, suffix) == 0; -} - - -char* -b_str_lstrip(char *str) -{ - if (str == NULL) - return NULL; - int i; - size_t str_len = strlen(str); - for (i = 0; i < str_len; i++) { - if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') && - (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') && - (str[i] != '\v')) - { - str += i; - break; - } - if (i == str_len - 1) { - str += str_len; - break; - } - } - return str; -} - - -char* -b_str_rstrip(char *str) -{ - if (str == NULL) - return NULL; - int i; - size_t str_len = strlen(str); - for (i = str_len - 1; i >= 0; i--) { - if ((str[i] != ' ') && (str[i] != '\t') && (str[i] != '\n') && - (str[i] != '\r') && (str[i] != '\t') && (str[i] != '\f') && - (str[i] != '\v')) - { - str[i + 1] = '\0'; - break; - } - if (i == 0) { - str[0] = '\0'; - break; - } - } - return str; -} - - -char* -b_str_strip(char *str) -{ - return b_str_lstrip(b_str_rstrip(str)); -} - - -char** -b_str_split(const char *str, char c, unsigned int max_pieces) -{ - if (!str) - return NULL; - char **rv = b_malloc(sizeof(char*)); - unsigned int i, start = 0, count = 0; - for (i = 0; i < strlen(str) + 1; i++) { - if (str[0] == '\0') - break; - if ((str[i] == c && (!max_pieces || count + 1 < max_pieces)) || str[i] == '\0') { - rv = b_realloc(rv, (count + 1) * sizeof(char*)); - rv[count] = b_malloc(i - start + 1); - memcpy(rv[count], str + start, i - start); - rv[count++][i - start] = '\0'; - start = i + 1; - } - } - rv = b_realloc(rv, (count + 1) * sizeof(char*)); - rv[count] = NULL; - return rv; -} - - -char* -b_str_replace(const char *str, const char search, const char *replace) -{ - char **pieces = b_str_split(str, search, 0); - if (pieces == NULL) - return NULL; - char* rv = b_strv_join((const char**) pieces, replace); - b_strv_free(pieces); - return rv; -} - - -void -b_strv_free(char **strv) -{ - if (strv == NULL) - return; - unsigned int i; - for (i = 0; strv[i] != NULL; i++) - free(strv[i]); - free(strv); -} - - -char* -b_strv_join(const char **strv, const char *separator) -{ - if (strv == NULL) - return NULL; - unsigned int i = 0; - b_string_t *str = b_string_new(); - for (i = 0; strv[i] != NULL; i++) { - str = b_string_append(str, strv[i]); - if (strv[i+1] != NULL) - str = b_string_append(str, separator); - } - return b_string_free(str, false); -} - - -unsigned int -b_strv_length(char **strv) -{ - if (!strv) - return 0; - unsigned int i; - for (i = 0; strv[i] != NULL; i++); - return i; -} - - -b_string_t* -b_string_new(void) -{ - b_string_t* rv = b_malloc(sizeof(b_string_t)); - rv->str = NULL; - rv->len = 0; - rv->allocated_len = 0; - - // initialize with empty string - rv = b_string_append(rv, ""); - - return rv; -} - - -char* -b_string_free(b_string_t *str, bool free_str) -{ - char *rv = NULL; - if (free_str) - free(str->str); - else - rv = str->str; - free(str); - return rv; -} - - -b_string_t* -b_string_append_len(b_string_t *str, const char *suffix, size_t len) -{ - if (suffix == NULL) - return str; - size_t old_len = str->len; - str->len += len; - if (str->len + 1 > str->allocated_len) { - str->allocated_len = (((str->len + 1) / B_STRING_CHUNK_SIZE) + 1) * B_STRING_CHUNK_SIZE; - str->str = b_realloc(str->str, str->allocated_len); - } - memcpy(str->str + old_len, suffix, len); - str->str[str->len] = '\0'; - return str; -} - - -b_string_t* -b_string_append(b_string_t *str, const char *suffix) -{ - if (suffix == NULL) - return str; - return b_string_append_len(str, suffix, strlen(suffix)); -} - - -b_string_t* -b_string_append_c(b_string_t *str, char c) -{ - size_t old_len = str->len; - str->len += 1; - if (str->len + 1 > str->allocated_len) { - str->allocated_len = (((str->len + 1) / B_STRING_CHUNK_SIZE) + 1) * B_STRING_CHUNK_SIZE; - str->str = b_realloc(str->str, str->allocated_len); - } - str->str[old_len] = c; - str->str[str->len] = '\0'; - return str; -} - - -b_string_t* -b_string_append_printf(b_string_t *str, const char *format, ...) -{ - va_list ap; - va_start(ap, format); - char *tmp = b_strdup_vprintf(format, ap); - va_end(ap); - str = b_string_append(str, tmp); - free(tmp); - return str; -} diff --git a/src/utils/trie.c b/src/utils/trie.c deleted file mode 100644 index 2e6a0d8..0000000 --- a/src/utils/trie.c +++ /dev/null @@ -1,199 +0,0 @@ -/* - * blogc: A blog compiler. - * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> - * - * This program can be distributed under the terms of the BSD License. - * See the file LICENSE. - */ - -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif /* HAVE_CONFIG_H */ - -#include <stdlib.h> -#include "utils.h" - - -b_trie_t* -b_trie_new(b_free_func_t free_func) -{ - b_trie_t *trie = b_malloc(sizeof(b_trie_t)); - trie->root = NULL; - trie->free_func = free_func; - return trie; -} - - -static void -b_trie_free_node(b_trie_t *trie, b_trie_node_t *node) -{ - if (node == NULL) - return; - if (node->data != NULL && trie->free_func != NULL) - trie->free_func(node->data); - b_trie_free_node(trie, node->next); - b_trie_free_node(trie, node->child); - free(node); -} - - -void -b_trie_free(b_trie_t *trie) -{ - if (trie == NULL) - return; - b_trie_free_node(trie, trie->root); - free(trie); -} - - -void -b_trie_insert(b_trie_t *trie, const char *key, void *data) -{ - if (data == NULL || key == NULL) - return; - - b_trie_node_t *parent = NULL; - b_trie_node_t *previous; - b_trie_node_t *current; - b_trie_node_t *tmp; - - while (1) { - - if (trie->root == NULL || (parent != NULL && parent->child == NULL)) { - current = b_malloc(sizeof(b_trie_node_t)); - current->key = *key; - current->data = NULL; - current->next = NULL; - current->child = NULL; - if (trie->root == NULL) - trie->root = current; - else - parent->child = current; - parent = current; - goto clean; - } - - tmp = parent == NULL ? trie->root : parent->child; - previous = NULL; - - while (tmp != NULL && tmp->key != *key) { - previous = tmp; - tmp = tmp->next; - } - - parent = tmp; - - if (previous == NULL || parent != NULL) - goto clean; - - current = b_malloc(sizeof(b_trie_node_t)); - current->key = *key; - current->data = NULL; - current->next = NULL; - current->child = NULL; - previous->next = current; - parent = current; - -clean: - if (*key == '\0') { - if (parent->data != NULL && trie->free_func != NULL) - trie->free_func(parent->data); - parent->data = data; - break; - } - key++; - } -} - - -void* -b_trie_lookup(b_trie_t *trie, const char *key) -{ - if (trie == NULL || trie->root == NULL || key == NULL) - return NULL; - - b_trie_node_t *parent = trie->root; - b_trie_node_t *tmp; - while (1) { - for (tmp = parent; tmp != NULL; tmp = tmp->next) { - - if (tmp->key == *key) { - if (tmp->key == '\0') - return tmp->data; - parent = tmp->child; - break; - } - } - if (tmp == NULL) - return NULL; - - if (*key == '\0') - break; - key++; - } - return NULL; -} - - -static void -b_trie_size_node(b_trie_node_t *node, unsigned int *count) -{ - if (node == NULL) - return; - - if (node->key == '\0') - (*count)++; - - b_trie_size_node(node->next, count); - b_trie_size_node(node->child, count); -} - - -unsigned int -b_trie_size(b_trie_t *trie) -{ - if (trie == NULL) - return 0; - - unsigned int count = 0; - b_trie_size_node(trie->root, &count); - return count; -} - - -static void -b_trie_foreach_node(b_trie_node_t *node, b_string_t *str, void (*func)(const char *key, void *data)) -{ - if (node == NULL) - return; - - if (node->key == '\0') { - func(str->str, node->data); - b_string_free(str, true); - } - - if (node->child != NULL) { - b_string_t *child = b_string_new(); - child = b_string_append(child, str->str); - child = b_string_append_c(child, node->key); - b_trie_foreach_node(node->child, child, func); - } - - if (node->next != NULL) - b_trie_foreach_node(node->next, str, func); - - if (node->child != NULL && node->next == NULL) - b_string_free(str, true); -} - - -void -b_trie_foreach(b_trie_t *trie, void (*func)(const char *key, void *data)) -{ - if (trie->root == NULL) - return; - - b_string_t *str = b_string_new(); - b_trie_foreach_node(trie->root, str, func); -} diff --git a/src/utils/utils.h b/src/utils/utils.h deleted file mode 100644 index dc67497..0000000 --- a/src/utils/utils.h +++ /dev/null @@ -1,79 +0,0 @@ -/* - * blogc: A blog compiler. - * Copyright (C) 2014-2016 Rafael G. Martins <rafael@rafaelmartins.eng.br> - * - * This program can be distributed under the terms of the BSD License. - * See the file LICENSE. - */ - -#ifndef _UTILS_UTILS_H -#define _UTILS_UTILS_H - -#include <stdbool.h> -#include <stdlib.h> -#include <stdarg.h> - -#define B_STRING_CHUNK_SIZE 128 - -typedef void (*b_free_func_t) (void *ptr); - -typedef struct _b_slist_t { - struct _b_slist_t *next; - void *data; -} b_slist_t; - -typedef struct _b_string_t { - char *str; - size_t len; - size_t allocated_len; -} b_string_t; - -typedef struct _b_trie_node_t { - char key; - void *data; - struct _b_trie_node_t *next, *child; -} b_trie_node_t; - -typedef struct _b_trie_t { - b_trie_node_t *root; - b_free_func_t free_func; -} b_trie_t; - -b_slist_t* b_slist_append(b_slist_t *l, void *data); -void b_slist_free_full(b_slist_t *l, b_free_func_t free_func); -void b_slist_free(b_slist_t *l); -unsigned int b_slist_length(b_slist_t *l); - -char* b_strdup(const char *s); -char* b_strndup(const char *s, size_t n); -char* b_strdup_vprintf(const char *format, va_list ap); -char* b_strdup_printf(const char *format, ...); -bool b_str_starts_with(const char *str, const char *prefix); -bool b_str_ends_with(const char *str, const char *suffix); -char* b_str_lstrip(char *str); -char* b_str_rstrip(char *str); -char* b_str_strip(char *str); -char** b_str_split(const char *str, char c, unsigned int max_pieces); -char* b_str_replace(const char *str, const char search, const char *replace); -void b_strv_free(char **strv); -char* b_strv_join(const char **strv, const char *separator); -unsigned int b_strv_length(char **strv); - -b_string_t* b_string_new(void); -char* b_string_free(b_string_t *str, bool free_str); -b_string_t* b_string_append_len(b_string_t *str, const char *suffix, size_t len); -b_string_t* b_string_append(b_string_t *str, const char *suffix); -b_string_t* b_string_append_c(b_string_t *str, char c); -b_string_t* b_string_append_printf(b_string_t *str, const char *format, ...); - -b_trie_t* b_trie_new(b_free_func_t free_func); -void b_trie_free(b_trie_t *trie); -void b_trie_insert(b_trie_t *trie, const char *key, void *data); -void* b_trie_lookup(b_trie_t *trie, const char *key); -unsigned int b_trie_size(b_trie_t *trie); -void b_trie_foreach(b_trie_t *trie, void (*func)(const char *key, void *data)); - -void* b_malloc(size_t size); -void* b_realloc(void *ptr, size_t size); - -#endif /* _UTILS_UTILS_H */ diff --git a/tests/check_content_parser.c b/tests/check_content_parser.c index 165810d..4f201d1 100644 --- a/tests/check_content_parser.c +++ b/tests/check_content_parser.c @@ -17,7 +17,7 @@ #include <string.h> #include "../src/content-parser.h" #include "../src/directives.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" static void @@ -82,6 +82,7 @@ static void test_content_parse(void **state) { size_t l = 0; + char *d = NULL; char *html = blogc_content_parse( "# um\n" "## dois\n" @@ -107,8 +108,8 @@ test_content_parse(void **state) "1. chunda\n" "3. fuuuu\n" "\n" - "+ chunda2\n" - "+ fuuuu2\n" + "- chunda2\n" + "- fuuuu2\n" "\n" "<style>\n" " chunda\n" @@ -117,9 +118,17 @@ test_content_parse(void **state) "guda\n" "yay\n" "\n" - "**bola**\n", &l); + "**bola**\n" + "-- foo-bar\n" + "--- bar\n" + "\n" + "-- asd\n" + "\n" + "--- lol\n", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "bola"); assert_string_equal(html, "<h1 id=\"um\">um</h1>\n" "<h2 id=\"dois\">dois</h2>\n" @@ -151,8 +160,13 @@ test_content_parse(void **state) "</style>\n" "<p>guda\n" "yay</p>\n" - "<p><strong>bola</strong></p>\n"); + "<p><strong>bola</strong>\n" + "– foo-bar\n" + "— bar</p>\n" + "<p>– asd</p>\n" + "<p>— lol</p>\n"); free(html); + free(d); } @@ -160,6 +174,7 @@ static void test_content_parse_crlf(void **state) { size_t l = 0; + char *d = NULL; char *html = blogc_content_parse( "# um\r\n" "## dois\r\n" @@ -195,9 +210,17 @@ test_content_parse_crlf(void **state) "guda\r\n" "yay\r\n" "\r\n" - "**bola**\r\n", &l); + "**bola**\r\n" + "-- foo-bar\r\n" + "--- bar\r\n" + "\r\n" + "-- asd\r\n" + "\r\n" + "--- lol\r\n", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "bola"); assert_string_equal(html, "<h1 id=\"um\">um</h1>\r\n" "<h2 id=\"dois\">dois</h2>\r\n" @@ -229,8 +252,13 @@ test_content_parse_crlf(void **state) "</style>\r\n" "<p>guda\r\n" "yay</p>\r\n" - "<p><strong>bola</strong></p>\r\n"); + "<p><strong>bola</strong>\r\n" + "– foo-bar\r\n" + "— bar</p>\r\n" + "<p>– asd</p>\r\n" + "<p>— lol</p>\r\n"); free(html); + free(d); } @@ -238,6 +266,7 @@ static void test_content_parse_with_excerpt(void **state) { size_t l = 0; + char *d = NULL; char *html = blogc_content_parse( "# test\n" "\n" @@ -246,9 +275,11 @@ test_content_parse_with_excerpt(void **state) "..\n" "\n" "guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 38); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda</p>\n" @@ -256,6 +287,8 @@ test_content_parse_with_excerpt(void **state) "lol</p>\n"); free(html); l = 0; + free(d); + d = NULL; html = blogc_content_parse( "# test\n" "\n" @@ -264,15 +297,18 @@ test_content_parse_with_excerpt(void **state) "...\n" "\n" "guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 38); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda</p>\n" "<p>guda\n" "lol</p>\n"); free(html); + free(d); } @@ -280,6 +316,7 @@ static void test_content_parse_with_excerpt_crlf(void **state) { size_t l = 0; + char *d = NULL; char *html = blogc_content_parse( "# test\r\n" "\r\n" @@ -288,9 +325,11 @@ test_content_parse_with_excerpt_crlf(void **state) "..\r\n" "\r\n" "guda\r\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 40); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\r\n" "<p>chunda</p>\r\n" @@ -298,6 +337,8 @@ test_content_parse_with_excerpt_crlf(void **state) "lol</p>\r\n"); free(html); l = 0; + free(d); + d = NULL; html = blogc_content_parse( "# test\r\n" "\r\n" @@ -306,26 +347,29 @@ test_content_parse_with_excerpt_crlf(void **state) "...\r\n" "\r\n" "guda\r\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 40); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\r\n" "<p>chunda</p>\r\n" "<p>guda\r\n" "lol</p>\r\n"); free(html); + free(d); } static void test_content_parse_header(void **state) { - char *html = blogc_content_parse("## bola", NULL); + char *html = blogc_content_parse("## bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\n"); free(html); - html = blogc_content_parse("## bola\n", NULL); + html = blogc_content_parse("## bola\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\n"); free(html); @@ -334,7 +378,7 @@ test_content_parse_header(void **state) "\n" "## bola\n" "\n" - "guda\n", NULL); + "guda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -347,11 +391,11 @@ test_content_parse_header(void **state) static void test_content_parse_header_crlf(void **state) { - char *html = blogc_content_parse("## bola", NULL); + char *html = blogc_content_parse("## bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\n"); free(html); - html = blogc_content_parse("## bola\r\n", NULL); + html = blogc_content_parse("## bola\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h2 id=\"bola\">bola</h2>\r\n"); free(html); @@ -360,7 +404,7 @@ test_content_parse_header_crlf(void **state) "\r\n" "## bola\r\n" "\r\n" - "guda\r\n", NULL); + "guda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -373,11 +417,11 @@ test_content_parse_header_crlf(void **state) static void test_content_parse_html(void **state) { - char *html = blogc_content_parse("<div>\n</div>", NULL); + char *html = blogc_content_parse("<div>\n</div>", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<div>\n</div>\n"); free(html); - html = blogc_content_parse("<div>\n</div>\n", NULL); + html = blogc_content_parse("<div>\n</div>\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<div>\n</div>\n"); free(html); @@ -387,7 +431,7 @@ test_content_parse_html(void **state) "<div>\n" "</div>\n" "\n" - "chunda\n", NULL); + "chunda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -400,11 +444,11 @@ test_content_parse_html(void **state) static void test_content_parse_html_crlf(void **state) { - char *html = blogc_content_parse("<div>\r\n</div>", NULL); + char *html = blogc_content_parse("<div>\r\n</div>", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<div>\r\n</div>\r\n"); free(html); - html = blogc_content_parse("<div>\r\n</div>\r\n", NULL); + html = blogc_content_parse("<div>\r\n</div>\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<div>\r\n</div>\r\n"); free(html); @@ -414,7 +458,7 @@ test_content_parse_html_crlf(void **state) "<div>\r\n" "</div>\r\n" "\r\n" - "chunda\r\n", NULL); + "chunda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -427,14 +471,14 @@ test_content_parse_html_crlf(void **state) static void test_content_parse_blockquote(void **state) { - char *html = blogc_content_parse("> bola\n> guda", NULL); + char *html = blogc_content_parse("> bola\n> guda", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<blockquote><p>bola\n" "guda</p>\n" "</blockquote>\n"); free(html); - html = blogc_content_parse("> bola\n> guda\n", NULL); + html = blogc_content_parse("> bola\n> guda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<blockquote><p>bola\n" @@ -445,9 +489,22 @@ test_content_parse_blockquote(void **state) "bola\n" "\n" "> bola\n" + "\n" + "chunda\n", NULL, NULL); + assert_non_null(html); + assert_string_equal(html, + "<p>bola</p>\n" + "<blockquote><p>bola</p>\n" + "</blockquote>\n" + "<p>chunda</p>\n"); + free(html); + html = blogc_content_parse( + "bola\n" + "\n" + "> bola\n" "> guda\n" "\n" - "chunda\n", NULL); + "chunda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -462,14 +519,14 @@ test_content_parse_blockquote(void **state) static void test_content_parse_blockquote_crlf(void **state) { - char *html = blogc_content_parse("> bola\r\n> guda", NULL); + char *html = blogc_content_parse("> bola\r\n> guda", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<blockquote><p>bola\r\n" "guda</p>\r\n" "</blockquote>\r\n"); free(html); - html = blogc_content_parse("> bola\r\n> guda\r\n", NULL); + html = blogc_content_parse("> bola\r\n> guda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<blockquote><p>bola\r\n" @@ -480,9 +537,22 @@ test_content_parse_blockquote_crlf(void **state) "bola\r\n" "\r\n" "> bola\r\n" + "\r\n" + "chunda\r\n", NULL, NULL); + assert_non_null(html); + assert_string_equal(html, + "<p>bola</p>\r\n" + "<blockquote><p>bola</p>\r\n" + "</blockquote>\r\n" + "<p>chunda</p>\r\n"); + free(html); + html = blogc_content_parse( + "bola\r\n" + "\r\n" + "> bola\r\n" "> guda\r\n" "\r\n" - "chunda\r\n", NULL); + "chunda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -497,13 +567,13 @@ test_content_parse_blockquote_crlf(void **state) static void test_content_parse_code(void **state) { - char *html = blogc_content_parse(" bola\n guda", NULL); + char *html = blogc_content_parse(" bola\n guda", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<pre><code>bola\n" "guda</code></pre>\n"); free(html); - html = blogc_content_parse(" bola\n guda\n", NULL); + html = blogc_content_parse(" bola\n guda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<pre><code>bola\n" @@ -515,7 +585,7 @@ test_content_parse_code(void **state) " bola\n" " guda\n" "\n" - "chunda\n", NULL); + "chunda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -529,13 +599,13 @@ test_content_parse_code(void **state) static void test_content_parse_code_crlf(void **state) { - char *html = blogc_content_parse(" bola\r\n guda", NULL); + char *html = blogc_content_parse(" bola\r\n guda", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<pre><code>bola\r\n" "guda</code></pre>\r\n"); free(html); - html = blogc_content_parse(" bola\r\n guda\r\n", NULL); + html = blogc_content_parse(" bola\r\n guda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<pre><code>bola\r\n" @@ -547,7 +617,7 @@ test_content_parse_code_crlf(void **state) " bola\r\n" " guda\r\n" "\r\n" - "chunda\r\n", NULL); + "chunda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -561,28 +631,28 @@ test_content_parse_code_crlf(void **state) static void test_content_parse_horizontal_rule(void **state) { - char *html = blogc_content_parse("bola\nguda\n\n**", NULL); + char *html = blogc_content_parse("bola\nguda\n\n**", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\n" "guda</p>\n" "<hr />\n"); free(html); - html = blogc_content_parse("bola\nguda\n\n++++", NULL); + html = blogc_content_parse("bola\nguda\n\n++++", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\n" "guda</p>\n" "<hr />\n"); free(html); - html = blogc_content_parse("bola\nguda\n\n--\n", NULL); + html = blogc_content_parse("bola\nguda\n\n--\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\n" "guda</p>\n" "<hr />\n"); free(html); - html = blogc_content_parse("bola\nguda\n\n****\n", NULL); + html = blogc_content_parse("bola\nguda\n\n****\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\n" @@ -594,7 +664,7 @@ test_content_parse_horizontal_rule(void **state) "\n" "**\n" "\n" - "chunda\n", NULL); + "chunda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -606,7 +676,7 @@ test_content_parse_horizontal_rule(void **state) "\n" "----\n" "\n" - "chunda\n", NULL); + "chunda\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\n" @@ -619,28 +689,28 @@ test_content_parse_horizontal_rule(void **state) static void test_content_parse_horizontal_rule_crlf(void **state) { - char *html = blogc_content_parse("bola\r\nguda\r\n\r\n**", NULL); + char *html = blogc_content_parse("bola\r\nguda\r\n\r\n**", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\r\n" "guda</p>\r\n" "<hr />\r\n"); free(html); - html = blogc_content_parse("bola\r\nguda\r\n\r\n++++", NULL); + html = blogc_content_parse("bola\r\nguda\r\n\r\n++++", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\r\n" "guda</p>\r\n" "<hr />\r\n"); free(html); - html = blogc_content_parse("bola\r\nguda\r\n\r\n--\r\n", NULL); + html = blogc_content_parse("bola\r\nguda\r\n\r\n--\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\r\n" "guda</p>\r\n" "<hr />\r\n"); free(html); - html = blogc_content_parse("bola\r\nguda\r\n\r\n****\r\n", NULL); + html = blogc_content_parse("bola\r\nguda\r\n\r\n****\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola\r\n" @@ -652,7 +722,7 @@ test_content_parse_horizontal_rule_crlf(void **state) "\r\n" "**\r\n" "\r\n" - "chunda\r\n", NULL); + "chunda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -664,7 +734,7 @@ test_content_parse_horizontal_rule_crlf(void **state) "\r\n" "----\r\n" "\r\n" - "chunda\r\n", NULL); + "chunda\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>bola</p>\r\n" @@ -682,7 +752,7 @@ test_content_parse_unordered_list(void **state) "\n" "* asd\n" "* qwe\n" - "* zxc", NULL); + "* zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -697,7 +767,7 @@ test_content_parse_unordered_list(void **state) "\n" "* asd\n" "* qwe\n" - "* zxc\n", NULL); + "* zxc\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -714,7 +784,7 @@ test_content_parse_unordered_list(void **state) "* qwe\n" "* zxc\n" "\n" - "fuuuu\n", NULL); + "fuuuu\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -734,7 +804,7 @@ test_content_parse_unordered_list(void **state) "* zxc\n" " 1234\n" "\n" - "fuuuu\n", NULL); + "fuuuu\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -750,7 +820,7 @@ test_content_parse_unordered_list(void **state) html = blogc_content_parse( "* asd\n" "* qwe\n" - "* zxc", NULL); + "* zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<ul>\n" @@ -770,7 +840,7 @@ test_content_parse_unordered_list_crlf(void **state) "\r\n" "* asd\r\n" "* qwe\r\n" - "* zxc", NULL); + "* zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -785,7 +855,7 @@ test_content_parse_unordered_list_crlf(void **state) "\r\n" "* asd\r\n" "* qwe\r\n" - "* zxc\r\n", NULL); + "* zxc\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -802,7 +872,7 @@ test_content_parse_unordered_list_crlf(void **state) "* qwe\r\n" "* zxc\r\n" "\r\n" - "fuuuu\r\n", NULL); + "fuuuu\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -822,7 +892,7 @@ test_content_parse_unordered_list_crlf(void **state) "* zxc\r\n" " 1234\r\n" "\r\n" - "fuuuu\r\n", NULL); + "fuuuu\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -838,7 +908,7 @@ test_content_parse_unordered_list_crlf(void **state) html = blogc_content_parse( "* asd\r\n" "* qwe\r\n" - "* zxc", NULL); + "* zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<ul>\r\n" @@ -858,7 +928,7 @@ test_content_parse_ordered_list(void **state) "\n" "1. asd\n" "2. qwe\n" - "3. zxc", NULL); + "3. zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -873,7 +943,7 @@ test_content_parse_ordered_list(void **state) "\n" "1. asd\n" "2. qwe\n" - "3. zxc\n", NULL); + "3. zxc\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -890,7 +960,7 @@ test_content_parse_ordered_list(void **state) "2. qwe\n" "3. zxc\n" "\n" - "fuuuu\n", NULL); + "fuuuu\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -910,7 +980,7 @@ test_content_parse_ordered_list(void **state) "3. zxc\n" " 1234\n" "\n" - "fuuuu\n", NULL); + "fuuuu\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\n" @@ -926,7 +996,7 @@ test_content_parse_ordered_list(void **state) html = blogc_content_parse( "1. asd\n" "2. qwe\n" - "3. zxc", NULL); + "3. zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<ol>\n" @@ -946,7 +1016,7 @@ test_content_parse_ordered_list_crlf(void **state) "\r\n" "1. asd\r\n" "2. qwe\r\n" - "3. zxc", NULL); + "3. zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -961,7 +1031,7 @@ test_content_parse_ordered_list_crlf(void **state) "\r\n" "1. asd\r\n" "2. qwe\r\n" - "3. zxc\r\n", NULL); + "3. zxc\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -978,7 +1048,7 @@ test_content_parse_ordered_list_crlf(void **state) "2. qwe\r\n" "3. zxc\r\n" "\r\n" - "fuuuu\r\n", NULL); + "fuuuu\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -998,7 +1068,7 @@ test_content_parse_ordered_list_crlf(void **state) "3. zxc\r\n" " 1234\r\n" "\r\n" - "fuuuu\r\n", NULL); + "fuuuu\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>lol</p>\r\n" @@ -1014,7 +1084,7 @@ test_content_parse_ordered_list_crlf(void **state) html = blogc_content_parse( "1. asd\r\n" "2. qwe\r\n" - "3. zxc", NULL); + "3. zxc", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<ol>\r\n" @@ -1037,15 +1107,15 @@ __wrap_blogc_directive_loader(blogc_directive_ctx_t *ctx, blogc_error_t **err) assert_null(ctx->argument); else assert_string_equal(ctx->argument, arg); - assert_int_equal(b_trie_size(ctx->params), mock_type(unsigned int)); + assert_int_equal(sb_trie_size(ctx->params), mock_type(unsigned int)); - for (unsigned int i = 0; i < b_trie_size(ctx->params); i++) { + for (unsigned int i = 0; i < sb_trie_size(ctx->params); i++) { const char *key = mock_type(const char*); const char *value = mock_type(const char*); - assert_string_equal(b_trie_lookup(ctx->params, key), value); + assert_string_equal(sb_trie_lookup(ctx->params, key), value); } - return b_strdup("CHUNDA\n"); + return sb_strdup("CHUNDA\n"); } @@ -1057,7 +1127,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); char *html = blogc_content_parse( ".. bola::", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1068,7 +1138,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola::\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1079,7 +1149,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola:: ", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1090,7 +1160,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola:: \n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1101,7 +1171,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola::\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1115,7 +1185,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola::\n" " :asd: qwe", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1129,7 +1199,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola::\n" " :asd: qwe\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1143,7 +1213,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola::\r\n" "\t:asd: qwe\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1160,7 +1230,7 @@ test_content_parse_directive(void **state) ".. bola::\n" "\t\t:asd: qwe\n" "\t\t:zxc: vbn", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1177,7 +1247,7 @@ test_content_parse_directive(void **state) ".. bola::\n" " :asd: qwe\n" " :zxc: vbn\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1194,7 +1264,7 @@ test_content_parse_directive(void **state) ".. bola::\r\n" " :asd: qwe\r\n" " :zxc: vbn\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1217,7 +1287,7 @@ test_content_parse_directive(void **state) " :ert: zxvc\n" " :qwe: bola\n" "\n" - "bola", NULL); + "bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1242,7 +1312,7 @@ test_content_parse_directive(void **state) " :ert: zxvc\r\n" " :qwe: bola\r\n" "\r\n" - "bola", NULL); + "bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1261,7 +1331,7 @@ test_content_parse_directive(void **state) "\n" ".. bola::\n" "\n" - ".. bola::", NULL); + ".. bola::", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1280,7 +1350,7 @@ test_content_parse_directive(void **state) "\n" ".. bola:: asd\n" "\n" - ".. bola:: asd\n", NULL); + ".. bola:: asd\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1299,7 +1369,7 @@ test_content_parse_directive(void **state) "\r\n" ".. bola::\r\n" "\r\n" - ".. bola::\r\n", NULL); + ".. bola::\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1321,7 +1391,7 @@ test_content_parse_directive(void **state) ".. bola::\n" " :asd: qwe\n" "\n" - ".. bola::", NULL); + ".. bola::", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1343,7 +1413,7 @@ test_content_parse_directive(void **state) ".. bola:: asd\n" " :asd: qwe\n" "\n" - ".. bola:: asd\n", NULL); + ".. bola:: asd\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1365,7 +1435,7 @@ test_content_parse_directive(void **state) ".. bola::\n" " :asd: qwe\n" "\n" - ".. bola::\n", NULL); + ".. bola::\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1387,7 +1457,7 @@ test_content_parse_directive(void **state) ".. bola::\r\n" " :asd: qwe\r\n" "\r\n" - ".. bola::\r\n", NULL); + ".. bola::\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1412,7 +1482,7 @@ test_content_parse_directive(void **state) " :asd: qwe\n" "\n" ".. bola::\n" - " :asd: zxc\n", NULL); + " :asd: zxc\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1437,7 +1507,7 @@ test_content_parse_directive(void **state) " :asd: qwe\r\n" "\r\n" ".. bola::\r\n" - " :asd: zxc\r\n", NULL); + " :asd: zxc\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1468,7 +1538,7 @@ test_content_parse_directive(void **state) "\n" ".. bola::\n" " :asd: qwe\n" - " :qwe: 456", NULL); + " :qwe: 456", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1499,7 +1569,7 @@ test_content_parse_directive(void **state) "\n" ".. bola:: asd\n" " :asd: qwe\n" - " :qwe: 456\n", NULL); + " :qwe: 456\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1530,7 +1600,7 @@ test_content_parse_directive(void **state) "\n" ".. bola::\n" " :asd: qwe\n" - " :qwe: 456\n", NULL); + " :qwe: 456\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1561,7 +1631,7 @@ test_content_parse_directive(void **state) "\r\n" ".. bola::\r\n" " :asd: qwe\r\n" - " :qwe: 456\r\n", NULL); + " :qwe: 456\r\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1574,7 +1644,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola:: chunda", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1585,7 +1655,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola:: chunda\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1596,7 +1666,7 @@ test_content_parse_directive(void **state) will_return(__wrap_blogc_directive_loader, 0); html = blogc_content_parse( ".. bola:: chunda\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1610,7 +1680,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola:: chunda\n" " :asd: qwe", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1624,7 +1694,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola:: chunda\n" " :asd: qwe\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1638,7 +1708,7 @@ test_content_parse_directive(void **state) html = blogc_content_parse( ".. bola:: chunda\r\n" " :asd: qwe\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1655,7 +1725,7 @@ test_content_parse_directive(void **state) ".. bola:: chunda\n" " :asd: qwe\n" " :zxc: vbn", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1672,7 +1742,7 @@ test_content_parse_directive(void **state) ".. bola:: chunda\n" " :asd: qwe\n" " :zxc: vbn\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1689,7 +1759,7 @@ test_content_parse_directive(void **state) ".. bola:: chunda\r\n" " :asd: qwe\r\n" " :zxc: vbn\r\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "CHUNDA\n"); @@ -1712,7 +1782,7 @@ test_content_parse_directive(void **state) " :ert: zxvc\n" " :qwe: bola\n" "\n" - "bola", NULL); + "bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\n" @@ -1737,7 +1807,7 @@ test_content_parse_directive(void **state) " :ert: zxvc\r\n" " :qwe: bola\r\n" "\r\n" - "bola", NULL); + "bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1773,7 +1843,7 @@ test_content_parse_directive(void **state) " :asd: qwe\r\n" " :ert: zxvc\r\n" "\r\n" - "bola", NULL); + "bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<h1 id=\"foo\">foo</h1>\r\n" @@ -1785,9 +1855,176 @@ test_content_parse_directive(void **state) static void +test_content_parse_description(void **state) +{ + char *d = NULL; + char *html = blogc_content_parse( + "# foo\n" + "\n" + "bar", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\n" + "<p>bar</p>\n"); + assert_non_null(d); + assert_string_equal(d, "bar"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\n" + "\n" + "bar\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\n" + "<p>bar</p>\n"); + assert_non_null(d); + assert_string_equal(d, "bar"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\n" + "\n" + "qwe\n" + "bar\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\n" + "<p>qwe\n" + "bar</p>\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\n" + "\n" + "> qwe\n" + "\n" + "bar\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\n" + "<blockquote><p>qwe</p>\n" + "</blockquote>\n" + "<p>bar</p>\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\n" + "\n" + "> qwe\n" + "> zxc\n" + "\n" + "bar\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\n" + "<blockquote><p>qwe\n" + "zxc</p>\n" + "</blockquote>\n" + "<p>bar</p>\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); +} + + +static void +test_content_parse_description_crlf(void **state) +{ + char *d = NULL; + char *html = blogc_content_parse( + "# foo\r\n" + "\r\n" + "bar", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\r\n" + "<p>bar</p>\r\n"); + assert_non_null(d); + assert_string_equal(d, "bar"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\r\n" + "\r\n" + "bar\r\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\r\n" + "<p>bar</p>\r\n"); + assert_non_null(d); + assert_string_equal(d, "bar"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\r\n" + "\r\n" + "qwe\r\n" + "bar\r\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\r\n" + "<p>qwe\r\n" + "bar</p>\r\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\r\n" + "\r\n" + "> qwe\r\n" + "\r\n" + "bar\r\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\r\n" + "<blockquote><p>qwe</p>\r\n" + "</blockquote>\r\n" + "<p>bar</p>\r\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); + d = NULL; + html = blogc_content_parse( + "# foo\r\n" + "\r\n" + "> qwe\r\n" + "> zxc\r\n" + "\r\n" + "bar\r\n", NULL, &d); + assert_non_null(html); + assert_string_equal(html, + "<h1 id=\"foo\">foo</h1>\r\n" + "<blockquote><p>qwe\r\n" + "zxc</p>\r\n" + "</blockquote>\r\n" + "<p>bar</p>\r\n"); + assert_non_null(d); + assert_string_equal(d, "qwe"); + free(html); + free(d); +} + + +static void test_content_parse_invalid_excerpt(void **state) { size_t l = 0; + char *d = NULL; char *html = blogc_content_parse( "# test\n" "\n" @@ -1795,9 +2032,11 @@ test_content_parse_invalid_excerpt(void **state) "..\n" "\n" "guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda\n" @@ -1806,6 +2045,8 @@ test_content_parse_invalid_excerpt(void **state) "lol</p>\n"); free(html); l = 0; + free(d); + d = NULL; html = blogc_content_parse( "# test\n" "\n" @@ -1813,9 +2054,11 @@ test_content_parse_invalid_excerpt(void **state) "\n" "...\n" "guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda</p>\n" @@ -1824,15 +2067,19 @@ test_content_parse_invalid_excerpt(void **state) "lol</p>\n"); free(html); l = 0; + free(d); + d = NULL; html = blogc_content_parse( "# test\n" "\n" "chunda..\n" "\n" "guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "chunda.."); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda..</p>\n" @@ -1840,21 +2087,26 @@ test_content_parse_invalid_excerpt(void **state) "lol</p>\n"); free(html); l = 0; + free(d); + d = NULL; html = blogc_content_parse( "# test\n" "\n" "chunda\n" "\n" "...guda\n" - "lol", &l); + "lol", &l, &d); assert_non_null(html); assert_int_equal(l, 0); + assert_non_null(d); + assert_string_equal(d, "chunda"); assert_string_equal(html, "<h1 id=\"test\">test</h1>\n" "<p>chunda</p>\n" "<p>...guda\n" "lol</p>\n"); free(html); + free(d); } @@ -1864,7 +2116,7 @@ test_content_parse_invalid_header(void **state) char *html = blogc_content_parse( "asd\n" "\n" - "##bola\n", NULL); + "##bola\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>asd</p>\n" @@ -1881,7 +2133,7 @@ test_content_parse_invalid_header_empty(void **state) "\n" "##\n" "\n" - "qwe\n", NULL); + "qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>asd</p>\n" @@ -1898,7 +2150,7 @@ test_content_parse_invalid_blockquote(void **state) char *html = blogc_content_parse( "> asd\n" "> bola\n" - "> foo\n", NULL); + "> foo\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>> asd\n" @@ -1907,7 +2159,7 @@ test_content_parse_invalid_blockquote(void **state) free(html); html = blogc_content_parse( "> asd\n" - "> bola", NULL); + "> bola", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>> asd\n" @@ -1922,7 +2174,7 @@ test_content_parse_invalid_code(void **state) char *html = blogc_content_parse( " asd\n" " bola\n" - " foo\n", NULL); + " foo\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p> asd\n" @@ -1932,7 +2184,7 @@ test_content_parse_invalid_code(void **state) html = blogc_content_parse( " asd\n" " bola\n" - " foo", NULL); + " foo", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p> asd\n" @@ -1946,11 +2198,11 @@ static void test_content_parse_invalid_horizontal_rule(void **state) { // this generates invalid html, but... - char *html = blogc_content_parse("** asd", NULL); + char *html = blogc_content_parse("** asd", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><strong> asd</p>\n"); free(html); - html = blogc_content_parse("** asd\n", NULL); + html = blogc_content_parse("** asd\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><strong> asd</p>\n"); free(html); @@ -1963,7 +2215,7 @@ test_content_parse_invalid_unordered_list(void **state) // more invalid html char *html = blogc_content_parse( "* asd\n" - "1. qwe", NULL); + "1. qwe", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><em> asd\n" @@ -1972,7 +2224,7 @@ test_content_parse_invalid_unordered_list(void **state) html = blogc_content_parse( "* asd\n" "1. qwe\n" - "\n", NULL); + "\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><em> asd\n" @@ -1980,7 +2232,7 @@ test_content_parse_invalid_unordered_list(void **state) free(html); html = blogc_content_parse( "* asd\n" - "1. qwe\n", NULL); + "1. qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><em> asd\n" @@ -1989,7 +2241,7 @@ test_content_parse_invalid_unordered_list(void **state) free(html); html = blogc_content_parse( "* asd\n" - "1. qwe\n", NULL); + "1. qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p><em> asd\n" @@ -2002,7 +2254,7 @@ test_content_parse_invalid_unordered_list(void **state) "* asd\n" "1. qwe\n" "\n" - "poi\n", NULL); + "poi\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>chunda</p>\n" @@ -2019,7 +2271,7 @@ test_content_parse_invalid_ordered_list(void **state) // more invalid html char *html = blogc_content_parse( "1. asd\n" - "* qwe", NULL); + "* qwe", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1. asd\n" @@ -2028,7 +2280,7 @@ test_content_parse_invalid_ordered_list(void **state) html = blogc_content_parse( "1. asd\n" "* qwe\n" - "\n", NULL); + "\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1. asd\n" @@ -2036,7 +2288,7 @@ test_content_parse_invalid_ordered_list(void **state) free(html); html = blogc_content_parse( "1. asd\n" - "* qwe\n", NULL); + "* qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1. asd\n" @@ -2045,7 +2297,7 @@ test_content_parse_invalid_ordered_list(void **state) free(html); html = blogc_content_parse( "1. asd\n" - "* qwe\n", NULL); + "* qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1. asd\n" @@ -2058,7 +2310,7 @@ test_content_parse_invalid_ordered_list(void **state) "1. asd\n" "* qwe\n" "\n" - "poi\n", NULL); + "poi\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>chunda</p>\n" @@ -2068,7 +2320,7 @@ test_content_parse_invalid_ordered_list(void **state) free(html); html = blogc_content_parse( "1 asd\n" - "* qwe\n", NULL); + "* qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1 asd\n" @@ -2076,7 +2328,7 @@ test_content_parse_invalid_ordered_list(void **state) free(html); html = blogc_content_parse( "a. asd\n" - "2. qwe\n", NULL); + "2. qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>a. asd\n" @@ -2084,18 +2336,18 @@ test_content_parse_invalid_ordered_list(void **state) free(html); html = blogc_content_parse( "1.\nasd\n" - "2. qwe\n", NULL); + "2. qwe\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1.\n" "asd\n" "2. qwe</p>\n"); free(html); - html = blogc_content_parse("1.\n", NULL); + html = blogc_content_parse("1.\n", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1.</p>\n"); free(html); - html = blogc_content_parse("1 ", NULL); + html = blogc_content_parse("1 ", NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>1 </p>\n"); free(html); @@ -2107,7 +2359,7 @@ test_content_parse_invalid_directive(void **state) { char *html = blogc_content_parse( ".. ", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. </p>\n"); @@ -2115,7 +2367,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. \n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. </p>\n"); @@ -2123,7 +2375,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. ", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. <br /></p>\n"); @@ -2131,7 +2383,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. \n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. <br /></p>\n"); @@ -2139,7 +2391,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. a", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. a</p>\n"); @@ -2147,7 +2399,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. a\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. a</p>\n"); @@ -2155,7 +2407,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd</p>\n"); @@ -2163,7 +2415,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd</p>\n"); @@ -2171,7 +2423,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd:", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd:</p>\n"); @@ -2179,7 +2431,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd:\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd:</p>\n"); @@ -2188,7 +2440,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2198,7 +2450,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2208,7 +2460,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :a", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2218,7 +2470,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :a\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2228,7 +2480,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2238,7 +2490,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2248,7 +2500,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as:", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2258,7 +2510,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as:\n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2268,7 +2520,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as: ", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2278,7 +2530,7 @@ test_content_parse_invalid_directive(void **state) html = blogc_content_parse( ".. asd::\n" " :as: \n", - NULL); + NULL, NULL); assert_non_null(html); assert_string_equal(html, "<p>.. asd::\n" @@ -2304,6 +2556,10 @@ test_content_parse_inline(void **state) assert_non_null(html); assert_string_equal(html, "<em>bola</em>"); free(html); + html = blogc_content_parse_inline("bola!"); + assert_non_null(html); + assert_string_equal(html, "bola!"); + free(html); } @@ -2419,10 +2675,22 @@ test_content_parse_inline_link(void **state) assert_non_null(html); assert_string_equal(html, "<a href=\"http://example.org/\">bola</a>\n"); free(html); + html = blogc_content_parse_inline("[bola!](http://example.org/)\n"); + assert_non_null(html); + assert_string_equal(html, "<a href=\"http://example.org/\">bola!</a>\n"); + free(html); html = blogc_content_parse_inline("[bola]\n(http://example.org/)\n"); assert_non_null(html); assert_string_equal(html, "<a href=\"http://example.org/\">bola</a>\n"); free(html); + html = blogc_content_parse_inline("[bola]\r\n(http://example.org/)\n"); + assert_non_null(html); + assert_string_equal(html, "<a href=\"http://example.org/\">bola</a>\n"); + free(html); + html = blogc_content_parse_inline("[bola] \r\n (http://example.org/)\n"); + assert_non_null(html); + assert_string_equal(html, "<a href=\"http://example.org/\">bola</a>\n"); + free(html); html = blogc_content_parse_inline("[bo\nla](http://example.org/)\n"); assert_non_null(html); assert_string_equal(html, "<a href=\"http://example.org/\">bo\nla</a>\n"); @@ -2435,6 +2703,16 @@ test_content_parse_inline_link(void **state) assert_non_null(html); assert_string_equal(html, "<a href=\"http://example.org/\"><code>bola(2)[3]**!\\</code></a>\n"); free(html); + html = blogc_content_parse_inline("test suite!)\n" + "depends on [cmocka](http://cmocka.org/), though.\n"); + assert_non_null(html); + assert_string_equal(html, "test suite!)\n" + "depends on <a href=\"http://cmocka.org/\">cmocka</a>, though.\n"); + free(html); + html = blogc_content_parse_inline("asd [bola]chunda(1234)"); + assert_non_null(html); + assert_string_equal(html, "asd [bola]chunda(1234)"); + free(html); // "invalid" html = blogc_content_parse_inline("[bola](\nhttp://example.org/)\n"); assert_non_null(html); @@ -2516,6 +2794,42 @@ test_content_parse_inline_image(void **state) assert_non_null(html); assert_string_equal(html, "<img src=\"http://example.org/\" alt=\"bola\">\n"); free(html); + html = blogc_content_parse_inline("![bola]\r\n(http://example.org/)\n"); + assert_non_null(html); + assert_string_equal(html, "<img src=\"http://example.org/\" alt=\"bola\">\n"); + free(html); + html = blogc_content_parse_inline("![bola] \r\n (http://example.org/)\n"); + assert_non_null(html); + assert_string_equal(html, "<img src=\"http://example.org/\" alt=\"bola\">\n"); + free(html); + html = blogc_content_parse_inline( + "[](https://blogc.rgm.io)"); + assert_non_null(html); + assert_string_equal(html, + "<a href=\"https://blogc.rgm.io\"><img src=\"picture.jpg\" " + "alt=\"This is the image alt text\"></a>"); + free(html); + html = blogc_content_parse_inline( + "[![This is the image alt text]\n" + "(picture.jpg)](https://blogc.rgm.io)"); + assert_non_null(html); + assert_string_equal(html, + "<a href=\"https://blogc.rgm.io\"><img src=\"picture.jpg\" " + "alt=\"This is the image alt text\"></a>"); + free(html); + html = blogc_content_parse_inline( + "[![This is the image alt text]\n" + "(picture.jpg)]\n" + "(https://blogc.rgm.io)"); + assert_non_null(html); + assert_string_equal(html, + "<a href=\"https://blogc.rgm.io\"><img src=\"picture.jpg\" " + "alt=\"This is the image alt text\"></a>"); + free(html); + html = blogc_content_parse_inline("asd ![bola]chunda(1234)"); + assert_non_null(html); + assert_string_equal(html, "asd ![bola]chunda(1234)"); + free(html); // "invalid" html = blogc_content_parse_inline("\n"); assert_non_null(html); @@ -2613,6 +2927,36 @@ test_content_parse_inline_line_break_crlf(void **state) } +static void +test_content_parse_inline_endash_emdash(void **state) +{ + char *html = blogc_content_parse_inline("foo -- bar"); + assert_non_null(html); + assert_string_equal(html, "foo – bar"); + free(html); + html = blogc_content_parse_inline("foo --- bar"); + assert_non_null(html); + assert_string_equal(html, "foo — bar"); + free(html); + html = blogc_content_parse_inline("`foo -- bar`"); + assert_non_null(html); + assert_string_equal(html, "<code>foo -- bar</code>"); + free(html); + html = blogc_content_parse_inline("`foo --- bar`"); + assert_non_null(html); + assert_string_equal(html, "<code>foo --- bar</code>"); + free(html); + html = blogc_content_parse_inline("``foo -- bar``"); + assert_non_null(html); + assert_string_equal(html, "<code>foo -- bar</code>"); + free(html); + html = blogc_content_parse_inline("``foo --- bar``"); + assert_non_null(html); + assert_string_equal(html, "<code>foo --- bar</code>"); + free(html); +} + + int main(void) { @@ -2639,6 +2983,8 @@ main(void) unit_test(test_content_parse_ordered_list), unit_test(test_content_parse_ordered_list_crlf), unit_test(test_content_parse_directive), + unit_test(test_content_parse_description), + unit_test(test_content_parse_description_crlf), unit_test(test_content_parse_invalid_excerpt), unit_test(test_content_parse_invalid_header), unit_test(test_content_parse_invalid_header_empty), @@ -2657,6 +3003,7 @@ main(void) unit_test(test_content_parse_inline_image), unit_test(test_content_parse_inline_line_break), unit_test(test_content_parse_inline_line_break_crlf), + unit_test(test_content_parse_inline_endash_emdash), }; return run_tests(tests); } diff --git a/tests/check_error.c b/tests/check_error.c index d3af9c0..8818b00 100644 --- a/tests/check_error.c +++ b/tests/check_error.c @@ -16,7 +16,7 @@ #include <cmocka.h> #include <string.h> #include "../src/error.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" static void diff --git a/tests/check_loader.c b/tests/check_loader.c index ac8bdb3..4a5dc32 100644 --- a/tests/check_loader.c +++ b/tests/check_loader.c @@ -18,7 +18,7 @@ #include <stdio.h> #include "../src/template-parser.h" #include "../src/loader.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" static void @@ -80,11 +80,11 @@ test_template_parse_from_file(void **state) { blogc_error_t *err = NULL; will_return(__wrap_blogc_file_get_contents, "bola"); - will_return(__wrap_blogc_file_get_contents, b_strdup("{{ BOLA }}\n")); - b_slist_t *l = blogc_template_parse_from_file("bola", &err); + will_return(__wrap_blogc_file_get_contents, sb_strdup("{{ BOLA }}\n")); + sb_slist_t *l = blogc_template_parse_from_file("bola", &err); assert_null(err); assert_non_null(l); - assert_int_equal(b_slist_length(l), 2); + assert_int_equal(sb_slist_length(l), 2); blogc_template_free_stmts(l); } @@ -95,7 +95,7 @@ test_template_parse_from_file_null(void **state) blogc_error_t *err = NULL; will_return(__wrap_blogc_file_get_contents, "bola"); will_return(__wrap_blogc_file_get_contents, NULL); - b_slist_t *l = blogc_template_parse_from_file("bola", &err); + sb_slist_t *l = blogc_template_parse_from_file("bola", &err); assert_null(err); assert_null(l); } @@ -106,20 +106,21 @@ test_source_parse_from_file(void **state) { blogc_error_t *err = NULL; will_return(__wrap_blogc_file_get_contents, "bola.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "--------\n" "bola")); - b_trie_t *t = blogc_source_parse_from_file("bola.txt", &err); + sb_trie_t *t = blogc_source_parse_from_file("bola.txt", &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_trie_size(t), 5); - assert_string_equal(b_trie_lookup(t, "ASD"), "123"); - assert_string_equal(b_trie_lookup(t, "FILENAME"), "bola"); - assert_string_equal(b_trie_lookup(t, "EXCERPT"), "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(t, "CONTENT"), "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(t, "RAW_CONTENT"), "bola"); - b_trie_free(t); + assert_int_equal(sb_trie_size(t), 6); + assert_string_equal(sb_trie_lookup(t, "ASD"), "123"); + assert_string_equal(sb_trie_lookup(t, "FILENAME"), "bola"); + assert_string_equal(sb_trie_lookup(t, "EXCERPT"), "<p>bola</p>\n"); + assert_string_equal(sb_trie_lookup(t, "CONTENT"), "<p>bola</p>\n"); + assert_string_equal(sb_trie_lookup(t, "RAW_CONTENT"), "bola"); + assert_string_equal(sb_trie_lookup(t, "DESCRIPTION"), "bola"); + sb_trie_free(t); } @@ -129,7 +130,7 @@ test_source_parse_from_file_null(void **state) blogc_error_t *err = NULL; will_return(__wrap_blogc_file_get_contents, "bola.txt"); will_return(__wrap_blogc_file_get_contents, NULL); - b_trie_t *t = blogc_source_parse_from_file("bola.txt", &err); + sb_trie_t *t = blogc_source_parse_from_file("bola.txt", &err); assert_null(err); assert_null(t); } @@ -139,41 +140,41 @@ static void test_source_parse_from_files(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - b_trie_t *c = b_trie_new(free); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 3); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 4); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola3"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2003-02-03 04:05:06"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 3); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 4); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola3"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2003-02-03 04:05:06"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -181,45 +182,45 @@ static void test_source_parse_from_files_filter_by_tag(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "TAGS: chunda\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "TAGS: bola, chunda\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_TAG", b_strdup("chunda")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_TAG", sb_strdup("chunda")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 5); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola2"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_TAG"), "chunda"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 5); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola2"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_TAG"), "chunda"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -227,77 +228,77 @@ static void test_source_parse_from_files_filter_by_page(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_PAGE", b_strdup("1")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("1")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 10); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola2"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "FILTER_PER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "CURRENT_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "NEXT_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "FIRST_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "LAST_PAGE"), "4"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 10); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola2"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "CURRENT_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "NEXT_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "FIRST_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "LAST_PAGE"), "4"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -305,78 +306,78 @@ static void test_source_parse_from_files_filter_by_page2(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_PAGE", b_strdup("3")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("3")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 11); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola5"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola6"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2005-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2006-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_PAGE"), "3"); - assert_string_equal(b_trie_lookup(c, "FILTER_PER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "CURRENT_PAGE"), "3"); - assert_string_equal(b_trie_lookup(c, "PREVIOUS_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "NEXT_PAGE"), "4"); - assert_string_equal(b_trie_lookup(c, "FIRST_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "LAST_PAGE"), "4"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 11); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola5"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola6"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2005-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2006-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PAGE"), "3"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "CURRENT_PAGE"), "3"); + assert_string_equal(sb_trie_lookup(c, "PREVIOUS_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "NEXT_PAGE"), "4"); + assert_string_equal(sb_trie_lookup(c, "FIRST_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "LAST_PAGE"), "4"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -384,77 +385,77 @@ static void test_source_parse_from_files_filter_by_page3(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_PAGE", b_strdup("1")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("1")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 10); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola2"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "FILTER_PER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "CURRENT_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "NEXT_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "FIRST_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "LAST_PAGE"), "4"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 10); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola2"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "CURRENT_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "NEXT_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "FIRST_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "LAST_PAGE"), "4"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -462,84 +463,84 @@ static void test_source_parse_from_files_filter_by_page_and_tag(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "TAGS: chunda\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "TAGS: chunda bola\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "TAGS: bola\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "TAGS: chunda\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "TAGS: yay chunda\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_TAG", b_strdup("chunda")); - b_trie_insert(c, "FILTER_PAGE", b_strdup("2")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_TAG", sb_strdup("chunda")); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("2")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 11); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola5"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola7"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2005-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2007-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_TAG"), "chunda"); - assert_string_equal(b_trie_lookup(c, "FILTER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "FILTER_PER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "CURRENT_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "PREVIOUS_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "FIRST_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "LAST_PAGE"), "2"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 11); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola5"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola7"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2005-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2007-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_TAG"), "chunda"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "CURRENT_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "PREVIOUS_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "FIRST_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "LAST_PAGE"), "2"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -547,77 +548,77 @@ static void test_source_parse_from_files_filter_by_page_invalid(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_PAGE", b_strdup("-1")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("-1")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 2); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 10); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola2"); - assert_string_equal(b_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); - assert_string_equal(b_trie_lookup(c, "FILTER_PAGE"), "-1"); - assert_string_equal(b_trie_lookup(c, "FILTER_PER_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "CURRENT_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "NEXT_PAGE"), "2"); - assert_string_equal(b_trie_lookup(c, "FIRST_PAGE"), "1"); - assert_string_equal(b_trie_lookup(c, "LAST_PAGE"), "4"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 2); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 10); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola2"); + assert_string_equal(sb_trie_lookup(c, "DATE_FIRST"), "2001-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2002-02-03 04:05:06"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PAGE"), "-1"); + assert_string_equal(sb_trie_lookup(c, "FILTER_PER_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "CURRENT_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "NEXT_PAGE"), "2"); + assert_string_equal(sb_trie_lookup(c, "FIRST_PAGE"), "1"); + assert_string_equal(sb_trie_lookup(c, "LAST_PAGE"), "4"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -625,64 +626,64 @@ static void test_source_parse_from_files_filter_by_page_invalid2(void **state) { will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "DATE: 2001-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola4.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7891\n" "DATE: 2004-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola5.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7892\n" "DATE: 2005-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola6.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7893\n" "DATE: 2006-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola7.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 7894\n" "DATE: 2007-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - s = b_slist_append(s, b_strdup("bola4.txt")); - s = b_slist_append(s, b_strdup("bola5.txt")); - s = b_slist_append(s, b_strdup("bola6.txt")); - s = b_slist_append(s, b_strdup("bola7.txt")); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "FILTER_PAGE", b_strdup("5")); - b_trie_insert(c, "FILTER_PER_PAGE", b_strdup("2")); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + s = sb_slist_append(s, sb_strdup("bola4.txt")); + s = sb_slist_append(s, sb_strdup("bola5.txt")); + s = sb_slist_append(s, sb_strdup("bola6.txt")); + s = sb_slist_append(s, sb_strdup("bola7.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "FILTER_PAGE", sb_strdup("5")); + sb_trie_insert(c, "FILTER_PER_PAGE", sb_strdup("2")); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_null(t); - b_trie_free(c); - b_slist_free_full(s, free); + sb_trie_free(c); + sb_slist_free_full(s, free); } @@ -695,39 +696,39 @@ test_source_parse_from_files_without_all_dates(void **state) "file, but not for all source files. This means that you may get wrong " "values for 'DATE_FIRST' and 'DATE_LAST' variables.\n"); will_return(__wrap_blogc_file_get_contents, "bola1.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 123\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola2.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 456\n" "DATE: 2002-02-03 04:05:06\n" "--------\n" "bola")); will_return(__wrap_blogc_file_get_contents, "bola3.txt"); - will_return(__wrap_blogc_file_get_contents, b_strdup( + will_return(__wrap_blogc_file_get_contents, sb_strdup( "ASD: 789\n" "DATE: 2003-02-03 04:05:06\n" "--------\n" "bola")); blogc_error_t *err = NULL; - b_slist_t *s = NULL; - s = b_slist_append(s, b_strdup("bola1.txt")); - s = b_slist_append(s, b_strdup("bola2.txt")); - s = b_slist_append(s, b_strdup("bola3.txt")); - b_trie_t *c = b_trie_new(free); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_strdup("bola1.txt")); + s = sb_slist_append(s, sb_strdup("bola2.txt")); + s = sb_slist_append(s, sb_strdup("bola3.txt")); + sb_trie_t *c = sb_trie_new(free); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_non_null(t); - assert_int_equal(b_slist_length(t), 3); // it is enough, no need to look at the items - assert_int_equal(b_trie_size(c), 3); - assert_string_equal(b_trie_lookup(c, "FILENAME_FIRST"), "bola1"); - assert_string_equal(b_trie_lookup(c, "FILENAME_LAST"), "bola3"); - assert_string_equal(b_trie_lookup(c, "DATE_LAST"), "2003-02-03 04:05:06"); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 3); // it is enough, no need to look at the items + assert_int_equal(sb_trie_size(c), 3); + assert_string_equal(sb_trie_lookup(c, "FILENAME_FIRST"), "bola1"); + assert_string_equal(sb_trie_lookup(c, "FILENAME_LAST"), "bola3"); + assert_string_equal(sb_trie_lookup(c, "DATE_LAST"), "2003-02-03 04:05:06"); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } @@ -735,16 +736,16 @@ static void test_source_parse_from_files_null(void **state) { blogc_error_t *err = NULL; - b_slist_t *s = NULL; - b_trie_t *c = b_trie_new(free); - b_slist_t *t = blogc_source_parse_from_files(c, s, &err); + sb_slist_t *s = NULL; + sb_trie_t *c = sb_trie_new(free); + sb_slist_t *t = blogc_source_parse_from_files(c, s, &err); assert_null(err); assert_null(t); - assert_int_equal(b_slist_length(t), 0); - assert_int_equal(b_trie_size(c), 0); - b_trie_free(c); - b_slist_free_full(s, free); - b_slist_free_full(t, (b_free_func_t) b_trie_free); + assert_int_equal(sb_slist_length(t), 0); + assert_int_equal(sb_trie_size(c), 0); + sb_trie_free(c); + sb_slist_free_full(s, free); + sb_slist_free_full(t, (sb_free_func_t) sb_trie_free); } diff --git a/tests/check_renderer.c b/tests/check_renderer.c index d6bc947..13e7309 100644 --- a/tests/check_renderer.c +++ b/tests/check_renderer.c @@ -19,10 +19,10 @@ #include "../src/renderer.h" #include "../src/source-parser.h" #include "../src/template-parser.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" -static b_slist_t* +static sb_slist_t* create_sources(unsigned int count) { const char *s[] = { @@ -47,12 +47,12 @@ create_sources(unsigned int count) }; assert_false(count > 3); blogc_error_t *err = NULL; - b_slist_t *l = NULL; + sb_slist_t *l = NULL; for (unsigned int i = 0; i < count; i++) { - l = b_slist_append(l, blogc_source_parse(s[i], strlen(s[i]), &err)); + l = sb_slist_append(l, blogc_source_parse(s[i], strlen(s[i]), &err)); assert_null(err); } - assert_int_equal(b_slist_length(l), count); + assert_int_equal(sb_slist_length(l), count); return l; } @@ -79,10 +79,10 @@ test_render_entry(void **state) "{% foreach TAGS %}lol {{ FOREACH_ITEM }} haha {% endforeach %}\n" "{% foreach TAGS_ASD %}yay{% endforeach %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -104,7 +104,7 @@ test_render_entry(void **state) "lol foo haha lol bar haha lol baz haha \n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -126,10 +126,10 @@ test_render_listing(void **state) "{% foreach TAGS_ASD %}yay{% endforeach %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(3); + sb_slist_t *s = create_sources(3); assert_non_null(s); char *out = blogc_render(l, s, NULL, true); assert_string_equal(out, @@ -153,7 +153,7 @@ test_render_listing(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -174,7 +174,7 @@ test_render_listing_empty(void **state) "{% foreach TAGS %}lol {{ FOREACH_ITEM }} haha {% endforeach %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); char *out = blogc_render(l, NULL, NULL, true); @@ -201,10 +201,10 @@ test_render_ifdef(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -212,7 +212,7 @@ test_render_ifdef(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -230,10 +230,10 @@ test_render_ifdef2(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -243,7 +243,7 @@ test_render_ifdef2(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -261,10 +261,10 @@ test_render_ifdef3(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -276,7 +276,7 @@ test_render_ifdef3(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -294,10 +294,10 @@ test_render_ifndef(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -309,7 +309,7 @@ test_render_ifndef(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -328,10 +328,10 @@ test_render_if_eq(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -344,7 +344,7 @@ test_render_if_eq(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -363,10 +363,10 @@ test_render_if_neq(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -379,7 +379,7 @@ test_render_if_neq(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -398,10 +398,10 @@ test_render_if_lt(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -414,7 +414,7 @@ test_render_if_lt(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -433,10 +433,10 @@ test_render_if_gt(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -449,7 +449,7 @@ test_render_if_gt(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -470,10 +470,10 @@ test_render_if_lt_eq(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -488,7 +488,7 @@ test_render_if_lt_eq(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -509,10 +509,10 @@ test_render_if_gt_eq(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -527,7 +527,7 @@ test_render_if_gt_eq(void **state) "\n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -540,10 +540,10 @@ test_render_foreach(void **state) "{% foreach TAGS %} {{ FOREACH_ITEM }} {% endforeach %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -551,7 +551,7 @@ test_render_foreach(void **state) " foo bar baz \n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -565,10 +565,10 @@ test_render_foreach_if(void **state) "{% endif %} {% endforeach %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); char *out = blogc_render(l, s, NULL, false); assert_string_equal(out, @@ -576,7 +576,7 @@ test_render_foreach_if(void **state) " bar \n" "\n"); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -596,21 +596,21 @@ test_render_outside_block(void **state) "{{ BOLA }}\n" "{% ifndef CHUNDA %}lol{% endif %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "GUDA", b_strdup("asd")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "GUDA", sb_strdup("asd")); char *out = blogc_render(l, s, c, false); assert_string_equal(out, "bola\n" "\n" "lol\n"); - b_trie_free(c); + sb_trie_free(c); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -629,14 +629,14 @@ test_render_prefer_local_variable(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); - b_trie_t *c = b_trie_new(free); - b_trie_insert(c, "GUDA", b_strdup("hehe")); - b_trie_insert(c, "LOL", b_strdup("hmm")); + sb_trie_t *c = sb_trie_new(free); + sb_trie_insert(c, "GUDA", sb_strdup("hehe")); + sb_trie_insert(c, "LOL", sb_strdup("hmm")); char *out = blogc_render(l, s, c, false); assert_string_equal(out, "\n" @@ -647,9 +647,9 @@ test_render_prefer_local_variable(void **state) "\n" "\n" "\n"); - b_trie_free(c); + sb_trie_free(c); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -665,12 +665,12 @@ test_render_respect_variable_scope(void **state) "{% ifdef BOLA %}{{ BOLA }}{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = create_sources(1); + sb_slist_t *s = create_sources(1); assert_non_null(s); - b_trie_t *c = b_trie_new(free); + sb_trie_t *c = sb_trie_new(free); char *out = blogc_render(l, s, c, false); assert_string_equal(out, "\n" @@ -679,9 +679,9 @@ test_render_respect_variable_scope(void **state) "\n" "asd\n" "\n"); - b_trie_free(c); + sb_trie_free(c); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -697,22 +697,22 @@ test_render_ifcount_bug(void **state) "{% endif %}\n" "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *l = blogc_template_parse(str, strlen(str), &err); + sb_slist_t *l = blogc_template_parse(str, strlen(str), &err); assert_non_null(l); assert_null(err); - b_slist_t *s = NULL; - s = b_slist_append(s, b_trie_new(free)); - b_trie_insert(s->data, "TITLE", b_strdup("bola")); - b_trie_t *c = b_trie_new(free); + sb_slist_t *s = NULL; + s = sb_slist_append(s, sb_trie_new(free)); + sb_trie_insert(s->data, "TITLE", sb_strdup("bola")); + sb_trie_t *c = sb_trie_new(free); char *out = blogc_render(l, s, c, false); assert_string_equal(out, "\n" "<h3>bola</h3>\n" "\n" "\n"); - b_trie_free(c); + sb_trie_free(c); blogc_template_free_stmts(l); - b_slist_free_full(s, (b_free_func_t) b_trie_free); + sb_slist_free_full(s, (sb_free_func_t) sb_trie_free); free(out); } @@ -720,112 +720,112 @@ test_render_ifcount_bug(void **state) static void test_get_variable(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "NAME", b_strdup("bola")); - b_trie_insert(g, "TITLE", b_strdup("bola2")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "NAME", b_strdup("chunda")); - b_trie_insert(l, "TITLE", b_strdup("chunda2")); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "NAME", sb_strdup("bola")); + sb_trie_insert(g, "TITLE", sb_strdup("bola2")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "NAME", sb_strdup("chunda")); + sb_trie_insert(l, "TITLE", sb_strdup("chunda2")); assert_string_equal(blogc_get_variable("NAME", g, l), "chunda"); assert_string_equal(blogc_get_variable("TITLE", g, l), "chunda2"); assert_null(blogc_get_variable("BOLA", g, l)); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_get_variable_only_local(void **state) { - b_trie_t *g = NULL; - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "NAME", b_strdup("chunda")); - b_trie_insert(l, "TITLE", b_strdup("chunda2")); + sb_trie_t *g = NULL; + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "NAME", sb_strdup("chunda")); + sb_trie_insert(l, "TITLE", sb_strdup("chunda2")); assert_string_equal(blogc_get_variable("NAME", g, l), "chunda"); assert_string_equal(blogc_get_variable("TITLE", g, l), "chunda2"); assert_null(blogc_get_variable("BOLA", g, l)); - b_trie_free(l); + sb_trie_free(l); } static void test_get_variable_only_global(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "NAME", b_strdup("bola")); - b_trie_insert(g, "TITLE", b_strdup("bola2")); - b_trie_t *l = NULL; + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "NAME", sb_strdup("bola")); + sb_trie_insert(g, "TITLE", sb_strdup("bola2")); + sb_trie_t *l = NULL; assert_string_equal(blogc_get_variable("NAME", g, l), "bola"); assert_string_equal(blogc_get_variable("TITLE", g, l), "bola2"); assert_null(blogc_get_variable("BOLA", g, l)); - b_trie_free(g); + sb_trie_free(g); } static void test_format_date(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "DATE_FORMAT", b_strdup("%H -- %M")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "DATE_FORMAT", b_strdup("%R")); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "DATE_FORMAT", sb_strdup("%H -- %M")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "DATE_FORMAT", sb_strdup("%R")); char *date = blogc_format_date("2015-01-02 03:04:05", g, l); assert_string_equal(date, "03:04"); free(date); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_date_with_global_format(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "DATE_FORMAT", b_strdup("%H -- %M")); - b_trie_t *l = b_trie_new(free); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "DATE_FORMAT", sb_strdup("%H -- %M")); + sb_trie_t *l = sb_trie_new(free); char *date = blogc_format_date("2015-01-02 03:04:05", g, l); assert_string_equal(date, "03 -- 04"); free(date); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_date_without_format(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_t *l = b_trie_new(free); + sb_trie_t *g = sb_trie_new(free); + sb_trie_t *l = sb_trie_new(free); char *date = blogc_format_date("2015-01-02 03:04:05", g, l); assert_string_equal(date, "2015-01-02 03:04:05"); free(date); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_date_without_date(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_t *l = b_trie_new(free); + sb_trie_t *g = sb_trie_new(free); + sb_trie_t *l = sb_trie_new(free); char *date = blogc_format_date(NULL, g, l); assert_null(date); free(date); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_variable(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "NAME", b_strdup("bola")); - b_trie_insert(g, "TITLE", b_strdup("bola2")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "NAME", b_strdup("chunda")); - b_trie_insert(l, "TITLE", b_strdup("chunda2")); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "NAME", sb_strdup("bola")); + sb_trie_insert(g, "TITLE", sb_strdup("bola2")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "NAME", sb_strdup("chunda")); + sb_trie_insert(l, "TITLE", sb_strdup("chunda2")); char *tmp = blogc_format_variable("NAME", g, l, NULL); assert_string_equal(tmp, "chunda"); free(tmp); @@ -833,37 +833,37 @@ test_format_variable(void **state) assert_string_equal(tmp, "chunda2"); free(tmp); assert_null(blogc_format_variable("BOLA", g, l, NULL)); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_variable_with_date(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "DATE", b_strdup("2010-11-12 13:14:15")); - b_trie_insert(g, "DATE_FORMAT", b_strdup("%R")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "DATE", b_strdup("2011-12-13 14:15:16")); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "DATE", sb_strdup("2010-11-12 13:14:15")); + sb_trie_insert(g, "DATE_FORMAT", sb_strdup("%R")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "DATE", sb_strdup("2011-12-13 14:15:16")); char *tmp = blogc_format_variable("DATE_FORMATTED", g, l, NULL); assert_string_equal(tmp, "14:15"); free(tmp); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } static void test_format_variable_foreach(void **state) { - b_slist_t *l = NULL; - l = b_slist_append(l, b_strdup("asd")); - l = b_slist_append(l, b_strdup("qwe")); + sb_slist_t *l = NULL; + l = sb_slist_append(l, sb_strdup("asd")); + l = sb_slist_append(l, sb_strdup("qwe")); char *tmp = blogc_format_variable("FOREACH_ITEM", NULL, NULL, l->next); assert_string_equal(tmp, "qwe"); free(tmp); - b_slist_free_full(l, free); + sb_slist_free_full(l, free); } @@ -877,31 +877,31 @@ test_format_variable_foreach_empty(void **state) static void test_split_list_variable(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "TAGS", b_strdup("asd lol hehe")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "TAGS", b_strdup("asd lol XD")); - b_slist_t *tmp = blogc_split_list_variable("TAGS", g, l); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "TAGS", sb_strdup("asd lol hehe")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "TAGS", sb_strdup("asd lol XD")); + sb_slist_t *tmp = blogc_split_list_variable("TAGS", g, l); assert_string_equal(tmp->data, "asd"); assert_string_equal(tmp->next->data, "lol"); assert_string_equal(tmp->next->next->data, "XD"); - b_slist_free_full(tmp, free); - b_trie_free(g); - b_trie_free(l); + sb_slist_free_full(tmp, free); + sb_trie_free(g); + sb_trie_free(l); } static void test_split_list_variable_not_found(void **state) { - b_trie_t *g = b_trie_new(free); - b_trie_insert(g, "TAGS", b_strdup("asd lol hehe")); - b_trie_t *l = b_trie_new(free); - b_trie_insert(l, "TAGS", b_strdup("asd lol XD")); - b_slist_t *tmp = blogc_split_list_variable("TAG", g, l); + sb_trie_t *g = sb_trie_new(free); + sb_trie_insert(g, "TAGS", sb_strdup("asd lol hehe")); + sb_trie_t *l = sb_trie_new(free); + sb_trie_insert(l, "TAGS", sb_strdup("asd lol XD")); + sb_slist_t *tmp = blogc_split_list_variable("TAG", g, l); assert_null(tmp); - b_trie_free(g); - b_trie_free(l); + sb_trie_free(g); + sb_trie_free(l); } diff --git a/tests/check_source_parser.c b/tests/check_source_parser.c index 8d6c039..d94dc70 100644 --- a/tests/check_source_parser.c +++ b/tests/check_source_parser.c @@ -17,7 +17,7 @@ #include <string.h> #include "../src/source-parser.h" #include "../src/error.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" static void @@ -31,23 +31,24 @@ test_source_parse(void **state) "\n" "bola\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(err); assert_non_null(source); - assert_int_equal(b_trie_size(source), 5); - assert_string_equal(b_trie_lookup(source, "VAR1"), "asd asd"); - assert_string_equal(b_trie_lookup(source, "VAR2"), "123chunda"); - assert_string_equal(b_trie_lookup(source, "EXCERPT"), + assert_int_equal(sb_trie_size(source), 6); + assert_string_equal(sb_trie_lookup(source, "VAR1"), "asd asd"); + assert_string_equal(sb_trie_lookup(source, "VAR2"), "123chunda"); + assert_string_equal(sb_trie_lookup(source, "EXCERPT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(source, "CONTENT"), + assert_string_equal(sb_trie_lookup(source, "CONTENT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(source, "RAW_CONTENT"), + assert_string_equal(sb_trie_lookup(source, "RAW_CONTENT"), "# This is a test\n" "\n" "bola\n"); - b_trie_free(source); + assert_string_equal(sb_trie_lookup(source, "DESCRIPTION"), "bola"); + sb_trie_free(source); } @@ -62,23 +63,24 @@ test_source_parse_crlf(void **state) "\r\n" "bola\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(err); assert_non_null(source); - assert_int_equal(b_trie_size(source), 5); - assert_string_equal(b_trie_lookup(source, "VAR1"), "asd asd"); - assert_string_equal(b_trie_lookup(source, "VAR2"), "123chunda"); - assert_string_equal(b_trie_lookup(source, "EXCERPT"), + assert_int_equal(sb_trie_size(source), 6); + assert_string_equal(sb_trie_lookup(source, "VAR1"), "asd asd"); + assert_string_equal(sb_trie_lookup(source, "VAR2"), "123chunda"); + assert_string_equal(sb_trie_lookup(source, "EXCERPT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\r\n" "<p>bola</p>\r\n"); - assert_string_equal(b_trie_lookup(source, "CONTENT"), + assert_string_equal(sb_trie_lookup(source, "CONTENT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\r\n" "<p>bola</p>\r\n"); - assert_string_equal(b_trie_lookup(source, "RAW_CONTENT"), + assert_string_equal(sb_trie_lookup(source, "RAW_CONTENT"), "# This is a test\r\n" "\r\n" "bola\r\n"); - b_trie_free(source); + assert_string_equal(sb_trie_lookup(source, "DESCRIPTION"), "bola"); + sb_trie_free(source); } @@ -95,23 +97,24 @@ test_source_parse_with_spaces(void **state) "\n" "bola\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(err); assert_non_null(source); - assert_int_equal(b_trie_size(source), 5); - assert_string_equal(b_trie_lookup(source, "VAR1"), "chunda"); - assert_string_equal(b_trie_lookup(source, "BOLA"), "guda"); - assert_string_equal(b_trie_lookup(source, "EXCERPT"), + assert_int_equal(sb_trie_size(source), 6); + assert_string_equal(sb_trie_lookup(source, "VAR1"), "chunda"); + assert_string_equal(sb_trie_lookup(source, "BOLA"), "guda"); + assert_string_equal(sb_trie_lookup(source, "EXCERPT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(source, "CONTENT"), + assert_string_equal(sb_trie_lookup(source, "CONTENT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(source, "RAW_CONTENT"), + assert_string_equal(sb_trie_lookup(source, "RAW_CONTENT"), "# This is a test\n" "\n" "bola\n"); - b_trie_free(source); + assert_string_equal(sb_trie_lookup(source, "DESCRIPTION"), "bola"); + sb_trie_free(source); } @@ -131,21 +134,21 @@ test_source_parse_with_excerpt(void **state) "guda\n" "yay"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(err); assert_non_null(source); - assert_int_equal(b_trie_size(source), 5); - assert_string_equal(b_trie_lookup(source, "VAR1"), "asd asd"); - assert_string_equal(b_trie_lookup(source, "VAR2"), "123chunda"); - assert_string_equal(b_trie_lookup(source, "EXCERPT"), + assert_int_equal(sb_trie_size(source), 6); + assert_string_equal(sb_trie_lookup(source, "VAR1"), "asd asd"); + assert_string_equal(sb_trie_lookup(source, "VAR2"), "123chunda"); + assert_string_equal(sb_trie_lookup(source, "EXCERPT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n"); - assert_string_equal(b_trie_lookup(source, "CONTENT"), + assert_string_equal(sb_trie_lookup(source, "CONTENT"), "<h1 id=\"this-is-a-test\">This is a test</h1>\n" "<p>bola</p>\n" "<p>guda\n" "yay</p>\n"); - assert_string_equal(b_trie_lookup(source, "RAW_CONTENT"), + assert_string_equal(sb_trie_lookup(source, "RAW_CONTENT"), "# This is a test\n" "\n" "bola\n" @@ -154,7 +157,41 @@ test_source_parse_with_excerpt(void **state) "\n" "guda\n" "yay"); - b_trie_free(source); + assert_string_equal(sb_trie_lookup(source, "DESCRIPTION"), "bola"); + sb_trie_free(source); +} + + +static void +test_source_parse_with_description(void **state) +{ + const char *a = + "VAR1: asd asd\n" + "VAR2: 123chunda\n" + "DESCRIPTION: huehuehuebrbr\n" + "----------\n" + "# This is a test\n" + "\n" + "bola\n"; + blogc_error_t *err = NULL; + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); + assert_null(err); + assert_non_null(source); + assert_int_equal(sb_trie_size(source), 6); + assert_string_equal(sb_trie_lookup(source, "VAR1"), "asd asd"); + assert_string_equal(sb_trie_lookup(source, "VAR2"), "123chunda"); + assert_string_equal(sb_trie_lookup(source, "EXCERPT"), + "<h1 id=\"this-is-a-test\">This is a test</h1>\n" + "<p>bola</p>\n"); + assert_string_equal(sb_trie_lookup(source, "CONTENT"), + "<h1 id=\"this-is-a-test\">This is a test</h1>\n" + "<p>bola</p>\n"); + assert_string_equal(sb_trie_lookup(source, "RAW_CONTENT"), + "# This is a test\n" + "\n" + "bola\n"); + assert_string_equal(sb_trie_lookup(source, "DESCRIPTION"), "huehuehuebrbr"); + sb_trie_free(source); } @@ -163,13 +200,13 @@ test_source_parse_config_empty(void **state) { const char *a = ""; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); assert_string_equal(err->msg, "Your source file is empty."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -178,14 +215,14 @@ test_source_parse_config_invalid_key(void **state) { const char *a = "bola: guda"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); assert_string_equal(err->msg, "Can't find a configuration key or the content separator.\n" "Error occurred near line 1, position 1: bola: guda"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -194,14 +231,14 @@ test_source_parse_config_no_key(void **state) { const char *a = "BOLa"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); assert_string_equal(err->msg, "Invalid configuration key.\n" "Error occurred near line 1, position 4: BOLa"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -210,14 +247,14 @@ test_source_parse_config_no_key2(void **state) { const char *a = "BOLA"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); assert_string_equal(err->msg, "Your last configuration key is missing ':' and the value\n" "Error occurred near line 1, position 5: BOLA"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -226,7 +263,7 @@ test_source_parse_config_no_value(void **state) { const char *a = "BOLA:\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -234,7 +271,7 @@ test_source_parse_config_no_value(void **state) "Configuration value not provided for 'BOLA'.\n" "Error occurred near line 1, position 6: BOLA:"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -243,7 +280,7 @@ test_source_parse_config_no_value2(void **state) { const char *a = "BOLA:"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -251,7 +288,7 @@ test_source_parse_config_no_value2(void **state) "Configuration value not provided for 'BOLA'.\n" "Error occurred near line 1, position 6: BOLA:"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -260,7 +297,7 @@ test_source_parse_config_reserved_name(void **state) { const char *a = "FILENAME: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -268,7 +305,7 @@ test_source_parse_config_reserved_name(void **state) "'FILENAME' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -277,7 +314,7 @@ test_source_parse_config_reserved_name2(void **state) { const char *a = "CONTENT: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -285,7 +322,7 @@ test_source_parse_config_reserved_name2(void **state) "'CONTENT' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -294,7 +331,7 @@ test_source_parse_config_reserved_name3(void **state) { const char *a = "DATE_FORMATTED: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -302,7 +339,7 @@ test_source_parse_config_reserved_name3(void **state) "'DATE_FORMATTED' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -311,7 +348,7 @@ test_source_parse_config_reserved_name4(void **state) { const char *a = "DATE_FIRST_FORMATTED: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -319,7 +356,7 @@ test_source_parse_config_reserved_name4(void **state) "'DATE_FIRST_FORMATTED' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -328,7 +365,7 @@ test_source_parse_config_reserved_name5(void **state) { const char *a = "DATE_LAST_FORMATTED: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -336,7 +373,7 @@ test_source_parse_config_reserved_name5(void **state) "'DATE_LAST_FORMATTED' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -345,7 +382,7 @@ test_source_parse_config_reserved_name6(void **state) { const char *a = "PAGE_FIRST: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -353,7 +390,7 @@ test_source_parse_config_reserved_name6(void **state) "'PAGE_FIRST' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -362,7 +399,7 @@ test_source_parse_config_reserved_name7(void **state) { const char *a = "PAGE_PREVIOUS: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -370,7 +407,7 @@ test_source_parse_config_reserved_name7(void **state) "'PAGE_PREVIOUS' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -379,7 +416,7 @@ test_source_parse_config_reserved_name8(void **state) { const char *a = "PAGE_CURRENT: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -387,7 +424,7 @@ test_source_parse_config_reserved_name8(void **state) "'PAGE_CURRENT' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -396,7 +433,7 @@ test_source_parse_config_reserved_name9(void **state) { const char *a = "PAGE_NEXT: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -404,7 +441,7 @@ test_source_parse_config_reserved_name9(void **state) "'PAGE_NEXT' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -413,7 +450,7 @@ test_source_parse_config_reserved_name10(void **state) { const char *a = "PAGE_LAST: asd\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -421,7 +458,7 @@ test_source_parse_config_reserved_name10(void **state) "'PAGE_LAST' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -430,7 +467,7 @@ test_source_parse_config_reserved_name11(void **state) { const char *a = "BLOGC_VERSION: 1.0\r\n"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -438,7 +475,7 @@ test_source_parse_config_reserved_name11(void **state) "'BLOGC_VERSION' variable is forbidden in source files. It will be set " "for you by the compiler."); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -447,7 +484,7 @@ test_source_parse_config_value_no_line_ending(void **state) { const char *a = "BOLA: asd"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -455,7 +492,7 @@ test_source_parse_config_value_no_line_ending(void **state) "No line ending after the configuration value for 'BOLA'.\n" "Error occurred near line 1, position 10: BOLA: asd"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -464,7 +501,7 @@ test_source_parse_invalid_separator(void **state) { const char *a = "BOLA: asd\n---#"; blogc_error_t *err = NULL; - b_trie_t *source = blogc_source_parse(a, strlen(a), &err); + sb_trie_t *source = blogc_source_parse(a, strlen(a), &err); assert_null(source); assert_non_null(err); assert_int_equal(err->type, BLOGC_ERROR_SOURCE_PARSER); @@ -472,7 +509,7 @@ test_source_parse_invalid_separator(void **state) "Invalid content separator. Must be more than one '-' characters.\n" "Error occurred near line 2, position 4: ---#"); blogc_error_free(err); - b_trie_free(source); + sb_trie_free(source); } @@ -484,6 +521,7 @@ main(void) unit_test(test_source_parse_crlf), unit_test(test_source_parse_with_spaces), unit_test(test_source_parse_with_excerpt), + unit_test(test_source_parse_with_description), unit_test(test_source_parse_config_empty), unit_test(test_source_parse_config_invalid_key), unit_test(test_source_parse_config_no_key), diff --git a/tests/check_template_parser.c b/tests/check_template_parser.c index f655896..40a09be 100644 --- a/tests/check_template_parser.c +++ b/tests/check_template_parser.c @@ -17,11 +17,11 @@ #include <string.h> #include "../src/template-parser.h" #include "../src/error.h" -#include "../src/utils/utils.h" +#include "../src/utils.h" static void -blogc_assert_template_stmt(b_slist_t *l, const char *value, +blogc_assert_template_stmt(sb_slist_t *l, const char *value, const blogc_template_stmt_type_t type) { blogc_template_stmt_t *stmt = l->data; @@ -34,7 +34,7 @@ blogc_assert_template_stmt(b_slist_t *l, const char *value, static void -blogc_assert_template_if_stmt(b_slist_t *l, const char *variable, +blogc_assert_template_if_stmt(sb_slist_t *l, const char *variable, blogc_template_stmt_operator_t operator, const char *operand) { blogc_template_stmt_t *stmt = l->data; @@ -64,7 +64,7 @@ test_template_parse(void **state) "{%- foreach BOLA %}hahaha{% endforeach %}\n" "{% if BOLA == \"1\\\"0\" %}aee{% endif %}"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_null(err); assert_non_null(stmts); blogc_assert_template_stmt(stmts, "Test", @@ -81,7 +81,7 @@ test_template_parse(void **state) BLOGC_TEMPLATE_ENDIF_STMT); blogc_assert_template_stmt(stmts->next->next->next->next->next->next, "\n", BLOGC_TEMPLATE_CONTENT_STMT); - b_slist_t *tmp = stmts->next->next->next->next->next->next->next; + sb_slist_t *tmp = stmts->next->next->next->next->next->next->next; blogc_assert_template_stmt(tmp, "BOLA", BLOGC_TEMPLATE_IFNDEF_STMT); blogc_assert_template_stmt(tmp->next, "\nbolao", BLOGC_TEMPLATE_CONTENT_STMT); blogc_assert_template_stmt(tmp->next->next, NULL, BLOGC_TEMPLATE_ENDIF_STMT); @@ -144,7 +144,7 @@ test_template_parse_crlf(void **state) "{%- foreach BOLA %}hahaha{% endforeach %}\r\n" "{% if BOLA == \"1\\\"0\" %}aee{% endif %}"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_null(err); assert_non_null(stmts); blogc_assert_template_stmt(stmts, "Test", @@ -161,7 +161,7 @@ test_template_parse_crlf(void **state) BLOGC_TEMPLATE_ENDIF_STMT); blogc_assert_template_stmt(stmts->next->next->next->next->next->next, "\r\n", BLOGC_TEMPLATE_CONTENT_STMT); - b_slist_t *tmp = stmts->next->next->next->next->next->next->next; + sb_slist_t *tmp = stmts->next->next->next->next->next->next->next; blogc_assert_template_stmt(tmp, "BOLA", BLOGC_TEMPLATE_IFNDEF_STMT); blogc_assert_template_stmt(tmp->next, "\r\nbolao", BLOGC_TEMPLATE_CONTENT_STMT); blogc_assert_template_stmt(tmp->next->next, NULL, BLOGC_TEMPLATE_ENDIF_STMT); @@ -232,7 +232,7 @@ test_template_parse_html(void **state) " </body>\n" "</html>\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_null(err); assert_non_null(stmts); blogc_assert_template_stmt(stmts, "<html>\n <head>\n ", @@ -251,7 +251,7 @@ test_template_parse_html(void **state) "\n ", BLOGC_TEMPLATE_CONTENT_STMT); blogc_assert_template_stmt(stmts->next->next->next->next->next->next->next, "listing_once", BLOGC_TEMPLATE_BLOCK_STMT); - b_slist_t *tmp = stmts->next->next->next->next->next->next->next->next; + sb_slist_t *tmp = stmts->next->next->next->next->next->next->next->next; blogc_assert_template_stmt(tmp, "\n <title>My cool blog - Main page</title>\n ", BLOGC_TEMPLATE_CONTENT_STMT); @@ -342,7 +342,7 @@ test_template_parse_ifdef_and_var_outside_block(void **state) "{{ BOLA }}\n" "{% ifndef CHUNDA %}{{ CHUNDA }}{% endif %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_null(err); assert_non_null(stmts); blogc_assert_template_stmt(stmts, "GUDA", BLOGC_TEMPLATE_IFDEF_STMT); @@ -358,7 +358,7 @@ test_template_parse_ifdef_and_var_outside_block(void **state) BLOGC_TEMPLATE_CONTENT_STMT); blogc_assert_template_stmt(stmts->next->next->next->next->next->next, "CHUNDA", BLOGC_TEMPLATE_IFNDEF_STMT); - b_slist_t *tmp = stmts->next->next->next->next->next->next->next; + sb_slist_t *tmp = stmts->next->next->next->next->next->next->next; blogc_assert_template_stmt(tmp, "CHUNDA", BLOGC_TEMPLATE_VARIABLE_STMT); blogc_assert_template_stmt(tmp->next, NULL, BLOGC_TEMPLATE_ENDIF_STMT); blogc_assert_template_stmt(tmp->next->next, "\n", @@ -373,7 +373,7 @@ test_template_parse_invalid_block_start(void **state) { const char *a = "{% ASD %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -411,7 +411,7 @@ test_template_parse_invalid_block_nested(void **state) "{% block entry %}\n" "{% block listing %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -429,7 +429,7 @@ test_template_parse_invalid_foreach_nested(void **state) "{% foreach A %}\n" "{% foreach B %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -445,7 +445,7 @@ test_template_parse_invalid_block_not_open(void **state) { const char *a = "{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -461,7 +461,7 @@ test_template_parse_invalid_endif_not_open(void **state) { const char *a = "{% block listing %}{% endif %}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -478,7 +478,7 @@ test_template_parse_invalid_endforeach_not_open(void **state) { const char *a = "{% endforeach %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -494,7 +494,7 @@ test_template_parse_invalid_block_name(void **state) { const char *a = "{% chunda %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -511,7 +511,7 @@ test_template_parse_invalid_block_type_start(void **state) { const char *a = "{% block ENTRY %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -527,7 +527,7 @@ test_template_parse_invalid_block_type(void **state) { const char *a = "{% block chunda %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -543,7 +543,7 @@ test_template_parse_invalid_ifdef_start(void **state) { const char *a = "{% block entry %}{% ifdef guda %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -560,7 +560,7 @@ test_template_parse_invalid_foreach_start(void **state) { const char *a = "{% block entry %}{% foreach guda %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -577,7 +577,7 @@ test_template_parse_invalid_ifdef_variable(void **state) { const char *a = "{% block entry %}{% ifdef BoLA %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -594,7 +594,7 @@ test_template_parse_invalid_ifdef_variable2(void **state) { const char *a = "{% block entry %}{% ifdef 0123 %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -611,7 +611,7 @@ test_template_parse_invalid_foreach_variable(void **state) { const char *a = "{% block entry %}{% foreach BoLA %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -628,7 +628,7 @@ test_template_parse_invalid_foreach_variable2(void **state) { const char *a = "{% block entry %}{% foreach 0123 %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -645,7 +645,7 @@ test_template_parse_invalid_if_operator(void **state) { const char *a = "{% block entry %}{% if BOLA = \"asd\" %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -662,7 +662,7 @@ test_template_parse_invalid_if_operand(void **state) { const char *a = "{% block entry %}{% if BOLA == asd %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -679,7 +679,7 @@ test_template_parse_invalid_if_operand2(void **state) { const char *a = "{% block entry %}{% if BOLA == \"asd %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -696,7 +696,7 @@ test_template_parse_invalid_if_operand3(void **state) { const char *a = "{% block entry %}{% if BOLA == 0123 %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -713,7 +713,7 @@ test_template_parse_invalid_block_end(void **state) { const char *a = "{% block entry }}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -729,7 +729,7 @@ test_template_parse_invalid_variable_name(void **state) { const char *a = "{% block entry %}{{ bola }}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -746,7 +746,7 @@ test_template_parse_invalid_variable_name2(void **state) { const char *a = "{% block entry %}{{ Bola }}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -763,7 +763,7 @@ test_template_parse_invalid_variable_name3(void **state) { const char *a = "{% block entry %}{{ 0123 }}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -780,7 +780,7 @@ test_template_parse_invalid_variable_end(void **state) { const char *a = "{% block entry %}{{ BOLA %}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -797,7 +797,7 @@ test_template_parse_invalid_close(void **state) { const char *a = "{% block entry %%\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -813,7 +813,7 @@ test_template_parse_invalid_close2(void **state) { const char *a = "{% block entry %}{{ BOLA }%{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -830,7 +830,7 @@ test_template_parse_invalid_if_not_closed(void **state) { const char *a = "{% block entry %}{% ifdef BOLA %}{% endblock %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -845,7 +845,7 @@ test_template_parse_invalid_block_not_closed(void **state) { const char *a = "{% block entry %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); @@ -859,7 +859,7 @@ test_template_parse_invalid_foreach_not_closed(void **state) { const char *a = "{% foreach ASD %}\n"; blogc_error_t *err = NULL; - b_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); + sb_slist_t *stmts = blogc_template_parse(a, strlen(a), &err); assert_non_null(err); assert_null(stmts); assert_int_equal(err->type, BLOGC_ERROR_TEMPLATE_PARSER); diff --git a/tests/check_utils.c b/tests/check_utils.c index a511dda..6a6ceca 100644 --- a/tests/check_utils.c +++ b/tests/check_utils.c @@ -13,38 +13,58 @@ #include <stdlib.h> -#include "../src/utils/utils.h" +#include "../src/utils.h" + +#define SB_STRING_CHUNK_SIZE 128 static void test_slist_append(void **state) { - b_slist_t *l = NULL; - l = b_slist_append(l, (void*) b_strdup("bola")); + sb_slist_t *l = NULL; + l = sb_slist_append(l, (void*) sb_strdup("bola")); assert_non_null(l); assert_string_equal(l->data, "bola"); assert_null(l->next); - l = b_slist_append(l, (void*) b_strdup("guda")); + l = sb_slist_append(l, (void*) sb_strdup("guda")); assert_non_null(l); assert_string_equal(l->data, "bola"); assert_non_null(l->next); assert_string_equal(l->next->data, "guda"); assert_null(l->next->next); - b_slist_free_full(l, free); + sb_slist_free_full(l, free); +} + + +static void +test_slist_prepend(void **state) +{ + sb_slist_t *l = NULL; + l = sb_slist_prepend(l, (void*) sb_strdup("bola")); + assert_non_null(l); + assert_string_equal(l->data, "bola"); + assert_null(l->next); + l = sb_slist_prepend(l, (void*) sb_strdup("guda")); + assert_non_null(l); + assert_string_equal(l->data, "guda"); + assert_non_null(l->next); + assert_string_equal(l->next->data, "bola"); + assert_null(l->next->next); + sb_slist_free_full(l, free); } static void test_slist_free(void **state) { - b_slist_t *l = NULL; - char *t1 = b_strdup("bola"); - char *t2 = b_strdup("guda"); - char *t3 = b_strdup("chunda"); - l = b_slist_append(l, (void*) t1); - l = b_slist_append(l, (void*) t2); - l = b_slist_append(l, (void*) t3); - b_slist_free(l); + sb_slist_t *l = NULL; + char *t1 = sb_strdup("bola"); + char *t2 = sb_strdup("guda"); + char *t3 = sb_strdup("chunda"); + l = sb_slist_append(l, (void*) t1); + l = sb_slist_append(l, (void*) t2); + l = sb_slist_append(l, (void*) t3); + sb_slist_free(l); assert_string_equal(t1, "bola"); assert_string_equal(t2, "guda"); assert_string_equal(t3, "chunda"); @@ -57,22 +77,23 @@ test_slist_free(void **state) static void test_slist_length(void **state) { - b_slist_t *l = NULL; - l = b_slist_append(l, (void*) b_strdup("bola")); - l = b_slist_append(l, (void*) b_strdup("guda")); - l = b_slist_append(l, (void*) b_strdup("chunda")); - assert_int_equal(b_slist_length(l), 3); - b_slist_free_full(l, free); + sb_slist_t *l = NULL; + l = sb_slist_append(l, (void*) sb_strdup("bola")); + l = sb_slist_append(l, (void*) sb_strdup("guda")); + l = sb_slist_append(l, (void*) sb_strdup("chunda")); + assert_int_equal(sb_slist_length(l), 3); + sb_slist_free_full(l, free); + assert_int_equal(sb_slist_length(NULL), 0); } static void test_strdup(void **state) { - char *str = b_strdup("bola"); + char *str = sb_strdup("bola"); assert_string_equal(str, "bola"); free(str); - str = b_strdup(NULL); + str = sb_strdup(NULL); assert_null(str); } @@ -80,16 +101,16 @@ test_strdup(void **state) static void test_strndup(void **state) { - char *str = b_strndup("bolaguda", 4); + char *str = sb_strndup("bolaguda", 4); assert_string_equal(str, "bola"); free(str); - str = b_strndup("bolaguda", 30); + str = sb_strndup("bolaguda", 30); assert_string_equal(str, "bolaguda"); free(str); - str = b_strndup("bolaguda", 8); + str = sb_strndup("bolaguda", 8); assert_string_equal(str, "bolaguda"); free(str); - str = b_strdup(NULL); + str = sb_strdup(NULL); assert_null(str); } @@ -97,10 +118,10 @@ test_strndup(void **state) static void test_strdup_printf(void **state) { - char *str = b_strdup_printf("bola"); + char *str = sb_strdup_printf("bola"); assert_string_equal(str, "bola"); free(str); - str = b_strdup_printf("bola, %s", "guda"); + str = sb_strdup_printf("bola, %s", "guda"); assert_string_equal(str, "bola, guda"); free(str); } @@ -109,140 +130,146 @@ test_strdup_printf(void **state) static void test_str_starts_with(void **state) { - assert_true(b_str_starts_with("bolaguda", "bola")); - assert_true(b_str_starts_with("bola", "bola")); - assert_false(b_str_starts_with("gudabola", "bola")); - assert_false(b_str_starts_with("guda", "bola")); - assert_false(b_str_starts_with("bola", "bolaguda")); + assert_true(sb_str_starts_with("bolaguda", "bola")); + assert_true(sb_str_starts_with("bola", "bola")); + assert_false(sb_str_starts_with("gudabola", "bola")); + assert_false(sb_str_starts_with("guda", "bola")); + assert_false(sb_str_starts_with("bola", "bolaguda")); } static void test_str_ends_with(void **state) { - assert_true(b_str_ends_with("bolaguda", "guda")); - assert_true(b_str_ends_with("bola", "bola")); - assert_false(b_str_ends_with("gudabola", "guda")); - assert_false(b_str_ends_with("guda", "bola")); - assert_false(b_str_ends_with("bola", "gudabola")); + assert_true(sb_str_ends_with("bolaguda", "guda")); + assert_true(sb_str_ends_with("bola", "bola")); + assert_false(sb_str_ends_with("gudabola", "guda")); + assert_false(sb_str_ends_with("guda", "bola")); + assert_false(sb_str_ends_with("bola", "gudabola")); } static void test_str_lstrip(void **state) { - char *str = b_strdup(" \tbola\n \t"); - assert_string_equal(b_str_lstrip(str), "bola\n \t"); + char *str = sb_strdup(" \tbola\n \t"); + assert_string_equal(sb_str_lstrip(str), "bola\n \t"); free(str); - str = b_strdup("guda"); - assert_string_equal(b_str_lstrip(str), "guda"); + str = sb_strdup("guda"); + assert_string_equal(sb_str_lstrip(str), "guda"); free(str); - str = b_strdup("\n"); - assert_string_equal(b_str_lstrip(str), ""); + str = sb_strdup("\n"); + assert_string_equal(sb_str_lstrip(str), ""); free(str); - str = b_strdup("\t \n"); - assert_string_equal(b_str_lstrip(str), ""); + str = sb_strdup("\t \n"); + assert_string_equal(sb_str_lstrip(str), ""); free(str); - str = b_strdup(""); - assert_string_equal(b_str_lstrip(str), ""); + str = sb_strdup(""); + assert_string_equal(sb_str_lstrip(str), ""); free(str); - assert_null(b_str_lstrip(NULL)); + assert_null(sb_str_lstrip(NULL)); } static void test_str_rstrip(void **state) { - char *str = b_strdup(" \tbola\n \t"); - assert_string_equal(b_str_rstrip(str), " \tbola"); + char *str = sb_strdup(" \tbola\n \t"); + assert_string_equal(sb_str_rstrip(str), " \tbola"); free(str); - str = b_strdup("guda"); - assert_string_equal(b_str_rstrip(str), "guda"); + str = sb_strdup("guda"); + assert_string_equal(sb_str_rstrip(str), "guda"); free(str); - str = b_strdup("\n"); - assert_string_equal(b_str_rstrip(str), ""); + str = sb_strdup("\n"); + assert_string_equal(sb_str_rstrip(str), ""); free(str); - str = b_strdup("\t \n"); - assert_string_equal(b_str_rstrip(str), ""); + str = sb_strdup("\t \n"); + assert_string_equal(sb_str_rstrip(str), ""); free(str); - str = b_strdup(""); - assert_string_equal(b_str_rstrip(str), ""); + str = sb_strdup(""); + assert_string_equal(sb_str_rstrip(str), ""); free(str); - assert_null(b_str_rstrip(NULL)); + assert_null(sb_str_rstrip(NULL)); } static void test_str_strip(void **state) { - char *str = b_strdup(" \tbola\n \t"); - assert_string_equal(b_str_strip(str), "bola"); + char *str = sb_strdup(" \tbola\n \t"); + assert_string_equal(sb_str_strip(str), "bola"); free(str); - str = b_strdup("guda"); - assert_string_equal(b_str_strip(str), "guda"); + str = sb_strdup("guda"); + assert_string_equal(sb_str_strip(str), "guda"); free(str); - str = b_strdup("\n"); - assert_string_equal(b_str_strip(str), ""); + str = sb_strdup("\n"); + assert_string_equal(sb_str_strip(str), ""); free(str); - str = b_strdup("\t \n"); - assert_string_equal(b_str_strip(str), ""); + str = sb_strdup("\t \n"); + assert_string_equal(sb_str_strip(str), ""); free(str); - str = b_strdup(""); - assert_string_equal(b_str_strip(str), ""); + str = sb_strdup(""); + assert_string_equal(sb_str_strip(str), ""); free(str); - assert_null(b_str_strip(NULL)); + assert_null(sb_str_strip(NULL)); } static void test_str_split(void **state) { - char **strv = b_str_split("bola:guda:chunda", ':', 0); + char **strv = sb_str_split("bola:guda:chunda", ':', 0); assert_string_equal(strv[0], "bola"); assert_string_equal(strv[1], "guda"); assert_string_equal(strv[2], "chunda"); assert_null(strv[3]); - b_strv_free(strv); - strv = b_str_split("bola:guda:chunda", ':', 2); + sb_strv_free(strv); + strv = sb_str_split("bola:guda:chunda", ':', 2); assert_string_equal(strv[0], "bola"); assert_string_equal(strv[1], "guda:chunda"); assert_null(strv[2]); - b_strv_free(strv); - strv = b_str_split("bola:guda:chunda", ':', 1); + sb_strv_free(strv); + strv = sb_str_split("bola:guda:chunda", ':', 1); assert_string_equal(strv[0], "bola:guda:chunda"); assert_null(strv[1]); - b_strv_free(strv); - strv = b_str_split("", ':', 1); + sb_strv_free(strv); + strv = sb_str_split("", ':', 1); assert_null(strv[0]); - b_strv_free(strv); - assert_null(b_str_split(NULL, ':', 0)); + sb_strv_free(strv); + assert_null(sb_str_split(NULL, ':', 0)); } static void test_str_replace(void **state) { - char *str = b_str_replace("bolao", 'o', "zaz"); + char *str = sb_str_replace("bolao", 'o', "zaz"); assert_string_equal(str, "bzazlazaz"); free(str); - str = b_str_replace("bolao", 'b', "zaz"); + str = sb_str_replace("bolao", 'b', "zaz"); assert_string_equal(str, "zazolao"); free(str); + str = sb_str_replace("bolao", 'b', NULL); + assert_string_equal(str, "bolao"); + free(str); + assert_null(sb_str_replace(NULL, 'b', "zaz")); } static void test_strv_join(void **state) { - const char *pieces[] = {"guda","bola", "chunda", NULL}; - char *str = b_strv_join(pieces, ":"); + char *pieces[] = {"guda","bola", "chunda", NULL}; + char *str = sb_strv_join(pieces, ":"); assert_string_equal(str, "guda:bola:chunda"); free(str); - const char *pieces2[] = {NULL}; - str = b_strv_join(pieces2, ":"); + char *pieces2[] = {NULL}; + str = sb_strv_join(pieces2, ":"); assert_string_equal(str, ""); free(str); - assert_null(b_strv_join(NULL, ":")); + assert_null(sb_strv_join(pieces, NULL)); + assert_null(sb_strv_join(NULL, ":")); + assert_null(sb_strv_join(NULL, NULL)); } @@ -250,68 +277,88 @@ static void test_strv_length(void **state) { char *pieces[] = {"guda","bola", "chunda", NULL}; - assert_int_equal(b_strv_length(pieces), 3); + assert_int_equal(sb_strv_length(pieces), 3); char *pieces2[] = {NULL}; - assert_int_equal(b_strv_length(pieces2), 0); - assert_int_equal(b_strv_length(NULL), 0); + assert_int_equal(sb_strv_length(pieces2), 0); + assert_int_equal(sb_strv_length(NULL), 0); } static void test_string_new(void **state) { - b_string_t *str = b_string_new(); + sb_string_t *str = sb_string_new(); assert_non_null(str); assert_string_equal(str->str, ""); assert_int_equal(str->len, 0); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); } static void test_string_free(void **state) { - b_string_t *str = b_string_new(); + sb_string_t *str = sb_string_new(); free(str->str); - str->str = b_strdup("bola"); + str->str = sb_strdup("bola"); str->len = 4; - str->allocated_len = B_STRING_CHUNK_SIZE; - char *tmp = b_string_free(str, false); + str->allocated_len = SB_STRING_CHUNK_SIZE; + char *tmp = sb_string_free(str, false); assert_string_equal(tmp, "bola"); free(tmp); + assert_null(sb_string_free(NULL, false)); +} + + +static void +test_string_dup(void **state) +{ + sb_string_t *str = sb_string_new(); + free(str->str); + str->str = sb_strdup("bola"); + str->len = 4; + str->allocated_len = SB_STRING_CHUNK_SIZE; + sb_string_t *new = sb_string_dup(str); + assert_non_null(new); + assert_string_equal(new->str, "bola"); + assert_int_equal(new->len, 4); + assert_int_equal(new->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(new, true)); + assert_null(sb_string_free(str, true)); + assert_null(sb_string_dup(NULL)); } static void test_string_append_len(void **state) { - b_string_t *str = b_string_new(); - str = b_string_append_len(str, "guda", 4); + sb_string_t *str = sb_string_new(); + str = sb_string_append_len(str, "guda", 4); assert_non_null(str); assert_string_equal(str->str, "guda"); assert_int_equal(str->len, 4); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); - str = b_string_new(); - str = b_string_append_len(str, "guda", 4); - str = b_string_append_len(str, "bola", 4); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append_len(str, "guda", 4); + str = sb_string_append_len(str, "bola", 4); assert_non_null(str); assert_string_equal(str->str, "gudabola"); assert_int_equal(str->len, 8); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); - str = b_string_new(); - str = b_string_append_len(str, "guda", 3); - str = b_string_append_len(str, "bola", 4); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append_len(str, "guda", 3); + str = sb_string_append_len(str, "bola", 4); assert_non_null(str); assert_string_equal(str->str, "gudbola"); assert_int_equal(str->len, 7); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); - str = b_string_new(); - str = b_string_append_len(str, "guda", 4); - str = b_string_append_len(str, + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append_len(str, "guda", 4); + str = sb_string_append_len(str, "cwlwmwxxmvjnwtidmjehzdeexbxjnjowruxjrqpgpfhmvwgqeacdjissntmbtsjidzkcw" "nnqhxhneolbwqlctcxmrsutolrjikpavxombpfpjyaqltgvzrjidotalcuwrwxtaxjiwa" "xfhfyzymtffusoqywaruxpybwggukltspqqmghzpqstvcvlqbkhquihzndnrvkaqvevaz" @@ -321,8 +368,8 @@ test_string_append_len(void **state) "dxntikgoqlidfnmdhxzevqzlzubvyleeksdirmmttqthhkvfjggznpmarcamacpvwsrnr" "ftzfeyasjpxoevyptpdnqokswiondusnuymqwaryrmdgscbnuilxtypuynckancsfnwtg" "okxhegoifakimxbbafkeannglvsxprqzfekdinssqymtfexf", 600); - str = b_string_append_len(str, NULL, 0); - str = b_string_append_len(str, + str = sb_string_append_len(str, NULL, 0); + str = sb_string_append_len(str, "cwlwmwxxmvjnwtidmjehzdeexbxjnjowruxjrqpgpfhmvwgqeacdjissntmbtsjidzkcw" "nnqhxhneolbwqlctcxmrsutolrjikpavxombpfpjyaqltgvzrjidotalcuwrwxtaxjiwa" "xfhfyzymtffusoqywaruxpybwggukltspqqmghzpqstvcvlqbkhquihzndnrvkaqvevaz" @@ -353,32 +400,40 @@ test_string_append_len(void **state) "pdnqokswiondusnuymqwaryrmdgscbnuilxtypuynckancsfnwtgokxhegoifakimxbba" "fkeannglvsxprqzfekdinssqymtfexf"); assert_int_equal(str->len, 1204); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE * 10); - assert_null(b_string_free(str, true)); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE * 10); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append_len(str, NULL, 0); + assert_non_null(str); + assert_string_equal(str->str, ""); + assert_int_equal(str->len, 0); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + assert_null(sb_string_append_len(NULL, "foo", 3)); } static void test_string_append(void **state) { - b_string_t *str = b_string_new(); - str = b_string_append(str, "guda"); + sb_string_t *str = sb_string_new(); + str = sb_string_append(str, "guda"); assert_non_null(str); assert_string_equal(str->str, "guda"); assert_int_equal(str->len, 4); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); - str = b_string_new(); - str = b_string_append(str, "guda"); - str = b_string_append(str, "bola"); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append(str, "guda"); + str = sb_string_append(str, "bola"); assert_non_null(str); assert_string_equal(str->str, "gudabola"); assert_int_equal(str->len, 8); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); - str = b_string_new(); - str = b_string_append(str, "guda"); - str = b_string_append(str, + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append(str, "guda"); + str = sb_string_append(str, "cwlwmwxxmvjnwtidmjehzdeexbxjnjowruxjrqpgpfhmvwgqeacdjissntmbtsjidzkcw" "nnqhxhneolbwqlctcxmrsutolrjikpavxombpfpjyaqltgvzrjidotalcuwrwxtaxjiwa" "xfhfyzymtffusoqywaruxpybwggukltspqqmghzpqstvcvlqbkhquihzndnrvkaqvevaz" @@ -388,8 +443,8 @@ test_string_append(void **state) "dxntikgoqlidfnmdhxzevqzlzubvyleeksdirmmttqthhkvfjggznpmarcamacpvwsrnr" "ftzfeyasjpxoevyptpdnqokswiondusnuymqwaryrmdgscbnuilxtypuynckancsfnwtg" "okxhegoifakimxbbafkeannglvsxprqzfekdinssqymtfexf"); - str = b_string_append(str, NULL); - str = b_string_append(str, + str = sb_string_append(str, NULL); + str = sb_string_append(str, "cwlwmwxxmvjnwtidmjehzdeexbxjnjowruxjrqpgpfhmvwgqeacdjissntmbtsjidzkcw" "nnqhxhneolbwqlctcxmrsutolrjikpavxombpfpjyaqltgvzrjidotalcuwrwxtaxjiwa" "xfhfyzymtffusoqywaruxpybwggukltspqqmghzpqstvcvlqbkhquihzndnrvkaqvevaz" @@ -420,18 +475,27 @@ test_string_append(void **state) "pdnqokswiondusnuymqwaryrmdgscbnuilxtypuynckancsfnwtgokxhegoifakimxbba" "fkeannglvsxprqzfekdinssqymtfexf"); assert_int_equal(str->len, 1204); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE * 10); - assert_null(b_string_free(str, true)); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE * 10); + assert_null(sb_string_free(str, true)); + str = sb_string_new(); + str = sb_string_append(str, NULL); + assert_non_null(str); + assert_string_equal(str->str, ""); + assert_int_equal(str->len, 0); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + assert_null(sb_string_append(NULL, "asd")); + assert_null(sb_string_append(NULL, NULL)); } static void test_string_append_c(void **state) { - b_string_t *str = b_string_new(); - str = b_string_append_len(str, "guda", 4); + sb_string_t *str = sb_string_new(); + str = sb_string_append_len(str, "guda", 4); for (int i = 0; i < 600; i++) - str = b_string_append_c(str, 'c'); + str = sb_string_append_c(str, 'c'); assert_non_null(str); assert_string_equal(str->str, "gudaccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" @@ -444,41 +508,43 @@ test_string_append_c(void **state) "ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc" "cccccccccccccccccccccccccccccccccccccccccccccccccccc"); assert_int_equal(str->len, 604); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE * 5); - assert_null(b_string_free(str, true)); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE * 5); + assert_null(sb_string_free(str, true)); + assert_null(sb_string_append_c(NULL, 0)); } static void test_string_append_printf(void **state) { - b_string_t *str = b_string_new(); - str = b_string_append_printf(str, "guda: %s %d", "bola", 1); + sb_string_t *str = sb_string_new(); + str = sb_string_append_printf(str, "guda: %s %d", "bola", 1); assert_non_null(str); assert_string_equal(str->str, "guda: bola 1"); assert_int_equal(str->len, 12); - assert_int_equal(str->allocated_len, B_STRING_CHUNK_SIZE); - assert_null(b_string_free(str, true)); + assert_int_equal(str->allocated_len, SB_STRING_CHUNK_SIZE); + assert_null(sb_string_free(str, true)); + assert_null(sb_string_append_printf(NULL, "asd")); } static void test_trie_new(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); assert_non_null(trie); assert_null(trie->root); assert_true(trie->free_func == free); - b_trie_free(trie); + sb_trie_free(trie); } static void test_trie_insert(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); - b_trie_insert(trie, "bola", b_strdup("guda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -491,7 +557,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->child->child->child->child->data, "guda"); - b_trie_insert(trie, "chu", b_strdup("nda")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -513,7 +579,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->next->child->child->child->data, "nda"); - b_trie_insert(trie, "bote", b_strdup("aba")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -542,7 +608,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->child->child->next->child->child->data, "aba"); - b_trie_insert(trie, "bo", b_strdup("haha")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -573,12 +639,12 @@ test_trie_insert(void **state) assert_true(trie->root->child->child->next->next->key == '\0'); assert_string_equal(trie->root->child->child->next->next->data, "haha"); - b_trie_free(trie); + sb_trie_free(trie); - trie = b_trie_new(free); + trie = sb_trie_new(free); - b_trie_insert(trie, "chu", b_strdup("nda")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); assert_true(trie->root->key == 'c'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'h'); @@ -589,7 +655,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->child->child->child->data, "nda"); - b_trie_insert(trie, "bola", b_strdup("guda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); assert_true(trie->root->key == 'c'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'h'); @@ -611,7 +677,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->next->child->child->child->child->data, "guda"); - b_trie_insert(trie, "bote", b_strdup("aba")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); assert_true(trie->root->key == 'c'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'h'); @@ -640,7 +706,7 @@ test_trie_insert(void **state) assert_string_equal(trie->root->next->child->child->next->child->child->data, "aba"); - b_trie_insert(trie, "bo", b_strdup("haha")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); assert_true(trie->root->key == 'c'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'h'); @@ -671,16 +737,16 @@ test_trie_insert(void **state) assert_true(trie->root->next->child->child->next->next->key == '\0'); assert_string_equal(trie->root->next->child->child->next->next->data, "haha"); - b_trie_free(trie); + sb_trie_free(trie); } static void test_trie_insert_duplicated(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); - b_trie_insert(trie, "bola", b_strdup("guda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -692,7 +758,7 @@ test_trie_insert_duplicated(void **state) assert_true(trie->root->child->child->child->child->key == '\0'); assert_string_equal(trie->root->child->child->child->child->data, "guda"); - b_trie_insert(trie, "bola", b_strdup("asdf")); + sb_trie_insert(trie, "bola", sb_strdup("asdf")); assert_true(trie->root->key == 'b'); assert_null(trie->root->data); assert_true(trie->root->child->key == 'o'); @@ -704,26 +770,30 @@ test_trie_insert_duplicated(void **state) assert_true(trie->root->child->child->child->child->key == '\0'); assert_string_equal(trie->root->child->child->child->child->data, "asdf"); - b_trie_free(trie); + sb_trie_free(trie); + + trie = NULL; + sb_trie_insert(trie, "bola", NULL); + assert_null(trie); } static void test_trie_keep_data(void **state) { - b_trie_t *trie = b_trie_new(NULL); + sb_trie_t *trie = sb_trie_new(NULL); char *t1 = "guda"; char *t2 = "nda"; char *t3 = "aba"; char *t4 = "haha"; - b_trie_insert(trie, "bola", t1); - b_trie_insert(trie, "chu", t2); - b_trie_insert(trie, "bote", t3); - b_trie_insert(trie, "bo", t4); + sb_trie_insert(trie, "bola", t1); + sb_trie_insert(trie, "chu", t2); + sb_trie_insert(trie, "bote", t3); + sb_trie_insert(trie, "bo", t4); - b_trie_free(trie); + sb_trie_free(trie); assert_string_equal(t1, "guda"); assert_string_equal(t2, "nda"); @@ -735,72 +805,74 @@ test_trie_keep_data(void **state) static void test_trie_lookup(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); + + sb_trie_insert(trie, "bola", sb_strdup("guda")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); - b_trie_insert(trie, "bola", b_strdup("guda")); - b_trie_insert(trie, "chu", b_strdup("nda")); - b_trie_insert(trie, "bote", b_strdup("aba")); - b_trie_insert(trie, "bo", b_strdup("haha")); + assert_string_equal(sb_trie_lookup(trie, "bola"), "guda"); + assert_string_equal(sb_trie_lookup(trie, "chu"), "nda"); + assert_string_equal(sb_trie_lookup(trie, "bote"), "aba"); + assert_string_equal(sb_trie_lookup(trie, "bo"), "haha"); - assert_string_equal(b_trie_lookup(trie, "bola"), "guda"); - assert_string_equal(b_trie_lookup(trie, "chu"), "nda"); - assert_string_equal(b_trie_lookup(trie, "bote"), "aba"); - assert_string_equal(b_trie_lookup(trie, "bo"), "haha"); + assert_null(sb_trie_lookup(trie, "arcoiro")); - assert_null(b_trie_lookup(trie, "arcoiro")); + sb_trie_free(trie); - b_trie_free(trie); + trie = sb_trie_new(free); - trie = b_trie_new(free); + sb_trie_insert(trie, "chu", sb_strdup("nda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); + sb_trie_insert(trie, "copa", sb_strdup("bu")); + sb_trie_insert(trie, "b", sb_strdup("c")); + sb_trie_insert(trie, "test", sb_strdup("asd")); - b_trie_insert(trie, "chu", b_strdup("nda")); - b_trie_insert(trie, "bola", b_strdup("guda")); - b_trie_insert(trie, "bote", b_strdup("aba")); - b_trie_insert(trie, "bo", b_strdup("haha")); - b_trie_insert(trie, "copa", b_strdup("bu")); - b_trie_insert(trie, "b", b_strdup("c")); - b_trie_insert(trie, "test", b_strdup("asd")); + assert_string_equal(sb_trie_lookup(trie, "bola"), "guda"); + assert_string_equal(sb_trie_lookup(trie, "chu"), "nda"); + assert_string_equal(sb_trie_lookup(trie, "bote"), "aba"); + assert_string_equal(sb_trie_lookup(trie, "bo"), "haha"); - assert_string_equal(b_trie_lookup(trie, "bola"), "guda"); - assert_string_equal(b_trie_lookup(trie, "chu"), "nda"); - assert_string_equal(b_trie_lookup(trie, "bote"), "aba"); - assert_string_equal(b_trie_lookup(trie, "bo"), "haha"); + assert_null(sb_trie_lookup(trie, "arcoiro")); - assert_null(b_trie_lookup(trie, "arcoiro")); + sb_trie_free(trie); - b_trie_free(trie); + assert_null(sb_trie_lookup(NULL, "bola")); } static void test_trie_size(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); - b_trie_insert(trie, "bola", b_strdup("guda")); - b_trie_insert(trie, "chu", b_strdup("nda")); - b_trie_insert(trie, "bote", b_strdup("aba")); - b_trie_insert(trie, "bo", b_strdup("haha")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); - assert_int_equal(b_trie_size(trie), 4); - assert_int_equal(b_trie_size(NULL), 0); + assert_int_equal(sb_trie_size(trie), 4); + assert_int_equal(sb_trie_size(NULL), 0); - b_trie_free(trie); + sb_trie_free(trie); - trie = b_trie_new(free); + trie = sb_trie_new(free); - b_trie_insert(trie, "chu", b_strdup("nda")); - b_trie_insert(trie, "bola", b_strdup("guda")); - b_trie_insert(trie, "bote", b_strdup("aba")); - b_trie_insert(trie, "bo", b_strdup("haha")); - b_trie_insert(trie, "copa", b_strdup("bu")); - b_trie_insert(trie, "b", b_strdup("c")); - b_trie_insert(trie, "test", b_strdup("asd")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); + sb_trie_insert(trie, "copa", sb_strdup("bu")); + sb_trie_insert(trie, "b", sb_strdup("c")); + sb_trie_insert(trie, "test", sb_strdup("asd")); - assert_int_equal(b_trie_size(trie), 7); - assert_int_equal(b_trie_size(NULL), 0); + assert_int_equal(sb_trie_size(trie), 7); + assert_int_equal(sb_trie_size(NULL), 0); - b_trie_free(trie); + sb_trie_free(trie); } @@ -809,8 +881,9 @@ static char *expected_keys[] = {"chu", "copa", "bola", "bote", "bo", "b", "test" static char *expected_datas[] = {"nda", "bu", "guda", "aba", "haha", "c", "asd"}; static void -mock_foreach(const char *key, void *data) +mock_foreach(const char *key, void *data, void *user_data) { + assert_string_equal(user_data, "foo"); assert_string_equal(key, expected_keys[counter]); assert_string_equal((char*) data, expected_datas[counter++]); } @@ -819,20 +892,23 @@ mock_foreach(const char *key, void *data) static void test_trie_foreach(void **state) { - b_trie_t *trie = b_trie_new(free); + sb_trie_t *trie = sb_trie_new(free); - b_trie_insert(trie, "chu", b_strdup("nda")); - b_trie_insert(trie, "bola", b_strdup("guda")); - b_trie_insert(trie, "bote", b_strdup("aba")); - b_trie_insert(trie, "bo", b_strdup("haha")); - b_trie_insert(trie, "copa", b_strdup("bu")); - b_trie_insert(trie, "b", b_strdup("c")); - b_trie_insert(trie, "test", b_strdup("asd")); + sb_trie_insert(trie, "chu", sb_strdup("nda")); + sb_trie_insert(trie, "bola", sb_strdup("guda")); + sb_trie_insert(trie, "bote", sb_strdup("aba")); + sb_trie_insert(trie, "bo", sb_strdup("haha")); + sb_trie_insert(trie, "copa", sb_strdup("bu")); + sb_trie_insert(trie, "b", sb_strdup("c")); + sb_trie_insert(trie, "test", sb_strdup("asd")); counter = 0; - b_trie_foreach(trie, mock_foreach); + sb_trie_foreach(trie, mock_foreach, "foo"); + sb_trie_foreach(NULL, mock_foreach, "foo"); + sb_trie_foreach(trie, NULL, "foo"); + sb_trie_foreach(NULL, NULL, "foo"); - b_trie_free(trie); + sb_trie_free(trie); } @@ -843,10 +919,11 @@ main(void) // slist unit_test(test_slist_append), + unit_test(test_slist_prepend), unit_test(test_slist_free), unit_test(test_slist_length), - // strings + // strfuncs unit_test(test_strdup), unit_test(test_strndup), unit_test(test_strdup_printf), @@ -859,8 +936,11 @@ main(void) unit_test(test_str_replace), unit_test(test_strv_join), unit_test(test_strv_length), + + // string unit_test(test_string_new), unit_test(test_string_free), + unit_test(test_string_dup), unit_test(test_string_append_len), unit_test(test_string_append), unit_test(test_string_append_c), |