dm-metamapper 0.1.0 → 0.1.1

data/lib/dm-metamapper/generator.rb

@@ -77,7 +77,7 @@ module DataMapper
           raise NoTemplateError, "Template does not exist at path #{template.full_path}"
         end
 
-        compiled = ERB.new(File.read(template.full_path)).result(binding)
+        compiled = ERB.new(File.read(template.full_path), nil, "%<>-").result(binding)
         path = respond_to?(:output_path) ? output_path(model, template) : template.output_name
         if !File.exists?(path) || File.read(path) != compiled
           File.open(path, 'w') {|f| f << compiled}

data/lib/dm-metamapper/template.rb

@@ -17,10 +17,10 @@ module DataMapper
       VALID_TYPES = [:global, :model]
 
       def initialize(name, opts={})
-        @name = name.to_s
-        @generator = parse_generator(opts.delete(:generator))
-        @type = parse_type(opts.delete(:type))
-        @template = (opts.delete(:template) || @name).to_s + ".erb"
+        @name          = name.to_s
+        @generator     = parse_generator(opts.delete(:generator))
+        @type          = parse_type(opts.delete(:type))
+        @template_name = parse_template(opts.delete(:template))
       end
 
       attr_reader :name, :type
@@ -30,23 +30,25 @@ module DataMapper
       end
 
       def full_path
-        File.join(@generator.config.template_dir, @template)
+        File.join(@generator.config.template_dir, @template_name)
       end
 
       private
 
       def parse_type(type)
-        unless type && VALID_TYPES.include?(type.to_sym)
-          raise InvalidTypeError, "type `#{type}' is not a recognized template " + 
-                                  "type. Valid types: #{VALID_TYPES.inspect}]" 
-        end
+        return type if type && VALID_TYPES.include?(type.to_sym)
 
-        type
+        raise InvalidTypeError, "type `#{type}' is not a recognized template " + 
+                                "type. Valid types: #{VALID_TYPES.inspect}]" 
       end
 
       def parse_generator(generator)
         generator || raise(NoGeneratorError, "opts did not contain :generator")
       end
+
+      def parse_template(template)
+        (template || @name).to_s + ".erb"
+      end
     end
   end
 end

data/lib/dm-metamapper/version.rb

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

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

@@ -1,5 +1,5 @@
-<% class_name = decolonize(model.name) %>
-<% all_caps_name = class_name.upcase %>
+<%- class_name = decolonize(model.name) -%>
+<%- all_caps_name = class_name.upcase -%>
 #ifndef T_<%= all_caps_name %>
 #define T_<%= all_caps_name %>
 #include "O_<%= class_name %>.hpp"
@@ -22,17 +22,18 @@ public:
     {
         _tables.push_back("<%= model.storage_name %>");
     }
-    <% many_to_one.each do |r| %> 
-    <% parent = decolonize(r[1].parent_model_name) %>
+
+    <%- many_to_one.each do |r| -%> 
+    <%- parent = decolonize(r[1].parent_model_name) -%>
     T_<%= class_name %>(const T_<%= parent %>& parent)
     {
         _tables.push_back("<%= model.storage_name %>");
         _tables.insert(_tables.end(), 
-	               parent._tables.begin(), parent._tables.end());
+                       parent._tables.begin(), parent._tables.end());
         
         _constraint._cond = "(<%= model.storage_name + "." + r[1].child_key.first.name.to_s %> = " + parent._tables[0] + ".<%= r[1].parent_key.first.name.to_s %>)";
         if (!parent._constraint.nil())
-	_constraint._cond += " AND " + parent._constraint._cond;
+        _constraint._cond += " AND " + parent._constraint._cond;
     } 
 
     T_<%= class_name %>(const I_<%= parent %>& parentId)
@@ -41,9 +42,9 @@ public:
         
         _constraint._cond = "(<%= model.storage_name + "." + r[1].child_key.first.name.to_s %> = " + parentId.to_s() + ")";
     } 
-    <% end %>
+    <%- end -%>
     
