mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/lib/dm-core/version.rb

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

data/lib/gems/dm-core-0.9.7/lib/dm-core.rb

@@ -0,0 +1,217 @@
+# This file begins the loading sequence.
+#
+# Quick Overview:
+# * Requires fastthread, support libs, and base.
+# * Sets the application root and environment for compatibility with frameworks
+#   such as Rails or Merb.
+# * Checks for the database.yml and loads it if it exists.
+# * Sets up the database using the config from the Yaml file or from the
+#   environment.
+#
+
+require 'date'
+require 'pathname'
+require 'set'
+require 'time'
+require 'yaml'
+
+require 'rubygems'
+
+gem 'addressable', '~>2.0'
+require 'addressable/uri'
+
+gem 'extlib', '~>0.9.8'
+require 'extlib'
+require "extlib/inflection"
+
+begin
+  require 'fastthread'
+rescue LoadError
+  # fastthread not installed
+end
+
+dir = Pathname(__FILE__).dirname.expand_path / 'dm-core'
+
+require dir / 'support'
+require dir / 'resource'
+require dir / 'model'
+
+require dir / 'dependency_queue'
+require dir / 'type'
+require dir / 'type_map'
+require dir / 'types'
+require dir / 'hook'
+require dir / 'associations'
+require dir / 'auto_migrations'
+require dir / 'identity_map'
+require dir / 'logger'
+require dir / 'migrator'
+require dir / 'naming_conventions'
+require dir / 'property_set'
+require dir / 'query'
+require dir / 'transaction'
+require dir / 'repository'
+require dir / 'scope'
+require dir / 'property'
+require dir / 'adapters'
+require dir / 'collection'
+require dir / 'is'
+
+# == Setup and Configuration
+# DataMapper uses URIs or a connection hash to connect to your data-store.
+# URI connections takes the form of:
+#   DataMapper.setup(:default, 'protocol://username:password@localhost:port/path/to/repo')
+#
+# Breaking this down, the first argument is the name you wish to give this
+# connection.  If you do not specify one, it will be assigned :default. If you
+# would like to connect to more than one data-store, simply issue this command
+# again, but with a different name specified.
+#
+# In order to issue ORM commands without specifying the repository context, you
+# must define the :default database. Otherwise, you'll need to wrap your ORM
+# calls in <tt>repository(:name) { }</tt>.
+#
+# Second, the URI breaks down into the access protocol, the username, the
+# server, the password, and whatever path information is needed to properly
+# address the data-store on the server.
+#
+# Here's some examples
+#   DataMapper.setup(:default, "sqlite3://path/to/your/project/db/development.db")
+#   DataMapper.setup(:default, "mysql://localhost/dm_core_test")
+#     # no auth-info
+#   DataMapper.setup(:default, "postgres://root:supahsekret@127.0.0.1/dm_core_test")
+#     # with auth-info
+#
+#
+# Alternatively, you can supply a hash as the second parameter, which would
+# take the form:
+#
+#   DataMapper.setup(:default, {
+#     :adapter  => 'adapter_name_here',
+#     :database => "path/to/repo",
+#     :username => 'username',
+#     :password => 'password',
+#     :host     => 'hostname'
+#   })
+#
+# === Logging
+# To turn on error logging to STDOUT, issue:
+#
+#   DataMapper::Logger.new(STDOUT, 0)
+#
+# You can pass a file location ("/path/to/log/file.log") in place of STDOUT.
+# see DataMapper::Logger for more information.
+#
+module DataMapper
+  extend Assertions
+
+  def self.root
+    @root ||= Pathname(__FILE__).dirname.parent.expand_path
+  end
+
+  ##
+  # Setups up a connection to a data-store
+  #
+  # @param Symbol name a name for the context, defaults to :default
+  # @param [Hash{Symbol => String}, Addressable::URI, String] uri_or_options
+  #   connection information
+  #
+  # @return Repository the resulting setup repository
+  #
+  # @raise ArgumentError "+name+ must be a Symbol, but was..." indicates that
+  #   an invalid argument was passed for name[Symbol]
+  # @raise [ArgumentError] "+uri_or_options+ must be a Hash, URI or String,
+  #   but was..." indicates that connection information could not be gleaned
+  #   from the given uri_or_options<Hash, Addressable::URI, String>
+  #
+  # -
+  # @api public
+  def self.setup(name, uri_or_options)
+    assert_kind_of 'name',           name,           Symbol
+    assert_kind_of 'uri_or_options', uri_or_options, Addressable::URI, Hash, String
+
+    case uri_or_options
+      when Hash
+        adapter_name = uri_or_options[:adapter].to_s
+      when String, DataObjects::URI, Addressable::URI
+        uri_or_options = DataObjects::URI.parse(uri_or_options) if uri_or_options.kind_of?(String)
+        adapter_name = uri_or_options.scheme
+    end
+
+    class_name = Extlib::Inflection.classify(adapter_name) + 'Adapter'
+
+    unless Adapters::const_defined?(class_name)
+      lib_name = "#{Extlib::Inflection.underscore(adapter_name)}_adapter"
+      begin
+        require root / 'lib' / 'dm-core' / 'adapters' / lib_name
+      rescue LoadError => e
+        begin
+          require lib_name
+        rescue Exception
+          # library not found, raise the original error
+          raise e
+        end
+      end
+    end
+
+    Repository.adapters[name] = Adapters::const_get(class_name).new(name, uri_or_options)
+  end
+
+  ##
+  # Block Syntax
+  #   Pushes the named repository onto the context-stack,
+  #   yields a new session, and pops the context-stack.
+  #
+  # Non-Block Syntax
+  #   Returns the current session, or if there is none,
+  #   a new Session.
+  #
+  # @param [Symbol] args the name of a repository to act within or return, :default is default
+  # @yield [Proc] (optional) block to execute within the context of the named repository
+  # @demo spec/integration/repository_spec.rb
+  def self.repository(name = nil) # :yields: current_context
+    current_repository = if name
+      raise ArgumentError, "First optional argument must be a Symbol, but was #{args.first.inspect}" unless name.is_a?(Symbol)
+      Repository.context.detect { |r| r.name == name } || Repository.new(name)
+    else
+      Repository.context.last || Repository.new(Repository.default_name)
+    end
+
+    if block_given?
+      current_repository.scope { |*block_args| yield(*block_args) }
+    else
+      current_repository
+    end
+  end
+
+  # A logger should always be present. Lets be consistent with DO
+  Logger.new(nil, :off)
+
+  ##
+  # destructively migrates the repository upwards to match model definitions
+  #
+  # @param [Symbol] name repository to act on, :default is the default
+  def self.migrate!(name = Repository.default_name)
+    repository(name).migrate!
+  end
+
+  ##
+  # drops and recreates the repository upwards to match model definitions
+  #
+  # @param [Symbol] name repository to act on, :default is the default
+  def self.auto_migrate!(repository_name = nil)
+    AutoMigrator.auto_migrate(repository_name)
+  end
+
+  def self.auto_upgrade!(repository_name = nil)
+    AutoMigrator.auto_upgrade(repository_name)
+  end
+
+  def self.prepare(*args, &blk)
+    yield repository(*args)
+  end
+
+  def self.dependency_queue
+    @dependency_queue ||= DependencyQueue.new
+  end
+end

