mockley_crew 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 993536215b5d2e4fe3a215e7b791fe4f7d270d88d4cabe27503ce96523baba24
+  data.tar.gz: 3374d188f2a337e4346885e8a1e842ee5d7ef765aa9d03b27331f038bf0f2be4
+SHA512:
+  metadata.gz: f7d9014166b658fa57d7b32385f88bd064d709a58b0844d3886e76910727fd0966e3890ed61c096b514cd9222cb25cf5f97dd2f773e26f729c015b6158fcca53
+  data.tar.gz: ebbb9d82dd74ace41203af0c67a8c81cae734beffa5e6d7d1488a900276852184cfeb65fecd2eff1b819607c7ec7aff29594bf01f65a87d2a3e20b9ab568d9dd

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Ariel Schvartz
+
+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.md

@@ -0,0 +1,28 @@
+# MockleyCrew
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mockley_crew'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install mockley_crew
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,22 @@
+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    = 'MockleyCrew'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/controllers/mockley_crew/application_controller.rb

@@ -0,0 +1,4 @@
+module MockleyCrew
+  class ApplicationController < ActionController::API
+  end
+end

data/app/controllers/mockley_crew/database/data_controller.rb

@@ -0,0 +1,26 @@
+module MockleyCrew
+  class Database::DataController < ApplicationController
+    rescue_from MockleyCrew::Errors::InvalidDataError do |exception|
+      render json: { success: false, message: "Invalid body structure" }, status: 400
+    end
+
+    rescue_from MockleyCrew::Errors::InvalidFactoryError do |exception|
+      render json: { success: false, message: "Invalid Factory", detailed_error: exception }, status: 400
+    end
+
+    def create
+      data = MockleyCrew::Data.new(data_params.to_h["_json"])
+      if data.save
+        render json: { success: true }, status: 201
+      else
+        render json: { success: false, request: data.as_json }, status: 422
+      end
+    end
+
+    private
+
+      def data_params
+        params.permit!
+      end
+  end
+end

data/app/controllers/mockley_crew/database_controller.rb

@@ -0,0 +1,22 @@
+module MockleyCrew
+  class DatabaseController < ApplicationController
+    skip_before_action :activate_database
+    skip_after_action :restore_database
+    skip_after_action :set_response_header
+    after_action :set_response_header, only: [:create]
+
+    def create
+      @database = MockleyCrew::Database.create
+      render json: { success: true, database: { name: @database.filename } }, status: 201
+    end
+
+    def destroy
+      if @database
+        @database.destroy
+        render json: { success: true }, status: 200
+      else
+        invalid_badge
+      end
+    end
+  end
+end

data/app/jobs/mockley_crew/application_job.rb

@@ -0,0 +1,4 @@
+module MockleyCrew
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/mockley_crew/application_mailer.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/mockley_crew/application_record.rb

@@ -0,0 +1,5 @@
+module MockleyCrew
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/config/initializers/mockley_crew.rb

@@ -0,0 +1,15 @@
+if defined?(ActionController::Base)
+  ActionController::Base.include(MockleyCrew::MockleyCrewHandled)
+end
+
+if defined?(ActionController::API)
+  ActionController::API.include(MockleyCrew::MockleyCrewHandled)
+end
+
+if defined?(DeviseController)
+  DeviseController.include(MockleyCrew::MockleyCrewHandled)
+end
+
+if defined?(DeviseTokenAuth)
+  DeviseTokenAuth::ApplicationController.include(MockleyCrew::MockleyCrewHandled)
+end

data/config/initializers/monkey_patch.rb

