Merge lp:~mhr3/unity/home-lens-ordering into lp:unity

[Michal Hruby]

Implement new ordering of categories for home lens

Implement new ordering of categories as requested by design (categories with the highest amount of personal content matches are on top, followed by categories without personal content [also sorted by number of matches]; plus apps are on top if they contain exact match or if they're binary name contains exact match).

[Paweł Stołowski (stolowski)]

The code looks good, looking forward for a test as agreed on IRC.

[Paweł Stołowski (stolowski)]

Looks good, tests pass. Minor comments:

498 + std::string key_name(key);
Can we get rid of an extra string copy here? I think it would be ok to use glib string comparison.

224 + std::string lens_id(categories_merger_.GetLensIdForCategory(order_vector.at(i)));
Make it const.

review: Needs Fixing

[Paweł Stołowski (stolowski)]

Cool!

review: Approve

=== modified file 'UnityCore/HomeLens.cpp'
--- UnityCore/HomeLens.cpp	2012-08-29 09:46:21 +0000
+++ UnityCore/HomeLens.cpp	2012-08-31 14:43:22 +0000
@@ -15,14 +15,17 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  * Authored by: Mikkel Kamstrup Erlandsen <[e-mail]>
+ *              Michal Hruby <[e-mail]>
  */
 
 #include <glib.h>
+#include <dee-icu.h>
 #include <string>
 #include <stdexcept>
 #include <map>
 #include <set>
 #include <utility>
+#include <algorithm>
 
 #include "GLibSignal.h"
 #include "HomeLens.h"
@@ -44,6 +47,8 @@
 const gchar* const HOMELENS_PRIORITY = "unity-homelens-priority";
 const gchar* const HOMELENS_RESULTS_MODEL = "unity-homelens-results-model";
 
+const unsigned RESULTS_NAME_COLUMN = 4;
+const unsigned RESULTS_COMMENT_COLUMN = 5;
 }
 
 /*
@@ -241,6 +246,9 @@
   void OnSourceRowRemoved(DeeModel* model, DeeModelIter* iter);
 
   std::vector<unsigned> GetDefaultOrder();
+  std::string GetLensIdForCategory(unsigned) const;
+  std::map<unsigned, Lens::Ptr> const& GetCategoryToLensMap() const;
+  MergeMode GetMergeMode() const { return merge_mode_; }
 
 protected:
   void RemoveSource(glib::Object<DeeModel> const& old_source);
@@ -249,6 +257,7 @@
   HomeLens::CategoryRegistry* cat_registry_;
   MergeMode merge_mode_;
   std::multimap<unsigned, unsigned, std::greater<unsigned> > category_ordering_;
+  std::map<unsigned, Lens::Ptr> category_to_owner_;
 };
 
 /*
@@ -274,12 +283,53 @@
   Impl(HomeLens* owner, MergeMode merge_mode);
   ~Impl();
 
+  struct CategorySorter
+  {
+    CategorySorter(std::map<unsigned, unsigned>& results_per_category,
+                   std::map<unsigned, Lens::Ptr> const& category_owner_map)
+      : results_per_category_(results_per_category)
+      , category_to_owner_(category_owner_map)
+    {}
+
+    bool operator() (unsigned cat_a, unsigned cat_b)
+    {
+      bool a_has_personal_content = false;
+      bool b_has_personal_content = false;
+
+      auto it = category_to_owner_.find(cat_a);
+      if (it != category_to_owner_.end() && it->second)
+      {
+        a_has_personal_content = it->second->provides_personal_content();
+      }
+      it = category_to_owner_.find(cat_b);
+      if (it != category_to_owner_.end() && it->second)
+      {
+        b_has_personal_content = it->second->provides_personal_content();
+      }
+
+      // prioritize categories that have private content
+      if (a_has_personal_content != b_has_personal_content)
+      {
+        return a_has_personal_content ? true : false;
+      }
+
+      return results_per_category_[cat_a] > results_per_category_[cat_b];
+    }
+
+    private:
+      std::map<unsigned, unsigned>& results_per_category_;
+      std::map<unsigned, Lens::Ptr> const& category_to_owner_;
+  };
+
   void OnLensAdded(Lens::Ptr& lens);
   gsize FindLensPriority (Lens::Ptr& lens);
   void EnsureCategoryAnnotation(Lens::Ptr& lens, DeeModel* results, DeeModel* categories);
   Lens::Ptr FindLensForUri(std::string const& uri);
   std::vector<unsigned> GetCategoriesOrder();
-  void LensSearchFinished(Lens::Ptr& lens);
+  void LensSearchFinished(Lens::Ptr const& lens);
+  bool ResultsContainVisibleMatch(unsigned category);
+
+  std::string const& last_search_string() const { return last_search_string_; }
 
   HomeLens* owner_;
   Lenses::LensList lenses_;
@@ -288,7 +338,11 @@
   HomeLens::CategoryMerger categories_merger_;
   HomeLens::FiltersMerger filters_merger_;
   int running_searches_;
+  bool apps_lens_contains_visible_match;
+  std::string last_search_string_;
   glib::Object<GSettings> settings_;
+  std::vector<unsigned> cached_categories_order_;
+  std::map<unsigned, glib::Object<DeeModel> > category_filter_models_;
 };
 
 /*
@@ -444,15 +498,19 @@
   target_tag = FindSourceToTargetTag(model);
   unsigned source_cat_offset = dee_model_get_position(model, iter);
 
+  Lens::Ptr owner_lens;
+  for (auto it = sources_by_owner_.begin(); it != sources_by_owner_.end(); ++it)
+  {
+    if (it->second == model)
+    {
+      owner_lens = it->first;
+      break;
+    }
+  }
+
   if (merge_mode_ == MergeMode::OWNER_LENS)
   {
-    for (auto it = sources_by_owner_.begin(); it != sources_by_owner_.end(); ++it)
-    {
-      if (it->second == model)
-      {
-        lens_name = it->first->name();
-      }
-    }
+    if (owner_lens) lens_name = owner_lens->name();
     display_name = lens_name.c_str();
   }
   else
@@ -489,6 +547,9 @@
     cat_registry_->RegisterCategoryOffset(results_model, source_cat_offset,
                                           display_name);
 
+  if (owner_lens) category_to_owner_[target_cat_index] = owner_lens;
+
+  // ensure priorities are taken into account, so default order works
   gsize lens_priority = GPOINTER_TO_SIZE(g_object_get_data(
                                    G_OBJECT(model), HOMELENS_PRIORITY));
   unsigned lens_prio = static_cast<unsigned>(lens_priority);
@@ -661,6 +722,23 @@
   return result;
 }
 
+std::string HomeLens::CategoryMerger::GetLensIdForCategory(unsigned cat) const
+{
+  auto lens_it = category_to_owner_.find(cat);
+  if (lens_it != category_to_owner_.end())
+  {
+    if (lens_it->second) return lens_it->second->id();
+  }
+
+  return "";
+}
+
+std::map<unsigned, Lens::Ptr> const&
+HomeLens::CategoryMerger::GetCategoryToLensMap() const
+{
+  return category_to_owner_;
+}
+
 HomeLens::Impl::Impl(HomeLens *owner, MergeMode merge_mode)
   : owner_(owner)
   , cat_registry_(owner)
@@ -668,6 +746,7 @@
   , categories_merger_(owner->categories()->model(), &cat_registry_, merge_mode)
   , filters_merger_(owner->filters()->model())
   , running_searches_(0)
+  , apps_lens_contains_visible_match(false)
   , settings_(g_settings_new("com.canonical.Unity.Dash"))
 {
   DeeModel* results = owner->results()->model();
@@ -782,7 +861,7 @@
 
   /* When we dispatch a search we inc the search count and when we finish
    * one we decrease it. When we reach 0 we'll emit search_finished. */
