dmapper 0.1

data/COPYING

@@ -0,0 +1,10 @@
+Copyright (c) 2011, Daniel Durante
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+    * Neither the name of Sinatra Fedora nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,153 @@
+= 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.
+
+== Installation
+    gem install dmapper
+
+== Usage
+
+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
+
+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).
+
+== 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
+
+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
+    
+    
+    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
+
+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 :password, String
+      property :date_created, DateTime, :default => Time.now
+      property :email, String
+    
+    
+    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
+
+Which creates (along with a copy model "UserCopy" of the same exact thing)
+
+    class User
+      include DataMapper::Resource
+    
+      property :id, Serial
+      property :name1, DateTime, :default => true, :accessor => private, :unique => true, :length => 1..5
+      property :last_name, String
+      property :Name1, String
+      property :first_name, String
+    
+      validates_format_of :name1, :as => :email_address 
+      validates_confirmation :name1, :confirm => :field 
+      validates_absence_of :name1 
+      validates_length_of :name1, :equals => 1 
+      validates_presence_of :name1, :within => 20..50, :when => [:title, :publish] 
+      validates_primitive_type_of :name1 
+    
+    end
+
+== Types
+
+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>
+
+More coming soon!
+
+== Property Validators
+
+This part belongs in the third section of the command for example:
+
+    dmap new user id str:name:[required,accessor=private]
+
+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...
+
+    property :name, String, :required => true, :accessor => :private
+
+
+=== Property Validator List
+
+[DataMapper's List]:: [DMap Command]
+<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>accessor</tt>:: <tt>accessor</tt>
+<tt>writer</tt>:: <tt>writer</tt>
+<tt>reader</tt>:: <tt>reader</tt>
+
+That's all the ones I know for now, let me know if there are more!
+
+== Validations
+
+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
+<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_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>
+
+== 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!

data/bin/dmap

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'fileutils'
+require 'erb'
+
+$: << File.join(File.dirname(__FILE__), '../lib/')
+require 'dmap'
+
+opt_parser = OptionParser.new do |opt|
+  opt.banner = "Usage: dmap COMMAND [OPTIONS]"
+  opt.separator ""
+  opt.separator "Commands"
+  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 ""
+end
+
+opt_parser.parse!
+
+if ARGV[0].nil?
+  puts opt_parser
+  exit 1
+end
+
+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,_]+)\]*$/
+if table_names.nil?
+  puts "Invalid table name, only characters A-Z, 0-9, and _ are allowed."
+  puts opt_parser
+  exit 1
+end
+
+# Store all of the tables for this action
+table_names[1].split(',').each do |table|
+  # camelcase model name
+  model_name = table.capitalize
+  model_name.gsub!(/(_(.))/) { |a| a.sub('_','').upcase }
+  table.downcase!
+
+  DMap::Tables.add model_name, model_name.underscore
+  if File.file? "./#{table}.rb"
+    puts "A model with the name of #{table} already exists."
+    exit 1
+  end
+end
+
+ARGV[2..-1].each do |command|
+  # TODO: Add a shortcut module/class
+  command = "serial:id" 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"
+    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]])
+  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."
+      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)
+    begin
+      keys[0] = property_class.superclass.parent_name
+    rescue
+      keys[0] = keys[0].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'
+      end
+    end
+  end
+
+  # Add validations
+  unless keys[2].nil?
+    keys[2].split(',').each do |cmds|
+      validation = cmds.split('=')
+
+      # Let's check if it's a validates_*_of first
+      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
+        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
+
+      # 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
+      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]
+      end
+    end
+  end
+end
+
+# Good for debugging
+#p DMap::Fields.list
+#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

data/lib/dmap.rb