@@ -0,0 +1,81 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionHandler
+      def establish_connection(config, opts = {})
+        resolver = ConnectionSpecification::Resolver.new(Base.configurations)
+        spec = resolver.spec(config)
+
+        remove_connection(spec.name)
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+        payload = {
+          connection_id: object_id
+        }
+        if spec
+          payload[:spec_name] = spec.name
+          payload[:config] = spec.config
+        end
+
+        message_bus.instrument("!connection.active_record", payload) do
+          owner_to_pool[spec.name] = ConnectionAdapters::ConnectionPool.new(spec, opts)
+        end
+
+        owner_to_pool[spec.name]
+      end
+    end
+
+    class ConnectionPool
+      def initialize(spec, opts = {})
+        super()
+
+        @spec = spec
+
+        @checkout_timeout = (spec.config[:checkout_timeout] && spec.config[:checkout_timeout].to_f) || 5
+        if @idle_timeout = spec.config.fetch(:idle_timeout, 300)
+          @idle_timeout = @idle_timeout.to_f
+          @idle_timeout = nil if @idle_timeout <= 0
+        end
+
+        # default max pool size to 5
+        @size = (spec.config[:pool] && spec.config[:pool].to_i) || 5
+
+        # This variable tracks the cache of threads mapped to reserved connections, with the
+        # sole purpose of speeding up the +connection+ method. It is not the authoritative
+        # registry of which thread owns which connection. Connection ownership is tracked by
+        # the +connection.owner+ attr on each +connection+ instance.
+        # The invariant works like this: if there is mapping of <tt>thread => conn</tt>,
+        # then that +thread+ does indeed own that +conn+. However, an absence of a such
+        # mapping does not mean that the +thread+ doesn't own the said connection. In
+        # that case +conn.owner+ attr should be consulted.
+        # Access and modification of <tt>@thread_cached_conns</tt> does not require
+        # synchronization.
+        @thread_cached_conns = Concurrent::Map.new(initial_capacity: @size)
+
+        @connections         = []
+        @automatic_reconnect = true
+
+        # Connection pool allows for concurrent (outside the main +synchronize+ section)
+        # establishment of new connections. This variable tracks the number of threads
+        # currently in the process of independently establishing connections to the DB.
+        @now_connecting = 0
+
+        @threads_blocking_new_connections = 0
+
+        @available = ConnectionLeasingQueue.new self
+
+        @lock_thread = false
+
+        unless opts[:no_reaper] == true
+          # +reaping_frequency+ is configurable mostly for historical reasons, but it could
+          # also be useful if someone wants a very low +idle_timeout+.
+          reaping_frequency = spec.config.fetch(:reaping_frequency, 60)
+          @reaper = Reaper.new(self, reaping_frequency && reaping_frequency.to_f)
+          t = @reaper.run
+          if opts[:thread_name].present?
+            t["thread_name"] = opts[:thread_name]
+          end
+        end
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+MockleyCrew::Engine.routes.draw do
+  resource :database, only: [:create, :destroy], controller: "database" do
+    resources :data, only: [:create], controller: 'database/data'
+  end
+end

data/lib/mockley_crew.rb

@@ -0,0 +1,52 @@
+require "factory_bot"
+
+require "mockley_crew/engine"
+require "mockley_crew/configuration"
+
+require "mockley_crew/errors/connection_not_made"
+require "mockley_crew/errors/database_not_found"
+require "mockley_crew/errors/database_with_no_name"
+require "mockley_crew/errors/invalid_data"
+require "mockley_crew/errors/invalid_factory"
+require "mockley_crew/errors/invalid_amount"
+
+require "mockley_crew/database"
+require "mockley_crew/factory_builder"
+require "mockley_crew/data"
+
+require "mockley_crew/mockley_crew_handled"
+
+module MockleyCrew
+  class << self
+    attr_writer :configuration
+    attr_accessor :sqlite3_loaded
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset_configuration
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+    if configuration.heroku?
+      set_sqlite3
+    end
+  end
+
+  def self.set_sqlite3
+    return if self.sqlite3_loaded == true
+
+    $: << "#{root}/vendor/gems/sqlite3/gems/sqlite3-1.3.13/lib/"
+    require 'sqlite3'
+    require 'active_record/connection_adapters/sqlite3_adapter'
+    self.sqlite3_loaded = true
+  end
+
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end

data/lib/mockley_crew/configuration.rb

@@ -0,0 +1,37 @@
+module MockleyCrew
+  class Configuration
+    attr_accessor :crew_folder, :factories, :crew_header, :heroku
+
+    def initialize args = {}
+      @crew_header = args["crew_header"] || "crew-man-badge"
+      @crew_folder = args["crew_folder"] || "#{Rails.root}/db/crew"
+      @heroku = args["heroku"] || false
+    end
+
+    def default_database_path
+      "#{@crew_folder}/default_database.db"
+    end
+
+    def database_files_path
+      "#{@crew_folder}/databases/"
+    end
+
+    def database_files
+      Dir["#{database_files_path}*.db"]
+    end
+
+    def database_codes
+      database_files.map do |filename|
+        File.basename(filename, ".db").split("_").last
+      end
+    end
+
+    def registered_factory? factory_name
+      FactoryBot.factories.registered?(factory_name)
+    end
+
+    def heroku?
+      @heroku == true
+    end
+  end
+end