-  lens->global_search_finished.connect([&] (Hints const& hints) {
+  lens->global_search_finished.connect([this, lens] (Hints const& hints) {
       running_searches_--;
 
       LensSearchFinished(lens);
@@ -852,13 +931,175 @@
   }
 }
 
-void HomeLens::Impl::LensSearchFinished(Lens::Ptr& lens)
-{
+void HomeLens::Impl::LensSearchFinished(Lens::Ptr const& lens)
+{
+  auto order_vector = categories_merger_.GetDefaultOrder();
+
+  // get number of results per category
+  std::map<unsigned, unsigned> results_per_cat;
+  for (unsigned i = 0; i < order_vector.size(); i++)
+  {
+    unsigned category = order_vector.at(i);
+    auto model = owner_->GetFilterModelForCategory(category);
+    results_per_cat[category] = model ? dee_model_get_n_rows(model) : 0;
+  }
+
+  CategorySorter sorter(results_per_cat,
+                        categories_merger_.GetCategoryToLensMap());
+  // stable sort based on number of results in each cat
+  std::stable_sort(order_vector.begin(), order_vector.end(), sorter);
+
+  // ensure shopping is second, need map[cat] = lens
+  int shopping_index = -1;
+  int apps_index = -1;
+  for (unsigned i = 0; i < order_vector.size(); i++)
+  {
+    // get lens that owns this category
+    std::string const& lens_id(categories_merger_.GetLensIdForCategory(order_vector.at(i)));
+    if (lens_id == "shopping.lens")
+      shopping_index = i;
+    else if (lens_id == "applications.lens")
+      apps_index = i;
+  }
+
+  if (lens->id() == "applications.lens")
+  {
+    // checking the results isn't extermely fast, so cache the result
+    apps_lens_contains_visible_match = ResultsContainVisibleMatch(order_vector[apps_index]);
+  }
+
+  // if there are no results in the apps category, we can't reorder,
+  // otherwise shopping won't end up being 2nd
+  if (apps_lens_contains_visible_match && apps_index > 0 && 
+      results_per_cat[order_vector[apps_index]] > 0)
+  {
+    // we want apps first
+    unsigned apps_cat_num = order_vector.at(apps_index);
+    order_vector.erase(order_vector.begin() + apps_index);
+    order_vector.insert(order_vector.begin(), apps_cat_num);
+
+    // we might shift the shopping index
+    if (shopping_index >= 0 && shopping_index < apps_index) shopping_index++;
+  }
+
+  if (shopping_index >= 0 && shopping_index != 2)
+  {
+    unsigned shopping_cat_num = order_vector.at(shopping_index);
+    order_vector.erase(order_vector.begin() + shopping_index);
+    order_vector.insert(order_vector.begin() + 2, shopping_cat_num);
+  }
+
+  if (cached_categories_order_ != order_vector)
+  {
+    cached_categories_order_ = order_vector;
+    owner_->categories_reordered();
+  }
+}
+
+bool HomeLens::Impl::ResultsContainVisibleMatch(unsigned category)
+{
+  // this method searches for match of the search string in the display name
+  // or comment fields
+  auto filter_model = owner_->GetFilterModelForCategory(category);
+  if (!filter_model) return false;
+  if (last_search_string_.empty()) return true;
+
+  int checked_results = 5;
+
+  glib::Object<DeeModel> model(dee_sequence_model_new());
+  dee_model_set_schema(model, "s", "s", NULL);
+
+  DeeModelIter* iter = dee_model_get_first_iter(filter_model);
+  DeeModelIter* end_iter = dee_model_get_last_iter(filter_model);
+
+  // add first few results to the temporary model
+  while (iter != end_iter)
+  {
+    glib::Variant name(dee_model_get_value(filter_model, iter, RESULTS_NAME_COLUMN),
+                       glib::StealRef());
+    glib::Variant comment(dee_model_get_value(filter_model, iter, RESULTS_COMMENT_COLUMN),
+                          glib::StealRef());
+    GVariant* members[2] = { name, comment };
+    dee_model_append_row(model, members);
+
+    iter = dee_model_next(filter_model, iter);
+    if (--checked_results <= 0) break;
+  }
+
+  if (dee_model_get_n_rows(model) == 0) return false;
+
+  // setup model reader, analyzer and instantiate an index
+  DeeModelReader reader;
+  dee_model_reader_new([] (DeeModel* m, DeeModelIter* iter, gpointer data) -> gchar*
+    {
+      return g_strdup_printf("%s\n%s",
+        dee_model_get_string(m, iter, 0),
+        dee_model_get_string(m, iter, 1));
+    }, NULL, NULL, &reader);
+  glib::Object<DeeAnalyzer> analyzer(DEE_ANALYZER(dee_text_analyzer_new()));
+  dee_analyzer_add_term_filter(analyzer,
+                               [] (DeeTermList* terms_in, DeeTermList* terms_out, gpointer data) -> void
+                               {
+                                 auto filter = static_cast<DeeICUTermFilter*>(data);
+                                 for (unsigned i = 0; i < dee_term_list_num_terms(terms_in); i++)
+                                 {
+                                   dee_term_list_add_term(terms_out, dee_icu_term_filter_apply(filter, dee_term_list_get_term(terms_in, i)));
+                                 }
+                               },
+                               dee_icu_term_filter_new_ascii_folder(),
+                               (GDestroyNotify)dee_icu_term_filter_destroy);
+  // ready to instantiate the index
+  glib::Object<DeeIndex> index(DEE_INDEX(dee_tree_index_new(model, analyzer, &reader)));
+
+  // tokenize the search string, so this will work with multiple words
+  glib::Object<DeeTermList> search_terms(DEE_TERM_LIST(g_object_new(DEE_TYPE_TERM_LIST, NULL)));
+  dee_analyzer_tokenize(analyzer, last_search_string_.c_str(), search_terms);
+
+  std::set<DeeModelIter*> iters;
+  for (unsigned i = 0; i < dee_term_list_num_terms(search_terms); i++)
+  {
+    glib::Object<DeeResultSet> results(dee_index_lookup(index, dee_term_list_get_term(search_terms, i), DEE_TERM_MATCH_PREFIX));
+    if (i == 0)
+    {
+      while (dee_result_set_has_next(results))
+      {
+        iters.insert(dee_result_set_next(results));
+      }
+    }
+    else
+    {
+      std::set<DeeModelIter*> iters2;
+      while (dee_result_set_has_next(results))
+      {
+        iters2.insert(dee_result_set_next(results));
+      }
+      // intersect the sets, set iterators are stable, so we can do this
+      auto it = iters.begin();
+      while (it != iters.end())
+      {
+        if (iters2.find(*it) == iters2.end())
+          iters.erase(it++);
+        else
+          ++it;
+      }
+      // no need to check more terms if the base set is already empty
+      if (iters.empty()) break;
+    }
+  }
+
+  // there is a match if the iterator is isn't empty
+  return !iters.empty();
 }
 
 std::vector<unsigned> HomeLens::Impl::GetCategoriesOrder()
 {
-  return categories_merger_.GetDefaultOrder();
+  auto default_order = categories_merger_.GetDefaultOrder();
+  if (!last_search_string_.empty() &&
+      cached_categories_order_.size() == default_order.size())
+  {
+    return cached_categories_order_;
+  }
+  return default_order;
 }
 
 HomeLens::HomeLens(std::string const& name,
@@ -871,6 +1112,9 @@
   , pimpl(new Impl(this, merge_mode))
 {
   count.SetGetterFunction(sigc::mem_fun(&pimpl->lenses_, &Lenses::LensList::size));
+  last_search_string.SetGetterFunction(sigc::mem_fun(pimpl, &HomeLens::Impl::last_search_string));
+  last_global_search_string.SetGetterFunction(sigc::mem_fun(pimpl, &HomeLens::Impl::last_search_string));
+
   search_in_global = false;
 }
 
@@ -933,6 +1177,8 @@
 
   /* Reset running search counter */
   pimpl->running_searches_ = 0;
+  pimpl->last_search_string_ = search_string;
+  pimpl->apps_lens_contains_visible_match = false;
 
   for (auto lens: pimpl->lenses_)
   {
@@ -985,5 +1231,15 @@
   return pimpl->GetCategoriesOrder();
 }
 
+glib::Object<DeeModel> HomeLens::GetFilterModelForCategory(unsigned category)
+{
+  auto it = pimpl->category_filter_models_.find(category);
+  if (it != pimpl->category_filter_models_.end()) return it->second;
+
+  auto model = Lens::GetFilterModelForCategory(category);
+  pimpl->category_filter_models_[category] = model;
+  return model;
+}
+
 }
 }

=== modified file 'UnityCore/HomeLens.h'
--- UnityCore/HomeLens.h	2012-08-16 14:41:23 +0000
+++ UnityCore/HomeLens.h	2012-08-31 14:43:22 +0000
@@ -75,6 +75,7 @@
   void Preview(std::string const& uri);
 
   std::vector<unsigned> GetCategoriesOrder();
+  glib::Object<DeeModel> GetFilterModelForCategory(unsigned category);
 
 private:
   class Impl;

=== modified file 'UnityCore/Lens.cpp'
--- UnityCore/Lens.cpp	2012-08-28 14:34:19 +0000
+++ UnityCore/Lens.cpp	2012-08-31 14:43:22 +0000
@@ -79,7 +79,8 @@
                         string const& results_model_name,
                         string const& global_results_model_name,
                         string const& categories_model_name,
-                        string const& filters_model_name);
+                        string const& filters_model_name,
+                        GVariantIter* hints_iter);
   void OnViewTypeChanged(ViewType view_type);
 
   void GlobalSearch(std::string const& search_string);
