railsless-active_record 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f122a117e6b93dbe3c7349d10e6161421bbf8dd7
+  data.tar.gz: 2503c67f693b02ab67decdaff8aa982d4e02d9d9
+SHA512:
+  metadata.gz: bb0e33c4b0de00d44b34545acccb0b96628186f89b08cb0804ac998a0f502493b9d1046f8dc0211c61693f0c64121b475920434d10a782e5d66e9bcf93388cc2
+  data.tar.gz: 398ea7f655fa43bf16c90c857cd73b1ed4fa422110e0ae9f0085364fadc0b88ce43ffbcaec8cc26225767ba1086d221c33751e9067bc0b350b480165ab3bb819

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# Dummy app ignores
+/spec/apps/sinatra-*/db/*.sqlite3

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+script:
+  - bundle exec rake spec SPEC_OPTS="--format d"

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rspec', '~> 2.14'
+  gem 'simplecov', '~> 0.7'
+end

data/README.md

@@ -0,0 +1,144 @@
+# Railsless-ActiveRecord [![Build Status](https://travis-ci.org/damncabbage/railsless-active_record.png?branch=master)](https://travis-ci.org/damncabbage/railsless-active_record)
+
+Provides a ActiveRecord Rake tasks and integration for Sinatra, Grape and other not-Rails frameworks.
+
+## Installation
+
+Add `gem 'railsless-active_record'` to your Gemfile (along with `gem 'sqlite3'`, or whatever other database you're using). Run `bundle install` to pull it down and set it up.
+
+### Rake
+
+In your Rakefile, add the following lines:
+
+```ruby
+require 'railsless/active_record/load_tasks'
+task :environment do
+  require './app' # or whatever the path to your app or server is.
+end
+```
+
+(You **will** need to put the app `require` inside the `:environment` block, or face having tasks like `db:generate:config` fail because of the app trying to establish a database connection immediately when required.)
+
+You'll then need to integrate this gem with your app; here's how to do it with some common non-Rails frameworks:
+
+### Sinatra
+
+In your application, add a `register Railsless::ActiveRecord::SinatraExtension` line to use the extension to manage your database configuration and connections, eg.
+
+```ruby
+require 'sinatra/base'
+require 'railsless/active_record/sinatra_extension'
+class MyApp < Sinatra::Base
+  register Railsless::ActiveRecord::SinatraExtension
+
+  # ... And the rest of your app goes here.
+end
+```
+
+... Or with the "Classic" style:
+
+```ruby
+require 'sinatra'
+require 'railsless/active_record/sinatra_extension'
+
+# get '/foo', ... etc.
+```
+
+### Grape
+
+TODO. :sweat_smile:
+
+### Generic
+
+```ruby
+require 'railsless/active_record'
+config = Railsless::ActiveRecord::Config.new
+config.root = File.dirname(__FILE__)
+
+# On app startup:
+Railsless::ActiveRecord.connect!(config)
+
+# On app shutdown:
+Railsless::ActiveRecord.disconnect!
+```
+
+
+## Configuration
+
+Run `rake db:generate:config` to generate a `config/database.yml` to fill in.
+
+If you don't, it will fall back to parsing `ENV['DATABASE_URL']` (eg. `sqlite3:///db/development.sqlite3`). If that isn't provided, this gem will raise an error.
+
+
+## Usage
+
+Have a look at the Rake tasks now available to you:
+
+```
+$ rake -T
+rake db:create              # Create the database from DATABASE_URL or config/database.yml for the current Rails.env (use db:create:all to create all dbs in the config)
+rake db:drop                # Drops the database using DATABASE_URL or the current Rails.env (use db:drop:all to drop all databases)
+rake db:fixtures:load       # Load fixtures into the current environment's database
+rake db:generate:config     # Generate and write a config/database.yml
+rake db:generate:migration  # Generate a database migration, eg: rake db:generate:migration NAME=CreatePosts
+rake db:migrate             # Migrate the database (options: VERSION=x, VERBOSE=false, SCOPE=blog)
+rake db:migrate:status      # Display status of migrations
+rake db:rollback            # Rolls the schema back to the previous version (specify steps w/ STEP=n)
+rake db:schema:cache:clear  # Clear a db/schema_cache.dump file
+rake db:schema:cache:dump   # Create a db/schema_cache.dump file
+rake db:schema:dump         # Create a db/schema.rb file that can be portably used against any DB supported by AR
+rake db:schema:load         # Load a schema.rb file into the database
+rake db:seed                # Load the seed data from db/seeds.rb
+rake db:setup               # Create the database, load the schema, and initialize with the seed data (use db:reset to also drop the db first)
+rake db:structure:dump      # Dump the database structure to db/structure.sql
+rake db:version             # Retrieves the current schema version number
+```
+
+Create a new DB migration with:
+
+```
+$ rake db:generate:migration NAME=create_posts
+```
+
+This will create a migration file in your migrations directory (`db/migrate`), eg.
+
+```ruby
+class CreateUsers < ActiveRecord::Migration
+  def change
+    create_table :posts do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Notes
+
+Apologies for the horrendous name. ActiveRecord has the gem name `activerecord`, but you need to `require 'active_record'` when using it. I decided to be up-front with you as to how to require the damn thing.
+
+Why not [sinatra-activerecord](https://github.com/janko-m/sinatra-activerecord)? It takes the (understandable) approach of *emulating* the ActiveRecord Rake tasks, instead of using them directly; this unfortunately which leaves large gaps in the set of tasks Rails users are used to. These ActiveRecord tasks have only really been able to be used directly since v4.0, though, so putting these changes back into Blake's/Janko's library would be very backwards-incompatible.
+
+## License
+
+Copyright 2013, Rob Howard
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+task :default => :spec

data/lib/railsless/active_record/config.rb

@@ -0,0 +1,65 @@
+require 'railsless/active_record/root'
+require 'logger'
+require 'yaml'
+require 'erb'
+
+module Railsless
+  module ActiveRecord
+    class Config
+      def self.attr_accessor_with_default(name, &block)
+        module_eval do
+          attr_writer name
+          define_method(name) do
+            # Don't cache the result; if you really needs to, define a method manually.
+            instance_variable_get(:"@#{name}") || instance_exec(&block)
+          end
+        end
+      end
+
+      def initialize(overrides={})
+        overrides.each { |attr,val| send(:"#{attr}=", val) }
+      end
+
+      # An overblown way of figuring out where the calling application's root
+      # is, borrowed from Rails.
+      attr_writer :root
+      def root
+        @root ||= Root.calculate
+      end
+
+      # Fumble around picking the right running environment.
+      attr_accessor_with_default(:env) do
+        ENV['RACK_ENV'] || ENV['SINATRA_ENV'] || ENV['RAILS_ENV'] || ENV['ENV'] || 'development'
+      end
+
+      attr_accessor_with_default(:db_config) do
+        case
+        when File.exist?(db_config_path)
+          YAML.load(read_config(db_config_path))
+        when ENV.has_key?('DATABASE_URL')
+          ENV.fetch('DATABASE_URL')
+        else
+          raise "Unable to locate database config; DATABASE_URL or config file at #{db_config_path} required."
+        end
+      end
+
+      attr_accessor_with_default(:db_config_path) do
+        File.join(root, 'config', 'database.yml')
+      end
+      attr_accessor_with_default(:db_path)     { File.join(root, 'db') }
+      attr_accessor_with_default(:seeds_path)  { File.join(db_path, 'seeds.rb') }
+      attr_accessor_with_default(:schema_path) { File.join(db_path, 'schema.rb') }
+      attr_accessor_with_default(:migrations_path) { File.join(db_path, 'migrate') }
+
+      attr_accessor_with_default(:logger) { Logger.new(STDOUT) }
+
+      protected
+
+        # Intentionally explodes violently if the file doesn't exist.
+        def read_config(filename)
+          ERB.new(File.read(filename)).result
+        end
+    end
+  end
+end
+

data/lib/railsless/active_record/load_tasks.rb

@@ -0,0 +1,13 @@
+require 'railsless/active_record'
+
+# HACK: Some internals of the ActiveRecord Rake tasks refer to Rails.root
+#       directly. Define it here if necessary, and be careful about it.
+unless defined?(Rails) && Rails.respond_to?(:root)
+  module Rails
+    def self.root
+      Railsless::ActiveRecord::Config.new.root
+    end
+  end
+end
+
+Railsless::ActiveRecord::Rake.load_tasks!

data/lib/railsless/active_record/rake.rb

@@ -0,0 +1,74 @@
+require 'active_record'
+require 'rake'
+require 'fileutils'
+
+module Railsless
+  module ActiveRecord
+    module Rake
+      module_function
+
+      TEMPLATES_PATH = File.expand_path('../../../templates', File.dirname(__FILE__))
+
+      def load_tasks!(config=nil)
+        config ||= Railsless::ActiveRecord::Config.new
+        load_database_tasks!(config)
+        load_generator_tasks!(config)
+      end
+
+      def load_database_tasks!(config)
+        extend ::Rake::DSL
+
+        # ActiveRecord looks to db:load_config for its DatabaseTasks setup.
+        # Load it up with our own configuration first.
+        namespace :db do
+          task :load_config do
+            ::ActiveRecord::Tasks::DatabaseTasks.root = config.root
+            ::ActiveRecord::Tasks::DatabaseTasks.env = config.env
+            ::ActiveRecord::Tasks::DatabaseTasks.db_dir = config.db_path
+            ::ActiveRecord::Tasks::DatabaseTasks.database_configuration = config.db_config
+            ::ActiveRecord::Tasks::DatabaseTasks.migrations_paths = config.migrations_path
+            ::ActiveRecord::Tasks::DatabaseTasks.seed_loader = SeedLoader.new(config.seeds_path)
+            ::ActiveRecord::Tasks::DatabaseTasks.fixtures_path = nil # TODO
+          end
+        end
+
+        # Stub out the :environment task that DatabaseTasks depends on.
+        # Ideally, the app using this library loads the app from within an
+        # :environment task (as per the README), but provide this as a fallback.
+        unless ::Rake::Task.task_defined? :environment
+          task :environment
+        end
+
+        load 'active_record/railties/databases.rake'
+      end
+
+      # Creates database.yml files and migrations.
+      def load_generator_tasks!(config)
+        extend ::Rake::DSL
+        namespace :db do
+          namespace :generate do
+
+            desc "Generate and write a config/database.yml"
+            task :config do
+              config_path = config.db_config_path
+              if File.exists?(config_path)
+                puts "Database config already exists at #{config_path}; skipping..."
+              else
+                FileUtils.cp(
+                  File.join(TEMPLATES_PATH, 'database.yml'),
+                  config_path
+                )
+              end
+            end
+
+            desc "Generate a database migration, eg: rake db:generate:migration NAME=CreatePosts"
+            task :migration do
+              # TODO: NAME=...
+              raise "Not Implemented"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/railsless/active_record/root.rb

@@ -0,0 +1,42 @@
+# Partially inspired by railties-4.0.0/lib/rails/engine.rb
+# In essence, it's:
+# - Picking a file to look for (eg. config.ru),
+# - Starting at an arbitrary directory (eg. the current working directory), and then
+# - Traversing back up the directory tree until it either finds a flag file, or hits
+#   the root folder.
+
+module Railsless
+  module ActiveRecord
+    class Root
+      def self.calculate(flag_file=nil, start_from=nil)
+        find_root_with_flag(
+          flag_file  || 'config.ru', # Look for something signifying Rack. Not much else to go on.
+          start_from || Dir.pwd # Yes, Rails does this.
+        )
+      end
+
+      # Starts from a directory, and works upwards looking for a particular file.
+      def self.find_root_with_flag(flag, starting_path)
+        # This process if only useful if the starting_path is an absolute path.
+        path = if starting_path[0] == '/'
+                 starting_path
+               else
+                 File.absolute_path(starting_path) # Relative; turn into absolute path
+               end
+
+        while path && File.directory?(path) && !File.exist?("#{path}/#{flag}")
+          parent = File.dirname(path)
+          path = (parent != path) && parent
+        end
+
+        if path && File.exist?("#{path}/#{flag}")
+          File.realpath path
+        else
+          raise "Could not find root path for hosting application"
+        end
+      end
+    end
+  end
+end
+
+

data/lib/railsless/active_record/seed_loader.rb

@@ -0,0 +1,14 @@
+module Railsless
+  module ActiveRecord
+    class SeedLoader
+      attr_accessor :path
+      def initialize(path)
+        @path = path
+      end
+
+      def load_seed
+        Kernel.load(path) if path && File.exist?(path)
+      end
+    end
+  end
+end

data/lib/railsless/active_record/sinatra_extension.rb

@@ -0,0 +1,40 @@
+require 'railsless/active_record'
+
+module Railsless
+  module ActiveRecord
+    module SinatraExtension
+
+      def self.registered(app)
+        unless app.respond_to?(:activerecord_config) && app.activerecord_config
+          app.set :activerecord_config, Railsless::ActiveRecord::Config.new
+        end
+        app.set :database, app.database
+        app.helpers SinatraExtensionHelper
+        app.after { Railsless::ActiveRecord.disconnect! }
+      end
+
+      def database
+        @database ||= Railsless::ActiveRecord.connect!(activerecord_config)
+      end
+
+      def activerecord_config=(config)
+        @database = nil
+        @activerecord_config = config
+        @database = Railsless::ActiveRecord.connect!(config)
+      end
+    end
+
+    module SinatraExtensionHelper
+      def database
+        settings.database
+      end
+    end
+  end
+end
+
+# HACK: Support classic apps by automatically registering the extension, as recommended
+#       by the Sinatra docs here: http://www.sinatrarb.com/extensions.html
+if defined?(Sinatra) && defined?(Sinatra::Application)
+  # We're using classic; sinatra/main defines Sinatra::Application, so hook into that.
+  Sinatra::Application.send(:register, ::Railsless::ActiveRecord::SinatraExtension)
+end

data/lib/railsless/active_record/version.rb

@@ -0,0 +1,5 @@
+module Railsless
+  module ActiveRecord
+    VERSION = "0.0.1"
+  end
+end

data/lib/railsless/active_record.rb

@@ -0,0 +1,27 @@
+require 'railsless/active_record/version'
+require 'railsless/active_record/config'
+require 'railsless/active_record/seed_loader'
+require 'railsless/active_record/rake'
+require 'active_record'
+
+module Railsless
+  module ActiveRecord
+    module_function
+
+    def connect!(config)
+      db_config = config.db_config
+      if db_config.is_a?(String)
+        ::ActiveRecord::Base.establish_connection(db_config)
+      else
+        ::ActiveRecord::Base.configurations = db_config
+        ::ActiveRecord::Base.establish_connection(config.env)
+      end
+      ::ActiveRecord::Base.logger = config.logger
+      ::ActiveRecord::Base
+    end
+
+    def disconnect!
+      ::ActiveRecord::Base.clear_active_connections!
+    end
+  end
+end

data/railsless-active_record.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'railsless/active_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "railsless-active_record"
+  spec.version       = Railsless::ActiveRecord::VERSION
+  spec.authors       = ["Rob Howard"]
+  spec.email         = ["rob@robhoward.id.au"]
+  spec.description   = %q{Provides a ActiveRecord Rake tasks and integration for Sinatra, Goliath, etc.}
+  spec.summary       = %q{Provides a ActiveRecord Rake tasks and integration for Sinatra, Goliath and other apps that aren't using Rails.}
+  spec.homepage      = "https://github.com/damncabbage/railsless-active_record"
+  spec.license       = "Apache License, Version 2.0"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_dependency "rake"
+  spec.add_dependency "activerecord", "~> 4.0" # < 4 is a pain in the butt to add Rake tasks for.
+end

data/spec/active_record/config_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Railsless::ActiveRecord::Config do
+  let(:config) do
+    described_class.new.tap do |c|
+      c.root = fixture('app_with_paths')
+    end
+  end
+
+  describe "#env" do
+    it "uses RACK_ENV, SINATRA_ENV, RAILS_ENV or ENV to determine environment" do
+      %w(RACK_ENV SINATRA_ENV RAILS_ENV ENV).each do |key|
+        with_blank_env do
+          ENV[key] = rand(1..999999).to_s
+          expect(config.env).to eq ENV[key]
+        end
+      end
+    end
+    it "defaults to 'development'" do
+      with_blank_env { expect(config.env).to eq 'development' }
+    end
+  end
+
+  describe "#db_config" do
+    let(:config_without_file) do
+      described_class.new.tap do |c|
+        c.root = fixture('find_root_with_flag')
+      end
+    end
+
+    it "uses a database config if it's present" do
+      expect(config.db_config).to eq({
+        'development' => {
+          'adapter'  => 'sqlite3',
+          'database' => 'db/development.sqlite3',
+          'pool'     => 5,
+          'timeout'  => 5000,
+        },
+      })
+    end
+    it "falls back to ENV['DATABASE_URL'] if no database config can be found" do
+      with_blank_env do
+        ENV['DATABASE_URL'] = 'sqlite3:///db/development.sqlite3'
+        expect(config_without_file.db_config).to eq ENV['DATABASE_URL']
+      end
+    end
+    it "explodes is neither config nor ENV['DATABASE_URL'] is present" do
+      with_blank_env do
+        expect { config_without_file.db_config }.to raise_error
+      end
+    end
+  end
+
+  it "has sensible defaults for the rest" do
+    expect(config.db_config_path).to eq File.join(config.root, 'config/database.yml')
+    expect(config.seeds_path).to eq File.join(config.root, 'db/seeds.rb')
+    expect(config.schema_path).to eq File.join(config.root, 'db/schema.rb')
+    expect(config.migrations_path).to eq File.join(config.root, 'db/migrate')
+    expect(config.logger).to be_a(Logger)
+  end
+
+  # Helpers
+
+  def with_blank_env(&block)
+    original = ENV
+    ENV.replace({})
+    yield if block_given?
+    ENV.replace(original)
+  end
+end

data/spec/active_record/root_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Railsless::ActiveRecord::Root do
+  let(:root) { described_class }
+
+  describe ".calculate" do
+    it "uses config.ru and the current working dir to find the app root" do
+      dir = fixture('find_root_with_flag')
+      expect(Dir).to receive(:pwd).and_return(dir)
+      expect(root.calculate).to eq dir
+    end
+  end
+
+  describe ".to eq dir.find_root_with_flag" do
+    it "finds a flag file in the starting directory (eg. current working dir)" do
+      starting = fixture('find_root_with_flag')
+      expect(root.find_root_with_flag('config.ru', starting)).to eq starting
+    end
+
+    it "looks up the tree until it finds the flag file" do
+      dir      = fixture('find_root_with_flag')
+      starting = File.join(dir, 'bin') # find_root_with_flag/bin
+      expect(root.find_root_with_flag('config.ru', starting)).to eq dir
+    end
+
+    # If this test explodes on your machine, it probably means you have a
+    # config.ru hanging around in a parent directory. :)
+    it "explodes when it can't find the flag file" do
+      starting = File.dirname(__FILE__)
+      expect {
+        root.find_root_with_flag('config.ru', starting)
+      }.to raise_error(StandardError, "Could not find root path for hosting application")
+    end
+  end
+end

data/spec/active_record/seed_loader_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Railsless::ActiveRecord::SeedLoader do
+  let(:seed_path) { fixture('seeds.rb') }
+  let(:bad_seed_path) { fixture('doesnt_exist.rb') }
+  before { stub_const('BlogPost', double) }
+
+  it "loads a seed file that exists" do
+    loader = Railsless::ActiveRecord::SeedLoader.new(seed_path)
+    expect(BlogPost).to receive(:create).with(:title => "Example")
+    loader.load_seed
+  end
+
+  it "ignores non-existent seeds" do
+    [bad_seed_path, nil].each do |path|
+      loader = Railsless::ActiveRecord::SeedLoader.new(path)
+      expect(BlogPost).to_not receive(:create)
+      expect(loader.load_seed).to be_nil
+    end
+  end
+end

data/spec/apps/sinatra-classic/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'sinatra'
+gem 'sqlite3'
+gem 'railsless-active_record',
+  :path => File.expand_path('../../..', File.dirname(__FILE__))

data/spec/apps/sinatra-classic/Rakefile

@@ -0,0 +1,4 @@
+require 'railsless/active_record/load_tasks'
+task :environment do
+  require './app'
+end

data/spec/apps/sinatra-classic/app.rb

@@ -0,0 +1,16 @@
+require 'sinatra'
+require 'railsless/active_record/sinatra_extension'
+require 'json'
+
+class Message < ActiveRecord::Base
+  # attributes: title
+end
+
+register Railsless::ActiveRecord::SinatraExtension
+
+get '/messages' do
+  Message.all.to_json
+end
+post '/messages' do
+  Message.create!(:title => params[:title]).to_json
+end

data/spec/apps/sinatra-classic/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/apps/sinatra-classic/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run Sinatra::Application

data/spec/apps/sinatra-classic/db/migrate/20140201145729_create_messages.rb

@@ -0,0 +1,8 @@
+class CreateMessages < ActiveRecord::Migration
+  def change
+    create_table :messages do |t|
+      t.string :title
+      t.timestamps
+    end
+  end
+end

data/spec/apps/sinatra-classic/db/schema.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20140201145729) do
+
+  create_table "messages", force: true do |t|
+    t.string   "title"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/spec/apps/sinatra-modular/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+gem 'sinatra'
+gem 'sqlite3'
+gem 'railsless-active_record',
+  :path => File.expand_path('../../..', File.dirname(__FILE__))

data/spec/apps/sinatra-modular/Rakefile

@@ -0,0 +1,4 @@
+require 'railsless/active_record/load_tasks'
+task :environment do
+  require './app'
+end

data/spec/apps/sinatra-modular/app.rb

@@ -0,0 +1,18 @@
+require 'sinatra/base'
+require 'railsless/active_record/sinatra_extension'
+require 'json'
+
+class Message < ActiveRecord::Base
+  # attributes: title
+end
+
+class TestSinatraApp < Sinatra::Base
+  register Railsless::ActiveRecord::SinatraExtension
+
+  get '/messages' do
+    Message.all.to_json
+  end
+  post '/messages' do
+    Message.create!(:title => params[:title]).to_json
+  end
+end

data/spec/apps/sinatra-modular/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/apps/sinatra-modular/config.ru

@@ -0,0 +1,2 @@
+require './app'
+run TestSinatraApp

data/spec/apps/sinatra-modular/db/migrate/20140201145729_create_messages.rb

@@ -0,0 +1,8 @@
+class CreateMessages < ActiveRecord::Migration
+  def change
+    create_table :messages do |t|
+      t.string :title
+      t.timestamps
+    end
+  end
+end

data/spec/apps/sinatra-modular/db/schema.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of Active Record to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.rb definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using db:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+ActiveRecord::Schema.define(version: 20140201145729) do
+
+  create_table "messages", force: true do |t|
+    t.string   "title"
+    t.datetime "created_at"
+    t.datetime "updated_at"
+  end
+
+end

data/spec/fixtures/app_with_paths/config/database.yml

@@ -0,0 +1,5 @@
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000

data/spec/fixtures/seeds.rb

@@ -0,0 +1,4 @@
+# Pretend ActiveRecord db/seeds.rb file
+BlogPost.create(
+  :title => "Example",
+)

data/spec/integrations/sinatra_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+require 'fileutils'
+require 'net/http'
+require 'open3'
+require 'json'
+
+# The following tests spin up a Sinatra app in a separate process; keeping it
+# isolated means we can test the entire DB and app lifecycle without risk of pollution.
+
+# This shared example is used by both the spec/apps/sinatra-modular and
+# spec/apps/sinatra-classic dummy apps. The meat of the specs are in the example;
+# see the bottom of file for app definitions. (We need to define the shared example
+# before we can use it.)
+shared_examples "a Sinatra app" do
+  before(:all) { run "bundle install" }
+
+  it "prints the expected list of ActiveRecord Rake tasks" do
+    out = run "bundle exec rake -T"
+    %w(
+      create drop fixtures:load migrate migrate:status rollback
+      schema:cache:clear schema:cache:dump schema:dump schema:load
+      seed setup structure:dump version
+      generate:config generate:migration
+    ).each do |task|
+      expect(out).to match /^rake db:#{task}/
+    end
+  end
+
+  context "generators" do
+    describe "db:generate:config" do
+      let(:config_path) do
+        File.join(app_path, 'config/database.yml')
+      end
+      let(:template_path) do
+        File.expand_path('../../templates/database.yml', File.dirname(__FILE__))
+      end
+
+      it "ignores an existing config file" do
+        expect(File).to exist(config_path)
+        out = run "bundle exec rake db:generate:config"
+        expect(out).to match /Database config already exists/
+      end
+
+      it "generates a config file that doesn't yet exist" do
+        FileUtils.rm_f(config_path)
+        out = run "bundle exec rake db:generate:config"
+        expect(File.read(config_path)).to eq File.read(template_path)
+      end
+
+      # Force a reset of the configuration, regardless of the test results.
+      after do
+        FileUtils.rm_f(config_path)
+        FileUtils.cp(template_path, config_path)
+      end
+    end
+
+    pending "'db:generate:migration NAME=NameHere' creates a migration" do
+      # TODO: 'NameHere' -> 'name_here' transform.
+    end
+  end
+
+  context "requests" do
+    # HACK: rackup doesn't allow "-p 0" for binding to a free non-privileged port.
+    #       Suggested terrible, race-conditioney alternative:
+    #         s = TCPServer.new('127.0.0.1', 0); port = s.addr[1]; s.close
+    let(:port) { rand(10_000..10_999) }
+    let(:host) { 'localhost' }
+
+    it "serves database-backed requests" do
+      run "bundle exec rake db:drop db:create db:migrate"
+      run_while "bundle exec rackup -p #{port}" do |stdout_and_err|
+        # Wait for Sinatra to show up; explode if it doesn't.
+        wait_for_port! host, port, 15 # seconds
+
+        uri = URI("http://#{host}:#{port}/messages")
+        expect(JSON.parse(Net::HTTP.get(uri))).to eq []
+
+        post = JSON.parse(Net::HTTP.post_form(uri, 'title' => "Hello World").body)
+        expect(post['title']).to eq "Hello World"
+
+        posts = JSON.parse(Net::HTTP.get(uri))
+        expect(posts.count).to eq 1
+        expect(posts[0]['title']).to eq post['title']
+      end
+    end
+  end
+
+  # Helpers
+
+  def run(command)
+    output = ""
+    Bundler.with_clean_env do
+      output, status = Open3.capture2(command, :chdir => app_path)
+      expect(status).to be_success
+    end
+    output
+  end
+
+  def run_while(command, &block)
+    Bundler.with_clean_env do
+      Open3.popen2e(command, :chdir => app_path) do |stdin, stdout_and_err, wait_thr|
+        pid = wait_thr.pid
+        begin
+          yield(stdout_and_err) if block_given?
+        ensure
+          # Have tried TERM, but Ruby 1.9.3 + Webrick flat-out ignores it.
+          # Break out kill -9.
+          Process.kill(:KILL, pid)
+        end
+      end
+    end
+  end
+
+  # Waits until a port is open; raise InlineTimeout::Error if times out.
+  def wait_for_port!(host, port, seconds, interval=0.5)
+    InlineTimeout.timeout(seconds, interval) do
+      begin
+        TCPSocket.new(host, port).close
+        true
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+        false
+      end
+    end
+  end
+end
+
+# Example require('sinatra/base'), class-based Sinatra app.
+describe "Sinatra 'Modular' Integration" do
+  def app_path
+    File.expand_path('../apps/sinatra-modular', File.dirname(__FILE__))
+  end
+  it_behaves_like "a Sinatra app"
+end
+
+# Example require('sinatra'), base-DSL-using Sinatra app.
+describe "Sinatra 'Classic' Integration" do
+  def app_path
+    File.expand_path('../apps/sinatra-classic', File.dirname(__FILE__))
+  end
+  it_behaves_like "a Sinatra app"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+
+require "simplecov"
+SimpleCov.start do
+  add_filter "/spec/"
+end
+require "rspec"
+
+# Library under test
+require File.expand_path('../lib/railsless/active_record', File.dirname(__FILE__))
+
+# Helpers
+Dir["#{File.dirname(__FILE__)}/support/**/*_helpers.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/fs_fixture_helpers.rb

