Changeset 534

Timestamp:

Feb 25, 2010, 10:05:31 AM (14 years ago)

Author:

rybkin

Message:

See C.L. 421

Location:

CMT/HEAD

Files:

• ChangeLog (modified) (1 diff)
• source/cmt_vcs.cxx (modified) (13 diffs)
• source/cmt_vcs.h (modified) (5 diffs)

CMT/HEAD/ChangeLog

@@ +1 @@
+2010-02-25    <rybkin@lal.in2p3.fr> 421
+
+        * source/cmt_vcs.h: In class Vcs, introduce functions checkout_module,
+        checkout_from_requirements. In class Vcs::Checkout, introduce members
+        m_requirements, m_command, m_recursive, m_context
+        * source/cmt_vcs.cxx: Implement introduced functions so that options
+        -R (recursive checkout) and -requirements (checkout from requirements file)
+        be functional with Subversion
+        
 2010-02-03    <rybkin@lal.in2p3.fr> 420
 

CMT/HEAD/source/cmt_vcs.cxx

@@ -128 +128 @@
   CvsImplementation& m_cvs;
 };
+
+class Walkthru : public Awk
+{
+public:
+  Walkthru (const Vcs::Checkout& checkout,
+            bool config, bool with_version_directory,
+            Vcs::VcsType type);
+  //  RecursivePass2 (CvsImplementation& cvs);
+  void begin ();
+  void filter (const cmt_string& line);
+
+private:
+  const Vcs::Checkout& m_checkout;
+  bool m_config;
+  bool m_with_version_directory;
+  Vcs::VcsType m_type;
+  //  CvsImplementation& m_cvs;
+};
+
+Walkthru::Walkthru (const Vcs::Checkout& checkout,
+                    bool config, bool with_version_directory,
+                    Vcs::VcsType type)
+  : m_checkout (checkout),
+    m_config (config), m_with_version_directory (with_version_directory),
+    m_type (type)
+{
+}
+
+void Walkthru::begin ()
+{
+}
+
+void Walkthru::filter (const cmt_string& line)
+{
+//   History& h = History::instance ();
+  
+//   if (h.is_installed (line)) return;
+  
+//   h.install (line);
+  
+  CmtSystem::cmt_string_vector words;
+  
+  CmtSystem::split (line, " \t", words);
+
+  enum
+    {
+      need_package,
+      need_version,
+      need_path,
+      no_need
+    } state = need_package;
+
+  cmt_string package;
+  cmt_string version;
+  cmt_string path;
+
+  for (int i = 1; i < words.size (); i++)
+    {
+      const cmt_string& s = words[i];
+
+      if (s[0] == '-') continue;
+
+      switch (state)
+        {
+        case need_package:
+          package = s;
+          state = need_version;
+          break;
+        case need_version:
+          version = s;
+          state = need_path;
+          break;
+        case need_path:
+          path = s;
+          state = no_need;
+          break;
+        }
+    }
+
+  if (version == "")
+    {
+      version = "*";
+    }
+
+  if (version.find ("*") != cmt_string::npos &&
+      !m_checkout.m_context)
+    {
+      /*
+        cerr << "# ================= Package " << package 
+        << " version " << version << " " << path 
+        << " has wild cards and will not be considered." << endl;
+      */
+      CmtMessage::warning (package + " " + version +
+                           (path != "" ? " " + path : "") +
+                           " has wildcards in version and will not be considered.");
+    }
+  else
+    {
+      //      static const cmt_string empty;
+      //      m_cvs.do_checkout_phase2 (path, package, version, empty);
+      cmt_string module ((path != "") ? path + "/" + package : package);
+      Vcs::checkout_module (m_checkout,
+                            m_config, m_with_version_directory,
+                            module, version,
+                            m_type);
+    }
+}
 
 /**
@@ -3128 +3235 @@
   cerr << "" << endl;
   cerr << "   modifier :" << endl;
-  cerr << "   -l        Do not process used packages (default)." << endl;
-  //cerr << "   -R        Process used products recursively." << endl;
-  cerr << "   -r rev    Check out version tag. (is sticky)" << endl;
-  cerr << "   -vd dir   Use this version directory instead of version tag." << endl;
-  cerr << "   -d dir    Check out into dir instead of module name." << endl;
-  cerr << "   -o offset Offset in the repository" << endl;
-  //cerr << "   -requirements <requirements file path>  Check out packages referenced in this requirements file" << endl;
+  cerr << "   -l          Do not process used packages (default)." << endl;
+  cerr << "   -R          Process used products recursively." << endl;
+  cerr << "   -r rev      Check out version tag. (is sticky)" << endl;
+  cerr << "   -vd dir     Use this version directory instead of version tag." << endl;
+  cerr << "   -d dir      Check out into dir instead of module name." << endl;
+  cerr << "   -o offset   Offset in the repository" << endl;
+  cerr << "   -requirements <requirements file path>  Check out packages referenced in this requirements file" << endl;
   //cerr << "   -t        Change file timestamps to the date of checkout" << endl;
   //cerr << "   -n        simulation mode on" << endl;
@@ -3140 +3247 @@
   //cerr << "   -v        verbose mode on" << endl;
   cerr << "   -rs suffix  Same as -r <packagename|projectname>suffix" << endl;
-  cerr << "   --help    print this help" << endl;
+  cerr << "   --help      Print this help" << endl;
   cerr << "" << endl;
   cerr << "(Modifiers are recognised anywhere on the command line.)" << endl;
@@ -3282 +3389 @@
           //m_head = false;
           //checkout_from_requirements (option);
+          checkout.m_requirements = option;
         }
       else if (need_version_tag_suffix)
@@ -3292 +3400 @@
           if (option == "-R")
             {
-              CmtMessage::warning ("Option " + option + " not implemented");
+              //CmtMessage::warning ("Option " + option + " not implemented");
+              //CmtMessage::warning ("Option " + option + " under testing");
               //m_recursive = true;
+              checkout.m_recursive = true;
             }
           else if (option == "-t")
@@ -3302 +3412 @@
           else if (option == "-l")
             {
+              checkout.m_recursive = false;
               //m_recursive = false;
             }
@@ -3337 +3448 @@
           else if (option == "-requirements")
             {
-              CmtMessage::warning ("Option " + option + " not implemented");
+              //CmtMessage::warning ("Option " + option + " under testing");
               need_requirements_file = true;
             }
@@ -3374 +3485 @@
     }
 
-  if (checkout.m_modules.size () < 1)
+  if (checkout.m_modules.size () < 1 &&
+      checkout.m_requirements == "")
     {
       CmtError::set (CmtError::syntax_error, "No module to checkout specified");
@@ -3381 +3493 @@
       return 2;
     }
-  //  checkout.print ();
+  //checkout.print ();
   return 0;
 }
@@ -3430 +3542 @@
 }
 
-void Svn::checkout (const Vcs::Checkout& checkout,
+void Svn::checkout (Vcs::Checkout checkout,
                    bool config, bool with_version_directory)
 {
@@ -3445 +3557 @@
       return;
     }
-
-  cmt_string cmd (checkout_command);
+  checkout.m_command = checkout_command;
+
+  /**
+   * Call checkout for each command line argument
+   */
+  for (int arg = 0; arg < checkout.m_modules.size (); arg++)
+    {
+      const cmt_string& module = checkout.m_modules[arg];
+      const cmt_string& version_tag = checkout.m_version_tag;
+      Vcs::checkout_module (checkout,
+                            config, with_version_directory,
+                            module, version_tag,
+                            Vcs::Svn);
+      //      do_checkout_phase1 (modules[arg], m_version_dir, version_tag);
+    }
+
+  /**
+   * Call checkout for used package in requirements file
+   */
+  if (checkout.m_requirements != "")
+    Vcs::checkout_from_requirements (checkout,
+                                     config, with_version_directory,
+                                     checkout.m_requirements,
+                                     Vcs::Svn);
+}
+
+void Vcs::checkout_module (const Vcs::Checkout& checkout,
+                           bool config, bool with_version_directory,
+                           const cmt_string& module, cmt_string version_tag,
+                           Vcs::VcsType type)
+{
+//   cmt_string checkout_command;
+//   Symbol* checkout_command_macro = Symbol::find ("svn_checkout_command");
+//   if (checkout_command_macro != 0)
+//     {
+//       checkout_command = checkout_command_macro->resolve_macro_value ();
+//     }
+//   if (checkout_command == "")
+//     {
+//       CmtError::set (CmtError::symbol_not_found,
+//                   "Macro svn_checkout_command not defined");
+//       return;
+//     }
+  if (checkout.m_context)
+    {
+      int i;
+      if (version_tag == "")
+        // version tag not specified on the command line
+        {
+        }
+      else if ((i = version_tag.find ("*")) != cmt_string::npos)
+        // version has wildcards (or not specified) in requirements
+        {
+        }
+    }
+
+  History& h = History::instance ();
+  cmt_string line (module + " " + version_tag);
+  //cerr << "get: " << line << endl;  
+  if (h.is_installed (line)) return;
+  h.install (line);
+  //cerr << "install: " << line << endl;  
+
+  cmt_string cmd (checkout.m_command);
   cmt_string msg;
 
@@ -3457 +3631 @@
     cmd += " --without_version_directory";
 
-  if (checkout.m_version_tag != "")
-    {
-      cmd += " -r " + checkout.m_version_tag;
-      msg += " (" + checkout.m_version_tag + ")";
+  if (version_tag != "")
+    {
+      cmd += " -r " + version_tag;
+      msg += " (" + version_tag + ")";
     }
   else
@@ -3480 +3654 @@
 
   /**
-   * Then call checkout for each argument
+   * Then call checkout for the module
    */
-  for (int arg = 0; arg < checkout.m_modules.size (); arg++)
-    {
-      const cmt_string& module = checkout.m_modules[arg];
-      CmtMessage::info ("Working on " + module + msg);
-      //      cerr << cmd + " " + module << endl;
-      int status = CmtSystem::execute (cmd + " " + module);
-      if (0 == status)
+  //   for (int arg = 0; arg < checkout.m_modules.size (); arg++)
+  //     {
+  //       const cmt_string& module = checkout.m_modules[arg];
+  CmtMessage::info ("Working on " + module + msg);
+  //      cerr << cmd + " " + module << endl;
+  int status = CmtSystem::execute (cmd + " " + module);
+  if (0 == status)
+    {
+      CmtMessage::info (module + " done.");
+      if (checkout.m_recursive)
         {
-          CmtMessage::info (module + " done.");
-        }
-      else
-        {
-          CmtError::set (CmtError::execution_failed, cmd + " " + module, status);
-        }
-      //      do_checkout_phase1 (modules[arg], m_version_dir, version_tag);
-    }
-}
+          cmt_string requirements;
+          if (checkout.m_checkout_dir != "")
+            {
+              requirements = checkout.m_checkout_dir;
+            }
+          else
+            {
+              requirements = module;
+              requirements.replace_all ("/", CmtSystem::file_separator ());
+            }
+          if (with_version_directory)
+            {
+              if (checkout.m_version_dir != "")
+                {
+                  requirements += CmtSystem::file_separator ();
+                  requirements += checkout.m_version_dir;
+                }
+              else
+                {
+                  if (version_tag != "")
+                    {
+                      requirements += CmtSystem::file_separator ();
+                      requirements += version_tag;
+                    }
+                  else
+                    { // checkout of trunk
+                      //
+                      static CmtSystem::cmt_string_vector versions;
+                      static cmt_string name;
+                      
+                      name = requirements;
+                      name += CmtSystem::file_separator ();
+                      name += "*";
+                      CmtSystem::scan_dir (name, versions);
+
+                      int n (0);
+                      for (int i = 0; i < versions.size (); i++)
+                        {
+                          const cmt_string& vers = versions[i];
+                          
+                          if (Cmt::get_debug ())
+                            {
+                              cout << "     ... version " << vers << " exists" << endl;
+                            }
+                          /*
+                            This check is not sufficient !! We need to check in addition
+                            that the selected directory is really the start of a true CMT
+                            package (ie with either /mgr/requirements or /cmt/requirements below)
+                          */
+                          
+                          cmt_string req;
+                          req = vers;
+                          //req = name;
+                          req += CmtSystem::file_separator ();
+                          req += "mgr";
+                          req += CmtSystem::file_separator ();
+                          req += "requirements";
+                          
+                          if (!CmtSystem::test_file (req))
+                            {
+                              req = vers;
+                              //req = name;
+                              req += CmtSystem::file_separator ();
+                              req += "cmt";
+                              req += CmtSystem::file_separator ();
+                              req += "requirements";
+                              
+                              if (!CmtSystem::test_file (req)) continue;
+                            }
+                          n += 1;
+                          if (n > 1)
+                            {
+                              CmtMessage::warning (requirements +
+                                                   ": Ambiguous choice"
+                                                   " for recursion");
+                              break;
+                            }
+                          CmtSystem::basename (vers, name);
+                          requirements += CmtSystem::file_separator ();
+                          requirements += name;
+                        } // end of for versions loop
+                      if (n < 1)
+                        {
+                          CmtMessage::error ("Cannot find package in " +
+                                             requirements +
+                                             " for recursion");
+                          CmtError::set (CmtError::package_not_found,
+                                         "in " + requirements);
+                          return;
+                        }
+                    } // end of checkout of trunk
+                }
+            } // end of with_version_directory
+          cmt_string cmt_req = requirements +
+            CmtSystem::file_separator () +
+            "cmt" +
+            CmtSystem::file_separator () +
+            "requirements";
+          cmt_string mgr_req = requirements +
+            CmtSystem::file_separator () +
+            "mgr" +
+            CmtSystem::file_separator () +
+            "requirements";
+          if (CmtSystem::test_file (cmt_req))
+            {
+              requirements = cmt_req;
+            }
+          else if (CmtSystem::test_file (mgr_req))
+            {
+              requirements = mgr_req;
+            }
+          else
+            {
+              CmtError::set (CmtError::path_not_found,
+                             cmt_req + " or " + mgr_req);
+              return;
+            }
+          Vcs::checkout_from_requirements (checkout,
+                                           config, with_version_directory,
+                                           requirements,
+                                           type);
+        } // end of checkout.m_recursive
+    }
+  else
+    {
+      CmtError::set (CmtError::execution_failed, cmd + " " + module, status);
+    }
+  //      do_checkout_phase1 (modules[arg], m_version_dir, version_tag);
+}
+
+void Vcs::checkout_from_requirements (const Vcs::Checkout& checkout,
+                                      bool config,
+                                      bool with_version_directory,
+                                      const cmt_string& requirements,
+                                      Vcs::VcsType type)
+{
+  CmtMessage::info ("Processing " + requirements);
+
+  cmt_string text;
+  if (!text.read (requirements))
+    {
+      CmtError::set (CmtError::path_not_found, requirements);
+      return;
+    }
+  static cmt_regexp expression ("^[ \t]*use[ \t]");
+
+//   RecursivePass1 p1;
+//   p1.run (text, expression);
+//   bool result = (p1.result () != "");
+//   if (result)
+//     cerr << p1.result () << endl;
+  Walkthru wth (checkout,
+                config,
+                with_version_directory,
+                type);
+  wth.run (text, expression);
+}