@@ -112,6 +113,7 @@
   Categories::Ptr const& categories() const;
   Filters::Ptr const& filters() const;
   bool connected() const;
+  bool provides_personal_content() const;
 
   string const& last_search_string() const { return last_search_string_; }
   string const& last_global_search_string() const { return last_global_search_string_; }
@@ -133,6 +135,7 @@
   Categories::Ptr categories_;
   Filters::Ptr filters_;
   bool connected_;
+  bool provides_personal_content_;
 
   string private_connection_name_;
   string last_search_string_;
@@ -174,6 +177,7 @@
   , categories_(new Categories(model_type))
   , filters_(new Filters(model_type))
   , connected_(false)
+  , provides_personal_content_(false)
   , proxy_(NULL)
 {
   if (model_type == ModelType::REMOTE)
@@ -206,6 +210,7 @@
   owner_->categories.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::categories));
   owner_->filters.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::filters));
   owner_->connected.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::connected));
+  owner_->provides_personal_content.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::provides_personal_content));
   owner_->last_search_string.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::last_search_string));
   owner_->last_global_search_string.SetGetterFunction(sigc::mem_fun(this, &Lens::Impl::last_global_search_string));
   owner_->view_type.changed.connect(sigc::mem_fun(this, &Lens::Impl::OnViewTypeChanged));