data/lib/gems/dm-core-0.9.7/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/lib/gems/dm-core-0.9.7/script/performance.rb

@@ -0,0 +1,284 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core', 'version')
+
+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', :off)
+adapter = DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{socket_file}")
+
+if configuration_options[:adapter]
+  sqlfile = File.join(File.dirname(__FILE__),'..','tmp','performance.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'
+
+  belongs_to :user, :class_name => 'ARUser', :foreign_key => 'user_id'
+end
+
+class ARUser < ActiveRecord::Base #:nodoc:
+  set_table_name 'users'
+
+  has_many :exhibits, :foreign_key => 'user_id'
+
+end
+
+ARExhibit.find_by_sql('SELECT 1')
+
+class Exhibit
+  include DataMapper::Resource
+
+  property :id,         Serial
+  property :name,       String
+  property :zoo_id,     Integer
+  property :user_id,    Integer
+  property :notes,      Text, :lazy => true
+  property :created_on, Date
+
+  belongs_to :user
+#  property :updated_at, DateTime
+end
+
+class User
+  include DataMapper::Resource
+
+  property :id,    Serial
+  property :name,  String
+  property :email, String
+  property :about, Text, :lazy => true
+  property :created_on, Date
+
+end
+
+touch_attributes = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+  end
+end
+
+touch_relationships = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.user
+  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
+
+  puts "Generating data for benchmarking..."
+
+  User.auto_migrate!
+  Exhibit.auto_migrate!
+
+  users = []
+  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
+
+  # Using the same paragraph for all exhibits because it is very slow
+  # to generate unique paragraphs for all exhibits.
+  paragraph = Faker::Lorem.paragraphs.join($/)
+
+  10_000.times do |i|
+    users << [
+      'INSERT INTO `users` (`name`,`email`,`created_on`) VALUES (?, ?, ?)',
+      Faker::Name.name,
+      Faker::Internet.email,
+      Date.today
+    ]
+
+    exhibits << [
+      'INSERT INTO `exhibits` (`name`, `zoo_id`, `user_id`, `notes`, `created_on`) VALUES (?, ?, ?, ?, ?)',
+      Faker::Company.name,
+      rand(10).ceil,
+      i,
+      paragraph,#Faker::Lorem.paragraphs.join($/),
+      Date.today
+    ]
+  end
+
+  puts "Inserting 10,000 users..."
+  10_000.times { |i| adapter.execute(*users.at(i)) }
+  puts "Inserting 10,000 exhibits..."
+  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/performance.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 users > #{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"
+# Inform about slow benchmark
+# answer = nil
+# until answer && answer[/^$|y|yes|n|no/]
+#   print("A slow benchmark exposing problems with SEL is newly added. It takes approx. 20s\n");
+#   print("you have scheduled it to run #{TIMES / 100} times.\nWould you still include the particular benchmark? [Yn]")
+#   STDOUT.flush
+#   answer = gets
+# end
+# run_rel_bench = answer[/^$|y|yes/] ? true : false
+
+
+RBench.run(TIMES) do
+
+  column :times
+  column :ar, :title => "AR 2.1"
+  column :dm, :title => "DM #{DataMapper::VERSION}"
+  column :diff, :compare => [:ar,:dm]
+
+  report "Model.new (instantiation)" do
+    ar { ARExhibit.new }
+    dm { Exhibit.new }
+  end
+
+  report "Model.new (setting attributes)" do
+    attrs = {:name => 'sam', :zoo_id => 1}
+    ar { ARExhibit.new(attrs) }
+    dm { Exhibit.new(attrs) }
+  end
+
+  report "Model.get specific (not cached)" do
+    ActiveRecord::Base.uncached { ar { touch_attributes[ARExhibit.find(1)] } }
+    dm { touch_attributes[Exhibit.get(1)] }
+  end
+
+  report "Model.get specific (cached)" do
+    ActiveRecord::Base.cache    { ar { touch_attributes[ARExhibit.find(1)] } }
+    Exhibit.repository(:default) { dm { touch_attributes[Exhibit.get(1)] } }
+  end
+
+  report "Model.first" do
+    ar { touch_attributes[ARExhibit.first] }
+    dm { touch_attributes[Exhibit.first] }
+  end
+
+  report "Model.all limit(100)", (TIMES / 10.0).ceil do
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 100)] }
+    dm { touch_attributes[Exhibit.all(:limit => 100)] }
+  end
+
+  report "Model.all limit(100) with relationship", (TIMES / 10.0).ceil do
+    ar { touch_relationships[ARExhibit.all(:limit => 100, :include => [:user])] }
+    dm { touch_relationships[Exhibit.all(:limit => 100)] }
+  end
+
+  report "Model.all limit(10,000)", (TIMES / 1000.0).ceil do
+    ar { touch_attributes[ARExhibit.find(:all, :limit => 10_000)] }
+    dm { touch_attributes[Exhibit.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
+    ar { ARExhibit.create(create_exhibit) }
+    dm { Exhibit.create(create_exhibit) }
+  end
+
+  report "Resource#attributes" do
+    attrs_first  = {:name => 'sam', :zoo_id => 1}
+    attrs_second = {:name => 'tom', :zoo_id => 1}
+    ar { e = ARExhibit.new(attrs_first); e.attributes = attrs_second }
+    dm { e = Exhibit.new(attrs_first); e.attributes = attrs_second }
+  end
+
+  report "Resource#update" do
+    ar { e = ARExhibit.find(1); e.name = 'bob'; e.save }
+    dm { e = Exhibit.get(1); e.name = 'bob'; e.save }
+  end
+
+  report "Resource#destroy" do
+    ar { ARExhibit.first.destroy }
+    dm { Exhibit.first.destroy }
+  end
+
+  report "Model.transaction" do
+    ar { ARExhibit.transaction { ARExhibit.new } }
+    dm { Exhibit.transaction { Exhibit.new } }
+  end
+
+  summary "Total"
+end
+
+connection = adapter.send(:create_connection)
+command = connection.create_command("DROP TABLE exhibits")
+command = connection.create_command("DROP TABLE users")
+command.execute_non_query rescue nil
+connection.close

data/lib/gems/dm-core-0.9.7/script/profile.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), '..', 'lib', 'dm-core')
+
+require 'rubygems'
+
+gem 'ruby-prof', '>=0.6.0'
+require 'ruby-prof'
+
+gem 'faker', '>=0.3.1'
+require 'faker'
+
+OUTPUT = DataMapper.root / 'profile_results.txt'
+#OUTPUT = DataMapper.root / 'profile_results.html'
+
+SOCKET_FILE = Pathname.glob(%w[
+  /opt/local/var/run/mysql5/mysqld.sock
+  /tmp/mysqld.sock
+  /tmp/mysql.sock
+  /var/mysql/mysql.sock
+  /var/run/mysqld/mysqld.sock
+]).find { |path| path.socket? }
+
+DataMapper::Logger.new(DataMapper.root / 'log' / 'dm.log', :debug)
+DataMapper.setup(:default, "mysql://root@localhost/data_mapper_1?socket=#{SOCKET_FILE}")
+
+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
+
+  auto_migrate!
+  create  # create one row for testing
+end
+
+touch_attributes = lambda do |exhibits|
+  [*exhibits].each do |exhibit|
+    exhibit.id
+    exhibit.name
+    exhibit.created_on
+    exhibit.updated_at
+  end
+end
+
+# RubyProf, making profiling Ruby pretty since 1899!
+def profile(&b)
+  result  = RubyProf.profile &b
+  printer = RubyProf::FlatPrinter.new(result)
+  #printer = RubyProf::GraphHtmlPrinter.new(result)
+  printer.print(OUTPUT.open('w+'))
+end
+
+profile do
+#  10_000.times { touch_attributes[Exhibit.get(1)] }
+#
+#  repository(:default) do
+#    10_000.times { touch_attributes[Exhibit.get(1)] }
+#  end
+#
+#  1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
+#
+#  repository(:default) do
+#    1000.times { touch_attributes[Exhibit.all(:limit => 100)] }
+#  end
+#
+#  10.times { touch_attributes[Exhibit.all(:limit => 10_000)] }
+#
+#  repository(:default) do
+#    10.times { touch_attributes[Exhibit.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
+  }
+
+  1000.times { Exhibit.create(create_exhibit) }
+end
+
+puts "Done!"

data/lib/gems/dm-migrations-0.9.7/lib/dm-migrations/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  class Migration
+    VERSION = "0.9.7"
+  end
+end

data/lib/gems/dm-migrations-0.9.7/lib/dm-migrations.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/migration'