dmapper 0.1 → 0.2

data/CHANGELOG

@@ -0,0 +1,16 @@
+0.2 July 4th, 2011
+
+* Properties now maintain correct order
+* Added tiny 'helpers' (e.g. Time.now becomes proc => { Time.now })
+* Switched the order of operations (from type:field:options to field:type:options)
+* Lazy accepts true/false/fields
+* Added a verbose option -v
+* Added a testing option -t
+* Added a backup option -b
+* Added a silent/suppress option -s
+* Much better validation handlers (still needs quite a bit of work)
+* Added association support!
+
+0.1 - July 3rd, 2011
+
+* Initial Release

data/README.rdoc

@@ -1,6 +1,8 @@
 = DMap
 
-DMap is a generator for creating models with {DataMapper}[http://datamapper.org]. It's currently under a lot of development but I, as well as others, use it when for production use. As of right now majority of the validations work as expected and property types.
+DMap is a generator for creating models with {DataMapper}[http://datamapper.org]. It's currently under a lot of development but I, as well as others, use it for production use. DataMapper gems are not even required for this gem/tool.
+
+"DMap a shorter way for saying, and using, DataMapper"
 
 == Installation
     gem install dmapper
@@ -9,53 +11,60 @@ DMap is a generator for creating models with {DataMapper}[http://datamapper.org]
 
 As of right now the only command available is <tt>new</tt>. Here's a basic example of DMap to explain the structure...
 
-    dmap new user id str:name str:email:required,unique str:password:required
+    dmap new user id name:string email:str:required,unique str:password:required
 
 The first, after <tt>dmap new</tt>, is the [table]. You can create multiple tables at a time by adding a comma (,). Every argument (<tt>space</tt>) is a separate [field]. Fields are divided into three sections by a colon (<tt>:</tt>). The first part is the field's [type]. The second part is the field's name, and the last part marks additional options for that field (explained later).
 
+== Options
+
+<b><tt>-b, --backup</tt></b>:: Backs up the current model files (renames them to *.rb.bk)
+<b><tt>-h, --help</tt></b>::  Displays help message
+<b><tt>-s, --silent</tt></b>:: If you entered incorrect values for a validation just suppress it and continue on.
+<b><tt>-t, --test</tt></b>:: Displays what DMap would have made into a file onto the screen.
+<b><tt>-v, --verbose</tt></b>:: Will print out the model(s) after changes have been made
+
 == Examples
 
 Using DMap is incredibly easy once you learn the basic structure of it all. Here's a quick example...
 
-    dmap new user id str:username str:email text:signature
+    dmap new user id username:str email:str signature:text
 
 Which creates (user.rb file in the folder that you're currently in)...
 
     class User
       include DataMapper::Resource
     
-      property :signature
-      property :username
-      property :id
-      property :email
+      property :id, Serial
+      property :username, String
+      property :email, String
+      property :signature, Text
     
     
     end
 
 Let's get a little more "complex"
 
-    dmap new user id str:username str:email,required str:name:required,unique str:password datetime:date_created:default=Time.now text:signature
+    dmap new user id username:str email:str:required name:str:required,unique password:str date_crtd:datetime:default=DateTime.now signature:text
 
 Which produces...
 
     class User
       include DataMapper::Resource
     
-      property :name, String, :required => true, :unique => true
-      property :required, String
-      property :signature, Text
-      property :username, String
       property :id, Serial
+      property :username, String
+      property :email, String, :required => true
+      property :name, String, :required => true, :unique => true
       property :password, String
-      property :date_created, DateTime, :default => Time.now
-      property :email, String
+      property :date_crtd, DateTime, :default => proc => { DateTime.now }
+      property :signature, Text
     
     
     end
 
 I know, still not that impressive, let's try something a tad more difficult...
 
-    dmap new user,user_copy id str:first_name,last_name datetime:name1:default=true,length=1..5,presence_of=title-publish20..50,length_of=1,absent,confirm=field,format=email_address,primitive,unique,accessor=private str:Name1
+    dmap new user,user_copy id first_name,last_name:str name1:datetime:default=true,length=1..5,presence_of=title-publish20..50,length_of=1,absent,confirm=field,format=email_address,primitive,unique,accessor=private Name1:str
 
 Which creates (along with a copy model "UserCopy" of the same exact thing)
 
@@ -63,10 +72,10 @@ Which creates (along with a copy model "UserCopy" of the same exact thing)
       include DataMapper::Resource
     
       property :id, Serial
-      property :name1, DateTime, :default => true, :accessor => private, :unique => true, :length => 1..5
+      property :first_name, String
       property :last_name, String
+      property :name1, DateTime, :default => true, :length => 1..5, :unique => true, :accessor => :private
       property :Name1, String
-      property :first_name, String
     
       validates_format_of :name1, :as => :email_address 
       validates_confirmation :name1, :confirm => :field 
@@ -81,21 +90,19 @@ Which creates (along with a copy model "UserCopy" of the same exact thing)
 
 Here is a list of all the types available from DataMapper, which ones we support, and custom aliases.
 
-<table>
-[DataMapper Property Type]</td><td>[DMap Command]</td><td>[Aliases]
-<tt>Boolean</tt>::<tt>Boolean</tt>::<tt>Bool</tt>
-<tt>String</tt>::<tt>String</tt>::<tt>Str, S</tt>
-<tt>Text</tt>::<tt>Text</tt>::<tt>Txt</tt>
-<tt>Float</tt>::<tt>Float</tt>::<tt>F</tt>
-<tt>Integer</tt>::<tt>Integer</tt>::<tt>Int, I</tt>
-<tt>Decimal</tt>::<tt>Decimal</tt>::<tt>Dec</tt>
-<tt>DateTime</tt>::<tt>DateTime</tt>::<tt>DT</tt>
-<tt>Date</tt>::<tt>Date</tt>::<tt>D</tt>
-<tt>Time</tt>::<tt>Time</tt>::<tt>T</tt>
-<tt>Object</tt>::<tt>Object</tt>::<tt>Obj</tt>
-<tt>Discriminator</tt>::<tt>Discriminator</tt>::<tt>Disc</tt>
-<tt>Binary</tt>::<tt>Binary</tt>::<tt>Blob, B</tt>
-</table>
+<b>DataMapper Property Type</b>:: <b>DMap Command/Aliases</b>
+<tt>Boolean</tt>::  <tt>boolean</tt>, <tt>bool</tt>
+<tt>String</tt>:: <tt>string</tt>, <tt>str, s</tt>
+<tt>Text</tt>:: <tt>text</tt>, <tt>txt</tt>
+<tt>Float</tt>::  <tt>float</tt>, <tt>f</tt>
+<tt>Integer</tt>::  <tt>integer</tt>, <tt>int, i</tt>
+<tt>Decimal</tt>::  <tt>decimal</tt>, <tt>dec</tt>
+<tt>DateTime</tt>:: <tt>datetime</tt>, <tt>dt</tt>
+<tt>Date</tt>:: <tt>date</tt>, <tt>d</tt>
+<tt>Time</tt>:: <tt>time</tt>, <tt>t</tt>
+<tt>Object</tt>:: <tt>object</tt>, <tt>obj</tt>
+<tt>Discriminator</tt>::  <tt>discriminator</tt>, <tt>disc</tt>
+<tt>Binary</tt>:: <tt>binary</tt>, <tt>blob, b</tt>
 
 More coming soon!
 
@@ -103,7 +110,7 @@ More coming soon!
 
 This part belongs in the third section of the command for example:
 
-    dmap new user id str:name:[required,accessor=private]
+    dmap new user id name:str:<b>required,accessor=private</b>
 
 Each validator is separated by a comma (<tt>,</tt>) and can have a value placed within it by an equal sign (<tt>=</tt>). The property name will look like...
 
@@ -112,11 +119,11 @@ Each validator is separated by a comma (<tt>,</tt>) and can have a value placed
 
 === Property Validator List
 
-[DataMapper's List]:: [DMap Command]
+<b>DataMapper's List</b>:: <b>DMap Command</b>
 <tt>required</tt>:: <tt>required</tt>
 <tt>default</tt>::  <tt>default</tt>
 <tt>key</tt>::  <tt>key</tt>
-<tt>lazy</tt>:: <tt>lazy</tt> - Only accepts "false" for now
+<tt>lazy</tt>:: <tt>lazy</tt>
 <tt>accessor</tt>:: <tt>accessor</tt>
 <tt>writer</tt>:: <tt>writer</tt>
 <tt>reader</tt>:: <tt>reader</tt>
@@ -127,27 +134,39 @@ That's all the ones I know for now, let me know if there are more!
 
 A list of all of the validates_*_of commands and which DMap currently supports
 
-[DataMapper's List]::   [DMap Command] [Notes]
-<tt>validates_absence_of</tt>:: <tt>absence, absent</tt>
-<tt>validates_acceptance_of</tt>::  <tt>acceptance, accept</tt>:: Does not accept :allow_nil options yet
-<tt>validates_with_block</tt>:: </td><td>Unsupported at this time
+Note: DMap currently does not support :allow_nil parameters. This will change in the future.
+
+<b>DataMapper's List</b>:: <b>DMap Command</b>
+<tt>validates_absence_of</tt>::  <tt>absence, absent</tt>
+<tt>validates_acceptance_of</tt>::  <tt>acceptance, accept</tt>
+<tt>validates_with_block</tt>:: Unsupported at this time
 <tt>validates_confirmation_of</tt>::  <tt>confirmation, confirm</tt>
 <tt>validates_format_of</tt>::  <tt>format</tt>
 <tt>validates_length_of</tt>::  <tt>length_of</tt>
 <tt>validates_with_method</tt>::  <tt>withmethod, method</tt>
-<tt>validates_numericality_of</tt>::  <tt>Unsupported</tt>
+<tt>validates_numericality_of</tt>::  Unsupported
 <tt>validates_primitive_type_of</tt>::  <tt>primitive</tt>
 <tt>validates_presence_of</tt>::  <tt>presence, present</tt>
 <tt>validates_uniqueness_of</tt>::  <tt>uniqueness</tt>
 <tt>validates_within</tt>:: <tt>within</tt>
 
+== Associations
+
+<b>DataMapper Command</b>:: <b>DMap Command</b>
+<tt>has 1</tt>::  <tt>has1, hasone</tt>
+<tt>has n</tt>::  <tt>hasn</tt>
+<tt>belongs_to</tt>:: <tt>belongs_to, belongs</tt>
+<tt>has_and_belongs_to_many</tt>::  <tt>hasmany</tt>
+
+Note: use hasn when wanting to use :through => :model and hasmany for wanting to :through => Resource
+
+Also, conditions are <b>not</b> supported through this generator (suggestions on this could be implemented would be helpful).
+
 == To Do
 
-* Add a verbose option
 * Add a way to add/edit/remove columns from pre-existing tables
-* Backup option before overwriting
 * All of the misc. property types
-* Better validation checkers
-* Associations! (this will be done first)
 * Template system similar to {Sinatra::Fedora's}[https://github.com/durango/sinatra_fedora] hatrack option
-* Better documentation!
+* Better documentation!
+* Migrations! (This will most likely be started after DM core team has finished the Veritas system).
+* Conditions with associations?

data/bin/dmap

@@ -14,6 +14,28 @@ opt_parser = OptionParser.new do |opt|
   opt.separator "     new <model name> [options]: Creates a new model"
   opt.separator "       e.g. dmap new User serial:id str:name:length=1..5,unique str:email text:signature"
   opt.separator ""
+
+  opt.on('-h', '--help', 'Displays this screen') do
+    puts opt
+    exit 1
+  end
+
+  opt.on('-v', '--verbose', 'Will print out the model(s) after changes have been made') do
+    DMap::Commands.options['verbose'] = true
+  end
+
+  opt.on('-b', '--backup', 'Backs up the old model from "model.rb" into "model.rb.bk"') do
+    DMap::Commands.options['backup'] = true
+  end
+
+  opt.on('-t', '--test', 'Displays what DMap would have made into a file onto the screen.') do
+    DMap::Commands.options['test'] = true
+    DMap::Commands.options['verbose'] = true
+  end
+
+  opt.on('-s', '--silent', 'If you entered incorrect values for a validation just suppress it and continue on.') do
+    DMap::Commands.options['silent'] = true
+  end
 end
 
 opt_parser.parse!
@@ -23,14 +45,14 @@ if ARGV[0].nil?
   exit 1
 end
 
-unless DMap::Commands.exists?(ARGV[0])
+unless DMap::Commands.exists? ARGV[0]
   puts ARGV[0] + " is not a valid command."
   puts opt_parser
   exit 1
 end
 
 # safe guard table names
-table_names = ARGV[1].match /^\[*([a-zA-Z0-9,_]+)\]*$/
+table_names = ARGV[1].to_s.match /^\[*([a-zA-Z0-9,_]+)\]*$/
 if table_names.nil?
   puts "Invalid table name, only characters A-Z, 0-9, and _ are allowed."
   puts opt_parser
@@ -45,7 +67,8 @@ table_names[1].split(',').each do |table|
   table.downcase!
 
   DMap::Tables.add model_name, model_name.underscore
-  if File.file? "./#{table}.rb"
+  File.rename("./#{table}.rb", "./#{table}.rb.bk") if File.file? "./#{table}.rb" and DMap::Commands.options['backup'] == true
+  if File.file? "./#{table}.rb" and DMap::Commands.options['test'] != true
     puts "A model with the name of #{table} already exists."
     exit 1
   end
@@ -53,40 +76,42 @@ end
 
 ARGV[2..-1].each do |command|
   # TODO: Add a shortcut module/class
-  command = "serial:id" if command == "id"
+  command = "id:serial" if command == "id"
 
   keys = command.split(':')
-  unless DMap::Fields.list.include?(keys[0]) or DMap::Properties.valid?(keys[0].camelcase)
-    puts keys[0] + " is not a valid property or field"
+  keys[1] = '' if keys[1].class.name == "NilClass"
+
+  unless DMap::Fields.list.include? keys[1] or DMap::Properties.valid? keys[1].camelcase
+    puts keys[1] + " is not a valid property or field"
     puts opt_parser
     exit 1
   end
 
   # Check if the "command" is a key first (keys always overrule)
-  if DMap::Fields.list.include?(keys[0])
-    keys.unshift(DMap::Fields.list[keys[0]])
+  if DMap::Fields.list.include?(keys[1])
+    keys.unshift(DMap::Fields.list[keys[1]])
   else
     # Can't create two fields with the same name
-    if DMap::Fields.list.include?(keys[1])
-      puts keys[1] + " is already a declared field. You cannot declare a field twice."
+    if DMap::Fields.list.include?(keys[0])
+      puts keys[0] + " is already a declared field. You cannot declare a field twice."
       puts opt_parser
       exit 1
     end
 
     # We really only need to do this when we're declaring a field with a type
     # Gets proper property name (e.g. "Dt" becomes "DateTime")
-    property_class = DMap::Properties.const_get(keys[0].camelcase)
+    property_class = DMap::Properties.const_get(keys[1].camelcase)
     begin
-      keys[0] = property_class.superclass.parent_name
+      keys[1] = property_class.superclass.parent_name
     rescue
-      keys[0] = keys[0].camelcase
+      keys[1] = keys[1].camelcase
     end
 
     # Allow to declare multiple fields at once
-    keys[1].split(',').each do |key|
-      DMap::Fields.add key, keys[0]
-      DMap::Tables.list.each do |table|
-        DMap::Properties.add table, key, keys[0], 'type'
+    keys[0].split(',').each do |key|
+      DMap::Fields.add key, keys[1]
+      DMap::Tables.list.each_value do |table|
+        DMap::Properties.add table, key, keys[1], 'type'
       end
     end
   end
@@ -96,52 +121,64 @@ ARGV[2..-1].each do |command|
     keys[2].split(',').each do |cmds|
       validation = cmds.split('=')
 
-      # Let's check if it's a validates_*_of first
+      # Does the validation exist?
+      # Check if the validation belongs to the property or within it's own command
       begin
-        if DMap::Validations.const_defined? validation[0].camelcase
-            # See if we're just an alias command...
-            original_class = DMap::Validations.const_get(validation[0].camelcase)
-            begin
-              original_name = original_class.superclass.parent_name
-            rescue
-              original_name = validation[0].camelcase
-            end
-            original_name = original_name.underscore.downcase
-
-            # Compile all of the otptions for the validation
-            struct = DMap::Validations.const_get(original_name.camelcase).validate validation[1]
-
-            # Finally, add the validations!
-            struct.each do |key, value|
-              DMap::Validations.add keys[1], original_name, key, value unless value.nil? || key == :cmd
-            end
-          next
-        end
-      end
-
-      # Does the validation exist
-      property = DMap::Properties.const_get keys[0].capitalize
-      unless property.respond_to? validation[0] or DMap::Validations.respond_to? validation[0]
-        puts "Invalid validation command " + validation[0] + " in type " + property.to_s
+        validate = DMap::Validations.const_get validation[0].camelcase
+      rescue
+        validate = DMap::Associations.const_get validation[0].camelcase
+      rescue
+        puts "Invalid validation command " + validation[0].camelcase + " in type " + validate.class.name.to_s
         puts opt_parser
         exit 1
       end
 
-      # Use class specific validation or generic if one doesn't exist
-      use_method = property.method validation[0] if property.respond_to? validation[0]
-      use_method = DMap::Validations.method validation[0] unless use_method
+      # Do we need a default value?
+      begin
+          validation[1] ||= validate.default
+      rescue
+      end
 
-      # Check to see if the validation returns true based on our input
-      unless use_method.call(validation[1]) == true
-        puts "Invalid value for validation " + validation[0] + " in type " + property.to_s
-        puts opt_parser
-        exit 1
+      # Store in variable for -s / silent option
+      valid_command = validate.method("is_valid?").call validation[1]
+      unless valid_command != true
+        if !validate.respond_to? "property"
+          # Compile all of the options for the validation
+          struct = validate.method("validate").call validation[1]
+
+          # Get the original name
+          begin
+            original_name = validate.superclass.parent_name.underscore
+          rescue
+            original_name = validation[0].underscore
+          end
+
+          # Finally, add the validations!
+          if struct.is_a?(Hash) or struct.is_a? Hash
+            struct.each do |key, value|
+              if validate.respond_to? "associations"
+                DMap::Associations.add keys[0], original_name, key, value unless value.nil? || key == :cmd
+              else
+                DMap::Validations.add keys[0], original_name, key, value unless value.nil? || key == :cmd
+              end
+            end
+          end
+        else
+          # Add the "core" validations (on properties)
+          struct = validate.method("validate").call validation[1]
+          DMap::Tables.list.each do |k, table|
+            validation[1] = true if validation[1].nil?
+            DMap::Properties.add table, keys[0], struct, validation[0]
+          end
+        end
       end
 
-      # Add the "core" validations (on properties)
-      DMap::Tables.list.each do |table|
-        validation[1] = true if validation[1].nil?
-        DMap::Properties.add table, keys[1], validation[1], validation[0]
+      if valid_command == false
+        puts validation[0] + " validation has an incorrect value for " + keys[0] + "."
+        if DMap::Commands.options['silent'] != true
+          puts opt_parser
+          exit 1
+        end
       end
     end
   end
@@ -152,21 +189,6 @@ end
 #p DMap::Tables.list
 #p DMap::Properties.list
 #p DMap::Validations.list
-#p DMap::Associations.list TODO
-
-case ARGV[0]
-when "new"
-  DMap::Tables.list.each do |table|
-    properties = DMap::Properties.list[table]
-    validations = DMap::Validations.list
-    p "Compiling model " + table[0]
-    obj = $new_block.result(binding)
-
-    handler = File.new(table[1] + ".rb", "w")
-    handler.write(obj)
-    handler.close
-    p table[0] + " saved successfully"
-  end
-else
-  puts opt_parser
-end
+#p DMap::Associations.list
+
+DMap::Commands.method("cmd_" + ARGV[0]).call