@@ -389,7 +394,8 @@
                      results_model_swarm_name,
                      global_results_model_swarm_name,
                      categories_model_swarm_name,
-                     filters_model_swarm_name);
+                     filters_model_swarm_name,
+                     hints_iter);
 
     if (models_changed) owner_->models_changed.emit();
   }
@@ -414,7 +420,8 @@
                                   string const& results_model_name,
                                   string const& global_results_model_name,
                                   string const& categories_model_name,
-                                  string const& filters_model_name)
+                                  string const& filters_model_name,
+                                  GVariantIter* hints_iter)
 {
   // Diff the properties received from those we have
   if (search_hint_ != search_hint)
@@ -435,6 +442,26 @@
     owner_->visible.EmitChanged(visible_);
   }
 
+  bool provides_personal_content = false;
+  gchar* key;
+  GVariant* value;
+
+  // g_variant_iter_loop manages the memory automatically, as long
+  // as the iteration is not stopped in the middle
+  while (g_variant_iter_loop(hints_iter, "{sv}", &key, &value))
+  {
+    if (g_strcmp0(key, "provides-personal-content") == 0)
+    {
+      provides_personal_content = g_variant_get_boolean(value) != FALSE;
+    }
+  }
+
+  if (provides_personal_content_ != provides_personal_content)
+  {
+    provides_personal_content_ = provides_personal_content;
+    owner_->provides_personal_content.EmitChanged(provides_personal_content_);
+  }
+
   if (private_connection_name_ != private_connection_name)
   {
     // FIXME: Update all the models as they are no longer valid when we use this
@@ -772,6 +799,11 @@
   return connected_;
 }
 
