dmapper 0.1 → 0.2

data/lib/dmap.rb

@@ -32,10 +32,11 @@
 libdir = File.dirname(__FILE__)
 $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
-# Core
+# core
 require 'dmap/core'
+require 'support/ordered_hash'
 
-# Properties
+# properties
 require 'dmap/properties/core'
 require 'dmap/properties/boolean'
 require 'dmap/properties/date' # DateTime, Date and Time
@@ -45,16 +46,24 @@ require 'dmap/properties/misc' # Object, Discriminator, Blob
 require 'dmap/properties/serial'
 require 'dmap/properties/string' # String and Text
 
-# Validations
+# validations
 require 'dmap/validations/core'
 require 'dmap/validations/absence'
-require 'dmap/validations/confirmation' # Confirmation and Acceptance
+require 'dmap/validations/access' # accessor, writer, and reader
+require 'dmap/validations/confirmation' # confirmation and acceptance
 require 'dmap/validations/format'
 require 'dmap/validations/length'
+require 'dmap/validations/misc' # key, required, lazy
 require 'dmap/validations/method'
 require 'dmap/validations/presence'
 require 'dmap/validations/primitive'
+require 'dmap/validations/uniqueness'
 require 'dmap/validations/within'
 
+# associations
+require 'dmap/associations/core'
+require 'dmap/associations/belongs_to'
+require 'dmap/associations/hasn'
+
 # Template for building new model
 require 'dmap/new'

data/lib/dmap/associations/belongs_to.rb

@@ -0,0 +1,29 @@
+module DMap
+  module Associations
+    class BelongsTo
+      attr_accessor :associations
+
+      def self.associations; true; end
+
+      def self.field
+        "belongs_to "
+      end
+
+      def self.parent_name
+        "BelongsTo"
+      end
+
+      def self.is_valid?(command=nil)
+        true
+      end
+
+      def self.validate(command=nil)
+        command = command.split('-')
+        command[1] = nil if command[1].nil?
+        command[1] = command[1].to_sym unless command[1].nil? or command[1] == "true" or command[1] == "false"
+        {:fields => command[0].underscore.to_sym, :key => command[1]}
+      end
+    end
+    class Belongs < BelongsTo; end;
+  end
+end

data/lib/dmap/associations/core.rb

@@ -0,0 +1,30 @@
+module DMap
+  module Associations
+    attr_accessor :list
+
+    class << self
+      def list
+        @list ||= OrderedHash.auto
+      end
+
+      # validates_*_of
+      def add(field, validation, bucket, value)
+        list[field][validation].store bucket, value unless value.nil?
+      end
+    end
+
+    module Core
+      module When
+        def self.run(validation)
+          { :when => validation.split('-').map { |x| ':' + x } }
+        end
+      end
+
+      module Fields
+        def self.run(validation)
+          { :fields => validation.split('-') }
+        end
+      end
+    end
+  end
+end

data/lib/dmap/associations/hasn.rb

@@ -0,0 +1,79 @@
+module DMap
+  module Associations
+    class HasN
+      attr_accessor :associations
+
+      def self.associations; true; end
+
+      def self.parent_name
+        "HasN"
+      end
+
+      def self.field
+        "has n, "
+      end
+
+      def self.is_valid?(command=nil)
+        (!command.nil? or command)
+      end
+
+      def self.validate(command=nil)
+        command = command.split('-')
+        command[1] = nil if command[1].nil?
+        command[1] = command[1].to_sym unless command[1].nil? or command[1] == "true" or command[1] == "false"
+        {:fields => command[0].underscore.to_sym, :through => command[1].to_sym}
+      end
+    end
+    class Hasn < HasN; end;
+
+    class HasMany
+      attr_accessor :associations
+
+      def self.associations; true; end
+
+      def self.parent_name
+        "HasMany"
+      end
+
+      def self.field
+        "has n, "
+      end
+
+      def self.is_valid?(command=nil)
+        (!command.nil? or command)
+      end
+
+      def self.validate(command=nil)
+        command = command.split('-')
+        command[1] = nil if command[1].nil?
+        {:fields => command[0].underscore.to_sym, :through => command[1]}
+      end
+    end
+    class Hasmany < HasMany; end;
+
+    class Has1
+      attr_accessor :associations
+
+      def self.associations; true; end
+
+      def self.field
+        "has 1, "
+      end
+
+      def self.parent_name
+        "Has1"
+      end
+
+      def self.is_valid?(command=nil)
+        (!command.nil? or command or command.is_a? Symbol)
+      end
+
+      def self.validate(command=nil)
+        command = command.split('-')
+        command[1] = nil if command[1].nil?
+        {:fields => command[0].underscore.to_sym, :through => command[1].to_sym}
+      end
+    end
+    class Hasone < Has1; end;
+  end
+end

