dm-metamapper 0.0.11 → 0.1.0

data/lib/dm-metamapper.rb

@@ -1,4 +1,5 @@
-$:.push File.dirname(__FILE__)
+lib = File.dirname(__FILE__)
+$:.push lib unless $:.include?(lib)
 
 require 'dm-core'
 require 'dm-metamapper/property'

data/lib/dm-metamapper/generators/cpp.rb

@@ -27,7 +27,7 @@ module DataMapper
               "Field<I_#{decolonize(model.name)}>"
             elsif key_to_parent[prop.name]
               "Field<I_#{key_to_parent[prop.name]}>"
-            elsif prop.type.ancestors.include?(DataMapper::Types::Enum)
+            elsif DataMapper::Property::Enum === prop
               name = prop.name.to_s.upcase
               enums[name] = prop
               "Field<Enum#{decolonize(model.name)}#{name}>"

data/lib/dm-metamapper/property.rb

@@ -1,8 +1,6 @@
-if DataMapper::VERSION > "1.0"
-  module DataMapper
-    class Property
-      accept_options :skip_generation
-    end
+module DataMapper
+  class Property
+    accept_options :skip_generation
   end
 end
 

data/lib/dm-metamapper/version.rb

@@ -0,0 +1,6 @@
+module DataMapper 
+  module MetaMapper
+    VERSION = "0.1.0" unless defined?(::DataMapper::MetaMapper::VERSION)
+  end
+  
+end

data/lib/templates/cpp/class.hpp.erb

@@ -34,6 +34,13 @@ public:
         if (!parent._constraint.nil())
 	_constraint._cond += " AND " + parent._constraint._cond;
     } 
+
+    T_<%= class_name %>(const I_<%= parent %>& parentId)
+    {
+        _tables.push_back("<%= model.storage_name %>");
+        
+        _constraint._cond = "(<%= model.storage_name + "." + r[1].child_key.first.name.to_s %> = " + parentId.to_s() + ")";
+    } 
     <% end %>
     
     <% model.generated_properties.each do |property| %>
