How can I make an embedded view take an argument from a URL?

In Drupal I use views to retrieve values in a complex way: so, eg, my view newest_product will retrieve nodes that are of type "product" and that have been added in the last two months. I might also want to filter this view by category, so I would keep my view "newest_product" and pass to it the "category" argument: that, is newest_product/cars, newest_product/bikes...

in this case "cars" and "bikes" are arguments to my view. I may also add further arguments to the view, as long as my content type would be suitable to that.

If I get right what you are trying to do, you're making nodes /A/B/C style... so you want all arguments to be passed to the view. Of course, if the view is embedded in the page, this is no easy thing, since the embedded view won't get the url arguments. You can do this in view argument handling code:

1) check the REAL path you get ex: list($a,$b,$c) = explode("/", $_GET["q"]);
2) if $a == "node" than no arguments decoding can be done by the view. In this case you have to manually get the path alias you want: $alias = drupal_get_path_alias("node/".$b) (where $b is the node->nid);

I think I've figured it out - but it requires a hook_menu call in your node xxx module, and a patch to path.inc in drupal core. This is in 4.7.

First of all you have to allow the node (the one you want to embed your view, in my case, og nodes) to take arguments from the url, and spell out what to do with them. So, in og.module's hook_menu (ie og_menu), you add:

// pull out arguments from url, and pass on to og_views_arguments
   if (arg(0) == 'node' && is_numeric(arg(1))) {
      $node = node_load(arg(1));
      if (og_is_group_type($node->type)) { //checks that this is an og node
        $items[] = array('path' => 'node/' . arg(1), 
          'title' => t('email'), 
          'callback' => 'og_views_arguments', 
          'callback arguments' => array($node, arg(2), arg(3)), 
          'access' => node_access('access content', $node), 
          'type' => MENU_CALLBACK);
      }
    }

'Callback arguments' get passed on to the function you specify in 'callback', and in this case I've only specified arg(2) and arg(3), although you could add more. Note that hook_menu receives the args in internal path form (not as an alias), so arg(0) is node and arg(1) is the node id.

Then you have to create your callback function in the xxxx.module for your node (ie. og.module). This takes the 'callback arguments' in the same order as they're specified in hook_menu, and then you can do something useful with them:

function og_views_arguments($node, $arg2, $arg3){
  //uncomment to check you're getting the args throug h correctly
  //print 'arg2: '. $arg2;
  //print 'arg3: '. $arg3;

  //assign to $_POST global variable, so you can access from elsewhere
  $_POST['arg2'] = $arg2;
  $_POST['arg3'] = $arg3; 

  //display the node as normal
  og_set_group_context($node); //just for og
  $output = node_show($node, $cid = FALSE);
  return $output;

}

Here I've put the args in $_POST variable, and I then link this up with the embedded view by saying $arg2 = $_POST['arg2'] and $arg3 = $_POST['arg3'], and then passing these to the view (as in the comment above).

At this point you should be able to go to node/xxx/arg2/arg3 and get both your arguments passed through to the view.

Next, if you use aliases, is to make sure your added arguments don't get cut off before you even get to the hook_menu call. By default the drupal_lookup_path function in path.inc (in the /includes folder) looks for a direct match between the path entered ($path), and the aliases in the {url_alias} table. So if you add anything onto the end of an alias (like an argument), you get redirectd immediately to "page not found".

Here, I've modified path.inc: first it looks for a direct match (as normal), but if it doesn't I then break up the $path and check if any of its components match the aliases in {url_alias}. We're trying to find if the root of $path is an alias, and if it matches, we then assume that all subsequent pieces of $path are arguments. Finally if none of the roots (here, up to three hierarchical levels) match an alias, we then go to "page not found".

    // Check $no_src for this $path in case we've already determined that there
    // isn't a path that has this alias
    elseif ($action == 'source' && !isset($no_src[$path])) {
      // Look for the value $path within the cached $map
      if (!$src = array_search($path, $map)) {
        if ($src = db_result(db_query("SELECT src FROM {url_alias} WHERE dst = '%s'", $path))) {
          $map[$src] = $path;
        }
        else {
          // There is no direct match to known aliases, but check if the alias roots
          // exist. If they do presume additional hierarchies are added arguments, 
          // & add them onto the $src url ie. for any given path (h1/h2/h3 etc.)we 
          // are trying to distinguish between the root alias components (r1/r2) and the 
          // argument components (a1/a2), by trying to match root path against the 
          // {url_alias} table  
          $path_pieces = explode('/', $path);
          if(count($path_pieces > 1)){ //path has 2 or more hierarchies ie h1./h2. etc. ...
            //check if the root is a recognised alias ...
            //at one root hierarchical level r1/a1/a2 etc.
            if ($src = db_result(db_query("SELECT src FROM {url_alias} WHERE dst = '%s'", $path_pieces[0]))){
              $root_h_number = 1;
            //at two root hierarchical levels r1/r2/a1/a2 etc.
            }elseif($src = db_result(db_query("SELECT src FROM {url_alias} WHERE dst = '%s'", $path_pieces[0]. '/'. $path_pieces[1]))){
              $root_h_number = 2;    
            //at three root hierarchical levels r1/r2/r3/a1/a2 etc.        
            }elseif($src = db_result(db_query("SELECT src FROM {url_alias} WHERE dst = '%s'", $path_pieces[0]. '/'. $path_pieces[1]. '/'. $path_pieces[2]))){
              $root_h_number = 3;
            }
          }
          if($src){ //one of the roots is an alias
            //add any remaining a. onto the $src path
            foreach($path_pieces as $path_piece_key => $path_piece){
              //add the arguments, but don't duplicate root pieces
              if($path_piece_key > ($root_h_number - 1)) $src .= '/'. $path_piece;
            } 
            //add to cache
            $map[$src] = $path;
          }else{
            // Even the roots (up to 3 hierarchies) cannot be matched to known aliases, hence ... 
            // We can't record anything into $map because we do not have a valid
            // index and there is no need because we have not learned anything
            // about any Drupal path. Thus cache to $no_src.
            $no_src[$path] = TRUE;
          }
        }
      }
      return $src;

This should go in around line 68 (on 4.7) in the "action='source'" section. Note this only properly distinguish arguments added onto aliases three or less levels deep (ie. r1/r2/r3 or less). Also, if you have a root alias that is more than one level (r1/r2 or greater), then you shouldn't have aliases using r1 that link to different nodes - because the search will pick up the r1 root (and redirect) before you get to r1/r2.

Note also that this prioritises matches to already-defined aliases ie. if you have two paths r1/r2 and r1/a1 which are the same, then it will to r1/r2. This is good, probably, because it means there are no extra sql overheads for aliases that are already defined - the extra queries only kick in if the alias is not found by a direct match.

NB. I know very little about security, and haven't really thought through the implications of this. I don't think there's any harm passing arguments from aliases to the internal paths, as arguments could be added to internal paths anyway. However, I've restricted the pick-up of arguments from internal paths (in hook_menu) to the node type I'm using to embed views in (og). And these only get passed via $_POST into the views calls - but probably they should be filtered in some way, because the data can be entered directly into the url. Any advice appreciated!

Phew - don't you just love open source! I just hope you can make some sense of this :)