--- nfo/perl/libs/Data/Rap/Engine.pm	2003/02/18 15:35:25	1.1
+++ nfo/perl/libs/Data/Rap/Engine.pm	2003/02/20 19:46:33	1.2
@@ -1,7 +1,12 @@
 ## ----------------------------------------------------------------------
-##  $Id: Engine.pm,v 1.1 2003/02/18 15:35:25 joko Exp $
+##  $Id: Engine.pm,v 1.2 2003/02/20 19:46:33 joko Exp $
 ## ----------------------------------------------------------------------
 ##  $Log: Engine.pm,v $
+##  Revision 1.2  2003/02/20 19:46:33  joko
+##  renamed and revamped some of modules
+##  renamed methods
+##  + sub run_executable
+##
 ##  Revision 1.1  2003/02/18 15:35:25  joko
 ##  + initial commit
 ##
@@ -15,46 +20,91 @@
 
 
 use Data::Dumper;
-use Data::Transform::Deep qw( refexpr2perlref );
-use Iterate;
 use Hash::Merge qw( merge );
+use Iterate;
+
+use shortcuts qw( run_cmd );
+use Data::Code::Ref qw( ref_slot );
+use Data::Transform::Deep qw( expand );
 
 
 sub performTarget {
   my $self = shift;
   my $targetname = shift;
-  my $target = $self->getTargetMetadata($targetname);
+  $self->perform_target($targetname);
+}
+
+sub perform_target {
+  my $self = shift;
+  my $targetname = shift;
+
+  $self->log("Performing Target '$targetname'.", 'notice');
+
+  #exit;
+
+  my $target = $self->getTargetDetails($targetname);
 
   # trace
     #print Dumper($target);
     #exit;
     
+  $self->perform_dependencies($target);
+  $self->perform_details($target);
+
+}
+
+sub perform_dependencies {
+  my $self = shift;
+  my $target = shift;
   # resolve dependencies (just run prior)
   if (my $targetname_dep = $target->{attrib}->{depends}) {
-    $self->performTarget($targetname_dep);
+    my @targets = split(/,\s|,/, $targetname_dep);
+    #print Dumper(@targets);
+    #$self->perform($targetname_dep);
+    #delete $target->{attrib}->{depends};
+    foreach (@targets) {
+      if (!$self->{__rap}->{dependencies}->{resolved}->{$_}++) {
+        $self->perform_target($_);
+      }
+    }
     delete $target->{attrib}->{depends};
   }
+}
 
+sub perform_details {
+  my $self = shift;
+  my $target = shift;
+  
+  #print Dumper($target);
+  #exit;
+  
   foreach my $entry (@{$target->{content}}) {
     my $command = $entry->{name};
     my $args = $entry->{attrib};
-    $self->run_command($command, $args);
+    $self->perform_command($command, $args);
+    # check recursiveness
+    if ($entry->{content} && ref $entry->{content}) {
+      $self->perform_details($entry);
+    }
   }
 }
 
 sub rc {
   my $self = shift;
-  return $self->run_command(@_);
+  return $self->perform_command(@_);
 }
 
-sub run_command {
+sub perform_command {
   my $self = shift;
   my $command = shift;
-  
+
   if (!$command) {
     $self->log("Command was empty!", 'warning');
     return;
   }
+
+  # FIXME: make '__PACKAGE__' go one level deeper properly!
+  $self->log( __PACKAGE__ . "->perform_command: " . $command, 'debug');
   
   my $args_list = shift;
   my $args = {};
@@ -69,43 +119,88 @@
     }
   }
   $command = '_' . $command;
-  if ($self->can($command)) {
-    $self->$command($args);
+  
+  
+  # determine container
+  my $container; # = $self->getInstance();
+  $container ||= $self;
+  
+  if ($container->can($command)) {
+    $container->$command($args);
   } else {
-    $self->log("Command \"$command\" not implemented.", "warning");
+    $self->log("Command '$command' not implemented.", "warning");
   }
+  
 }
 