-    <% model.generated_properties.each do |property| %>
+    <%- model.generated_properties.each do |property| -%>
     struct E_<%= property.name %>{
         E_<%= property.name %>() 
         {  
@@ -57,14 +58,14 @@ public:
     E_<%= property.name %> _<%= property.name %>(){ 
         return E_<%= property.name %>();
     }
-    <% end %>    
+    <%- end -%>    
 
     void getFields(std::vector<std::string>& rFields)
     {
         rFields.clear();
-        <% model.generated_properties.each do |property| %>
+        <%- model.generated_properties.each do |property| -%>
         rFields.push_back("<%= property.name %>");
-        <% end %>
+        <%- end -%>
     }
 
     void select(const Condition& c, 
@@ -79,21 +80,21 @@ public:
                                    additional, res);
         r.resize(res.size());
         for(size_t i = 0; i < res.size(); ++i){
-            <% model.generated_properties.each do |property| %>
+            <%- model.generated_properties.each do |property| -%>
             r[i]._f_<%= property.name %>._base = 
-            <% if DataMapper::Property::Enum === property %>
+            <%- if DataMapper::Property::Enum === property -%>
                 (<%= property.cpp_name %>::Base)UTILS::fromString<size_t>(res[i]["<%= property.name %>"]);
-            <% else %>
+            <%- else -%>
                 UTILS::fromString<<%= property.cpp_name %>::Base>(res[i]["<%= property.name %>"]);
-            <% end %>
-            <% end %>
+            <%- end -%>
+            <%- end -%>
         }
     }
 
     size_t count(const Condition& c)
     {
         Condition c1 = _constraint.nil() ? c : _constraint && c;
-	return DBFace::instance()->count(_tables, c1._cond);
+        return DBFace::instance()->count(_tables, c1._cond);
     }
 
     void erase(const Condition& c)
@@ -101,6 +102,7 @@ public:
         Condition c1 = _constraint.nil() ? c : _constraint && c;
         DBFace::instance()->erase(_tables, c1._cond);
     }
+
     void erase()
     {   
         DBFace::instance()->erase(_tables, _constraint._cond);
@@ -113,6 +115,7 @@ public:
         Condition c1 = _constraint.nil() ? c : _constraint && c;
         select(c1, "", r);
     }
+
     void select(std::vector<O_<%= class_name %>>& r)
     {
         select(_constraint, "", r);
@@ -137,9 +140,29 @@ public:
         return first(_constraint);
     }
 
-
-
-
+    bool insertAllFields(std::vector<O_<%= class_name %>>::const_iterator begin,
+                         std::vector<O_<%= class_name %>>::const_iterator end)
+    {
+	std::vector<std::string> fields;
+        <%- model.generated_properties.each do |property| -%>
+        <% if property.name != model.serial.name %>
+        fields.push_back(std::string("<%= property.name %>"));
+        <%- end -%>
+        <%- end -%>
+	std::vector<std::vector<std::string> > rows;
+	for (; begin != end; ++begin){
+	    const O_<%= class_name %>& r = *begin;
+	    std::vector<std::string> row;
+	    <%- model.generated_properties.each do |property| -%>
+            <% if property.name != model.serial.name %>
+            row.push_back(UTILS::toString(r._<%= property.name %>()));
+            <%- end -%>
+            <%- end -%>
+	    rows.push_back(row);
+	}
+        return DBFace::instance()->insert("<%= model.storage_name %>",
+					  fields, rows);
+    }
 
     Condition                 _constraint;    
     std::vector<std::string>  _tables;

data/lib/templates/cpp/dmmm_dbface.cpp.erb

@@ -87,7 +87,8 @@ DBFace::select(const vector<string>& tables,
     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]] = UTILS::toString(mysqlRes[i][columns[j].c_str()]);
+	    if (!mysqlRes[i][columns[j].c_str()].is_null())
+ 	        rRes.back()[columns[j]] = UTILS::toString(mysqlRes[i][columns[j].c_str()]);
     }
     return true;
 }
