Difference between revisions of "Design Specs: API"

From WormBaseWiki
Jump to navigationJump to search
Line 60: Line 60:
 
  sub compile_data_pack {
 
  sub compile_data_pack {
  
my $object = shift @_;
+
  my $object = shift @_;
my $class = $object->class;
+
  my $class = $object->class;
my $common_name = common_name($object, $class);
+
  my $common_name = common_name($object, $class);
my %data_pack;
+
  my %data_pack;
 
 
$data_pack{'id'} = $object;
+
  $data_pack{'id'} = $object;
$data_pack{'name'} = $common_name;
+
  $data_pack{'name'} = $common_name;
$data_pack{'class'} = $class;
+
  $data_pack{'class'} = $class;
 
return \%data_pack;
 
 
 
 +
  return \%data_pack;
 
  }
 
  }
  

Revision as of 15:22, 8 March 2010

API Specs

  • Objects stop here -- what is passed to displays will be strings and numbers
  • Define data building blocks for common display formats -- lists, tables, build off these blocks
  • Provide consistent data access methods to above for display
  • Define common data packs? -- e.g. id and common names?
  • Analyze user reported data issues and build more robustness for common problems (e.g. object not found can't call method)

Notes 2010.02.04

  • The API need not be aware of presentation details. It doesn't need to know about tables, for example, although it should handle generic one and two dimensional arrays.
  • We may want to consider passing some objects through to templates. If we pass WormBase::API objects, templates can then do additional on-the-fly data extraction.
  • We probably DON'T want to pass Ace objects. This means that your data munging subroutines will need to do something like:
 $allele = $gene->Allele;
 $returned_data => { data => "$allele" };

This will stringify the name of the object and prevent it from being passed as an object.


Notes 2010.03.03

  • Maintain subsection level for return data structure -- most likely use hash for each anticipated data slot
  • Update elegansSubs subroutines to function in data pull mode here -- e.g. Object2URL will return a data structure containing data for generating URL
  • Another pack: Object2Human_readable_info, e.g. Common_name, GO_Term, etc.
  • For the template -- Update tableize, create form_URL, Objects for manipulating Ace data.

Notes 2010.03.08

  • more granular return data for API, data collation will be performed by controller
  • higher abstraction for Object::common_name to be used by all classes
 sub common_name {
  
   my $object = shift @_;
   my $class = shift @_;
   my $common_name;    
   
   if ($class =~ /gene/i) {

$common_name = $object->Public_name || $object->CGC_name || $object->Molecular_name || eval { $object->Corresponding_CDS->Corresponding_protein } || $object;

   }
   elsif ($class =~ /protein/i) {
   	$common_name = 
   	$object->Gene_name
   	|| eval { $object->Corresponding_CDS->Corresponding_protein }
   	||$object;
   }	
   
   my $data = $common_name;
   return $data;
}
  • package returned object into a hash containing name, id, and class information
sub compile_data_pack {
 my $object = shift @_;
 my $class = $object->class;
 my $common_name = common_name($object, $class);
 my %data_pack;
 $data_pack{'id'} = $object;
 $data_pack{'name'} = $common_name;
 $data_pack{'class'} = $class;
 return \%data_pack;	
}

Resources

You can find the API in the WormBase mercurial repository:

lib/WormBase/API


There are tests in t/

cd WormBase // the directory where you've checked out your code
prove -l t/API/Object/Gene.t

These are obviously dependent on being able to connect to the database...


Issues Table

Issue Notes Pros Cons
Let ACE objects through
minimal API programming breaking the MVC barriers
Allow API objects trough Need to create std. data passing structures; need to create methods which can use data structures maintain MVC barriers, flexibility for views; need programming from the view side more complex than letting ACE objects through
Create "query language" need to create std. data return structures; need standard syntax provides mechanisms to do complex queries involving data from related objects; with an accompanying data structure standard, easy access to returned data for view complexity, question of robustness
Code to deal with missing objects from tags Analyze user reported errors for priorities provide good measure of robustness added complexity to coding; use 80/20 rule
Learn the ropes of TT better provide more guidance re: above choices