@@ -0,0 +1,60 @@
+=begin
+ dmap.rb - Foundation of dmap
+ *
+ * Copyright (c) 2011, Daniel Durante <officedebo at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+=end
+
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+# Core
+require 'dmap/core'
+
+# Properties
+require 'dmap/properties/core'
+require 'dmap/properties/boolean'
+require 'dmap/properties/date' # DateTime, Date and Time
+require 'dmap/properties/decimal' # Float and Decimal
+require 'dmap/properties/integer'
+require 'dmap/properties/misc' # Object, Discriminator, Blob
+require 'dmap/properties/serial'
+require 'dmap/properties/string' # String and Text
+
+# Validations
+require 'dmap/validations/core'
+require 'dmap/validations/absence'
+require 'dmap/validations/confirmation' # Confirmation and Acceptance
+require 'dmap/validations/format'
+require 'dmap/validations/length'
+require 'dmap/validations/method'
+require 'dmap/validations/presence'
+require 'dmap/validations/primitive'
+require 'dmap/validations/within'
+
+# Template for building new model
+require 'dmap/new'

data/lib/dmap/core.rb

@@ -0,0 +1,53 @@
+# We'll be needing to convert to CamelCase and under_score quite a bit 
+class String
+  def camelcase
+    self.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+#DMap Core functions + Table and Fields
+module DMap
+  # List available commands here
+  class Commands
+    def self.exists?(command)
+      list = %w[ new ].include? command
+    end
+  end
+
+  class Fields
+    attr_accessor :list
+    
+    def self.list
+      @list ||= Hash[]
+    end
+
+    def self.add(field, property=nil)
+      list.store field, property unless property.nil?
+    end
+  end
+
+  class Tables
+    attr_accessor :list
+
+    def inheritance(value=nil)
+      list.push value unless value.nil?
+    end
+    
+    def self.list
+      @list ||= Hash[]
+    end
+
+    def self.add(key, value=nil)
+      list[key] = {} if list[key].nil?
+      list.store key, value unless value.nil?
+    end
+  end
+end

data/lib/dmap/new.rb

@@ -0,0 +1,39 @@
+$new_block = ERB.new <<-EOF
+class <%= table[0] %>
+  include DataMapper::Resource
+<%
+  $str = ''
+  properties.each do |k, val|
+      $str += '  property :' + k
+      $str += ', ' + val["type"] unless val["type"].nil?
+    val.each do |key, v|
+      next if key == "type"
+      v = ":" + v if v == "protected" || v == "private" || v == "public"
+      $str += ', :' + key + ' => ' + v.to_s
+    end
+    $str += "\n"
+  end
+
+  $str += "\n"
+
+  validations.each do |field, value|
+    value.each do |key, v|
+      $str += "  validates_" + key + " :" + field + ", "
+      v.each do |k, cmd|
+        next if k == :null
+        cmd = ":" + field if cmd == :self
+        cmd = '"' + cmd + '"' if cmd.is_a?(String)
+        k = ":" + k.to_s if k.is_a?(Symbol)
+        cmd = ":" + cmd.to_s if cmd.is_a?(Symbol)
+        cmd = "[" + cmd.map {|x| ":" + x}.join(', ') + "]" if cmd.is_a?(Array)
+
+        $str += k.to_s + " => " + cmd.to_s + ", "
+      end
+      $str.slice!(-2)
+      $str += "\n"
+    end
+  end
+%>
+<%= $str %>
+end
+EOF

data/lib/dmap/properties.rb

@@ -0,0 +1,36 @@
+module DMap
+  module Properties
+    attr_accessor :list
+    class << self
+  
+      def required(value)
+        value.is_a?(Boolean)
+      end
+  
+      def valid?(klass)
+        begin
+          # Don't need if I need to do the sub() thing anymore...
+          self.const_get(klass.capitalize.sub('Datetime', 'DateTime')).is_a?(Class)
+        rescue
+          false
+        end
+      end
+  
+      def list
+        @list ||= Hash[]
+      end
+  
+      def add(table, property=nil, value=nil, bucket=nil)
+        list[table] = {} if list[table].nil?
+        unless property.nil?
+          list[table][property] = {} if list[table][property].nil?
+          if bucket.nil?
+            list[table].store property, value unless value.nil?
+          else
+            list[table][property][bucket] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dmap/properties/boolean.rb

