sam-dm-core 0.9.6

data/lib/dm-core/type_map.rb

@@ -0,0 +1,80 @@
+# TODO: move to dm-more/dm-migrations
+
+module DataMapper
+  class TypeMap
+
+    attr_accessor :parent, :chains
+
+    def initialize(parent = nil, &blk)
+      @parent, @chains = parent, {}
+
+      blk.call(self) unless blk.nil?
+    end
+
+    def map(type)
+      @chains[type] ||= TypeChain.new
+    end
+
+    def lookup(type)
+      if type_mapped?(type)
+        lookup_from_map(type)
+      else
+        lookup_by_type(type)
+      end
+    end
+
+    def lookup_from_map(type)
+      lookup_from_parent(type).merge(map(type).translate)
+    end
+
+    def lookup_from_parent(type)
+      if !@parent.nil? && @parent.type_mapped?(type)
+        @parent[type]
+      else
+        {}
+      end
+    end
+
+    # @raise <DataMapper::TypeMap::Error> if the type is not a default primitive or has a type map entry.
+    def lookup_by_type(type)
+      raise DataMapper::TypeMap::Error.new(type) unless type.respond_to?(:primitive) && !type.primitive.nil?
+
+      lookup(type.primitive).merge(Type::PROPERTY_OPTIONS.inject({}) {|h, k| h[k] = type.send(k); h})
+    end
+
+    alias [] lookup
+
+    def type_mapped?(type)
+      @chains.has_key?(type) || (@parent.nil? ? false : @parent.type_mapped?(type))
+    end
+
+    class TypeChain
+      attr_accessor :primitive, :attributes
+
+      def initialize
+        @attributes = {}
+      end
+
+      def to(primitive)
+        @primitive = primitive
+        self
+      end
+
+      def with(attributes)
+        raise "method 'with' expects a hash" unless attributes.kind_of?(Hash)
+        @attributes.merge!(attributes)
+        self
+      end
+
+      def translate
+        @attributes.merge((@primitive.nil? ? {} : {:primitive => @primitive}))
+      end
+    end # class TypeChain
+
+    class Error < StandardError
+      def initialize(type)
+        super("Type #{type} must have a default primitive or type map entry")
+      end
+    end
+  end # class TypeMap
+end # module DataMapper

data/lib/dm-core/types.rb

@@ -0,0 +1,19 @@
+dir = Pathname(__FILE__).dirname.expand_path / 'types'
+
+require dir / 'boolean'
+require dir / 'discriminator'
+require dir / 'text'
+require dir / 'paranoid_datetime'
+require dir / 'paranoid_boolean'
+require dir / 'object'
+require dir / 'serial'
+
+unless defined?(DM)
+  DM = DataMapper::Types
+end
+
+module DataMapper
+  module Resource
+    include Types
+  end # module Resource
+end # module DataMapper