@@ -167,6 +168,39 @@ DBFace::getLastInsertId(Query& rQuery, size_t& rId)
     return true;
 }
 
+bool 
+DBFace::insert(const string& table, 
+	       const vector<string>& fields,
+	       const vector<vector<string> >& rows)
+{
+    if (fields.size() == 0 || rows.size() == 0)
+	return true;
+
+    Query q = _connection.query();
+    q << "INSERT INTO " << table << " (";
+    for (size_t i = 0; i < fields.size(); ++i){
+	if (i != 0)
+	    q << ",";
+	q << fields[i];
+    }
+    q << ")VALUES";
+    for (size_t i = 0; i < rows.size(); ++i){
+	if (i != 0)
+	    q << ",";
+	q << "(";
+	for(size_t j = 0; j < rows[i].size(); ++j){
+	    if (j != 0)
+		q << ",";
+	    q << quote << rows[i][j];
+	}
+	q << ")";
+    }
+    log(q.str());
+    bool ok = executeQuery(q);
+    return ok;
+}
+
+
 bool 
 DBFace::insert(const string& table, 
 	       const map<string, string>& field2Val,

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

@@ -23,6 +23,11 @@ public:
     bool insert(const std::string& table, 
 		const std::map<std::string, std::string>& field2Val,
 		size_t& rInsertId);
+    bool insert(const std::string& table, 
+	        const std::vector<std::string>& fields,
+	        const std::vector<std::vector<std::string> >& rows);
+
+
     bool update(const std::string& table, 
 		const std::map<std::string, std::string>& field2Val,
 		const std::string& where);

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

@@ -5,12 +5,11 @@
 
 namespace DMMM {
 
-<% models.each do |model| %>
-<% model_name = decolonize(model.name) %>
+<%- models.each do |model| -%>
+<%- model_name = decolonize(model.name) -%>
 class DummyO_<%= model_name %>;
 typedef ID::Id<DummyO_<%= model_name %>> I_<%= model_name %>;
-<% end %>
-
+<%- end -%>
 
 } //namespace DMMM
 #endif //DMMM_IDENTIFIERS_HPP

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

@@ -1,5 +1,5 @@
-<% class_name = decolonize(model.name) %>
-<% all_caps_name = class_name.upcase %>
+<%- class_name = decolonize(model.name) -%>
+<%- all_caps_name = class_name.upcase -%>
 #ifndef O_<%= all_caps_name %>
 #define O_<%= all_caps_name %>
 
@@ -10,16 +10,13 @@
 #include "dmmm_identifiers.hpp"
 #include "dmmm_fields.hpp"
 #include "dmmm_comparators.hpp"
-<% many_to_one.each do |relative| %>
+<%- many_to_one.each do |relative| -%>
 #include "T_<%= decolonize(relative[1].parent_model.to_s) %>.hpp"
-<% end %>
+<%- end -%>
 
-<%# self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::OneToMany::Relationship'}.each do |relative| %>
-<%# end %>
-
-<% model.enums.each do |name, property| %>
+<%- model.enums.each do |name, property| -%>
 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 %>
+<%- end -%>
 
 namespace DMMM {
 
@@ -27,24 +24,24 @@ class O_<%= class_name %>{
 public:
 
     O_<%= class_name %>() {}
-    <% many_to_one.each do |r| %> 
-    <% parent = decolonize(r[1].parent_model_name) %>
+    <%- many_to_one.each do |r| -%> 
+    <%- parent = decolonize(r[1].parent_model_name) -%>
     O_<%= class_name %>(const O_<%= parent %>& parent) 
         : _f_<%= r[1].child_key.first.name.to_s %>(parent._<%= r[1].parent_key.first.name.to_s %>())
         {}
     O_<%= class_name %>(const I_<%= parent %>& parent_id) 
         : _f_<%= r[1].child_key.first.name.to_s %>(parent_id)
         {}
-    <% end %>
+    <%- end -%>
 
-    <% if model.serial %>
+    <%- if model.serial -%>
     O_<%= class_name %>(const I_<%= class_name %>& id) 
         : _f_<%= model.serial.name %>(id)
         {}
-    <% end %>
+    <%- end -%>
 
 
-    <% model.generated_properties.each do |property| %>
+    <%- model.generated_properties.each do |property| -%>
     const <%= property.cpp_name %>::Base& _<%= property.name %>() const { 
         return _f_<%= property.name %>._base; 
     }
@@ -52,71 +49,71 @@ public:
         _f_<%= property.name %>._dirty = true; 
         return _f_<%= property.name %>._base; 
     }
-    <% end %>
+    <%- end -%>
 
-    <% if model.serial %>
+    <%- if model.serial -%>
     bool update(){
         std::map<std::string, std::string> field2Val;
-        <% model.generated_properties.each do |property| %>
+        <%- model.generated_properties.each do |property| -%>
         if (_f_<%= property.name %>._dirty)
             field2Val["<%= property.name %>"] = 
                 UTILS::toString(_f_<%= property.name %>._base);
-        <% end %>
+        <%- end -%>
         std::string where =
-	    "<%= model.serial.name %>=" + UTILS::toString(_f_<%= model.serial.name %>._base);
+            "<%= model.serial.name %>=" + UTILS::toString(_f_<%= model.serial.name %>._base);
         if (DBFace::instance()->update("<%= model.storage_name %>", 
                                        field2Val, where))
         {
-            <% model.generated_properties.each do |property| %>
+            <%- model.generated_properties.each do |property| -%>
             _f_<%= property.name %>._dirty = false;
-            <% end %>
-	    return true;
-	}
-	else
-	    return false;
+            <%- end -%>
+            return true;
+        }
+        else
+            return false;
     }
-    <% end %>
+    <%- end -%>
 
     bool insert(){
         std::map<std::string, std::string> field2Val;
-        <% model.generated_properties.each do |property| %>
+        <%- model.generated_properties.each do |property| -%>
         if (_f_<%= property.name %>._dirty)
             field2Val["<%= property.name %>"] = 
                 UTILS::toString(_f_<%= property.name %>._base);
-        <% end %>
+        <%- end -%>
         <% if model.serial %>
         if (DBFace::instance()->
                 insert("<%= model.storage_name %>", field2Val,
                        _f_<%= model.serial.name %>._base.serialization()))
-	<% else %>
+        <%- else -%>
         size_t id;
         if (DBFace::instance()->
                 insert("<%= model.storage_name %>", field2Val,
-                       id))
-        <% end %>
+                    id))
+        <%- end -%>
         {
-            <% model.generated_properties.each do |property| %>
+            <%- model.generated_properties.each do |property| -%>
             _f_<%= property.name %>._dirty = false;
-            <% end %>
+            <%- end -%>
             return true;
         }
- 	else
-	    return false;
- 				   
+        else
+            return false;
+                                   
     }
 
-    <% many_to_one.each do |r| %> 
-    <% parent = decolonize(r[1].parent_model_name) %>
+    <%- many_to_one.each do |r| -%> 
+    <%- parent = decolonize(r[1].parent_model_name) -%>
     std::pair<O_<%= parent %>, bool> <%= r[0] %>(){
         T_<%= parent %> T(T_<%= parent %>::E_<%= r[1].parent_key.first.name.to_s %>() == _<%= r[1].child_key.first.name.to_s %>());
-	return T.first();
+        return T.first();
     }
-    <% end %>
+    <%- end -%>
 
 private:
-    <% model.generated_properties.each do |property| %>
+    <%- model.generated_properties.each do |property| -%>
     <%= property.cpp_name %> _f_<%= property.name %>;
-    <% end %>
+    <%- end -%>
 
     friend class T_<%= class_name %>;
 };

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dm-metamapper
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Jonah Honeyman
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-19 00:00:00 +02:00
+date: 2011-02-03 00:00:00 +02:00
 default_executable: 
 dependencies: []