+bool Lens::Impl::provides_personal_content() const
+{
+  return provides_personal_content_;
+}
+
 Lens::Lens(string const& id_,
            string const& dbus_name_,
            string const& dbus_path_,

=== modified file 'UnityCore/Lens.h'
--- UnityCore/Lens.h	2012-08-28 14:34:19 +0000
+++ UnityCore/Lens.h	2012-08-31 14:43:22 +0000
@@ -114,6 +114,7 @@
   nux::RWProperty<Categories::Ptr> categories;
   nux::RWProperty<Filters::Ptr> filters;
   nux::RWProperty<bool> connected;
+  nux::RWProperty<bool> provides_personal_content;
   nux::ROProperty<std::string> last_search_string;
   nux::ROProperty<std::string> last_global_search_string;
 

=== modified file 'tests/test_home_lens.cpp'
--- tests/test_home_lens.cpp	2012-08-16 14:41:23 +0000
+++ tests/test_home_lens.cpp	2012-08-31 14:43:22 +0000
@@ -18,6 +18,7 @@
 #include "test_utils.h"
 
 using namespace std;
+using namespace unity;
 using namespace unity::dash;
 
 namespace
@@ -61,6 +62,7 @@
     : Lens(id, "", "", name, "lens-icon.png",
            description, search_hint, true, "",
            ModelType::LOCAL)
+    , num_results_(-1)
   {
     search_in_global(true);
     connected.SetGetterFunction(sigc::mem_fun(this, &StaticTestLens::force_connected));
@@ -101,28 +103,37 @@
 
     row_buf[1] = g_variant_new_string("");
     row_buf[3] = g_variant_new_string("");
-    row_buf[4] = g_variant_new_string("");
     row_buf[5] = g_variant_new_string("");
     row_buf[6] = g_variant_new_string("");
     row_buf[7] = NULL;
 
     unsigned int i;
-    for (i = 0; i < search_string.size(); i++)
+    unsigned int results_count = search_string.size();
+    if (num_results_ >= 0) results_count = static_cast<unsigned>(num_results_);
+    for (i = 0; i < results_count; i++)
     {
       ostringstream uri;
-      uri << "uri+" << search_string.at(i) << "+" << id();
+      char res_id(i >= search_string.size() ? '-' : search_string.at(i));
+      uri << "uri+" << res_id << "+" << id();
       row_buf[0] = g_variant_new_string(uri.str().c_str());
       row_buf[2] = g_variant_new_uint32(i % 3);
+      glib::String name(g_strdup_printf("%s - %d",
+            results_base_name_.empty() ?
+                search_string.c_str() : results_base_name_.c_str(),
+            i));
+      row_buf[4] = g_variant_new_string(name);
 
       dee_model_append_row(model, row_buf);
     }
 
     g_free(row_buf);
+
+    global_search_finished.emit(Hints());
   }
 
   void GlobalSearch(string const& search_string)
   {
-    /* Dispatch search async, because that's */
+    /* Dispatch search async, because that's what it'd normally do */
     LensSearchClosure* closure = g_new0(LensSearchClosure, 1);
     closure->lens = this;
     closure->search_string = g_strdup(search_string.c_str());
@@ -144,6 +155,19 @@
 
   }
 
+  void SetResultsBaseName(string const& name)
+  {
+    results_base_name_ = name;
+  }
+
+  void SetNumResults(int count)
+  {
+    num_results_ = count;
+  }
+
+private:
+  string results_base_name_;
+  int num_results_;
 };
 
 static gboolean dispatch_global_search(gpointer userdata)