data/lib/dmap/core.rb

@@ -13,24 +13,99 @@ class String
   end
 end
 
-#DMap Core functions + Table and Fields
+# DMap Core functions + Table and Fields
 module DMap
   # List available commands here
   class Commands
+    attr_accessor :options
+
     def self.exists?(command)
-      list = %w[ new ].include? command
+      self.respond_to? "cmd_" + command
+    end
+
+    def self.options
+      @options ||= OrderedHash.new
+    end
+
+    # Each command has a cmd_ prefix
+    def self.cmd_new
+      validations = DMap::Validations.list
+      associations = DMap::Associations.list
+      DMap::Tables.list.each do |k, table|
+        properties = DMap::Properties.list[table]
+        obj = $new_block.result(binding)
+
+        if DMap::Commands.options['test'].nil? or DMap::Commands.options['test'] == false
+          handler = File.new(table + ".rb", "w")
+          handler.write(obj)
+          handler.close
+          p table.camelcase + " saved successfully"
+        end
+
+        if DMap::Commands.options['verbose'] == true
+          puts obj
+        end
+      end
+    end
+  end
+
+  # Rendering options since command-line is all string
+  class Render
+    def self.run(command, value)
+      value = Hash[value.class.name, value] unless value.is_a?(Hash)
+      if command.match(/^:/).nil?
+        command = ':' + command
+      end
+
+      value.each do |key, val|
+        next if val.nil?
+        temp = val.to_s.split(' ')
+        match = val.match(/^\[(.*?)\]$/) if val.is_a? String
+        if temp.length > 1 and match.class.name != "MatchData"
+          val = '"' + temp.join(' ').strip + '"'
+        end
+
+        if val.class.name == "Array"
+          val.flatten!
+          val = '[' + val.join(', ').to_s + ']'
+        end
+
+        next if val.nil?
+        case command
+          when ":within"
+            temp = val.split('..')
+            [':' + command, Range.new(temp[0], temp[1])]
+          else
+            [command.to_s, val]
+        end
+      end
+    end
+  end
+
+  class Helpers
+    def self.run(command)
+      return command unless command.is_a? String
+
+      case command.downcase
+        when "time.now"
+          "proc => { Time.now }"
+        when "datetime.now"
+          "proc => { DateTime.now }"
+        else
+          command
+      end
     end
   end
 
   class Fields
     attr_accessor :list
-    
+
     def self.list
-      @list ||= Hash[]
+      @list ||= OrderedHash.new_by
     end
 
     def self.add(field, property=nil)
-      list.store field, property unless property.nil?
+      list.push field, property unless property.nil?
     end
   end
 
@@ -42,12 +117,12 @@ module DMap
     end
     
     def self.list
-      @list ||= Hash[]
+      @list ||= OrderedHash.new_by
     end
 
     def self.add(key, value=nil)
-      list[key] = {} if list[key].nil?
-      list.store key, value unless value.nil?
+      #list[key] = {} if list[key].nil?
+      list.push key, value unless value.nil?
     end
   end
 end

data/lib/dmap/new.rb

@@ -1,5 +1,5 @@
 $new_block = ERB.new <<-EOF
-class <%= table[0] %>
+class <%= table.camelcase %>
   include DataMapper::Resource
 <%
   $str = ''
@@ -7,9 +7,23 @@ class <%= table[0] %>
       $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
