mack-data_mapper 0.8.2 → 0.8.3

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

@@ -1,7 +0,0 @@
-module DataMapper
-  module More
-    module Aggregates
-      VERSION = "0.9.7"
-    end
-  end
-end

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

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

data/lib/gems/dm-core-0.9.7/script/all

@@ -1,5 +0,0 @@
-#!/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

@@ -1,284 +0,0 @@
-#!/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

@@ -1,87 +0,0 @@
-#!/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-serializer-0.9.7/lib/dm-serializer.rb

@@ -1,183 +0,0 @@
-require Pathname('rexml/document')
-
-begin
-  require 'faster_csv'
-rescue LoadError
-  nil
-end
-
-begin
-  require Pathname('json/ext')
-rescue LoadError
-  require Pathname('json/pure')
-end
-
-module DataMapper
-  module Serialize
-
-    # Serialize a Resource to JavaScript Object Notation (JSON; RFC 4627)
-    #
-    # @return <String> a JSON representation of the Resource
-    def to_json(options = {})
-      result = '{ '
-      fields = []
-
-      # FIXME: this should go into bunch of protected methods shared with other serialization methods
-      only_properties     = Array(options[:only])
-      excluded_properties = Array(options[:exclude])
-      exclude_read_only   = options[:without_read_only_attributes] || false
-
-      propset = self.class.properties(repository.name).reject do |p|
-        next if only_properties.include? p.name
-        excluded_properties.include?(p.name) || !(only_properties.empty? || only_properties.include?(p.name))
-      end
-
-      fields += propset.map do |property|
-        "#{property.name.to_json}: #{send(property.getter).to_json}"
-      end
-
-      if self.respond_to?(:serialize_properties)
-        self.serialize_properties.each do |k,v|
-          fields << "#{k.to_json}: #{v.to_json}"
-        end
-      end
-
-      if self.class.respond_to?(:read_only_attributes) && exclude_read_only
-        self.class.read_only_attributes.each do |property|
-          fields << "#{property.to_json}: #{send(property).to_json}"
-        end
-      end
-
-      # add methods
-      (options[:methods] || []).each do |meth|
-        if self.respond_to?(meth)
-          fields << "#{meth.to_json}: #{send(meth).to_json}"
-        end
-      end
-
-      # Note: if you want to include a whole other model via relation, use :methods
-      # comments.to_json(:relationships=>{:user=>{:include=>[:first_name],:methods=>[:age]}})
-      # add relationships
-      (options[:relationships] || {}).each do |rel,opts|
-        if self.respond_to?(rel)
-          fields << "#{rel.to_json}: #{send(rel).to_json(opts)}"
-        end
-      end
-
-      result << fields.join(', ')
-      result << ' }'
-      result
-    end
-
-    # Serialize a Resource to comma-separated values (CSV).
-    #
-    # @return <String> a CSV representation of the Resource
-    def to_csv(writer = '')
-      FasterCSV.generate(writer) do |csv|
-        row = []
-        self.class.properties(repository.name).each do |property|
-         row << send(property.name).to_s
-        end
-        csv << row
-      end
-    end
-
-    # Serialize a Resource to XML
-    #
-    # @return <REXML::Document> an XML representation of this Resource
-    def to_xml(opts = {})
-
-      to_xml_document(opts).to_s
-    end
-
-    # Serialize a Resource to YAML
-    #
-    # @return <YAML> a YAML representation of this Resource
-    def to_yaml(opts = {})
-      YAML::quick_emit(object_id,opts) do |out|
-        out.map(nil,to_yaml_style) do |map|
-          self.class.properties(repository.name).each do |property|
-            value = send(property.name.to_sym)
-            map.add(property.name, value.is_a?(Class) ? value.to_s : value)
-          end
-          (instance_variable_get("@yaml_addes") || []).each do |k,v|
-            map.add(k.to_s,v)
-          end
-        end
-      end
-    end
-
-    protected
-
-    # Return the name of this Resource - to be used as the root element name.
-    # This can be overloaded.
-    #
-    # @return <String> name of this Resource
-    def xml_element_name
-      Extlib::Inflection.underscore(self.class.name)
-    end
-
-    # Return a REXML::Document representing this Resource
-    #
-    # @return <REXML::Document> an XML representation of this Resource
-    def to_xml_document(opts={}, doc=nil)
-      doc ||= REXML::Document.new
-      root = doc.add_element(xml_element_name)
-
-      #TODO old code base was converting single quote to double quote on attribs
-
-      self.class.properties(repository.name).each do |property|
-          value = send(property.name)
-          node = root.add_element(property.name.to_s)
-          unless property.type == String
-            node.attributes["type"] = property.type.to_s.downcase
-          end
-          node << REXML::Text.new(value.to_s) unless value.nil?
-      end
-      doc
-    end
-
-  end # module Serialize
-
-  module Resource
-    include Serialize
-  end # module Resource
-
-  class Collection
-    def to_yaml(opts = {})
-      to_a.to_yaml(opts)
-    end
-
-    def to_json(opts = {})
-      "[" << map {|e| e.to_json(opts)}.join(",") << "]"
-    end
-
-    def to_xml(opts = {})
-      to_xml_document(opts).to_s
-    end
-
-    def to_csv
-      result = ""
-      each do |item|
-        result << item.to_csv + "\n"
-      end
-      result
-    end
-
-    protected
-    def xml_element_name
-      Extlib::Inflection.tableize(self.model.to_s)
-    end
-
-    def to_xml_document(opts={})
-      doc = REXML::Document.new
-      root = doc.add_element(xml_element_name)
-      root.attributes["type"] = 'array'
-      each do |item|
-        item.send(:to_xml_document, opts, root)
-      end
-      doc
-    end
-  end
-
-end # module DataMapper