@@ -0,0 +1,14 @@
+module DMap
+  module Properties
+    class Boolean
+      def self.default(value)
+        value.to_bool.is_a?(Boolean)
+      end
+
+      def self.parent_name
+        "Boolean"
+      end
+    end
+    class Bool < Boolean; end
+  end
+end

data/lib/dmap/properties/core.rb

@@ -0,0 +1,35 @@
+module DMap
+  module Properties
+    attr_accessor :list
+    class << self
+      # default methods
+      def required(value)
+        value.is_a?(Boolean)
+      end
+
+      def valid?(klass)
+        begin
+          self.const_get(klass.capitalize).is_a?(Class)
+        rescue
+          false
+        end
+      end
+
+      def list
+        @list ||= Hash[]
+      end
+
+      def add(table, property=nil, value=nil, bucket=nil)
+        list[table] = {} if list[table].nil?
+        unless property.nil?
+          list[table][property] = {} if list[table][property].nil?
+          if bucket.nil?
+            list[table].store property, value unless value.nil?
+          else
+            list[table][property][bucket] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dmap/properties/date.rb

@@ -0,0 +1,29 @@
+module DMap
+  module Properties
+    class Date
+      def self.parent_name
+        "Date"
+      end
+    end
+    class D < Date; end
+
+    class DateTime
+      def self.default(value=nil)
+        true
+      end
+
+      def self.parent_name
+        "DateTime"
+      end
+    end
+    class Datetime < DateTime; end
+    class Dt < DateTime; end
+
+    class Time
+      def self.parent_name
+        "Time"
+      end
+    end
+    class T < Time; end
+  end
+end

data/lib/dmap/properties/decimal.rb

@@ -0,0 +1,17 @@
+module Dmap
+  module Properties
+    class Float
+      def self.parent_name
+        "Float"
+      end
+    end
+    class F < Float; end
+
+    class Decimal
+      def self.parent_name
+        "Decimal"
+      end
+    end
+    class Dec < Decimal; end
+  end
+end

data/lib/dmap/properties/integer.rb

@@ -0,0 +1,15 @@
+module DMap
+  module Properties
+    class Integer
+      def length(value)
+        false unless (value.is_a(Fixnum) || value.is_a(Integer))
+      end
+
+      def self.parent_name
+        "Integer"
+      end
+    end
+    class Int < Integer; end
+    class I < Integer; end
+  end
+end

data/lib/dmap/properties/misc.rb

@@ -0,0 +1,25 @@
+module DMap
+  module Properties
+    class Object
+      def self.parent_name
+        "Object"
+      end
+    end
+    class Obj < Object; end
+
+    class Discriminator
+      def self.parent_name
+        "Discriminator"
+      end
+    end
+    class Disc < Discriminator; end
+
+    class Binary
+      def self.parent_name
+        "Binary"
+      end
+    end
+    class Blob < Binary; end
+    class B < Binary; end
+  end
+end

data/lib/dmap/properties/serial.rb

@@ -0,0 +1,10 @@
+module DMap
+  module Properties
+    class Serial
+      def self.parent_name
+        "Serial"
+      end
+    end
+    class Primary < Serial; end
+  end
+end

data/lib/dmap/properties/string.rb

@@ -0,0 +1,22 @@
+module DMap
+  module Properties
+    class String
+      def self.default(value)
+        true
+      end
+      
+      def self.parent_name
+        "String"
+      end
+    end
+    class Str < String; end
+    class S < String; end
+
+    class Text
+      def self.parent_name
+        "Text"
+      end
+    end
+    class Txt < Text; end
+  end
+end

data/lib/dmap/validations/absence.rb

