dm-metamapper 0.0.3 → 0.0.4

data/.autospec

@@ -0,0 +1,6 @@
+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

@@ -3,3 +3,5 @@
 .bundle/*
 .rvmrc
 *.gem
+*.gemspec
+output

data/Gemfile

@@ -10,6 +10,7 @@ group :test do
   gem "data_objects"
   gem "do_sqlite3", do_gems_version
   gem "do_mysql", do_gems_version
+  gem "ZenTest"
 end
 
 group :deploy do

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/example/Makefile

@@ -1,4 +1,4 @@
 all:
 	echo "generating code"
-	cd ..; 	bundle exec ruby -r example/example.rb -e "DataMapper::MetaMapper.generate(:cpp)"
+	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.rb

@@ -4,6 +4,7 @@ require "bundler"
 Bundler.setup(:default, :test)
 require "dm-core"
 require "lib/dm-metamapper.rb"
+require "dm-metamapper/generators/cpp"
 
 #DataMapper.setup(:default, "sqlite3::memory:")
 DataMapper.setup(:default, "mysql://root@localhost/dmmm")
@@ -12,8 +13,6 @@ class User
   include DataMapper::Resource
   extend DataMapper::MetaMapper::Extension
 
-  generates :cpp
-
   has n,    :dogs
 
   property :id,           Serial
@@ -26,8 +25,6 @@ class Dog
   include DataMapper::Resource
   extend DataMapper::MetaMapper::Extension
 
-  generates :cpp
-
   belongs_to :user
   has n,     :little_fleas
 
@@ -41,8 +38,6 @@ class LittleFlea
   include DataMapper::Resource
   extend DataMapper::MetaMapper::Extension
 
-  generates :cpp
- 
   belongs_to :dog
 
   property :id,       Serial

data/lib/dm-metamapper/config.rb

@@ -0,0 +1,21 @@
+module DataMapper
+  module MetaMapper
+    class Config < Hash
+      def initialize
+        super
+        self.merge! DataMapper::MetaMapper._default_opts
+      end
+
+      alias_method :use, :merge!
+
+      def method_missing(meth, *args)
+        if keys.include?(meth.to_sym)
+          self[meth.to_sym]
+        else
+          raise NoMethodError, "undefined method `#{meth}' for #{self.class}:#{self.class.class}"
+        end
+      end
+    end
+  end
+end
+

data/lib/dm-metamapper/extension.rb

@@ -1,12 +1,14 @@
 module DataMapper
   module MetaMapper
     module Extension
-      def generates(*layouts)
-        @_generation_formats = Array(layouts)
+      def doesnt_generate(*layouts)
+        @_skipped_generation_formats = Array(layouts)
       end
+      alias_method :dont_generate, :doesnt_generate
+      alias_method :skip_generation, :doesnt_generate
 
       def generates?(format)
-        @_generation_formats.include?(format)
+        !@_skipped_generation_formats.include?(format)
       end
 
       def generate(format)
@@ -19,16 +21,11 @@ module DataMapper
         }
       end
 
-      def _get_binding
-        binding
-      end
-
       def self.extended(base)
         DataMapper::MetaMapper.register(base)
-        base.instance_variable_set(:@_generation_formats, [])
-        class <<base; attr_reader :_generation_formats end
+        base.instance_variable_set(:@_skipped_generation_formats, [])
+        class <<base; attr_reader :_skipped_generation_formats end
       end
-
     end
   end
 end

data/lib/dm-metamapper/generator.rb

@@ -1,33 +1,15 @@
 module DataMapper
   module MetaMapper
     class Generator
-      class GeneratedFile
-        def initialize(&blk)
-          instance_eval(&blk) if block_given?
-        end
-
-        attr_reader :template, :file_name_prefix, :file_name_suffix
-
-        def template_name(template)
-          @template = template
-        end
-
-        def prefix(str)
-          @file_name_prefix = str
-        end
-
-        def suffix(str)
-          @file_name_suffix = str
-        end
-      end
+      class NoTemplateError < StandardError; end
 
       @subclasses = []
 
       class << self
         attr_reader :subclasses,
-                    :generated_model_files,
-                    :generated_global_files,
-                    :proxy_blk
+                    :generated_files,
+                    :config,
+                    :setup_model_blk
 
         def [](generator)
           @subclasses.find {|klass| klass.generator_name == generator}
@@ -38,77 +20,72 @@ module DataMapper
           @generator_name = name
         end
 
-        private
-
-        def generates_file(&blk)
-          @generated_model_files ||= []
-          @generated_model_files << GeneratedFile.new(&blk)
+        def run(model, opts)
+          @model = model
+          @config.use :output_dir => opts[:output_dir] if opts[:output_dir]
+          new(model).run
         end
 
-        def generates_global_file(&blk)
-          @generated_global_files ||= []
-          @generated_global_files << GeneratedFile.new(&blk)
+        private
+
+        def generates_file(type, name, opts={})
+          opts.merge! :type => type, :generator => self
+          @generated_files << Template.new(name, opts)
         end
 
-        def proxy(&blk)
-          @proxy_blk = blk
+        def setup_model(&blk)
+          @setup_model_blk = blk
         end
 
         def inherited(klass)
           @subclasses ||= []
           @subclasses << klass
-          klass.instance_variable_set(:@generator_name, @generator_name)
+          klass.instance_variable_set(:@generator_name, klass.name.split("::").last.snake_case.to_sym)
+          klass.instance_variable_set(:@setup_model_blk, Proc.new{})
+          klass.instance_variable_set(:@config, Config.new)
+          klass.instance_variable_set(:@generated_files, TemplateCollection.new)
         end
       end
-    end
-  end
-end
 
-class DataMapper::MetaMapper::Proxy; end
-
-class CPPGenerator < DataMapper::MetaMapper::Generator
-  generator_name :cpp
-
-  generates_global_file{ template_name "dmmm_identifiers.hpp.erb" }
-  generates_global_file{ template_name "dmmm_comparators.hpp.erb" }
-  generates_global_file{ template_name "dmmm_fields.hpp.erb" }
-  generates_global_file{ template_name "dmmm_utils.hpp.erb" }
-  generates_global_file{ template_name "dmmm_utils.cpp.erb" }
-  generates_global_file{ template_name "dmmm_dbface.cpp.erb" }
-  generates_global_file{ template_name "dmmm_dbface.h.erb" }
-  generates_global_file{ template_name "dmmm_id.hpp.erb" }
-
-  proxy do
-    puts "Generating files for model " + self.name.to_s
-    key_to_parent = {}
-    relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r|
-      key_to_parent[r[1].child_key.first.name.to_s] = r[1].parent_model_name.to_const_string.sub(/::/,'_')
-      puts "#{r[1].child_key.first.name.to_s} -> #{key_to_parent[r[1].child_key.first.name.to_s]}"
-    end
+      # model can be nil or DataMapper::Model
+      def initialize(model)
+        @model = model
 
-    properties.each do |e| 
-      cpp_name = if e.serial?
-        "Field<I_#{e.model.name.sub(/::/,'_')}>"
-      elsif !key_to_parent[e.name.to_s].nil?
-        "Field<I_#{key_to_parent[e.name.to_s]}>"
-      else           
-        "F_#{e.primitive}"
+        instance_eval(&self.class.setup_model_blk) if model
+
+        @templates = if model
+          self.class.generated_files.models
+        else
+          self.class.generated_files.global
+        end
       end
 
-      e.instance_variable_set(:@cpp_name, cpp_name)
-    end
-  end
+      attr_reader :model
 
-  generates_file do
-    suffix ".hpp"
-    prefix "O_"
-    template_name "instance.hpp.erb"
-  end
+      def run
+        @templates.each {|template| generate template }
+      end
+
+      private
+
+      def models
+        DataMapper::MetaMapper.models
+      end
+
+      def generate(template)
+        if !File.exists? template.full_path
+          raise NoTemplateError, "Template does not exist at path #{template.full_path}"
+        end
+
+        compiled = ERB.new(File.read(template.full_path)).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}
+        end
+
+      end
+    end
 
-  generates_file do
-    suffix".hpp"
-    prefix "T_"
-    template_name "class.hpp.erb"
   end
 end
 

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

@@ -0,0 +1,68 @@
+module DataMapper
+  module MetaMapper
+    module Generators
+      class CPP < DataMapper::MetaMapper::Generator
+        config[:template_dir] = File.expand_path('../../../templates/cpp', __FILE__)
+
+        generates_file :global, "dmmm_identifiers.hpp"
+        generates_file :global, "dmmm_comparators.hpp"
+        generates_file :global, "dmmm_fields.hpp"
+        generates_file :global, "dmmm_utils.hpp"
+        generates_file :global, "dmmm_utils.cpp"
+        generates_file :global, "dmmm_dbface.cpp"
+        generates_file :global, "dmmm_dbface.h"
+        generates_file :global, "dmmm_id.hpp"
+
+        generates_file :model, "O_%model%.hpp", :template => "instance.hpp"
+        generates_file :model, "T_%model%.hpp", :template => "class.hpp"
+
+        setup_model do
+          key_to_parent = many_to_one.inject({}) do |hash, (r,m)|
+            hash[m.child_key.first.name] = decolonize(m.parent_model_name.to_const_string)
+            hash
+          end
+          model.properties.each do |prop|
+            cpp_name = if prop.serial?
+              "Field<I_#{decolonize(model.name)}>"
+            elsif key_to_parent[prop.name]
+              "Field<I_#{key_to_parent[prop.name]}>"
+            else           
+              "F_#{decolonize(prop.primitive.to_s)}"
+            end
+
+            (class << prop; self; end).instance_eval{ attr_accessor :cpp_name }
+            prop.cpp_name = cpp_name
+          end
+        end
+
+        def output_path(model, template)
+          name = model ? template.name.sub("%model%", decolonize(model.name)) : template.name
+          File.join(self.class.config.output_dir, name)
+        end
+
+        private
+
+        def decolonize(str)
+          str.sub(/::/,'_')
+        end
+
+        def many_to_one
+          return unless model
+          @many_to_one ||= model.relationships.select {|r,m|
+            m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'
+          }
+          #in case of ruby < 1.9
+          if Array === @many_to_one
+            temp = @many_to_one
+            @many_to_one = {}
+            temp.each{|t| @many_to_one[t[0]] = t[1]}
+          end
+
+          @many_to_one
+        end
+      end
+    end
+  end
+end
+
+

data/lib/dm-metamapper/metamapper.rb

@@ -1,59 +1,31 @@
 module DataMapper
   module MetaMapper
+    @_default_opts = {
+      :template_dir => Dir.pwd,
+      :output_dir => Dir.pwd
+    }
+
     class << self
-      attr_reader :models
+      attr_reader :models, :_default_opts
+
+      def use(opts)
+        @_default_opts.merge! opts
+      end
 
       def register(klass)
         @models ||= []
         @models << klass unless models.member?(klass)
       end
 
-      def generate(format, context=nil)
+      def generate(format, opts = {})
+        context = opts.delete(:context)
         generator = Generator[format]
+        generator.run(context, opts)
 
-        if context
-          context.instance_eval(&generator.proxy_blk) if generator.proxy_blk
-          type, _binding = :generated_model_files, context._get_binding
-        else
-          type, _binding = :generated_global_files, binding
-        end
-
-        generator.send(type).each do |generated_file|
-          temp_filename = [
-            File.dirname(__FILE__), 
-            "../templates", 
-            generator.generator_name, 
-            generated_file.template
-          ].join('/')
-
-          result_base_name = context ? context.name.to_s.sub(/::/,'_') : generated_file.template.sub(/\.erb$/,'')
-
-          result_filename = File.join(
-            File.dirname(__FILE__), "../../output", [
-              generated_file.file_name_prefix,
-              result_base_name,
-              generated_file.file_name_suffix
-            ].join
-          )
-
-          if File.exists?(temp_filename)
-            STDOUT.puts "writing file " + result_filename
-            template = ERB.new(File.read(temp_filename))
-            result = template.result(_binding)
-            File.open(result_filename, 'w') { |f| f << result }
-          else
-            STDERR.puts "ERROR: " + temp_filename + " does not exist"
-          end
-        end
-
-        if !context
-          models.select {|model| 
-            model.generates?(format)
-          }.each {|model| 
-            model.generate(format)
-          } 
-        end
-
+        models.each {|model| 
+          opts[:context] = model
+          generate(format, opts)
+        } if !context
       end
     end
   end

data/lib/dm-metamapper/template.rb

@@ -0,0 +1,53 @@
+module DataMapper
+  module MetaMapper
+    class NoGeneratorError < ArgumentError; end
+    class InvalidTypeError < StandardError; end
+
+    class TemplateCollection < Array
+      def models
+        self.select {|t| t.type == :model}
+      end
+
+      def global
+        self.select {|t| t.type == :global}
+      end
+    end
+
+    class Template
+      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"
+      end
+
+      attr_reader :name, :type
+
+      def output_path
+        File.join(@generator.config.output_dir, @name)
+      end
+
+      def full_path
+        File.join(@generator.config.template_dir, @template)
+      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
+
+        type
+      end
+
+      def parse_generator(generator)
+        generator || raise(NoGeneratorError, "opts did not contain :generator")
+      end
+    end
+  end
+end
+

data/lib/dm-metamapper.rb

@@ -2,7 +2,9 @@ $:.push File.dirname(__FILE__)
 
 require 'dm-core'
 require 'dm-metamapper/property'
+require 'dm-metamapper/config'
 require 'dm-metamapper/metamapper'
 require 'dm-metamapper/extension'
+require 'dm-metamapper/template'
 require 'dm-metamapper/generator'
 

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

@@ -1,4 +1,4 @@
-<% class_name = self.name.sub(/::/,'_') %>
+<% class_name = decolonize(model.name) %>
 <% all_caps_name = class_name.upcase %>
 #ifndef T_<%= all_caps_name %>
 #define T_<%= all_caps_name %>
@@ -15,49 +15,47 @@ public:
 
     T_<%= class_name %>() 
     {
-        _tables.push_back("<%= storage_name %>");
+        _tables.push_back("<%= model.storage_name %>");
     }
     T_<%= class_name %>(const Condition& c) 
         : _constraint(c)
     {
-        _tables.push_back("<%= storage_name %>");
+        _tables.push_back("<%= model.storage_name %>");
     }
-    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
-    <% parent = r[1].parent_model_name.sub(/::/,'_') %>
+    <% many_to_one.each do |r| %> 
+    <% parent = decolonize(r[1].parent_model_name) %>
     T_<%= class_name %>(const T_<%= parent %>& parent)
     {
-        _tables.push_back("<%= storage_name %>");
+        _tables.push_back("<%= model.storage_name %>");
         _tables.insert(_tables.end(), 
 	               parent._tables.begin(), parent._tables.end());
         
-        _constraint._cond = "(<%= storage_name + "." + r[1].child_key.first.name.to_s %> = " + parent._tables[0] + ".<%= r[1].parent_key.first.name.to_s %>)";
+        _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;
     } 
-
     <% end %>
     
-    <% generated_properties.each do |property| %>
+    <% model.generated_properties.each do |property| %>
     struct E_<%= property.name %>{
         E_<%= property.name %>() 
         {  
-            _field = "<%= storage_name %>.<%= property.name.to_s %>";
+            _field = "<%= model.storage_name %>.<%= property.name.to_s %>";
         }
         std::string _field;
         typedef T_<%= class_name %>::Condition ConditionType;
-        typedef <%= property.instance_variable_get(:@cpp_name) %>::Base ComparerType;
+        typedef <%= property.cpp_name %>::Base ComparerType;
     };
 
     E_<%= property.name %> _<%= property.name %>(){ 
         return E_<%= property.name %>();
     }
-
     <% end %>    
 
     void getFields(std::vector<std::string>& rFields)
     {
         rFields.clear();
-        <% generated_properties.each do |property| %>
+        <% model.generated_properties.each do |property| %>
         rFields.push_back("<%= property.name %>");
         <% end %>
     }
@@ -74,9 +72,9 @@ public:
                                    additional, res);
         r.resize(res.size());
         for(size_t i = 0; i < res.size(); ++i){
-            <% generated_properties.each do |property| %>
+            <% model.generated_properties.each do |property| %>
             r[i]._f_<%= property.name %>._base = 
-                UTILS::fromString<<%= property.instance_variable_get(:@cpp_name) %>::Base>(res[i]["<%= property.name %>"]);
+                UTILS::fromString<<%= property.cpp_name %>::Base>(res[i]["<%= property.name %>"]);
             <% end %>
         }
     }
@@ -104,7 +102,7 @@ public:
     }
 
     std::pair<O_<%= class_name %>, bool> select(const I_<%= class_name %>& id){
-        return first(E_<%= serial.name %>() == id);
+        return first(E_<%= model.serial.name %>() == id);
     }
 
     std::pair<O_<%= class_name %>, bool> first(const Condition& c)

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

@@ -6,7 +6,7 @@
 namespace DMMM {
 
 <% models.each do |model| %>
-<% model_name = model.name.sub(/::/,'_') %>
+<% model_name = decolonize(model.name) %>
 class DummyO_<%= model_name %>;
 typedef UTILS::Id<DummyO_<%= model_name %>> I_<%= model_name %>;
 <% end %>

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

@@ -1,4 +1,4 @@
-<% class_name = self.name.sub(/::/,'_') %>
+<% class_name = decolonize(model.name) %>
 <% all_caps_name = class_name.upcase %>
 #ifndef O_<%= all_caps_name %>
 #define O_<%= all_caps_name %>
@@ -10,8 +10,8 @@
 #include "dmmm_identifiers.hpp"
 #include "dmmm_fields.hpp"
 #include "dmmm_comparators.hpp"
-<% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |relative| %>
-#include "T_<%= relative[1].parent_model.to_s.sub(/::/,'_') %>.hpp"
+<% many_to_one.each do |relative| %>
+#include "T_<%= decolonize(relative[1].parent_model.to_s) %>.hpp"
 <% end %>
 
 <%# self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::OneToMany::Relationship'}.each do |relative| %>
@@ -22,8 +22,8 @@ class O_<%= class_name %>{
 public:
 
     O_<%= class_name %>() {}
-    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
-    <% parent = r[1].parent_model_name.sub(/::/,'_') %>
+    <% 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 %>())
         {}
@@ -32,53 +32,50 @@ public:
         {}
     <% end %>
 
-    <% generated_properties.each do |property| %>
-    const <%= property.instance_variable_get(:@cpp_name) %>::Base& _<%= property.name %>() const { 
+    <% model.generated_properties.each do |property| %>
+    const <%= property.cpp_name %>::Base& _<%= property.name %>() const { 
         return _f_<%= property.name %>._base; 
     }
-    <%= property.instance_variable_get(:@cpp_name) %>::Base& _<%= property.name %>() { 
+    <%= property.cpp_name %>::Base& _<%= property.name %>() { 
         _f_<%= property.name %>._dirty = true; 
         return _f_<%= property.name %>._base; 
     }
-
     <% end %>
 
-    <% if serial %>
+    <% if model.serial %>
     bool update(){
         std::map<std::string, std::string> field2Val;
-        <% 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 %>
         std::string where =
-	    "<%= serial.name %>=" + UTILS::toString(_f_<%= serial.name %>._base);
-        return DBFace::instance()->update("<%= storage_name %>", 
+	    "<%= model.serial.name %>=" + UTILS::toString(_f_<%= model.serial.name %>._base);
+        return DBFace::instance()->update("<%= model.storage_name %>", 
                                           field2Val, where);
     }
-
     <% end %>
 
-
     bool insert(){
         std::map<std::string, std::string> field2Val;
-        <% 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 %>
-        <% if serial %>
+        <% if model.serial %>
         if (DBFace::instance()->
-                insert("<%= storage_name %>", field2Val,
-                       _f_<%= serial.name %>._base.serialization()))
+                insert("<%= model.storage_name %>", field2Val,
+                       _f_<%= model.serial.name %>._base.serialization()))
 	<% else %>
         size_t id;
         if (DBFace::instance()->
-                insert("<%= storage_name %>", field2Val,
+                insert("<%= model.storage_name %>", field2Val,
                        id))
         <% end %>
         {
-            <% generated_properties.each do |property| %>
+            <% model.generated_properties.each do |property| %>
             _f_<%= property.name %>._dirty = false;
             <% end %>
             return true;
@@ -88,21 +85,19 @@ public:
  				   
     }
 
-    <% self.relationships.select{|r,m| m.class.name == 'DataMapper::Associations::ManyToOne::Relationship'}.each do |r| %> 
-    <% parent = r[1].parent_model_name.sub(/::/,'_') %>
+    <% 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();
     }
     <% end %>
 
-
 private:
-    <% generated_properties.each do |property| %>
-    <%= property.instance_variable_get(:@cpp_name) %> _f_<%= property.name %>;
+    <% model.generated_properties.each do |property| %>
+    <%= property.cpp_name %> _f_<%= property.name %>;
     <% end %>
 
-
     friend class T_<%= class_name %>;
 };
 

data/spec/dm-metamapper/generator_spec.rb

@@ -0,0 +1,62 @@
+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

@@ -0,0 +1,29 @@
+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

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

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-$:.push(File.join(File.dirname(__FILE__), "../lib"))
+$:.push File.expand_path('../lib', __FILE__)
 
 require 'rubygems'
 require 'bundler'
@@ -6,3 +6,5 @@ Bundler.setup(:default, :test)
 require 'spec'
 
 require 'dm-metamapper'
+
+DMMM = DataMapper::MetaMapper

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Jonah Honeyman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-09 00:00:00 +03:00
+date: 2010-06-15 00:00:00 +03:00
 default_executable: 
 dependencies: []
 
@@ -28,21 +28,24 @@ extensions: []
 extra_rdoc_files: 
 - README.md
 files: 
+- .autospec
 - .gitignore
 - Gemfile
 - README.md
 - Rakefile
 - VERSION
-- dm-metamapper.gemspec
 - example/.gitignore
 - example/Makefile
 - example/example.cpp
 - example/example.rb
 - lib/dm-metamapper.rb
+- lib/dm-metamapper/config.rb
 - lib/dm-metamapper/extension.rb
 - lib/dm-metamapper/generator.rb
+- lib/dm-metamapper/generators/cpp.rb
 - lib/dm-metamapper/metamapper.rb
 - lib/dm-metamapper/property.rb
+- lib/dm-metamapper/template.rb
 - lib/templates/cpp/class.hpp.erb
 - lib/templates/cpp/dmmm_comparators.hpp.erb
 - lib/templates/cpp/dmmm_dbface.cpp.erb
@@ -53,7 +56,9 @@ files:
 - lib/templates/cpp/dmmm_utils.cpp.erb
 - lib/templates/cpp/dmmm_utils.hpp.erb
 - lib/templates/cpp/instance.hpp.erb
-- output/.gitignore
+- spec/dm-metamapper/generator_spec.rb
+- spec/dm-metamapper/template_spec.rb
+- spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/jonuts/dm-metamapper
@@ -87,3 +92,5 @@ 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

data/dm-metamapper.gemspec

@@ -1,66 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{dm-metamapper}
-  s.version = "0.0.3"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jonah Honeyman", "Omer Tamuz"]
-  s.date = %q{2010-06-09}
-  s.description = %q{C++ API for databases created with DM. Hard typing, compile time checked queries.}
-  s.email = %q{jonah@honeyman.org}
-  s.extra_rdoc_files = [
-    "README.md"
-  ]
-  s.files = [
-    ".gitignore",
-     "Gemfile",
-     "README.md",
-     "Rakefile",
-     "VERSION",
-     "dm-metamapper.gemspec",
-     "example/.gitignore",
-     "example/Makefile",
-     "example/example.cpp",
-     "example/example.rb",
-     "lib/dm-metamapper.rb",
-     "lib/dm-metamapper/extension.rb",
-     "lib/dm-metamapper/generator.rb",
-     "lib/dm-metamapper/metamapper.rb",
-     "lib/dm-metamapper/property.rb",
-     "lib/templates/cpp/class.hpp.erb",
-     "lib/templates/cpp/dmmm_comparators.hpp.erb",
-     "lib/templates/cpp/dmmm_dbface.cpp.erb",
-     "lib/templates/cpp/dmmm_dbface.h.erb",
-     "lib/templates/cpp/dmmm_fields.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_utils.hpp.erb",
-     "lib/templates/cpp/instance.hpp.erb",
-     "output/.gitignore",
-     "spec/spec_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/jonuts/dm-metamapper}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Code generating C++ ORM}
-  s.test_files = [
-    "spec/spec_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
-

data/output/.gitignore

@@ -1 +0,0 @@
-*