@@ -213,6 +237,25 @@
   Lens::Ptr lens_2_;
 };
 
+class ThreeStaticTestLenses : public StaticTestLenses
+{
+public:
+  ThreeStaticTestLenses()
+  : lens_1_(new StaticTestLens("first.lens", "First Lens", "The very first lens", "First search hint"))
+  , lens_2_(new StaticTestLens("second.lens", "Second Lens", "The second lens", "Second search hint"))
+  , lens_3_(new StaticTestLens("applications.lens", "Applications", "The applications lens", "Search applications"))
+  {
+    list_.push_back(lens_1_);
+    list_.push_back(lens_2_);
+    list_.push_back(lens_3_);
+  }
+
+private:
+  Lens::Ptr lens_1_;
+  Lens::Ptr lens_2_;
+  Lens::Ptr lens_3_;
+};
+
 TEST(TestHomeLens, TestConstruction)
 {
   HomeLens home_lens_("name", "description", "searchhint");
@@ -354,7 +397,13 @@
 
   home_lens_.Search("ape");
 
-  Utils::WaitForTimeoutMSec();
+  bool finished = false;
+  home_lens_.search_finished.connect([&finished] (Lens::Hints const& hints)
+  {
+    finished = true;
+  });
+
+  Utils::WaitUntil(finished);
 
   /* Validate counts */
   EXPECT_EQ(dee_model_get_n_rows(results), 6); // 3 hits from each lens
@@ -388,4 +437,210 @@
   EXPECT_EQ(cat_shared, dee_model_get_uint32(results, iter, CAT_COLUMN));
 }
 