@@ -0,0 +1,11 @@
+module FSFixtureHelpers
+  def fixture(path)
+    File.expand_path(
+      File.join('..', 'fixtures', path),
+      File.dirname(__FILE__)
+    )
+  end
+end
+RSpec.configure do |c|
+  c.include FSFixtureHelpers
+end

data/spec/support/inline_timeout_helpers.rb

@@ -0,0 +1,15 @@
+module InlineTimeout
+  module_function
+
+  def self.timeout(seconds, interval=nil)
+    start = Time.now.to_i
+    begin
+      result = yield
+      return if result
+      sleep(interval) if interval && interval > 0
+    end until (Time.now.to_i - start) > seconds
+    raise Error, "Timeout after #{seconds} seconds"
+  end
+
+  class Error < StandardError; end
+end

data/templates/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  pool: 5
+  timeout: 5000

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: railsless-active_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Rob Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Provides a ActiveRecord Rake tasks and integration for Sinatra, Goliath,
+  etc.
+email:
+- rob@robhoward.id.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- lib/railsless/active_record.rb
+- lib/railsless/active_record/config.rb
+- lib/railsless/active_record/load_tasks.rb
+- lib/railsless/active_record/rake.rb
+- lib/railsless/active_record/root.rb
+- lib/railsless/active_record/seed_loader.rb
+- lib/railsless/active_record/sinatra_extension.rb
+- lib/railsless/active_record/version.rb
+- railsless-active_record.gemspec
+- spec/active_record/config_spec.rb
+- spec/active_record/root_spec.rb
+- spec/active_record/seed_loader_spec.rb
+- spec/apps/sinatra-classic/Gemfile
+- spec/apps/sinatra-classic/Rakefile
+- spec/apps/sinatra-classic/app.rb
+- spec/apps/sinatra-classic/config.ru
+- spec/apps/sinatra-classic/config/database.yml
+- spec/apps/sinatra-classic/db/migrate/20140201145729_create_messages.rb
+- spec/apps/sinatra-classic/db/schema.rb
+- spec/apps/sinatra-modular/Gemfile
+- spec/apps/sinatra-modular/Rakefile
+- spec/apps/sinatra-modular/app.rb
+- spec/apps/sinatra-modular/config.ru
+- spec/apps/sinatra-modular/config/database.yml
+- spec/apps/sinatra-modular/db/migrate/20140201145729_create_messages.rb
+- spec/apps/sinatra-modular/db/schema.rb
+- spec/fixtures/app_with_paths/config/database.yml
+- spec/fixtures/find_root_with_flag/app.rb
+- spec/fixtures/find_root_with_flag/bin/app
+- spec/fixtures/find_root_with_flag/config.ru
+- spec/fixtures/seeds.rb
+- spec/integrations/sinatra_spec.rb
+- spec/spec_helper.rb
+- spec/support/fs_fixture_helpers.rb
+- spec/support/inline_timeout_helpers.rb
+- templates/database.yml
+homepage: https://github.com/damncabbage/railsless-active_record
+licenses:
+- Apache License, Version 2.0
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Provides a ActiveRecord Rake tasks and integration for Sinatra, Goliath and
+  other apps that aren't using Rails.
+test_files:
+- spec/active_record/config_spec.rb
+- spec/active_record/root_spec.rb
+- spec/active_record/seed_loader_spec.rb
+- spec/apps/sinatra-classic/Gemfile
+- spec/apps/sinatra-classic/Rakefile
+- spec/apps/sinatra-classic/app.rb
+- spec/apps/sinatra-classic/config.ru
+- spec/apps/sinatra-classic/config/database.yml
+- spec/apps/sinatra-classic/db/migrate/20140201145729_create_messages.rb
+- spec/apps/sinatra-classic/db/schema.rb
+- spec/apps/sinatra-modular/Gemfile
+- spec/apps/sinatra-modular/Rakefile
+- spec/apps/sinatra-modular/app.rb
+- spec/apps/sinatra-modular/config.ru
+- spec/apps/sinatra-modular/config/database.yml
+- spec/apps/sinatra-modular/db/migrate/20140201145729_create_messages.rb
+- spec/apps/sinatra-modular/db/schema.rb
+- spec/fixtures/app_with_paths/config/database.yml
+- spec/fixtures/find_root_with_flag/app.rb
+- spec/fixtures/find_root_with_flag/bin/app
+- spec/fixtures/find_root_with_flag/config.ru
+- spec/fixtures/seeds.rb
+- spec/integrations/sinatra_spec.rb
+- spec/spec_helper.rb
+- spec/support/fs_fixture_helpers.rb
+- spec/support/inline_timeout_helpers.rb