mass_record 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 054417da2bfb6c27e10c6cab4a43749a4e7c5928
+  data.tar.gz: 2cc23822c8fadd28876fa92ddeedd0d55d020611
+SHA512:
+  metadata.gz: 796999b036af5527ac05d769d037f46ec45d22cca212348fe012dd147e736f047792ef2f98858b8d94a565db16e665127e9f77583c969c6e7243af2f9478892d
+  data.tar.gz: 03a884f22b6df45f46fe11cc0a192b115a86a22302015abc434792ab89c64faa7037b17e1962755a2f3cc9a715ace191536340bcee17a2d6955c5b236bde2aff

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= MassRecord
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MassRecord'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/mass_record/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/mass_record/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/mass_record/application_controller.rb

@@ -0,0 +1,4 @@
+module MassRecord
+  class ApplicationController < ActionController::Base
+  end
+end

data/app/helpers/mass_record/application_helper.rb

@@ -0,0 +1,4 @@
+module MassRecord
+  module ApplicationHelper
+  end
+end

data/app/views/layouts/mass_record/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>MassRecord</title>
+  <%= stylesheet_link_tag    "mass_record/application", media: "all" %>
+  <%= javascript_include_tag "mass_record/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+MassRecord::Engine.routes.draw do
+end

data/lib/mass_record/engine.rb

@@ -0,0 +1,5 @@
+module MassRecord
+  class Engine < ::Rails::Engine
+    isolate_namespace MassRecord
+  end
+end

data/lib/mass_record/version.rb

@@ -0,0 +1,3 @@
+module MassRecord
+  VERSION = "0.0.1"
+end

data/lib/mass_record.rb