+TEST(TestHomeLens, TestOrderingAfterSearch)
+{
+  HomeLens home_lens_("name", "description", "searchhint",
+                      HomeLens::MergeMode::OWNER_LENS);
+  ThreeStaticTestLenses lenses_;
+  DeeModel* results = home_lens_.results()->model();
+  DeeModel* cats = home_lens_.categories()->model();
+  DeeModel* filters = home_lens_.filters()->model();
+  DeeModelIter* iter;
+  unsigned int lens1_cat = 0;
+  // the lens is added as third, so must have cat == 2
+  unsigned int apps_lens_cat = 2;
+  const unsigned int URI_COLUMN = 0;
+  const unsigned int CAT_COLUMN = 2;
+
+  home_lens_.AddLenses(lenses_);
+
+  bool order_changed = false;
+  home_lens_.categories_reordered.connect([&order_changed] ()
+  {
+    order_changed = true;
+  });
+
+  home_lens_.Search("ape");
+
+  bool finished = false;
+  home_lens_.search_finished.connect([&finished] (Lens::Hints const& hints)
+  {
+    finished = true;
+  });
+  Utils::WaitUntil(finished);
+
+  /* Validate counts */
+  EXPECT_EQ(dee_model_get_n_rows(results), 9); // 3 hits from each lens
+  EXPECT_EQ(dee_model_get_n_rows(cats), 3); // 3 cats since we are merging categories by lens
+  EXPECT_EQ(dee_model_get_n_rows(filters), 0); // We ignore filters deliberately currently
+
+  /* Validate the category order */
+  auto order = home_lens_.GetCategoriesOrder();
+
+  /* The home lens includes applications lens which contains exact match, must
+   * be first category */
+  EXPECT_EQ(order.at(0), apps_lens_cat);
+
+  /* Plus the categories reordered should have been emitted */
+  EXPECT_EQ(order_changed, true);
+
+  /* The model will not be sorted acording to the categories though. */
+  iter = dee_model_get_iter_at_row(results, 0);
+  EXPECT_EQ(string("uri+a+first.lens"), string(dee_model_get_string(results, iter, URI_COLUMN)));
+  EXPECT_EQ( dee_model_get_uint32(results, iter, CAT_COLUMN), lens1_cat);
+}
+
+TEST(TestHomeLens, TestOrderingWithExactAppsMatch)
+{
+  HomeLens home_lens_("name", "description", "searchhint",
+                      HomeLens::MergeMode::OWNER_LENS);
+  ThreeStaticTestLenses lenses_;
+  // the lens is added as third, so must have cat == 2
+  unsigned int apps_lens_cat = 2;
+
+  home_lens_.AddLenses(lenses_);
+  Lens::Ptr apps_lens = lenses_.GetLens("applications.lens");
+
+  auto static_lens = dynamic_pointer_cast<StaticTestLens>(apps_lens);
+  static_lens->SetNumResults(1);
+
+  bool order_changed = false;
+  home_lens_.categories_reordered.connect([&order_changed] ()
+  {
+    order_changed = true;
+  });
+
+  home_lens_.Search("ape");
+
+  bool finished = false;
+  home_lens_.search_finished.connect([&finished] (Lens::Hints const& hints)
+  {
+    finished = true;
+  });
+  Utils::WaitUntil(finished);
+
+  /* Validate counts */
+  EXPECT_EQ(home_lens_.results()->count(), 7); // 3+3+1 hits
+  EXPECT_EQ(home_lens_.categories()->count(), 3); // 3 cats since we are merging categories by lens
+  EXPECT_EQ(home_lens_.filters()->count(), 0); // We ignore filters deliberately currently
+
+  /* Validate the category order */
+  auto order = home_lens_.GetCategoriesOrder();
+
+  /* The home lens includes applications lens and it contains exact match,
+   * so must be the first category, even though there are fewer results than
+   * in the other categories */
+  EXPECT_EQ(order.at(0), apps_lens_cat);
+
+  /* Plus the categories reordered should have been emitted */
+  EXPECT_EQ(order_changed, true);
+}
+
+TEST(TestHomeLens, TestOrderingWithoutExactAppsMatch)
+{
+  HomeLens home_lens_("name", "description", "searchhint",
+                      HomeLens::MergeMode::OWNER_LENS);
+  ThreeStaticTestLenses lenses_;
+  // the lens is added as third, so must have cat == 2
+  unsigned int apps_lens_cat = 2;
+
+  home_lens_.AddLenses(lenses_);
+  Lens::Ptr apps_lens = lenses_.GetLens("applications.lens");
+
+  auto static_lens = dynamic_pointer_cast<StaticTestLens>(apps_lens);
+  static_lens->SetResultsBaseName("noapes");
+  static_lens->SetNumResults(1);
+
+  bool order_changed = false;
+  home_lens_.categories_reordered.connect([&order_changed] ()
+  {
+    order_changed = true;
+  });
+
+  home_lens_.Search("ape");
+
+  bool finished = false;
+  home_lens_.search_finished.connect([&finished] (Lens::Hints const& hints)
+  {
+    finished = true;
+  });
+  Utils::WaitUntil(finished);
+
+  /* Validate counts */
+  EXPECT_EQ(home_lens_.results()->count(), 7); // 3+3+1 hits
+  EXPECT_EQ(home_lens_.categories()->count(), 3); // 3 cats since we are merging categories by lens
+  EXPECT_EQ(home_lens_.filters()->count(), 0); // We ignore filters deliberately currently
+
+  /* Validate the category order */
+  auto order = home_lens_.GetCategoriesOrder();
+
+  /* The home lens includes applications lens but it doesn't contain exact
+   * match, so can't be the first category */
+  EXPECT_NE(order.at(0), apps_lens_cat);
+
+  /* Plus the categories reordered should have been emitted */
+  EXPECT_EQ(order_changed, true);
+}
+
+TEST(TestHomeLens, TestOrderingByNumResults)
+{
+  HomeLens home_lens_("name", "description", "searchhint",
+                      HomeLens::MergeMode::OWNER_LENS);
+  ThreeStaticTestLenses lenses_;
+  unsigned int lens1_cat = 0;
+  unsigned int lens2_cat = 1;
+  // the lens is added as third, so must have cat == 2
+  unsigned int apps_lens_cat = 2;
+
+  home_lens_.AddLenses(lenses_);
+
+  Lens::Ptr lens = lenses_.GetLensAtIndex(2);
+  auto static_lens = dynamic_pointer_cast<StaticTestLens>(lens);
+  static_lens->SetResultsBaseName("noapes"); // no exact match in apps lens
+  static_lens->SetNumResults(2);
+
+  static_lens = dynamic_pointer_cast<StaticTestLens>(lenses_.GetLensAtIndex(0));
+  static_lens->SetNumResults(1);
+  static_lens = dynamic_pointer_cast<StaticTestLens>(lenses_.GetLensAtIndex(1));
+  static_lens->SetNumResults(3);
+
+  bool order_changed = false;
+  home_lens_.categories_reordered.connect([&order_changed] ()
+  {
+    order_changed = true;
+  });
+
+  home_lens_.Search("ape");
+
+  bool finished = false;
+  home_lens_.search_finished.connect([&finished] (Lens::Hints const& hints)
+  {
+    finished = true;
+  });
+  Utils::WaitUntil(finished);
+
+  /*
+   * lens1 -> 1 result
+   * lens2 -> 3 results
+   * lens3 -> 2 results (apps.lens)
+   */
+
+  /* Validate counts */
+  EXPECT_EQ(home_lens_.results()->count(), 6); // 1+3+2 hits
+  EXPECT_EQ(home_lens_.categories()->count(), 3); // 3 cats since we are merging categories by lens
+  EXPECT_EQ(home_lens_.filters()->count(), 0); // We ignore filters deliberately currently
+
+  /* Validate the category order */
+  auto order = home_lens_.GetCategoriesOrder();
+
+  /* The home lens includes applications lens but it doesn't contain exact
+   * match, so can't be the first category */
+  EXPECT_EQ(order.at(0), lens2_cat);
+  EXPECT_EQ(order.at(1), apps_lens_cat);
+  EXPECT_EQ(order.at(2), lens1_cat);
+
+  /* Plus the categories reordered should have been emitted */
+  EXPECT_EQ(order_changed, true);
+}
+
 }