-sub set_property {
-  my $self = shift;
-  my $args = shift;
 
-  my $name;
-  my $value;
-  
-  if (ref $args) {
-    $self->interpolate($args) ;
-    $name = $args->{name};
-    $value = $args->{value};
+sub merge_properties {
+  my $self = shift;
+  my $name = shift;
+  my $data = shift;
 
-  } else {
-    $name = $args;
-    $value = shift;
-  }
+  $self->log("merge-name: $name");
+  #print "name: $name", "\n";
+  #print Dumper($data);
+  #exit;
 
   # check if slot (or childs of it) is/are already occupied
-  if (my $oldvalue = refexpr2perlref($self, $name, undef, '.')) {
+  #if (my $data_old = ref_slot($self, $name, undef, '.')) {
+  if (my $data_old = $self->get_property($name)) {
+    #print "old:", "\n";
+    #print Dumper($data_old);
+    
     # FIXME: review - any options for 'merge' here?
-    $value = merge($oldvalue, $value);
+    my $data_new = merge($data_old, $data);
+    #print "DATA NEE! - MERGE!", "\n";
+    #print Dumper($data_new);
+    #exit;
+    #hash2object($self, $data_new);
+    $self->set_property( { name => $name, value => $data_new } );
+    
+  } else {
+
+=pod    
+    # make up a dummy hash matching the structure of the destination one
+      my $dummy = {};
+      ref_slot($dummy, $name, $data, '.');
+      print Dumper($dummy);
+    
+    # mix into destination
+      mixin($self, $dummy, { init => 1 });
+=cut
+
+      ref_slot($self, $name, $data, '.');
+
   }
+  
+  
+  #print Dumper($self);
+  #exit;
+  #$self->
+
+}
+
+sub set_property {
+  my $self = shift;
+  my $args = shift;
+
+  $self->interpolate($args) ;
+  my $name = $args->{name};
+  my $value = $args->{value};
+  $name = '__rap.properties.' . $name;
+
+  $self->log("set-name: $name");
 
   # fill property slot with given value
   if ($value) {
-    refexpr2perlref($self, $name, $value, '.');
+    ref_slot($self, $name, $value, '.');
   }
   
+  #print Dumper($self);
+  
   # FIXME!!!
-  return if ! ref $args;
+  #return if ! ref $args;
 
   # fill property slot with (probably bigger) data structure from property-/configuration-style - file
   if (my $file = $args->{file}) {
@@ -123,7 +218,7 @@
     }
 
   } elsif (my $command = $args->{command}) {
-    $self->run_command($command, $args);
+    $self->perform_command($command, $args);
   
   }
 
@@ -137,10 +232,38 @@
   #$self->interpolate($args);
 
   #my $name = $args->{name};
+  my $result;
+
+  if (!$name) {
+    $self->log( __PACKAGE__ . ": no name!", 'critical');
+    
+  } elsif ($name eq '/') {
+    $result = expand($self);
 
-  # get property slot and return value
-  return refexpr2perlref($self, $name, undef, '.');
+  } elsif ($name eq '.') {
+    if (my $instance = $self->getInstance()) {
+      $result = expand($instance);
+    } else {
+      $result = ref_slot($self, '__rap.properties', undef, '.');
+      
+    }
+
+  } else {
+
+    $name = '__rap.properties.' . $name;
+    
+    $self->log("get-name: $name");
+    
+    # get property slot and return value
+    $result = ref_slot($self, $name, undef, '.');
+    
+    # FIXME: Is this okay? It's provided for now in order not
+    # to deliver an 'undef' to the regex below inside 'interpolate'.
+    # revamp this, maybe!
+    #$result ||= '';    # NO!!!
+  }
   
+  return $result;
 }
 
 sub interpolate {
@@ -152,5 +275,46 @@
   }
 }
 
+sub run_executable {
+  my $self = shift;
+  my $opts = shift;
+
+  if ($opts->{executable}) {
+
+    my $program = $opts->{executable};
+    delete $opts->{executable};
+
+    my @buf;
+    foreach (keys %$opts) {
+      my $value = $opts->{$_};
+      if ($value =~ /\s/) {
+        $value = "\"$value\"";
+      }
+      push @buf, "--$_=$value";
+    }
+  
+    my $cmd = $program . ' ' . join(' ', @buf);
+    
+    # trace
+      #print "command: $cmd", "\n";
+    
+    # start process
+      # V1: via shortcut
+      #$ENV{PERL5LIB} = join(' ', @INC);
+      
+      # FIXME!!! what about the other slots of @INC?
+      $ENV{PERL5LIB} = $INC[0];
+      
+      #print Dumper(%ENV);
+      run_cmd($cmd);
+      # V2: via IPC::Run
+      # ....  (TODO)
+    
+    
+  }
+  
+}
+
+
 1;
 __END__