@@ -0,0 +1,15 @@
+module DMap
+  module Validations
+    class AbsenceOf
+      def self.parent_name
+        "AbsenceOf"
+      end
+
+      def self.validate(command=nil)
+        {:null => true}
+      end
+    end
+    class Absence < AbsenceOf; end
+    class Absent < AbsenceOf; end
+  end
+end

data/lib/dmap/validations/confirmation.rb

@@ -0,0 +1,25 @@
+module DMap
+  module Validations
+    class Confirmation
+      def self.parent_name
+        "Confirmation"
+      end
+
+      def self.validate(command=nil)
+        {:confirm => command.to_sym}
+      end
+    end
+    class Confirm < Confirmation; end
+
+    class Acceptance
+      def self.parent_name
+        "Acceptance"
+      end
+
+      def self.validate(command=nil)
+        {:accept => command.to_s}
+      end
+    end
+    class Accept < Acceptance; end
+  end
+end

data/lib/dmap/validations/core.rb

@@ -0,0 +1,95 @@
+module DMap
+  # Default validations if Property::Type doesn't have it
+  module Validations
+    attr_accessor :list
+
+    class << self
+      def list
+        @list ||= Hash[]
+      end
+
+      def default(value=nil)
+        true
+      end
+
+      def length(value=nil)
+        true if value.match /^\d+$/ or value.match /^\d+\.\.\d+$/
+      end
+
+      def unique(value=nil)
+        true
+      end
+
+      def key(value=nil)
+        true
+      end
+
+      def required(value=nil)
+        true
+      end
+
+      def lazy(value=nil)
+        false # Not true since lazy is loaded by default
+      end
+
+      def accessor(value=nil)
+        return true if value == "protected" or value == "private" or value == "public"
+      end
+
+      def writer(value=nil)
+        return true if value == "protected" or value == "private" or value == "public"
+      end
+
+      def reader(value=nil)
+        return true if value == "protected" or value == "private" or value == "public"
+      end
+
+      # validates_*_of
+      def add(field, validation, bucket, value)
+        list[field] = {} if list[field].nil?
+        list[field][validation] = {} if list[field][validation].nil?
+        list[field][validation][bucket] = {} if list[field][validation][bucket].nil?
+        list[field][validation].store bucket, value unless value.nil?
+      end
+    end
+
+    module Core
+      module When
+        def self.run(validation)
+          {:when => validation.split('-')}
+        end
+      end
+
+      module Fields
+        def self.run(validation)
+          {:fields => validation.split('-')}
+        end
+      end
+
+      module Numbers
+        def self.run(validation)
+          # Let's get the minimum/maximum numbers e.g. 20min50max
+          minimum = validation[/(\d+)min/, 1] # fetch min
+          unless minimum.nil? # take it out
+            validation.sub!(/\d+min/i, '')
+          end
+
+          maximum = validation[/(\d+)max/, 1]
+          unless maximum.nil? # take it out
+            validation.sub!(/\d+max/i, '')
+          end
+
+          # Now for the min..max e.g. 20..50
+          within = validation[/(\d+\.\.\d+)/, 1] unless minimum or maximum
+          validation.sub!(/\d+\.\.\d+/, '')
+
+          # Just equals? e.g. length_of=5
+          equals = validation[/^(\d+)$/, 1] unless minimum or maximum
+          validation.sub!(/^\d+$/, '')
+
+          {:cmd => validation, :min => minimum, :max => maximum, :within => within, :equals => equals}
+        end
+      end
+    end
+  end
+end

data/lib/dmap/validations/format.rb

@@ -0,0 +1,15 @@
+module DMap
+  module Validations
+    class FormatOf
+      def self.parent_name
+        "FormatOf"
+      end
+
+      def self.validate(command=nil)
+        command = command.to_sym if command.match(/^[A-Za-z]/)
+        {:as => command}
+      end
+    end
+    class Format < FormatOf; end
+  end
+end