data/lib/dm-core/types/boolean.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Types
+    class Boolean < DataMapper::Type
+      primitive TrueClass
+    end # class Boolean
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/discriminator.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Types
+    class Discriminator < DataMapper::Type
+      primitive Class
+      track :set
+      default lambda { |r,p| p.model }
+      nullable false
+
+      def self.bind(property)
+        model = property.model
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def self.descendants
+            (@descendants ||= []).uniq!
+            @descendants
+          end
+
+          after_class_method :inherited, :add_scope_for_discriminator
+
+          def self.add_scope_for_discriminator(retval, target)
+            target.descendants << target
+            target.default_scope.update(#{property.name.inspect} => target.descendants)
+            propagate_descendants(target)
+          end
+
+          def self.propagate_descendants(target)
+            descendants << target
+            superclass.propagate_descendants(target) if superclass.respond_to?(:propagate_descendants)
+          end
+        EOS
+      end
+    end # class Discriminator
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/object.rb

@@ -0,0 +1,24 @@
+require "base64"
+
+module DataMapper
+  module Types
+    class Object < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+      track :hash
+
+      def self.typecast(value, property)
+        value
+      end
+
+      def self.dump(value, property)
+        Base64.encode64(Marshal.dump(value))
+      end
+
+      def self.load(value, property)
+        value.nil? ? nil : Marshal.load(Base64.decode64(value))
+      end
+    end
+  end
+end

data/lib/dm-core/types/paranoid_boolean.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Types
+    class ParanoidBoolean < DataMapper::Type(Boolean)
+      primitive TrueClass
+      default   false
+      lazy      true
+
+      def self.bind(property)
+        model = property.model
+        repository = property.repository
+
+        model.send(:set_paranoid_property, property.name){true}
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+
+          def self.with_deleted
+            with_exclusive_scope(#{property.name.inspect} => true) do
+              yield
+            end
+          end
+
+          def destroy
+            self.class.paranoid_properties.each do |name, blk|
+              attribute_set(name, blk.call(self))
+            end
+            save
+          end
+        EOS
+
+        model.default_scope(repository.name).update(property.name => false)
+      end
+    end # class ParanoidBoolean
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/paranoid_datetime.rb

@@ -0,0 +1,33 @@
+module DataMapper
+  module Types
+    class ParanoidDateTime < DataMapper::Type(DateTime)
+      primitive DateTime
+      lazy      true
+
+      def self.bind(property)
+        model = property.model
+        repository = property.repository
+
+        model.send(:set_paranoid_property, property.name){DateTime.now}
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+
+          def self.with_deleted
+            with_exclusive_scope(#{property.name.inspect}.not => nil) do
+              yield
+            end
+          end
+
+          def destroy
+            self.class.paranoid_properties.each do |name, blk|
+              attribute_set(name, blk.call(self))
+            end
+            save
+          end
+        EOS
+
+        model.default_scope(repository.name).update(property.name => nil)
+      end
+    end # class ParanoidDateTime
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/serial.rb

@@ -0,0 +1,9 @@
+# FIXME: can we alias this to the class Text if it isn't already defined?
+module DataMapper
+  module Types
+    class Serial < DataMapper::Type
+      primitive Integer
+      serial true
+    end # class Text
+  end # module Types
+end # module DataMapper

data/lib/dm-core/types/text.rb

@@ -0,0 +1,10 @@
+# FIXME: can we alias this to the class Text if it isn't already defined?
+module DataMapper
+  module Types
+    class Text < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+    end # class Text
+  end # module Types
+end # module DataMapper

data/lib/dm-core/version.rb

@@ -0,0 +1,3 @@
+module DataMapper
+  VERSION = '0.9.6' unless defined?(DataMapper::VERSION)
+end

data/script/all

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+rake spec:unit
+ADAPTER=sqlite3  rake spec:integration
+ADAPTER=mysql    rake spec:integration
+ADAPTER=postgres rake spec:integration

data/script/performance.rb

@@ -0,0 +1,203 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+
+require 'rubygems'
+require 'ftools'
+
+# sudo gem install rbench
+# OR git clone git://github.com/somebee/rbench.git , rake install
+gem 'rbench', '>=0.2.2'
+require 'rbench'
+
+gem 'faker', '>=0.3.1'
+require 'faker'
+
+gem 'activerecord', '>=2.1.0'
+require 'active_record'
+
+socket_file = Pathname.glob(%w[
+  /opt/local/var/run/mysql5/mysqld.sock
+  tmp/mysqld.sock
+  /tmp/mysqld.sock
+  tmp/mysql.sock
+  /tmp/mysql.sock
+  /var/mysql/mysql.sock
+  /var/run/mysqld/mysqld.sock
+]).find { |path| path.socket? }
+
+configuration_options = {
+  :adapter => 'mysql',
+  :username => 'root',
+  :password => '',
+  :database => 'data_mapper_1',
+}
+
+configuration_options[:socket] = socket_file unless socket_file.nil?
+
+log_dir = DataMapper.root / 'log'
+log_dir.mkdir unless log_dir.directory?
+
+DataMapper::Logger.new(log_dir / 'dm.log', :debug)
+adapter = DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{socket_file}")
+
+if configuration_options[:adapter]
+  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','perf.sql')
+  mysql_bin = %w[mysql mysql5].select{|bin| `which #{bin}`.length > 0 }
+  mysqldump_bin = %w[mysqldump mysqldump5].select{|bin| `which #{bin}`.length > 0 }
+end
+
+ActiveRecord::Base.logger = Logger.new(log_dir / 'ar.log')
+ActiveRecord::Base.logger.level = 0
+
+ActiveRecord::Base.establish_connection(configuration_options)
+
+class ARExhibit < ActiveRecord::Base #:nodoc:
+  set_table_name 'exhibits'
+end
+
+ARExhibit.find_by_sql('SELECT 1')
+
+class Exhibit
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :name,       String
+  property :zoo_id,     Integer
+  property :notes,      Text, :lazy => true
+  property :created_on, Date
+#  property :updated_at, DateTime
+end
+
+touch_attributes = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+#    exhibit.updated_at
+  end
+end
+
+
+c = configuration_options
+
+if sqlfile && File.exists?(sqlfile)
+  puts "Found data-file. Importing from #{sqlfile}"
+  #adapter.execute("LOAD DATA LOCAL INFILE '#{sqlfile}' INTO TABLE exhibits")
+  `#{mysql_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} < #{sqlfile}`
+else
+
+  Exhibit.auto_migrate!
+
+  exhibits = []
+  # pre-compute the insert statements and fake data compilation,
+  # so the benchmarks below show the actual runtime for the execute
+  # method, minus the setup steps
+  10_000.times do
+    exhibits << [
+      'INSERT INTO `exhibits` (`name`, `zoo_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?)',
+      Faker::Company.name,
+      rand(10).ceil,
+      Faker::Lorem.paragraphs.join($/),
+      Date.today
+    ]
+  end
+  10_000.times { |i| adapter.execute(*exhibits.at(i)) }
+
+  if sqlfile
+    answer = nil
+    until answer && answer[/^$|y|yes|n|no/]
+      print("Would you like to dump data into tmp/perf.sql (for faster setup)? [Yn]");
+      STDOUT.flush
+      answer = gets
+    end
+
+    if answer[/^$|y|yes/]
+      File.makedirs(File.dirname(sqlfile))
+      #adapter.execute("SELECT * INTO OUTFILE '#{sqlfile}' FROM exhibits;")
+      `#{mysqldump_bin} -u #{c[:username]} #{"-p#{c[:password]}" unless c[:password].blank?} #{c[:database]} exhibits > #{sqlfile}`
+      puts "File saved\n"
+    end
+  end
+
+end
+
+TIMES = ENV['x'] ? ENV['x'].to_i : 10_000
+
+puts "You can specify how many times you want to run the benchmarks with rake:perf x=(number)"
+puts "Some tasks will be run 10 and 1000 times less than (number)"
+puts "Benchmarks will now run #{TIMES} times"
+
+RBench.run(TIMES) do
+
+  column :times
+  column :dm, :title => "DM 0.9.4"
+  column :ar, :title => "AR 2.1"
+  column :diff, :compare => [:dm,:ar]
+
+  report "Model.new (instantiation)" do
+    dm { Exhibit.new }
+    ar { ARExhibit.new }
+  end
+
+  report "Model.new (setting attributes)" do
+    attrs = {:name => 'sam', :zoo_id => 1}
+    dm { Exhibit.new(attrs) }
+    ar { ARExhibit.new(attrs) }
+  end
+
+  report "Model.get specific (not cached)" do
+    dm { touch_attributes[Exhibit.get(1)] }
+    ActiveRecord::Base.uncached { ar { touch_attributes[ARExhibit.find(1)] } }
+  end
+
+  report "Model.get specific (cached)" do
+    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)]    } }
+    ActiveRecord::Base.cache    { ar { touch_attributes[ARExhibit.find(1)] } }
+  end
+
+  report "Model.first" do
+    dm { touch_attributes[Exhibit.first]   }
+    ar { touch_attributes[ARExhibit.first] }
+  end
+
+  report "Model.all limit(100)", TIMES / 10 do
+    dm { touch_attributes[Exhibit.all(:limit => 100)] }
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 100)] }
+  end
+
+  report "Model.all limit(10,000)", TIMES / 1000 do
+    dm { touch_attributes[Exhibit.all(:limit => 10_000)] }
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 10_000)] }
+  end
+
+  create_exhibit = {
+    :name       => Faker::Company.name,
+    :zoo_id     => rand(10).ceil,
+    :notes      => Faker::Lorem.paragraphs.join($/),
+    :created_on => Date.today
+  }
+
+  report "Model.create" do
+    dm { Exhibit.create(create_exhibit)   }
+    ar { ARExhibit.create(create_exhibit) }
+  end
+
+  report "Resource#update" do
+    dm { e = Exhibit.get(1); e.name = 'bob'; e.save   }
+    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save  }
+  end
+
+  report "Resource#destroy" do
+    dm { Exhibit.first.destroy }
+    ar { ARExhibit.first.destroy }
+  end
+
+  summary "Total"
+
+end
+
+connection = adapter.send(:create_connection)
+command = connection.create_command("DROP TABLE exhibits")
+command.execute_non_query rescue nil
+connection.close