fix: find-in-text returning a string instead of a zip-loc

[Mertzenich]

Find in Text Selector Return Value

This pull request aims to fix #83, caused due to the find-in-text selector
returning a string rather than a zip-loc as expected. I have also added
a test assertion which checks for the expected functionality.

Problem Description

When using the find-in-text selector in the last position of a child
selector no result will be found. Expected behavior is restored when you
wrap find-in-text with the and selector. Here is an example of the
problem:

(require '[hickory.core :as h]
         '[hickory.select :as s])

(def html "<div><span>Apocalypse</span></div>")

(def htree (-> html
               h/parse
               h/as-hickory))

(s/select
 (s/child (s/tag :div)
          (s/find-in-text #"Apocalypse"))
 htree)
;; Expected Result => [{:type :element
;;                      :attrs nil
;;                      :tag :span
;;                      :content ["Apocalypse"]}]
;; Actual Result   => []

(s/select
 (s/child (s/tag :div)
          ;; Wrapping `find-in-text` in `and`
          (s/and (s/find-in-text #"Apocalypse")))
 htree)
;; We get the expected result:
;; => [{:type :element
;;      :attrs nil
;;      :tag :span
;;      :content ["Apocalypse"]}]

Solution

The current version of find-in-text is supposed to return a function that takes
a zip-loc and returns a zip-loc if the node contains a text block matching a
provided regular expression. The current body of the function is as follows (minor
readability changes):

(defn find-in-text
  [re]
  (fn [hzip-loc]
    (some #(re-find re %)
          (->> (zip/node hzip-loc)
               :content
               (filter string?)))))

The issue is in the return value of the returned function. Running
(some #(re-find re %) ...) will return the first string matching the regex
rather than the zip-loc. For example:

(some #(re-find #"Luke" %)
      ["Matthew" "Mark" "Luke" "John"])
;; => "Luke"

The solution was quite simple: instead of returning the result of (some ...) we
check whether the result returned anything and if it did we then can return the
provided zip-loc. The result is as follows:

(defn find-in-text
  [re]
  (fn [hzip-loc]
    (when (some #(re-find re %)
                (->> (zip/node hzip-loc)
                     :content
                     (filter string?)))
      hzip-loc)))