data/lib/mockley_crew/data.rb

@@ -0,0 +1,45 @@
+module MockleyCrew
+  class Data
+    attr_accessor :builders
+
+    def initialize params = []
+      raise Errors::InvalidDataError unless params.is_a? Array
+
+      params.each do |p|
+        raise Errors::InvalidDataError unless p.is_a? Hash
+        
+        builders.push FactoryBuilder.new(p)
+      end
+    end
+
+    def builders
+      @builders ||= []
+    end
+
+    def save
+      success = true
+      ActiveRecord::Base.transaction do
+        @builders.each do |b|
+          unless b.save
+            success = false
+          end
+        end
+        raise ActiveRecord::Rollback unless success
+      end
+      return success
+    end
+
+    def as_json
+      @builders.map do |b|
+        h = {
+          "factory" => b.factory,
+          "options" => b.options
+        }
+        unless b.errors.blank?
+          h["errors"] = b.errors
+        end
+        h
+      end
+    end
+  end
+end

data/lib/mockley_crew/database.rb

@@ -0,0 +1,183 @@
+module MockleyCrew
+  class Database
+    class << self
+      def connect args = {}
+        if args["filename"].present?
+          args["database"] = "#{MockleyCrew.configuration.database_files_path}#{args["filename"]}"
+        end
+
+        self.commit_transactions
+
+        ActiveRecord::Base.connection_handler.establish_connection({
+          adapter: "sqlite3",
+          database: args["database"],
+          host: args["host"] || File.basename(args["database"], ".*"),
+          username: "crew_master",
+          password: "crew_man"
+        }, {
+          thread_name: args["thread_name"] || "mockley_crew_default"
+        })
+      end
+
+      def migrate
+        ActiveRecord::Migration.verbose = false
+        ActiveRecord::Base.connection.migration_context.migrate
+        ActiveRecord::Migration.verbose = true
+      end
+
+      def disconnect
+        self.commit_transactions
+
+        if ActiveRecord::Base.connected?
+          ActiveRecord::Base.connection.close
+          ActiveRecord::Base.connection.disconnect!
+
+          self.restore_default_connection
+        else
+          raise "Cannot disconnect. You are already disconnected from the database."
+        end
+      end
+
+      def restore_default_connection
+        ActiveRecord::Base.connection_handler.establish_connection(
+          ActiveRecord::Base.configurations[Rails.env], no_reaper: true
+        )
+      end
+
+      def commit_transactions
+        if ActiveRecord::Base.connected?
+          if ActiveRecord::Base.connection.transaction_open?
+            ActiveRecord::Base.connection.commit_transaction
+          end
+        else
+          raise "Cannot commit transactions. You are disconnected from the database."
+        end
+      end
+
+      def terminate_thread filename
+        thread = Thread.list.select { |t| t["thread_name"] == filename }.first
+        thread.kill if thread
+      end
+
+      def create_default_database
+        unless File.exists?(MockleyCrew.configuration.default_database_path)
+          Database.connect("database" => MockleyCrew.configuration.default_database_path)
+          Database.migrate
+        end
+      end
+
+      def delete_default_databse
+        if File.exists?(MockleyCrew.configuration.default_database_path)
+          File.delete(MockleyCrew.configuration.default_database_path) 
+          terminate_thread "mockley_crew_default"
+        end
+      end
+
+      def reset_default_database
+        delete_default_databse
+        create_default_database
+      end
+
+      def remove_file_by_full_filename filename
+        File.delete(filename)
+      end
+
+      def remove_file_by_filename filename
+        self.remove_file_by_full_filename(MockleyCrew.configuration.database_files_path + filename)
+      end
+
+      def clean_database_files seconds = 60
+        MockleyCrew.configuration.database_files.each do |filename|
+          filename_parts = File.basename(filename, ".db").split("_");
+          if Time.zone.now.to_i - filename_parts.first.to_i >= seconds or filename_parts.length < 2
+            self.remove_file_by_full_filename(filename)
+          end
+        end
+      end
+
+      def next_name
+        "#{Time.zone.now.to_i}_#{generate_unique_code}.db"
+      end
+
+      def generate_unique_code
+        loop do
+          code = SecureRandom.hex(10)
+          break code unless MockleyCrew.configuration.database_codes.include?(code)
+        end
+      end
+
+      def find_by_filename filename
+        db = self.new(filename: filename)
+        if db.exists?
+          return db
+        else
+          return nil
+        end
+      end
+
+      def create
+        db = self.new
+        db.save
+        db
+      end
+    end
+
+    attr_accessor :filename
+
+    def initialize args = {}
+      args.each do |k, v|
+        self.send("#{k}=".to_sym, v)
+      end
+
+      unless self.filename.present?
+        self.filename = self.class.next_name
+      end
+    end
+
+    def exists?
+      File.exists?(full_file_path)
+    end
+
+    def get_name
+      File.basename(@filename, ".*").split("_").last
+    end
+
+    def get_created_at
+      Time.at(File.basename(@filename, ".*").split("_").first.to_i)
+    end
+
+    def save
+      self.create_database_file unless File.exists?(full_file_path)
+    end
+
+    def full_file_path
+      "#{MockleyCrew.configuration.database_files_path}#{@filename}"
+    end
+
+    def create_database_file
+      self.class.create_default_database unless File.exists?(MockleyCrew.configuration.default_database_path)
+      
+      FileUtils.mkdir_p(File.dirname(full_file_path))
+      FileUtils.cp MockleyCrew.configuration.default_database_path, full_file_path
+    end
+
+    def connect
+      self.class.connect(
+        "thread_name" => @filename,
+        "filename" => @filename
+      )
+    end
+    alias_method :on, :connect
+
+    def disconnect
+      self.class.disconnect
+    end
+    alias_method :off, :disconnect
+
+    def destroy
+      self.disconnect
+      self.class.remove_file_by_filename(self.filename)
+      self.class.terminate_thread(self.filename)
+    end
+  end
+end