CMT/HEAD/source/cmt_vcs.h

@@ -13 +13 @@
 {
  public:
+
+  typedef enum
+    {
+      Cvs,
+      Svn
+    } VcsType;
+
+ public:
   
 /*   static void tags (const CmtSystem::cmt_string_vector& arguments); */
@@ -23 +31 @@
   {
   public:
+    Checkout ()
+      : m_recursive (false), m_context (false)
+      { }
     cmt_string m_version_tag;
     cmt_string m_checkout_dir;
@@ -28 +39 @@
     cmt_string m_offset;
     CmtSystem::cmt_string_vector m_modules;
+    cmt_string m_requirements;
+    cmt_string m_command;
+    bool m_recursive;
+    bool m_context;
     void print ()
       {
@@ -38 +53 @@
             cerr << "m_modules[" << arg << "]: " << m_modules[arg] << endl;
           }
+        cerr << "m_requirements: " << m_requirements << endl;
+        cerr << "m_command: " << m_command << endl;
+        cerr << "m_recursive: " << m_recursive << endl;
+        cerr << "m_context: " << m_context << endl;
       }
   };
+
+  static void checkout_module (const Checkout& checkout,
+                               bool config, bool with_version_directory,
+                               const cmt_string& module, cmt_string version_tag,
+                               VcsType type);
+  static void checkout_from_requirements (const Checkout& checkout,
+                                          bool config, bool with_version_directory,
+                                          const cmt_string& requirements,
+                                          VcsType type);
 
  private:
@@ -54 +82 @@
  public:
   
-  static void checkout (const Vcs::Checkout& checkout,
+  static void checkout (Vcs::Checkout checkout,
                        bool config, bool with_version_directory);
 };