@@ -40,9 +40,9 @@ dual_control initialize()

     unistd unistd (unistd::create());

     directory directory (directory::create (unistd, pwd));

     fstreams fstreams (fstreams::create());

-    user_token_supplier user_token_supplier (user_token_supplier::create (

+    tokens tokens (tokens::create (

                 fstreams));

-    validator validator (validator::create (directory, user_token_supplier));

+    validator validator (validator::create (directory, tokens));

     pam pam (pam::create());

     conversation conversation (conversation::create (pam));

     sys_syslog sys_syslog (sys_syslog::create());

@@ -20,12 +20,12 @@

 namespace

 {

-class user_token_supplier_impl : public user_token_supplier_ifc

+class tokens_impl : public tokens_ifc

 {

 private:

     fstreams fstreams_;

 public:

-    user_token_supplier_impl (fstreams &fstreams) :

+    tokens_impl (fstreams &fstreams) :

         fstreams_ (fstreams) {}

     std::string token (user &user)

     {

@@ -43,9 +43,9 @@ public:

     }

 };

 }

-user_token_supplier user_token_supplier::create (fstreams &fstreams)

+tokens tokens::create (fstreams &fstreams)

 {

-    return user_token_supplier (user_token_supplier::delegate

-                                (new user_token_supplier_impl (fstreams)));

+    return tokens (tokens::delegate

+                                (new tokens_impl (fstreams)));

 }

@@ -18,32 +18,32 @@

 #include "user.h"

 #include "sys_fstream.h"

-class user_token_supplier_ifc

+class tokens_ifc

 {

 public:

-    virtual ~user_token_supplier_ifc() {}

+    virtual ~tokens_ifc() {}

     virtual std::string token (user &user)

     {

         return "";

     }

 };

-class user_token_supplier

+class tokens

 {

 public:

-    typedef std::shared_ptr<user_token_supplier_ifc> delegate;

+    typedef std::shared_ptr<tokens_ifc> delegate;

 private:

     delegate delegate_;

 public:

-    user_token_supplier (delegate delegate) :

+    tokens (delegate delegate) :

         delegate_ (delegate) {}

-    user_token_supplier() : user_token_supplier (

-            delegate (new user_token_supplier_ifc)) {}

+    tokens() : tokens (

+            delegate (new tokens_ifc)) {}

     std::string token (user &user)

     {

         return delegate_->token (user);

     }

-    static user_token_supplier create (fstreams &fstreams);

+    static tokens create (fstreams &fstreams);

 };

 #endif

@@ -71,7 +71,7 @@ int reads_from_the_right_file ()

     //file_reader test_file_reader (file_reader::delegate (new fake_file_reader));

     user test_user (user::delegate (new fake_user (home_directory)));

-    user_token_supplier supplier (user_token_supplier::create (

+    tokens supplier (tokens::create (

                                       test_streams));

     //when

@@ -91,7 +91,7 @@ int returns_empty_string_if_file_open_fail()

     fstreams test_streams (fstreams::delegate (new fake_fstreams (token_file,

                            "654321")));

     user test_user (user::delegate (new fake_user (home_directory)));

-    user_token_supplier supplier (user_token_supplier::create (

+    tokens supplier (tokens::create (

                                       test_streams));

     //when

@@ -20,12 +20,12 @@ class impl : public validator_ifc

 {

 private:

     directory directory_;

-    user_token_supplier user_token_supplier_;

+    tokens tokens_;

 public:

     impl (const directory &directory,

-          const user_token_supplier user_token_supplier) :

+          const tokens tokens) :

         directory_ (directory),

-        user_token_supplier_ (user_token_supplier) {}

+        tokens_ (tokens) {}

     bool validate (const std::string &requester_user_name,

                    const std::string &authorizer_user_name,

                    const std::string &token)

@@ -44,17 +44,17 @@ public:

             return false;

         }

-        std::string user_token = user_token_supplier_.token (found_user[0]);

+        std::string user_token = tokens_.token (found_user[0]);

         return user_token == token;

     }

 };

 }

 validator validator::create (const directory &directory,

-                             const user_token_supplier &user_token_supplier)

+                             const tokens &tokens)

 {

     std::shared_ptr<validator_ifc> delegate (new impl (directory,

-            user_token_supplier));

+            tokens));

     return validator (delegate);

 }

@@ -47,7 +47,7 @@ public:

                                     authorizer_token);

     }

     static validator create (const directory &directory,

-                             const user_token_supplier &token_supplier);

+                             const tokens &token_supplier);

 };

 #endif

@@ -39,13 +39,13 @@ public:

     }

 };

-class fake_user_token_supplier : public user_token_supplier_ifc

+class fake_tokens : public tokens_ifc

 {

 private:

     std::string token_;

 public:

-    fake_user_token_supplier (const std::string &token) : token_ (token) {}

-    fake_user_token_supplier() : token_ ("_NOT_A_TOKEN") {}

+    fake_tokens (const std::string &token) : token_ (token) {}

+    fake_tokens() : token_ ("_NOT_A_TOKEN") {}

     std::string token (user &user)

     {

         return token_;

@@ -63,11 +63,11 @@ bool validator_validates()

     // given

     std::string token = "token";

-    user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier (token)));

+    tokens tokens (share (new

+            fake_tokens (token)));

     std::string user_name = "msmith";

     directory directory (share (new fake_directory (user_name)));

-    validator validator = validator::create (directory, user_token_supplier);

+    validator validator = validator::create (directory, tokens);

     // when

     bool actual = validator.validate ("requester", user_name, token);

@@ -82,10 +82,10 @@ bool validator_fails_unknown_user()

     // given

     std::string token = "token";

-    user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier));

+    tokens tokens (share (new

+            fake_tokens));

     directory directory (share (new fake_directory));

-    validator validator = validator::create (directory, user_token_supplier);

+    validator validator = validator::create (directory, tokens);

     // when

     bool actual = validator.validate ("requester", "notuser", token);

@@ -99,11 +99,11 @@ bool validator_fails_incorrect_token()

 {

     // given

-    user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier));

+    tokens tokens (share (new

+            fake_tokens));

     std::string user_name = "msmith";

     directory directory (share (new fake_directory (user_name)));

-    validator validator = validator::create (directory, user_token_supplier);

+    validator validator = validator::create (directory, tokens);

     // when

     bool actual = validator.validate ("requester", user_name, "token");

@@ -120,9 +120,9 @@ bool validator_fails_with_own_token()

     std::string authorizer_user_name (requester_user_name);

     std::string authorizer_token ("token");

     directory directory (share (new fake_directory (authorizer_user_name)));

-    user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier (authorizer_token)));

-    validator validator = validator::create (directory, user_token_supplier);

+    tokens tokens (share (new

+            fake_tokens (authorizer_token)));

+    validator validator = validator::create (directory, tokens);

     // when

     bool actual = validator.validate (requester_user_name, authorizer_user_name,

@@ -141,9 +141,9 @@ bool validator_fails_with_unknown_requester()

     std::string authorizer_user_name ("authorizer");

     std::string authorizer_token ("token");

     directory directory (share (new fake_directory (authorizer_user_name)));

-    user_token_supplier user_token_supplier (share (new

-            fake_user_token_supplier (authorizer_token)));

-    validator validator = validator::create (directory, user_token_supplier);

+    tokens tokens (share (new

+            fake_tokens (authorizer_token)));

+    validator validator = validator::create (directory, tokens);

     // when

     bool actual = validator.validate (requester_user_name, authorizer_user_name,