@@ -0,0 +1,373 @@
+require "mass_record/engine"
+
+module MassRecord
+	mattr_accessor :path, :folder_path, :database_connection
+	self.path = {}
+	self.folder_path = "tmp/#{Rails.env}"
+	self.path[:queries] = "tmp/#{Rails.env}"
+	self.path[:queued_queries] = "tmp/#{Rails.env}"
+	self.path[:errored_queries] = "tmp/#{Rails.env}"
+	self.path[:completed_queries] = "tmp/#{Rails.env}"
+
+	module Actions
+		path = {}
+		folder_path = "tmp/#{Rails.env}"
+		path[:queries] = "#{folder_path}/queries"
+		path[:queued_queries] = "#{path[:queries]}/queued"
+		path[:errored_queries] = "#{path[:queries]}/errored"
+		path[:completed_queries] = "#{path[:queries]}/completed"
+
+		# accepts an array of objects with the option to specify what rails operation to perform
+		def queue_for_quick_query object_array, 
+			operation: :save, 
+			folder:{queued:path[:queued_queries]}, 
+			file_tag:Time.now.strftime("%Y%m%d%H%M%S").to_s,
+			key:{
+				table: "table",
+				operation: "operation",
+				object: "object"			
+			}
+
+			object_array = [object_array] unless object_array.is_a? Array
+			queue = []
+
+			object_array.each do |object|
+				queue << {key[:table] => object.class.table_name, key[:operation] =>  operation, key[:object] => object} unless object.blank?
+			end
+
+			File.open(folder[:queued]+"/#{operation.to_s}_#{file_tag}.json",'w'){|f| f.write queue.to_json}
+		end
+
+		def execute_queued_queries key:{
+				operation:"operation", 
+				table:"table", 
+				object:"object"
+			},synonyms:{
+				insert: [:create, :new, :add, :insert, :post],
+				update: [:update,:edit,:modify,:put,:patch],
+				select: [:read,:select,:get]
+			},folder:{
+				queued:path[:queued_queries],
+				errored:path[:errored_queries],
+				completed:path[:completed_queries]
+			},file_tag:Time.now.strftime("%Y%m%d%H%M%S").to_s
+
+			files = Dir.foreach(folder[:queued]).collect{|x| x}.keep_if{|y|y=~/\.json$/i}
+			json_objects = []
+
+			# rename to avoid double processing
+			files.each{|x| File.rename "#{folder[:queued]}/#{x}","#{folder[:queued]}/#{x}.processing"}
+
+			# load all the json
+			files.each do |file|
+				File.open("#{folder[:queued]}/#{file}.processing",'r') do |f|
+					json = JSON.parse(f.read)
+					json_objects += json
+				end
+			end
+
+			# validate all objects
+			json_objects = mass_validate json_objects
+
+			# get all operations and tables in use
+			operations = json_objects.collect{|x| x[key[:operation]].to_sym}.to_set.to_a
+
+			# open database connection
+			database_connection = ActiveRecord::Base.connection
+
+			# construct mass queries
+			errors = {}
+			operations.each do |op|
+				if synonyms[:insert].include? op
+					errors[:insert] = mass_insert_by_table json_objects.select{|x| synonyms[:insert].include? x[key[:operation]].to_sym.downcase}, key:key
+				elsif synonyms[:update].include? op
+					errors[:update] = mass_update_by_table json_objects.select{|x| synonyms[:update].include? x[key[:operation]].to_sym.downcase}, key:key
+				elsif op == :save	# needs to intelligently determine if the order already exists, insert if not, update if so
+					errors[:save] = mass_save_by_table json_objects.select{|x| :save == x[key[:operation]].to_sym.downcase}, key:key
+				elsif op == :delete
+				elsif synonyms[:select].include? op
+				else
+				end
+			end
+
+			# close database connection
+			database_connection.close
+
+			# move to appropriate folder and remove '.processing' from the filename
+			files = Dir.foreach(folder[:queued]).collect{|x| x}.keep_if{|y|y=~/\.json\.processing$/i}
+			errors_present = errors.any?{|op,h| h.any?{|table,a| a.count > 0 }}
+			files.each{|x| File.rename "#{folder[:queued]}/#{x}","#{errors_present ? folder[:errored] : folder[:completed]}/group_#{file_tag}_#{x.gsub /\.processing$/,''}"}
+
+			return errors
+		end
+
+		def mass_validate objects
+			# TODO: write logic, should return only valid objects
+			return objects
+		end
+
+		def mass_update_by_table json_objects, key:{}
+			begin
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = {}
+				tables.each do |table|
+					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+					errors[table.to_sym] = mass_update hashes, into:table
+				end
+				return errors
+			rescue Exception => e
+				return {method:e} unless defined? errors
+				errors[:method] = e if defined? errors
+				return errors
+			end
+		end
+
+		def mass_save_by_table json_objects, key:{}
+			begin
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = {}
+				tables.each do |table|
+					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+					model = table.classify.constantize
+					pk = model.primary_key
+
+					# organize hashes based on whether they exist (based on their primary key(s)) in the table or not
+					if pk.is_a? Array
+						ids = hashes.reject{|x| pk.any?{|k| x[k].blank?}}.collect{|x| x.select{|k,v| pk.include? k}}	# only accept full sets of pk's
+						where_clauses = []
+						ids.each do |id|
+							equivalence_clauses = []
+							id.each do |k,v|
+								equivalence_clauses << "#{ActiveRecord::Base.connection.quote_column_name k} = #{ActiveRecord::Base.connection.quote(ActiveRecord::Base.connection.type_cast(v, model.column_types[k]))}"
+							end
+							where_clauses << "(#{equivalence_clauses.join ' and '})"
+						end
+						existing_id_sets = ActiveRecord::Base.connection.execute("SELECT #{pk.join ', '} FROM #{table} WHERE #{where_clauses.join ' OR '}").collect{|x| Hash[x.map.with_index{|x,i| [pk[i],x]}]}
+						insert_hashes = hashes.reject{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
+						update_hashes = hashes.select{|h| existing_id_sets.any?{|set| h == h.merge(set)}}
+					else
+						ids = hashes.reject{|x| x[pk].blank?}.collect{|x| x[pk]}	# should not include null values
+						existing_ids = ActiveRecord::Base.connection.execute("SELECT #{pk} FROM #{table} WHERE #{pk} in ('#{ids.join "','"}')").collect{|x| x.first.to_s}
+						insert_hashes = hashes.reject{|x| existing_ids.include? x[pk].to_s}
+						update_hashes = hashes.select{|x| existing_ids.include? x[pk].to_s}
+					end
+
+					# perform the appropriate operations
+					errors[table.to_sym] = []
+					errors[table.to_sym] += mass_update update_hashes, into:model unless update_hashes.blank?
+					errors[table.to_sym] += mass_insert insert_hashes, into:model unless insert_hashes.blank?
+				end	
+				return errors
+			rescue Exception => e
+				return {method:e} unless defined? errors
+				errors[:method] = e if defined? errors
+				return errors
+			end
+		end
+
+		def mass_update hashes, into:nil
+			begin
+				return false if hashes.blank? or into.blank?
+
+				model = into.is_a?(String) ? into.classify.constantize : into
+				id_column_name = model.primary_key
+				created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
+				updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
+				solitary_queries = []
+				t = model.arel_table
+
+				# organize by unique column sets
+				unique_column_sets = {}
+
+				hashes.each do |hash|
+					column_set = hash.keys.sort
+					unique_column_sets[column_set] = [] unless unique_column_sets.has_key? column_set and unique_column_sets[column_set].is_a? Array
+					unique_column_sets[column_set] << hash
+				end
+
+				# assemble list of queries (1 for each unique set of columns)
+				queries = []
+
+				unique_column_sets.each do |column_set, hash_group|
+					if id_column_name.is_a? Array
+						ids = hash_group.collect{|hash| Hash[id_column_name.map.with_index{|column_name,i| [column_name,hash[column_name]] }]}
+						update = 	"UPDATE #{model.table_name} SET "
+						where_clauses = []
+						id_column_name.each do |key|
+							value_set = ids.collect{|id_set| ActiveRecord::Base.connection.quote(ActiveRecord::Base.connection.type_cast(id_set[key], model.column_types[key]))}
+							where_clauses << "(#{model.table_name}.#{key} in (#{value_set.join ','}))"
+						end
+						where = "WHERE #{where_clauses.join ' and '}"
+
+						set_fragments = {}
+
+						hash_group.each do |hash|
+							hash = convert_to_db_format hash, model:model
+							if id_column_name.all?{|column_name| hash.has_key? column_name}	# if the hash has all primary keys
+								hash.each do |k,v|
+									unless id_column_name.include? k 	# don't allow the update of primary key columns
+										set_fragments[k] = [] unless set_fragments.has_key? k and set_fragments[k].is_a? Array
+										case_fragments = []
+										id_column_name.each do |key|
+											case_fragments << "#{ActiveRecord::Base.connection.quote_column_name key} = #{ActiveRecord::Base.connection.quote hash[key]}"
+										end
+										set_fragments[k] << "WHEN (#{case_fragments.join ' and '}) THEN #{ActiveRecord::Base.connection.quote v}"
+									end
+								end
+							end
+						end
+					else
+						ids = hash_group.collect{|x| x[id_column_name]}
+						update = 	"UPDATE #{model.table_name} SET "
+						where = 	"WHERE #{model.table_name}.#{id_column_name} in ('#{ids.join("','")}')"
+
+						set_fragments = {}
+
+						hash_group.each do |hash|
+							hash = convert_to_db_format hash, model:model 	# TODO: adapt the method to work nicely with updates (ie- don't overwrite the created_at)
+							if hash.has_key? id_column_name
+								hash.each do |k,v|
+									if k != id_column_name
+										set_fragments[k] = [] unless set_fragments.has_key? k and set_fragments[k].is_a? Array
+										set_fragments[k] << "WHEN #{ActiveRecord::Base.connection.quote hash[id_column_name]} THEN #{ActiveRecord::Base.connection.quote v}"
+									end
+								end
+							end
+						end
+					end
+
+					set_columns = []
+
+					set_fragments.each do |column, values|
+						set_columns << "#{column} = CASE #{model.table_name}.#{id_column_name} #{values.join ' '} END" unless id_column_name.is_a? Array
+						set_columns << "#{column} = CASE #{values.join ' '} END" if id_column_name.is_a? Array
+					end
+
+					queries << "#{update} #{set_columns.join ', '} #{where}"
+				end
+				# [{"id"=>545, "header"=>"new system","details"=>"ya, it worked"},{"id"=>546, "header"=>"sweet system"},{"id"=>547, "header"=>"THAT system","details"=>"ya, it worked"}]
+				errors = []
+				# execute the queries
+				queries.each do |sql|
+					begin
+						query sql
+					rescue Exception => e
+						puts e.message
+						errors << e
+					end
+				end	
+				return errors		
+			rescue Exception => e
+				return (defined? errors) ? (errors << e) : [e]
+			end
+		end
+
+		def mass_insert_by_table json_objects, key:{}
+			begin		
+				tables = json_objects.collect{|x| x[key[:table]]}.to_set.to_a
+
+				errors = {}
+				tables.each do |table|
+					hashes = json_objects.select{|o| o[key[:table]] == table}.collect{|x| x[key[:object]]}
+					errors[table.to_sym] = mass_insert hashes, into:table
+				end
+				return errors
+			rescue Exception => e
+				return {method:e} unless defined? errors
+				errors[:method] = e if defined? errors
+				return errors
+			end
+		end
+
+		def mass_insert hashes, into:nil
+			begin
+				return false if hashes.blank? or into.blank?
+
+				# create an array of single insert queries
+				model = into.is_a?(String) ? into.classify.constantize : into
+				id_column_name = model.primary_key
+				created_at = model.attribute_alias?("created_at") ? model.attribute_alias("created_at") : "created_at"
+				updated_at = model.attribute_alias?("updated_at") ? model.attribute_alias("updated_at") : "updated_at"
+				solitary_queries = []
+				t = model.arel_table
+
+				hashes.each do |h|
+					im = Arel::InsertManager.new(ActiveRecord::Base)
+					unless id_column_name.is_a? Array 	# don't modify the id fields if there are concatenated primary keys
+						h.delete id_column_name if model.columns.select{|x| x.name == id_column_name}.first.extra == 'auto_increment' or h[id_column_name].blank?
+					end
+					h = convert_to_db_format h, model:model, created_at:created_at, updated_at:updated_at
+					pairs = h.collect do |k,v|
+						[t[k.to_sym],v]
+					end
+					im.insert pairs
+					solitary_queries << im.to_sql
+				end
+
+				# group the queries by unique column lists
+				concentrated_queries = {}
+
+				solitary_queries.each do |q|
+					k = q.gsub /\s*VALUES.*$/,''
+					concentrated_queries[k] = [] unless concentrated_queries.has_key? k and concentrated_queries[k].is_a? Array
+					concentrated_queries[k] << q.gsub(/^.*VALUES\s*/,'')
+				end
+
+				errors = []
+				# reparse the queries and execute them
+				concentrated_queries.each do |k,v|
+					begin
+						query "#{k} VALUES #{v.join(", ")}"				
+					rescue Exception => e
+						puts e.message
+						errors << e
+					end
+				end
+				return errors
+			rescue Exception => e
+				return (defined? errors) ? (errors << e) : [e]
+			end
+		end
+
+
+		def convert_to_db_format json_object, model:nil, created_at:'created_at', updated_at:'updated_at'
+			throw "No Model provided, cannot format the data for the specified columns" if model.blank?
+
+			json_date_regex = /^"?\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[\+\-]\d{2}:\d{2}"?$/i
+			time = Time.now.to_s(:db)
+			crud_times = [created_at,updated_at]
+			json_object.each do |k,v|
+				v = Time.parse v if v.is_a? String and v =~ json_date_regex												# fix funky to_json format if present
+				v = time if crud_times.include? k and (v.blank? or k == updated_at) and model.column_names.include? k	# add crud time if it is blank and it is a column in the model or if it is update_at just add the time
+
+				# convert to correct database type
+				begin 
+					v = ActiveRecord::Base.connection.type_cast v, model.column_types[k]
+				rescue Exception => e 	# If it is a text field, automatically yamlize it if there is a non text type passed in (just like normal active record saves)
+					v = ActiveRecord::Base.connection.type_cast v.to_yaml, model.column_types[k] if e.is_a? TypeError and model.column_types[k].type == :text
+				end
+				json_object[k] = v
+			end
+
+			return json_object
+		end
+
+		def query sql
+			if database_connection.blank?
+				res = ActiveRecord::Base.connection.execute sql
+				ActiveRecord::Base.connection.close
+			else
+				res = database_connection.execute sql
+			end
+
+			return res
+		end
+	end
+
+	class << self
+		include Actions
+	end
+
+end

data/lib/tasks/mass_record_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :mass_record do
+#   # Task goes here
+# end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+  <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track' => true %>
+  <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/bin/bundle

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+load Gem.bin_path('bundler', 'bundle')

data/test/dummy/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/test/dummy/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative '../config/boot'
+require 'rake'
+Rake.application.run

data/test/dummy/config/application.rb

@@ -0,0 +1,23 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require(*Rails.groups)
+require "mass_record"
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+  end
+end
+

data/test/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)