+      next if key == "type" or v.nil?
+      keys = DMap::Render.run key, v
+      keys.each do |field, value|
+        next if value.nil? or value == ""
+
+        $str += ', :' + key + ' => '
+        # Add strings around values that need it
+        if value.class.name == "String" and value.split(' ').length > 1
+          $str += '"' + value + '"'
+        # Turn a string into an "Array"
+        elsif value.class.name == "Array"
+          $str += '[' + value.join(', ') + ']'
+        else
+          value = DMap::Helpers.run(value)
+          $str += value.to_s
+        end
+      end
     end
     $str += "\n"
   end
@@ -21,17 +35,44 @@ class <%= table[0] %>
       $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)
+        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.join(', ') + "]" if cmd.is_a? Array
 
-        $str += k.to_s + " => " + cmd.to_s + ", "
+        keys = DMap::Render.run k, cmd
+        keys.each do |index, item|
+          item = item.gsub(/^"/, "" ).gsub(/"$/m, "" )
+          if item.is_a?(String) and item.split(' ').length > 1 and item.match(/^\\[/).nil?
+            item = '"' + item + '"'
+          end
+          $str += k.to_s + " => " + item + ", "
+        end
       end
       $str.slice!(-2)
       $str += "\n"
     end
+
+    $str += "\n" if associations.length > 0
+    associations.each do |field, value|
+      value.each do |key, v|
+        $str += '  ' + DMap::Associations.const_get(key.camelcase).method('field').call
+        $str += ':' + v[:fields].to_s + ', ' unless v[:fields].nil?
+        unless v[:through].empty?
+          $str += ':through => '
+          if v[:through].is_a? Symbol
+            $str += ':' + v[:through].to_s
+          else
+            $str += v[:through].to_s
+          end
+          $str += ', '
+        end
+        $str.slice!(-2)
+        $str += "\n"
+      end
+    end
   end
 %>
 <%= $str %>

data/lib/dmap/properties/core.rb

@@ -3,26 +3,23 @@ module DMap
     attr_accessor :list
     class << self
       # default methods
-      def required(value)
-        value.is_a?(Boolean)
+      def default
       end
 
       def valid?(klass)
         begin
-          self.const_get(klass.capitalize).is_a?(Class)
+          self.const_get(klass.capitalize).is_a? Class
         rescue
           false
         end
       end
 
       def list
-        @list ||= Hash[]
+        @list ||= OrderedHash.auto
       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

data/lib/dmap/validations/absence.rb

@@ -1,14 +1,23 @@
 module DMap
   module Validations
     class AbsenceOf
+      # for aliases
       def self.parent_name
         "AbsenceOf"
       end
 
+      # Return true if it's valid
+      def self.is_valid?(command)
+        true
+      end
+
+      # This is what's returned to our template
       def self.validate(command=nil)
         {:null => true}
       end
     end
+
+    # aliases
     class Absence < AbsenceOf; end
     class Absent < AbsenceOf; end
   end

data/lib/dmap/validations/access.rb

@@ -0,0 +1,58 @@
+module DMap
+  module Validations
+    class Accessor
+      attr_accessor :property
+
+      def self.property; true; end;
+
+      # for aliases
+      def self.parent_name
+        "Accessor"
+      end
+
+      # Return true if it's valid
+      def self.is_valid?(command)
+        (command == "protected" or command == "public" or command == "private")
+      end
+
+      # This is what's returned to our template
+      def self.validate(command=nil)
+        command ||= "protected"
+        ":" + command
+      end
+    end
+
+    # aliases
+    class Access < Accessor; end
+
+    class Writer
+      attr_accessor :property
+
+      def self.property; true; end;
+
+      def self.is_valid?(command)
+        (command == "protected" or command == "public" or command == "private")
+      end
+
+      def self.validate(command=nil)
+        command ||= "protected"
+        ":" + command
+      end
+    end
+
+    class Reader
+      attr_accessor :property
+
+      def self.property; true; end;
+
+      def self.is_valid?(command)
+        (command == "protected" or command == "public" or command == "private")
+      end
+
+      def self.validate(command=nil)
+        command ||= "protected"
+        ":" + command
+      end
+    end
+  end
+end