data/lib/mockley_crew/engine.rb

@@ -0,0 +1,11 @@
+module MockleyCrew
+  class Engine < ::Rails::Engine
+    isolate_namespace MockleyCrew
+    # config.generators.api_only = true
+
+    config.generators do |g|
+      g.test_framework :rspec
+      # g.fixture_replacement :factory_girl, dir: 'spec/factories'
+    end
+  end
+end

data/lib/mockley_crew/errors/connection_not_made.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class ConnectionNotMadeError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/errors/database_not_found.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class DatabaseNotFoundError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/errors/database_with_no_name.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class DatabaseWithNoNameError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/errors/invalid_amount.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class InvalidAmountError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/errors/invalid_data.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class InvalidDataError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/errors/invalid_factory.rb

@@ -0,0 +1,6 @@
+module MockleyCrew
+  module Errors
+    class InvalidFactoryError < StandardError
+    end
+  end
+end

data/lib/mockley_crew/factory_builder.rb

@@ -0,0 +1,41 @@
+module MockleyCrew
+  class FactoryBuilder
+    attr_accessor :factory, :options, :errors
+
+    def initialize params = {}
+      raise Errors::InvalidDataError unless params.is_a? Hash
+      raise Errors::InvalidDataError unless params.keys.include?("factory")
+      
+      @factory = params["factory"]
+      unless MockleyCrew.configuration.registered_factory?(@factory.to_sym)
+        @factory = @factory.singularize
+        unless MockleyCrew.configuration.registered_factory?(@factory.to_sym)
+          raise Errors::InvalidFactoryError
+        end
+      end
+
+      params["options"] ||= {}
+      params["options"].reverse_merge!(
+        "amount" => 1,
+        "attributes" => {}
+      )
+      @options = params["options"]
+
+      raise Errors::InvalidAmountError unless @options["amount"].to_i > 0
+
+      @errors = {}
+    end
+
+    def save
+      begin
+        FactoryBot.create_list(@factory.to_sym, @options["amount"].to_i, @options["attributes"])
+        return true
+      rescue NoMethodError => e
+        self.errors[:attributes] = { message: "Invalid Attributes", detailed_error: e }
+      rescue ActiveRecord::RecordInvalid => e
+        self.errors[:attributes] = { message: "Model Validation Error", detailed_error: e }
+      end
+      return false
+    end
+  end
+end