data/lib/dmap/validations/length.rb

@@ -0,0 +1,13 @@
+module DMap
+  module Validations
+    class LengthOf
+      def self.parent_name
+        "LengthOf"
+      end
+
+      def self.validate(command=nil)
+        ret = DMap::Validations::Core::Numbers.run command
+      end
+    end
+  end
+end

data/lib/dmap/validations/method.rb

@@ -0,0 +1,14 @@
+module DMap
+  module Validations
+    class WithMethod
+      def self.parent_name
+        "WithMethod"
+      end
+
+      def self.validate(command=nil)
+        {:method => command.to_sym}
+      end
+    end
+    class Method < WithMethod; end
+  end
+end

data/lib/dmap/validations/presence.rb

@@ -0,0 +1,16 @@
+module DMap
+  module Validations
+    class PresenceOf
+      def self.parent_name
+        "PresenceOf"
+      end
+
+      def self.validate(command=nil)
+        ret = DMap::Validations::Core::Numbers.run command
+        ret1 = DMap::Validations::Core::When.run ret[:cmd]
+        ret.merge!(ret1)
+      end
+    end
+    class Present < PresenceOf; end
+  end
+end

data/lib/dmap/validations/primitive.rb

@@ -0,0 +1,16 @@
+module DMap
+  module Validations
+    class PrimitiveTypeOf
+      def self.parent_name
+        "PrimitiveTypeOf"
+      end
+
+      def self.validate(command=nil)
+        {:null => true}
+      end
+    end
+    class PrimitiveType < PrimitiveTypeOf; end
+    class PrimitiveOf < PrimitiveTypeOf; end
+    class Primitive < PrimitiveTypeOf; end
+  end
+end

data/lib/dmap/validations/uniqueness.rb

@@ -0,0 +1,14 @@
+module DMap
+  module Validations
+    class UniquenessOf
+      def self.parent_name
+        "UniquenessOf"
+      end
+
+      def self.validate(command=nil)
+        {:field => :self}
+      end
+    end
+    class Uniqueness < UniquenessOf; end
+  end
+end

data/lib/dmap/validations/within.rb

@@ -0,0 +1,15 @@
+module DMap
+  module Validations
+    class Within
+      def self.parent_name
+        "Within"
+      end
+
+      def self.validate(command=nil)
+        ret = DMap::Validations::Core::Numbers.run command
+        ret1 = DMap::Validations::Core::Fields.run command
+        ret.merge!(ret1)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification 
+name: dmapper
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Daniel Durante
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-02 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: data_mapper
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Create models easily for DataMapper using the command line.
+email: officedebo@gmail.com
+executables: 
+- dmap
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- bin/dmap
+- lib/dmap/core.rb
+- lib/dmap/new.rb
+- lib/dmap/properties/boolean.rb
+- lib/dmap/properties/core.rb
+- lib/dmap/properties/date.rb
+- lib/dmap/properties/decimal.rb
+- lib/dmap/properties/integer.rb
+- lib/dmap/properties/misc.rb
+- lib/dmap/properties/serial.rb
+- lib/dmap/properties/string.rb
+- lib/dmap/properties.rb
+- lib/dmap/validations/absence.rb
+- lib/dmap/validations/confirmation.rb
+- lib/dmap/validations/core.rb
+- lib/dmap/validations/format.rb
+- lib/dmap/validations/length.rb
+- lib/dmap/validations/method.rb
+- lib/dmap/validations/presence.rb
+- lib/dmap/validations/primitive.rb
+- lib/dmap/validations/uniqueness.rb
+- lib/dmap/validations/within.rb
+- lib/dmap.rb
+- COPYING
+- README.rdoc
+has_rdoc: true
+homepage: https://github.com/durango/dmap
+licenses: 
+- MIT
+post_install_message: 
+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: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Generators for DataMapper
+test_files: []
+