@@ -74,7 +81,7 @@ public:
         for(size_t i = 0; i < res.size(); ++i){
             <% model.generated_properties.each do |property| %>
             r[i]._f_<%= property.name %>._base = 
-            <% if property.type.ancestors.include?(DataMapper::Types::Enum) %>
+            <% if DataMapper::Property::Enum === property %>
                 (<%= property.cpp_name %>::Base)UTILS::fromString<size_t>(res[i]["<%= property.name %>"]);
             <% else %>
                 UTILS::fromString<<%= property.cpp_name %>::Base>(res[i]["<%= property.name %>"]);

data/lib/templates/cpp/dmmm_comparators.hpp~

@@ -0,0 +1,75 @@
+#ifndef PPORM_COMPARATORS_H
+#define PPORM_COMPARATORS_H
+
+#include <string>
+
+#include <sstream>
+
+namespace PPORM {
+template<class E>
+typename E::ConditionType operator== (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " = '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator< (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " < '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator<= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " <= '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator> (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " > '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator>= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " >= '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator!= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " != '" + toString(x) + "'";
+    return c;
+}
+
+template<class E>
+typename E::ConditionType operator%= (E e, const typename E::ComparerType& x){
+    typename E::ConditionType c;
+    c._cond = e._field + " LIKE '" + toString(x) + "'";
+    return c;
+}
+
+template<class C>
+C operator&& (const C& c1, const C& c2){
+    C c;
+    c._cond = "(" + c1._cond + ") AND (" + c2._cond + ")";
+    return c;
+}
+
+template<class C>
+C operator|| (const C& c1, const C& c2){
+    C c;
+    c._cond = "(" + c1._cond + ") OR (" + c2._cond + ")";
+    return c;
+}
+
+
+} //namespace PPORM
+
+#endif //PPORM_COMPARATORS_H

data/lib/templates/cpp/dmmm_dbface.cpp~

@@ -0,0 +1,190 @@
+#include "dbface.h"
+#include "utils.hpp"
+using namespace mysqlpp;
+using namespace std;
+
+DBFace* DBFace::_this = NULL;
+
+DBFace::DBFace(const string& database, const string& host, 
+	       const string& user, const string& password)
+    :_database(database)
+{
+    _this = this;
+    if (!_connection.connect(database.c_str(), host.c_str(), 
+			     user.c_str(), password.c_str())){
+        cerr << "Could not connect to DB";
+        exit(-1);
+    }     
+    _dbtype2BaseType["int"] = "int";
+    _dbtype2BaseType["bigint"] = "int";
+    _dbtype2BaseType["tinyint"] = "int";
+    _dbtype2BaseType["text"] = "std::string";
+    _dbtype2BaseType["float"] = "double";
+    _dbtype2BaseType["datetime"] = "std::string";
+    _dbtype2BaseType["date"] = "std::string";
+    _dbtype2BaseType["varchar"] = "std::string";
+}
+
+bool
+DBFace::select(const std::string& table, 
+	       const std::vector<string>& columns,
+	       const std::string& where, 
+	       const std::string& additional, 
+	       QueryRes& rRes)
+{
+    Query q = _connection.query();
+    
+    q << "SELECT ";
+    for (size_t i = 0; i < columns.size(); ++i){
+	if (i > 0)
+	    q << ",";
+	q << columns[i];
+    }
+    q << " FROM " << table;
+    if (where.size())
+	q << " WHERE " << where;
+    if (additional.size())
+	q << " " << additional;
+//    cout << q << endl;
+    StoreQueryResult mysqlRes;
+    try{
+	mysqlRes = q.store();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return false;
+    }
+    
+    for (size_t i = 0; i < mysqlRes.num_rows(); ++i){
+	rRes.resize(rRes.size() + 1);
+	for (size_t j = 0; j < columns.size(); ++j)
+	    rRes.back()[columns[j]] = toString(mysqlRes[i][columns[j].c_str()]);
+    }
+    return true;
+}
+
+bool
+DBFace:: selectTables(QueryRes& rRes)
+{
+    vector<string> columns;
+    columns.push_back("table_name");
+    string where = "table_schema='" + _database + "'";
+    return select("information_schema.tables", columns, where, "", rRes);
+}
+
+
+bool
+DBFace::selectColumns(const string& table, QueryRes& rRes)
+{
+    vector<string> columns;
+    columns.push_back("column_name");
+    columns.push_back("data_type");
+    string where = 
+	"table_schema='" + _database + 
+	"'" + " and table_name='" + table + "'";
+    return select("information_schema.columns", columns, where, "", rRes);
+}
+
+
+void
+DBFace::getTables(vector<Table>& rTables)
+{
+    QueryRes res;
+    selectTables(res);
+    for (size_t i = 0; i < res.size(); ++i){
+	rTables.resize(rTables.size() + 1);
+	Table& table = rTables.back();
+	table._name = res[i]["table_name"];
+	QueryRes resCols;
+	selectColumns(res[i]["table_name"], resCols);
+	table._hasId = false;
+	for (size_t j = 0; j < resCols.size(); ++j){
+	    Column col;
+	    col._field = resCols[j]["column_name"];
+	    col._type = resCols[j]["data_type"];
+	    table._columns.push_back(col);
+	    if (col._field == "id")
+		table._hasId = true;
+	}
+    }    
+}
+
+bool
+DBFace::executeQuery(Query& q)
+{
+    boost::mutex::scoped_lock lock(_mutex);
+    try{
+        q.execute();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return false;
+    }
+    return true;
+}
+
+bool 
+DBFace::insert(const string& table, 
+	       const map<string, string>& field2Val)
+{
+    if (field2Val.size() == 0)
+	return true;
+
+    Query q = _connection.query();
+    q << "INSERT INTO " << table << " (";
+    for (map<string, string>::const_iterator it = field2Val.begin(); 
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << it->first;
+    }
+    q << ")VALUES(";
+    for (map<string, string>::const_iterator it = field2Val.begin(); 
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << quote << it->second;
+    }
+    q << ")";
+    return executeQuery(q);
+}
+
+bool
+DBFace::update(const string& table, 
+	       const map<string, string>& field2Val,
+	       const string& where)
+{
+    Query q = _connection.query();
+    
+    q << "UPDATE " << table << " SET ";
+    for (map<string, string>::const_iterator it = field2Val.begin();
+	 it != field2Val.end(); ++it)
+    {
+	if (it != field2Val.begin())
+	    q << ",";
+	q << it->first << "=" << quote << it->second;
+    }
+    if (where.size())
+	q << " WHERE " << where;
+//    cout << q << endl;
+    return executeQuery(q);
+}
+
+string 
+DBFace::now()
+{
+    Query q = _connection.query();
+    
+    q << "SELECT NOW()";
+    StoreQueryResult mysqlRes;
+    try{
+	mysqlRes = q.store();
+    }
+    catch (const mysqlpp::Exception& er) {
+        cerr << "Query failed: " << q << endl << er.what();
+        return string();
+    }
+    return toString(mysqlRes[0]["now()"]);
+}

data/lib/templates/cpp/dmmm_dbface.h~

@@ -0,0 +1,47 @@
+#ifndef DBFACE_H
+#define DBFACE_H
+
+#include <map>
+#include <mysql++.h>
+#include <boost/thread/mutex.hpp>
+#include "pporm.h"
+
+
+class DBFace{
+public:
+    static DBFace* instance() { return _this; }
+    
+    DBFace(const std::string& database, const std::string& host, 
+	   const std::string& user, const std::string& password);
+    
+    bool insert(const std::string& table, 
+		const std::map<std::string, std::string>& field2Val);
+    bool update(const std::string& table, 
+		const std::map<std::string, std::string>& field2Val,
+		const std::string& where);
+    bool select(const std::string& table, 
+		const std::vector<std::string>& columns,
+		const std::string& where,
+		const std::string& additional,		
+		QueryRes& rRes);
+    bool selectTables(QueryRes& rRes);
+    bool selectColumns(const std::string& table, QueryRes& rRes);
+    void getTables(std::vector<Table>& rTables);
+    const std::map<std::string, std::string>& dbtype2BaseType() const 
+	{ return _dbtype2BaseType; }
+    
+    std::string now(); 
+    
+private:
+    bool executeQuery(mysqlpp::Query& rQuery);
+    
+private:
+    mysqlpp::Connection                 _connection;
+    const std::string                   _database;
+    std::map<std::string, std::string>  _dbtype2BaseType;
+    mutable boost::mutex                _mutex;
+    static DBFace*                      _this;		
+};
+
+
+#endif //DB_H

data/lib/templates/cpp/dmmm_fields.hpp.erb~

@@ -0,0 +1,27 @@
+#ifndef PPORM_FIELDS_H
+#define PPORM_FIELDS_H
+
+#include <string>
+
+#include <sstream>
+
+#include "utils.hpp"
+
+namespace PPORM {
+
+template<class T>
+struct Field{
+    Field<T>() :_dirty(false) {}
+    typedef T Base;
+    bool _dirty;
+    T _base;
+}; //class Field
+
+typedef Field<int> F_Integer;
+typedef Field<double> F_Float;
+typedef Field<std::string> F_String;
+typedef Field<bool> F_TrueString;
+
+} //namespace PPORM
+
+#endif //PPORM_FIELDS_H

data/lib/templates/cpp/dmmm_fields.hpp~

@@ -0,0 +1,31 @@
+#ifndef PPORM_FIELDS_H
+#define PPORM_FIELDS_H
+
+#include <string>
+
+#include <sstream>
+
+#include "utils.hpp"
+
+namespace PPORM {
+
+template<class T>
+struct Field{
+    Field<T>() :_dirty(false) {}
+    typedef T Base;
+    bool _dirty;
+    T _base;
+}; //class Field
+
+typedef Field<int> F_bigint;
+typedef Field<std::string> F_date;
+typedef Field<std::string> F_datetime;
+typedef Field<double> F_float;
+typedef Field<int> F_int;
+typedef Field<std::string> F_text;
+typedef Field<int> F_tinyint;
+typedef Field<std::string> F_varchar;
+
+} //namespace PPORM
+
+#endif //PPORM_FIELDS_H

data/lib/templates/cpp/dmmm_id.h~

@@ -0,0 +1,75 @@
+#ifndef	_ID_HPP
+#define	_ID_HPP
+
+#include <iosfwd>
+#include <string>
+#include <sstream>
+
+namespace PPORM{
+template<class T>
+class Id {
+
+public:
+    explicit Id(size_t id) : _id(id) {}
+    Id() {}
+
+    inline Id operator++() { 
+	++_id; return *this; 
+    }
+    
+    inline Id operator++(int) { 
+	Id val=*this; 
+	++*this; 
+	return val; 
+    }
+
+    inline bool operator==(const Id& that) const { 
+	return _id == that._id; 
+    }
+    inline bool operator< (const Id& that) const { 
+	return _id <  that._id; 
+    }
+    inline bool operator<=(const Id& that) const { 
+	return _id <= that._id; 
+    }
+    inline bool operator> (const Id& that) const { 
+	return _id > that._id; 
+    }
+    inline bool operator!=(const Id& that) const { 
+	return ! (*this == that); 
+    }
+
+    std::string to_s() const {
+        std::ostringstream oss;
+	oss << _id;
+        return oss.str();
+    }
+
+
+    inline size_t& serialization() { return _id; }
+
+private:
+    size_t _id;
+
+};
+
+
+}; //namespace PPORM
+
+template<class T>
+std::ostream& 
+operator<< (std::ostream& os, const PPORM::Id<T>& id)
+{ 
+    os << id.to_s(); 
+    return os;
+}
+
+template<class T>
+std::istream& 
+operator>> (std::istream& is, PPORM::Id<T>& id)
+{ 
+    is >> id.serialization(); 
+    return is;
+}
+
+#endif //_ID_HPP

data/lib/templates/cpp/dmmm_identifiers.hpp~

@@ -0,0 +1,208 @@
+#ifndef PPORM_IDENTIFIERS_HPP
+#define PPORM_IDENTIFIERS_HPP
+
+#include "id.hpp"
+
+namespace PPORM {
+
+class DummyO_AccountIssues;
+typedef Id<DummyO_AccountIssues> I_AccountIssues;
+
+class DummyO_AccountResearchKeywords;
+typedef Id<DummyO_AccountResearchKeywords> I_AccountResearchKeywords;
+
+class DummyO_Accounts;
+typedef Id<DummyO_Accounts> I_Accounts;
+
+class DummyO_AdminProps;
+typedef Id<DummyO_AdminProps> I_AdminProps;
+
+class DummyO_Assignments;
+typedef Id<DummyO_Assignments> I_Assignments;
+
+class DummyO_Backlinks;
+typedef Id<DummyO_Backlinks> I_Backlinks;
+
+class DummyO_Broadcasts;
+typedef Id<DummyO_Broadcasts> I_Broadcasts;
+
+class DummyO_Canonicals;
+typedef Id<DummyO_Canonicals> I_Canonicals;
+
+class DummyO_ClankPages;
+typedef Id<DummyO_ClankPages> I_ClankPages;
+
+class DummyO_ClankPlacements;
+typedef Id<DummyO_ClankPlacements> I_ClankPlacements;
+
+class DummyO_ClankSourceKeywords;
+typedef Id<DummyO_ClankSourceKeywords> I_ClankSourceKeywords;
+
+class DummyO_ClankSources;
+typedef Id<DummyO_ClankSources> I_ClankSources;
+
+class DummyO_Competitions;
+typedef Id<DummyO_Competitions> I_Competitions;
+
+class DummyO_Contacts;
+typedef Id<DummyO_Contacts> I_Contacts;
+
+class DummyO_Diagnostics;
+typedef Id<DummyO_Diagnostics> I_Diagnostics;
+
+class DummyO_Differentials;
+typedef Id<DummyO_Differentials> I_Differentials;
+
+class DummyO_DriveBackLogs;
+typedef Id<DummyO_DriveBackLogs> I_DriveBackLogs;
+
+class DummyO_DriveTasks;
+typedef Id<DummyO_DriveTasks> I_DriveTasks;
+
+class DummyO_Emphases;
+typedef Id<DummyO_Emphases> I_Emphases;
+
+class DummyO_ErrorReports;
+typedef Id<DummyO_ErrorReports> I_ErrorReports;
+
+class DummyO_GoogleSuggestions;
+typedef Id<DummyO_GoogleSuggestions> I_GoogleSuggestions;
+
+class DummyO_HashCount;
+typedef Id<DummyO_HashCount> I_HashCount;
+
+class DummyO_HistoricalRankingPowers;
+typedef Id<DummyO_HistoricalRankingPowers> I_HistoricalRankingPowers;
+
+class DummyO_HistoricalScores;
+typedef Id<DummyO_HistoricalScores> I_HistoricalScores;
+
+class DummyO_HttpErrors;
+typedef Id<DummyO_HttpErrors> I_HttpErrors;
+
+class DummyO_Images;
+typedef Id<DummyO_Images> I_Images;
+
+class DummyO_IssuePageClasses;
+typedef Id<DummyO_IssuePageClasses> I_IssuePageClasses;
+
+class DummyO_IssuePages;
+typedef Id<DummyO_IssuePages> I_IssuePages;
+
+class DummyO_Issues;
+typedef Id<DummyO_Issues> I_Issues;
+
+class DummyO_KeywordExclusions;
+typedef Id<DummyO_KeywordExclusions> I_KeywordExclusions;
+
+class DummyO_Keywords;
+typedef Id<DummyO_Keywords> I_Keywords;
+
+class DummyO_Links;
+typedef Id<DummyO_Links> I_Links;
+
+class DummyO_LoggedActions;
+typedef Id<DummyO_LoggedActions> I_LoggedActions;
+
+class DummyO_MirrorLogs;
+typedef Id<DummyO_MirrorLogs> I_MirrorLogs;
+
+class DummyO_NonHtmls;
+typedef Id<DummyO_NonHtmls> I_NonHtmls;
+
+class DummyO_Notifications;
+typedef Id<DummyO_Notifications> I_Notifications;
+
+class DummyO_PageClasses;
+typedef Id<DummyO_PageClasses> I_PageClasses;
+
+class DummyO_PageHeaders;
+typedef Id<DummyO_PageHeaders> I_PageHeaders;
+
+class DummyO_PageSearchKeywords;
+typedef Id<DummyO_PageSearchKeywords> I_PageSearchKeywords;
+
+class DummyO_PageTrackedKeywords;
+typedef Id<DummyO_PageTrackedKeywords> I_PageTrackedKeywords;
+
+class DummyO_Pages;
+typedef Id<DummyO_Pages> I_Pages;
+
+class DummyO_PlacementContacts;
+typedef Id<DummyO_PlacementContacts> I_PlacementContacts;
+
+class DummyO_Rankings;
+typedef Id<DummyO_Rankings> I_Rankings;
+
+class DummyO_Redirects;
+typedef Id<DummyO_Redirects> I_Redirects;
+
+class DummyO_SavedSearches;
+typedef Id<DummyO_SavedSearches> I_SavedSearches;
+
+class DummyO_SearchCompetitionKeywords;
+typedef Id<DummyO_SearchCompetitionKeywords> I_SearchCompetitionKeywords;
+
+class DummyO_SearchCompetitions;
+typedef Id<DummyO_SearchCompetitions> I_SearchCompetitions;
+
+class DummyO_SearchEngineSearchKeywords;
+typedef Id<DummyO_SearchEngineSearchKeywords> I_SearchEngineSearchKeywords;
+
+class DummyO_SearchEngines;
+typedef Id<DummyO_SearchEngines> I_SearchEngines;
+
+class DummyO_SearchKeywords;
+typedef Id<DummyO_SearchKeywords> I_SearchKeywords;
+
+class DummyO_Searches;
+typedef Id<DummyO_Searches> I_Searches;
+
+class DummyO_Sessions;
+typedef Id<DummyO_Sessions> I_Sessions;
+
+class DummyO_Settings;
+typedef Id<DummyO_Settings> I_Settings;
+
+class DummyO_StatusUpdateTypes;
+typedef Id<DummyO_StatusUpdateTypes> I_StatusUpdateTypes;
+
+class DummyO_StatusUpdates;
+typedef Id<DummyO_StatusUpdates> I_StatusUpdates;
+
+class DummyO_TableSettings;
+typedef Id<DummyO_TableSettings> I_TableSettings;
+
+class DummyO_Taggings;
+typedef Id<DummyO_Taggings> I_Taggings;
+
+class DummyO_Tags;
+typedef Id<DummyO_Tags> I_Tags;
+
+class DummyO_ToolsCompetitors;
+typedef Id<DummyO_ToolsCompetitors> I_ToolsCompetitors;
+
+class DummyO_ToolsResearchKeywords;
+typedef Id<DummyO_ToolsResearchKeywords> I_ToolsResearchKeywords;
+
+class DummyO_ToolsSuggestions;
+typedef Id<DummyO_ToolsSuggestions> I_ToolsSuggestions;
+
+class DummyO_Tooltips;
+typedef Id<DummyO_Tooltips> I_Tooltips;
+
+class DummyO_TrackedBacklinks;
+typedef Id<DummyO_TrackedBacklinks> I_TrackedBacklinks;
+
+class DummyO_TrackedKeywords;
+typedef Id<DummyO_TrackedKeywords> I_TrackedKeywords;
+
+class DummyO_Users;
+typedef Id<DummyO_Users> I_Users;
+
+class DummyO_Wikilinks;
+typedef Id<DummyO_Wikilinks> I_Wikilinks;
+
+
+} //namespace PPORM
+#endif //PPORM_IDENTIFIERS_HPP

data/lib/templates/cpp/dmmm_utils.cpp.erb~

@@ -0,0 +1,8 @@
+#include "dmmm_utils.hpp"
+
+template<>
+std::string
+fromString<std::string>(const std::string& s)
+{
+    return s;
+}

data/lib/templates/cpp/dmmm_utils.hpp~

@@ -0,0 +1,39 @@
+#ifndef UTILS_HPP
+#define UTILS_HPP
+
+#include <vector>
+#include <map>
+#include <sstream>
+
+template<class T>
+std::string
+toString(const T& t)
+{
+    std::ostringstream oss;
+    oss << t;
+    
+    return oss.str();
+}
+
+template<class T>
+T
+fromString(const std::string& s)
+{
+    std::istringstream iss;
+    iss.str(s);
+    
+    T ret;
+    iss >> ret;
+    
+    return ret;
+}
+
+template<>
+std::string
+fromString<std::string>(const std::string& s)
+{
+    return s;
+}
+
+
+#endif //UTILS_HPP

data/lib/templates/cpp/instance.hpp.erb

@@ -18,7 +18,7 @@
 <%# end %>
 
 <% model.enums.each do |name, property| %>
-enum Enum<%= class_name %><%= name %> { <%= property.type.flag_map.map{|v, k| class_name.upcase + "_" + property.name.to_s.upcase + "_" + k.to_s.sub(".","_").upcase + " = " + v.to_s}.join(", ") %> };
+enum Enum<%= class_name %><%= name %> { <%= property.flag_map.map{|v, k| class_name.upcase + "_" + property.name.to_s.upcase + "_" + k.to_s.sub(".","_").upcase + " = " + v.to_s}.join(", ") %> };
 <% end %>
 
 namespace DMMM {

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dm-metamapper
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 11
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors: 
 - Jonah Honeyman
@@ -15,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-08 00:00:00 -04:00
+date: 2010-12-19 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -28,38 +29,35 @@ extensions: []
 extra_rdoc_files: 
 - README.md
 files: 
-- .autospec
-- .gitignore
-- Gemfile
-- README.md
-- Rakefile
-- VERSION
-- example/.gitignore
-- example/Makefile
-- example/example.cpp
-- example/example.rb
-- lib/dm-metamapper.rb
-- lib/dm-metamapper/config.rb
 - lib/dm-metamapper/generator.rb
-- lib/dm-metamapper/generators/cpp.rb
-- lib/dm-metamapper/metamapper.rb
 - lib/dm-metamapper/model.rb
+- lib/dm-metamapper/config.rb
+- lib/dm-metamapper/generators/cpp.rb
 - lib/dm-metamapper/property.rb
+- lib/dm-metamapper/version.rb
+- lib/dm-metamapper/metamapper.rb
 - lib/dm-metamapper/template.rb
-- lib/templates/cpp/class.hpp.erb
-- lib/templates/cpp/dmmm_comparators.hpp.erb
+- lib/dm-metamapper.rb
+- lib/templates/cpp/dmmm_fields.hpp~
 - lib/templates/cpp/dmmm_dbface.cpp.erb
-- lib/templates/cpp/dmmm_dbface.h.erb
+- lib/templates/cpp/dmmm_utils.hpp~
+- lib/templates/cpp/dmmm_id.h~
+- lib/templates/cpp/dmmm_identifiers.hpp.erb
+- lib/templates/cpp/dmmm_utils.cpp.erb~
+- lib/templates/cpp/dmmm_dbface.h~
+- lib/templates/cpp/dmmm_fields.hpp.erb~
+- lib/templates/cpp/dmmm_comparators.hpp~
+- lib/templates/cpp/dmmm_comparators.hpp.erb
 - lib/templates/cpp/dmmm_fields.hpp.erb
+- lib/templates/cpp/dmmm_dbface.h.erb
+- lib/templates/cpp/instance.hpp.erb
 - lib/templates/cpp/dmmm_id.hpp.erb
-- lib/templates/cpp/dmmm_identifiers.hpp.erb
 - lib/templates/cpp/dmmm_utils.cpp.erb
+- lib/templates/cpp/dmmm_dbface.cpp~
 - lib/templates/cpp/dmmm_utils.hpp.erb
-- lib/templates/cpp/instance.hpp.erb
-- spec/dm-metamapper/generator_spec.rb
-- spec/dm-metamapper/template_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
+- lib/templates/cpp/class.hpp.erb
+- lib/templates/cpp/dmmm_identifiers.hpp~
+- README.md
 has_rdoc: true
 homepage: http://github.com/jonuts/dm-metamapper
 licenses: []
@@ -70,27 +68,31 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 23
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.6
+rubyforge_project: dm-metamapper
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Code generating C++ ORM
-test_files: 
-- spec/spec_helper.rb
-- spec/dm-metamapper/generator_spec.rb
-- spec/dm-metamapper/template_spec.rb
+test_files: []
+

data/.autospec

@@ -1,6 +0,0 @@
-Autotest.add_hook :reset do |at|
-  at.clear_mappings
-  at.add_exception(/\.git/)
-  at.add_mapping(%r{^spec/.*_spec}) {|name,_| at.files_matching(/#{name}/)}
-  at.add_mapping(//) {|_,_| at.files_matching %r{spec/.*_spec}}
-end

data/.gitignore

@@ -1,6 +0,0 @@
-*~
-*.sw[p|o]
-.bundle/*
-.rvmrc
-*.gem
-output

data/Gemfile

@@ -1,22 +0,0 @@
-source :rubygems
-
-dm_gems_version   = "~> 0.10"
-do_gems_version   = "~> 0.10"
-
-gem "dm-core", dm_gems_version
-gem "dm-types", dm_gems_version
-
-
-group :test do
-  gem "rspec"
-  gem "data_objects"
-  gem "do_sqlite3", do_gems_version
-  gem "do_mysql", do_gems_version
-  gem "ZenTest"
-end
-
-group :deploy do
-  gem "jeweler"
-end
-
-# vim: set ft=ruby:

data/Rakefile

@@ -1,24 +0,0 @@
-begin
-  require 'bundler'
-  Bundler.setup :deploy
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "dm-metamapper"
-    gemspec.summary = "Code generating C++ ORM"
-    gemspec.description = "C++ API for databases created with DM. Hard typing, compile time checked queries."
-    gemspec.email = "jonah@honeyman.org"
-    gemspec.homepage = "http://github.com/jonuts/dm-metamapper"
-    gemspec.authors = ["Jonah Honeyman", "Omer Tamuz"]
-  end
-rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
-end
-
-desc "local gem build and install"
-task :local do
-  sh "rvm ree@drive"
-  sh "gem uninstall -a dm-metamapper"
-  sh "gem build dm-metamapper.gemspec"
-  version = File.read("VERSION").chomp
-  sh "gem install -l ./dm-metamapper-#{version}.gem"
-end

data/VERSION

@@ -1 +0,0 @@
-0.0.11

data/example/.gitignore

@@ -1 +0,0 @@
-example

data/example/Makefile

@@ -1,4 +0,0 @@
-all:
-	echo "generating code"
-	cd ..; 	bundle exec ruby -r example/example.rb -e "DataMapper::MetaMapper.generate(:cpp, :output_dir => './output')"
-	g++ ../output/dmmm_utils.cpp ../output/dmmm_dbface.cpp example.cpp -I ../output -I /usr/include/mysql -I /usr/local/include/mysql++ -I /usr/local/mysql/include/mysql -lmysqlpp -lmysqlclient /usr/lib/libboost_thread-mt.so -L/usr/lib -L/usr/local/lib -Wall -o example

data/example/example.cpp

@@ -1,78 +0,0 @@
-#include <vector>
-#include "dmmm_dbface.h"
-#include "T_User.hpp"
-#include "T_Dog.hpp"
-#include "T_LittleFlea.hpp"
-
-using namespace std;
-using namespace DMMM;
-
-int main(int argc, char* argv[])
-{
-    string host("localhost");
-    string user("root");
-    string database("dmmm");
-    string password("");
-    DBFace dbFace(database, host, user, password, &cout);
-
-    T_Dog d;
-    T_User u;
-    d.erase();
-    u.erase();
-
-    O_User u1;
-    u1._name() = "omer";
-    u1._balance() = 5.3;
-    u1._weight() = 10;
-    u1.insert();
-    
-    O_Dog d1;
-    d1._user_id() = u1._id();
-    d1._name() = "spot";
-    d1._stinks() = true;
-    d1._color() = DOG_COLOR_WHITE;
-    d1.insert();
-
-    d1 = d.select(d1._id()).first;
-
-    O_Dog d2(u1);
-    d2._name() = "rover";
-    d2._stinks() = false;
-    d2.insert();
-
-    O_User u2;
-    u2._name() = "jonah";
-    u2.insert();
-
-    O_Dog d3(u2._id());
-    d3._name() = "rover";
-    d3._stinks() = false;
-    d3.insert();
-
-    O_LittleFlea f1(d3);
-    f1.insert();
-    
-    vector<O_Dog> dogs;
-    d.select((d._stinks() == false) && (d._name() %= "\%over"), dogs);
-    for(size_t i = 0; i < dogs.size(); ++i){
-	dogs[i]._name() = string("good_") + dogs[i]._name();
-	dogs[i].update();
-	cout << dogs[i]._name() 
-	     << " belongs to " << dogs[i].user().first._name() 
-	     << endl;
-    }
-
-
-    T_Dog dconst(T_User(u._name() == "omer"));
-    dogs.clear();
-    dconst.select(d._stinks() == true, dogs);
-    cout << dogs.size() 
-	 << " dogs meet criterion" << endl;
-    cout << dconst.count(d._stinks() == true) 
-	 << " dogs meet criterion" << endl;
-    dconst.erase();
-
-    d.erase(d._user_id() == u2._id());
-
-    return 0;
-}

data/example/example.rb

@@ -1,50 +0,0 @@
-require "erb"
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-require "dm-core"
-require "dm-types"
-require File.expand_path("../../lib/dm-metamapper.rb", __FILE__)
-require "dm-metamapper/generators/cpp"
-
-#DataMapper.setup(:default, "sqlite3::memory:")
-DataMapper.setup(:default, "mysql://root@localhost/dmmm")
-
-COLORS = [
-  :blue,
-  :white,
-  "light.red"
-]
-
-class User
-  include DataMapper::Resource
-
-  has n,    :dogs
-
-  property :id,           Serial
-  property :name,         String
-  property :balance,      Float
-  property :weight,       Integer
-end
-
-class Dog
-  include DataMapper::Resource
-
-  belongs_to :user
-  has n,     :little_fleas
-
-  property :id,       Serial
-  property :user_id,  Integer
-  property :name,     String
-  property :color,    Enum[*COLORS]
-  property :stinks,   Boolean
-end
-
-class LittleFlea
-  include DataMapper::Resource
-
-  belongs_to :dog
-
-  property :id,       Serial
-  property :dog_id,   Integer
-end

data/spec/dm-metamapper/generator_spec.rb

@@ -1,62 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-class MyGenerator < DMMM::Generator;end
-
-class LolModel
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-end
-
-describe "Generator" do
-  describe "General" do
-    it "is configurable" do
-      MyGenerator.config.should == DMMM.instance_variable_get(:@_default_opts)
-    end
-
-    it "stores a block to extend models" do
-      blk = proc { @__foo__ = "lol" }
-      MyGenerator.send(:setup_model, &blk)
-      MyGenerator.setup_model_blk.should == blk
-    end
-  end
-
-  describe "Templates" do
-    it "has a template store" do
-      DMMM::TemplateCollection.should === MyGenerator.generated_files
-    end
-
-    it "stores template info" do
-      MyGenerator.send(:generates_file, :model, "foo")
-      MyGenerator.generated_files.size.should == 1
-      MyGenerator.generated_files.first.name.should == "foo"
-    end
-  end
-
-  describe ".new" do
-    before :each do
-      MyGenerator.instance_variable_set :@generated_files, DMMM::TemplateCollection.new
-      model_files = ["foo", "bar", "baz", "bleh"]
-
-      model_files.each do |f|
-        MyGenerator.send :generates_file, :model, f
-      end
-    end
-
-    it "requires model info" do
-      lambda {MyGenerator.new}.should raise_error(ArgumentError)
-    end
-
-    it "has model templates when called with model" do
-      @generator = MyGenerator.new(LolModel)
-      @generator.instance_variable_get(:@templates).should == MyGenerator.generated_files.models
-    end
-
-    it "has global templates when called without model" do
-      @generator = MyGenerator.new nil
-      @generator.instance_variable_get(:@templates).should == MyGenerator.generated_files.global
-    end
-  end
-end
-

data/spec/dm-metamapper/template_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path("../../spec_helper", __FILE__)
-
-class LolGenerator < DMMM::Generator; end
-
-describe "Template" do
-  describe "invalid" do
-    it "requires a name" do
-      lambda {DMMM::Template.new}.should raise_error(ArgumentError)
-    end
-
-    it "requires a generator" do
-      lambda {DMMM::Template.new(:foo)}.should raise_error(DMMM::NoGeneratorError)
-    end
-
-    it "requires a valid type" do
-      lambda {DMMM::Template.new(:few, generator: LolGenerator)}.
-        should raise_error(DMMM::InvalidTypeError)
-    end
-  end
-
-  describe "valid" do
-    before :all do
-      @template = DMMM::Template.new :foo, 
-        generator: LolGenerator,
-        type: :global
-    end
-  end
-end
-

data/spec/spec.opts

@@ -1,4 +0,0 @@
---colour
---loadby random
---format profile
---backtrace

data/spec/spec_helper.rb

@@ -1,10 +0,0 @@
-$:.push File.expand_path('../lib', __FILE__)
-
-require 'rubygems'
-require 'bundler'
-Bundler.setup(:default, :test)
-require 'spec'
-
-require 'dm-metamapper'
-
-DMMM = DataMapper::MetaMapper