data/lib/mockley_crew/mockley_crew_handled.rb

@@ -0,0 +1,40 @@
+module MockleyCrew::MockleyCrewHandled
+  extend ActiveSupport::Concern
+
+  included do
+    prepend_before_action :activate_database, if: :mockley_crew_header_present?
+    prepend_before_action :set_database, if: :mockley_crew_header_present?
+    append_after_action :restore_database, if: :mockley_crew_header_present?
+    append_after_action :set_response_header, if: :mockley_crew_header_present?
+
+    rescue_from MockleyCrew::Errors::DatabaseNotFoundError, with: :invalid_badge
+  end
+
+  private
+
+    def mockley_crew_header_present?
+      request.headers[MockleyCrew.configuration.crew_header].present?
+    end
+
+    def activate_database
+      @database.on
+    end
+
+    def restore_database
+      @database.off
+    end
+
+    def set_database
+      @database_name = request.headers[MockleyCrew.configuration.crew_header]
+      @database = MockleyCrew::Database.find_by_filename(@database_name)
+    end
+
+    def set_response_header
+      return unless @database
+      response.set_header(MockleyCrew.configuration.crew_header, @database.filename)
+    end
+
+    def invalid_badge
+      render json: { success: false, error: "Invalid badge" }, status: 403 
+    end
+end

data/lib/mockley_crew/version.rb

@@ -0,0 +1,3 @@
+module MockleyCrew
+  VERSION = '1.0.0'
+end

data/lib/tasks/mockley_crew.rake

@@ -0,0 +1,21 @@
+namespace :mockley_crew do
+  desc "Clear the mockley crew created database files"
+  task :clear do
+    MockleyCrew::Database.clean_database_files(0)
+  end
+end
+
+# require 'thor'
+# require 'mockley_crew'
+
+# module MockleyCrew
+#   class CLI < Thor
+
+#     desc "clear", "Clear the mockley crew SQLite3 created database files"
+#     def clear
+#       MockleyCrew.
+#       puts "Clearing"
+#     end
+
+#   end
+# end

data/lib/tasks/mockley_crew_tasks.rake

@@ -0,0 +1,21 @@
+namespace :mockley_crew do
+  desc "Clear the mockley crew created database files"
+  task :clear do
+    puts "Clearing"
+  end
+end
+
+# require 'thor'
+# require 'mockley_crew'
+
+# module MockleyCrew
+#   class CLI < Thor
+
+#     desc "clear", "Clear the mockley crew SQLite3 created database files"
+#     def clear
+#       MockleyCrew.
+#       puts "Clearing"
+#     end
+
+#   end
+# end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: mockley_crew
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ariel Schvartz
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: factory_bot_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: With Mockley Crew, you can create fake databases to use from your API
+  consumer. This way, you can isolate the consumer tests by having multiple data scenarios
+  built on your API.
+email:
+- ari.shh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/controllers/mockley_crew/application_controller.rb
+- app/controllers/mockley_crew/database/data_controller.rb
+- app/controllers/mockley_crew/database_controller.rb
+- app/jobs/mockley_crew/application_job.rb
+- app/mailers/mockley_crew/application_mailer.rb
+- app/models/mockley_crew/application_record.rb
+- config/initializers/mockley_crew.rb
+- config/initializers/monkey_patch.rb
+- config/routes.rb
+- lib/mockley_crew.rb
+- lib/mockley_crew/configuration.rb
+- lib/mockley_crew/data.rb
+- lib/mockley_crew/database.rb
+- lib/mockley_crew/engine.rb
+- lib/mockley_crew/errors/connection_not_made.rb
+- lib/mockley_crew/errors/database_not_found.rb
+- lib/mockley_crew/errors/database_with_no_name.rb
+- lib/mockley_crew/errors/invalid_amount.rb
+- lib/mockley_crew/errors/invalid_data.rb
+- lib/mockley_crew/errors/invalid_factory.rb
+- lib/mockley_crew/factory_builder.rb
+- lib/mockley_crew/mockley_crew_handled.rb
+- lib/mockley_crew/version.rb
+- lib/tasks/mockley_crew.rake
+- lib/tasks/mockley_crew_tasks.rake
+homepage: https://github.com/arielschvartz/mockley_crew
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Rock your API integration tests by mocking data into multiple SQLite3 instances
+test_files: []