trails-mvc 0.1.0

data/dynamic-archive/spec/base_spec.rb

@@ -0,0 +1,252 @@
+require 'byebug'
+require 'base'
+require 'db_connection'
+require 'securerandom'
+
+describe DynamicArchive::Base do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  context 'before ::finalize!' do
+    before(:each) do
+      class Cat < DynamicArchive::Base
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :Cat)
+    end
+
+    describe '::table_name' do
+      it 'generates default name' do
+        expect(Cat.table_name).to eq('cats')
+      end
+    end
+
+    describe '::table_name=' do
+      it 'sets table name' do
+        class Human < DynamicArchive::Base
+          self.table_name = 'humans'
+        end
+
+        expect(Human.table_name).to eq('humans')
+
+        Object.send(:remove_const, :Human)
+      end
+    end
+
+    describe '::columns' do
+      it 'returns a list of all column names as symbols' do
+        expect(Cat.columns).to eq([:id, :name, :owner_id])
+      end
+
+      it 'only queries the DB once' do
+        expect(DBConnection).to(
+          receive(:execute2).exactly(1).times.and_call_original)
+        3.times { Cat.columns }
+      end
+    end
+
+    describe '#attributes' do
+      it 'returns @attributes hash byref' do
+        cat_attributes = {name: 'Gizmo'}
+        c = Cat.new
+        c.instance_variable_set('@attributes', cat_attributes)
+
+        expect(c.attributes).to equal(cat_attributes)
+      end
+
+      it 'lazily initializes @attributes to an empty hash' do
+        c = Cat.new
+
+        expect(c.instance_variables).not_to include(:@attributes)
+        expect(c.attributes).to eq({})
+        expect(c.instance_variables).to include(:@attributes)
+      end
+    end
+  end
+
+  context 'after ::finalize!' do
+    before(:all) do
+      class Cat < DynamicArchive::Base
+        self.finalize!
+      end
+
+      class Human < DynamicArchive::Base
+        self.table_name = 'humans'
+
+        self.finalize!
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, :Cat)
+      Object.send(:remove_const, :Human)
+    end
+
+    describe '::finalize!' do
+      it 'creates getter methods for each column' do
+        c = Cat.new
+        expect(c.respond_to? :something).to be false
+        expect(c.respond_to? :name).to be true
+        expect(c.respond_to? :id).to be true
+        expect(c.respond_to? :owner_id).to be true
+      end
+
+      it 'creates setter methods for each column' do
+        c = Cat.new
+        c.name = "Nick Diaz"
+        c.id = 209
+        c.owner_id = 2
+        expect(c.name).to eq 'Nick Diaz'
+        expect(c.id).to eq 209
+        expect(c.owner_id).to eq 2
+      end
+
+      it 'created getter methods read from attributes hash' do
+        c = Cat.new
+        c.instance_variable_set(:@attributes, {name: "Nick Diaz"})
+        expect(c.name).to eq 'Nick Diaz'
+      end
+
+      it 'created setter methods use attributes hash to store data' do
+        c = Cat.new
+        c.name = "Nick Diaz"
+
+        expect(c.instance_variables).to include(:@attributes)
+        expect(c.instance_variables).not_to include(:@name)
+        expect(c.attributes[:name]).to eq 'Nick Diaz'
+      end
+    end
+
+    describe '#initialize' do
+      it 'calls appropriate setter method for each item in params' do
+        # We have to set method expectations on the cat object *before*
+        # #initialize gets called, so we use ::allocate to create a
+        # blank Cat object first and then call #initialize manually.
+        c = Cat.allocate
+
+        expect(c).to receive(:name=).with('Don Frye')
+        expect(c).to receive(:id=).with(100)
+        expect(c).to receive(:owner_id=).with(4)
+
+        c.send(:initialize, {name: 'Don Frye', id: 100, owner_id: 4})
+      end
+
+      it 'throws an error when given an unknown attribute' do
+        expect do
+          Cat.new(favorite_band: 'Anybody but The Eagles')
+        end.to raise_error "unknown attribute 'favorite_band'"
+      end
+    end
+
+    describe '::all, ::parse_all' do
+      it '::all returns all the rows' do
+        cats = Cat.all
+        expect(cats.count).to eq(5)
+      end
+
+      it '::parse_all turns an array of hashes into objects' do
+        hashes = [
+          { name: 'cat1', owner_id: 1 },
+          { name: 'cat2', owner_id: 2 }
+        ]
+
+        cats = Cat.parse_all(hashes)
+        expect(cats.length).to eq(2)
+        hashes.each_index do |i|
+          expect(cats[i].name).to eq(hashes[i][:name])
+          expect(cats[i].owner_id).to eq(hashes[i][:owner_id])
+        end
+      end
+
+      it '::all returns a list of objects, not hashes' do
+        cats = Cat.all
+        cats.each { |cat| expect(cat).to be_instance_of(Cat) }
+      end
+    end
+
+    describe '::find' do
+      it 'fetches single objects by id' do
+        c = Cat.find(1)
+
+        expect(c).to be_instance_of(Cat)
+        expect(c.id).to eq(1)
+      end
+
+      it 'returns nil if no object has the given id' do
+        expect(Cat.find(123)).to be_nil
+      end
+    end
+
+    describe '#attribute_values' do
+      it 'returns array of values' do
+        cat = Cat.new(id: 123, name: 'cat1', owner_id: 1)
+
+        expect(cat.attribute_values).to eq([123, 'cat1', 1])
+      end
+    end
+
+    describe '#insert' do
+      let(:cat) { Cat.new(name: 'Gizmo', owner_id: 1) }
+
+      before(:each) { cat.insert }
+
+      it 'inserts a new record' do
+        expect(Cat.all.count).to eq(6)
+      end
+
+      it 'sets the id once the new record is saved' do
+        expect(cat.id).to eq(DBConnection.last_insert_row_id)
+      end
+
+      it 'creates a new record with the correct values' do
+        # pull the cat again
+        cat2 = Cat.find(cat.id)
+
+        expect(cat2.name).to eq('Gizmo')
+        expect(cat2.owner_id).to eq(1)
+      end
+    end
+
+    describe '#update' do
+      it 'saves updated attributes to the DB' do
+        human = Human.find(2)
+
+        human.fname = 'Matthew'
+        human.lname = 'von Rubens'
+        human.update
+
+        # pull the human again
+        human = Human.find(2)
+        expect(human.fname).to eq('Matthew')
+        expect(human.lname).to eq('von Rubens')
+      end
+    end
+
+    describe '#save' do
+      it 'calls #insert when record does not exist' do
+        human = Human.new
+        expect(human).to receive(:insert)
+        human.save
+      end
+
+      it 'calls #update when record already exists' do
+        human = Human.find(1)
+        expect(human).to receive(:update)
+        human.save
+      end
+    end
+
+    describe '#destroy' do
+      it 'deletes the record from the table' do
+        jimmy = Human.new(fname: "Jimmy", lname: "John")
+        jimmy.save
+        expect(jimmy.fname).to eq(Human.all.last.fname)
+
+        jimmy.destroy
+        expect(jimmy.fname).to_not eq(Human.all.last.fname)
+      end
+    end
+  end
+end

data/dynamic-archive/spec/searchable_spec.rb

@@ -0,0 +1,44 @@
+require 'searchable'
+
+describe 'Searchable' do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  before(:all) do
+    class Cat < DynamicArchive::Base
+      finalize!
+    end
+
+    class Human < DynamicArchive::Base
+      self.table_name = 'humans'
+
+      finalize!
+    end
+  end
+
+  it '#where searches with single criterion' do
+    cats = Cat.where(name: 'Breakfast')
+    cat = cats.first
+
+    expect(cats.length).to eq(1)
+    expect(cat.name).to eq('Breakfast')
+  end
+
+  it '#where can return multiple objects' do
+    humans = Human.where(house_id: 1)
+    expect(humans.length).to eq(2)
+  end
+
+  it '#where searches with multiple criteria' do
+    humans = Human.where(fname: 'Matt', house_id: 1)
+    expect(humans.length).to eq(1)
+
+    human = humans[0]
+    expect(human.fname).to eq('Matt')
+    expect(human.house_id).to eq(1)
+  end
+
+  it '#where returns [] if nothing matches the criteria' do
+    expect(Human.where(fname: 'Nowhere', lname: 'Man')).to eq([])
+  end
+end

data/dynamic-archive/spec/validatable_spec.rb

@@ -0,0 +1,81 @@
+require 'validatable'
+
+describe 'Validatable' do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  before(:all) do
+    class Cat < DynamicArchive::Base
+      finalize!
+    end
+
+    class Human < DynamicArchive::Base
+      self.table_name = 'humans'
+      validates :fname, :lname, presence: true
+
+      finalize!
+    end
+  end
+
+  it '::validations returns a hash of hashes' do
+    expect(Cat.validations).to be_a(Hash)
+    expect(Cat.validations[:name]).to eq({})
+  end
+
+  it '::validations returns any validations added' do
+    expect(Human.validations[:fname]).to eq({ presence: true })
+  end
+
+  it '#save calls validations' do
+    alex = Human.new(fname: "Alex")
+    expect(Human).to receive(:presence).twice
+    alex.save
+  end
+
+  it "doesn't save invalid instances" do
+    alex = Human.new(fname: "Alex")
+    alex.save
+    expect(alex.errors[0]).to eq("lname did not pass presence validation")
+    expect(Human.all.last.fname).to_not eq("Alex")
+  end
+
+  it "#uniqueness does not prevent updating attributes" do
+    class Human
+      validates :fname, uniqueness: true
+    end
+
+    alex = Human.new(fname: "Alex", lname: "Rodriguez")
+    alex.save
+    alex.lname = "The Great"
+    alex.save
+
+    expect(alex.errors[0]).to be_nil
+  end
+
+  it "#uniqueness doesn't allow two entries with same value if true" do
+    class Human
+      validates :fname, uniqueness: true
+    end
+
+    alex1 = Human.new(fname: "Alex", lname: "Rodriguez")
+    alex1.save
+
+    alex2 = Human.new(fname: "Alex", lname: "de Ronde")
+    alex2.save
+    expect(alex2.errors[0]).to eq("fname did not pass uniqueness validation")
+  end
+
+  it "#uniqueness does not add flag unconstrained attributes" do
+    class Human
+      validates :fname, uniqueness: true
+    end
+
+    alex = Human.new(fname: "Alex", lname: "Rodriguez")
+    alex.save
+    natalie = Human.new(fname: "Natalie", lname: "Lin")
+    natalie.save
+
+    expect(natalie.errors[0]).to be_nil
+    expect(alex.errors[0]).to be_nil
+  end
+end

data/dynamic-archive/testing_database/database.rb

@@ -0,0 +1,6 @@
+ENV['ROOT_FOLDER'] = File.dirname(__FILE__)
+ENV['MIGRATIONS_FOLDER'] = File.join(ENV['ROOT_FOLDER'], 'migrations')
+
+ENV['SCHEMA_FILE'] = File.join(ENV['ROOT_FOLDER'], 'schema.sql')
+ENV['SEED_FILE'] = File.join(ENV['ROOT_FOLDER'], 'seed.sql')
+ENV['DB_FILE'] = File.join(ENV['ROOT_FOLDER'], 'database.db')

data/dynamic-archive/testing_database/migrations/bats_migration.sql

@@ -0,0 +1,7 @@
+CREATE TABLE bats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);

data/dynamic-archive/testing_database/migrations/cats_migration.sql

@@ -0,0 +1,7 @@
+CREATE TABLE cats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);

data/dynamic-archive/testing_database/migrations/houses_migration.sql

@@ -0,0 +1,4 @@
+CREATE TABLE houses (
+  id INTEGER PRIMARY KEY,
+  address VARCHAR(255) NOT NULL
+);

data/dynamic-archive/testing_database/migrations/humans_migration.sql

@@ -0,0 +1,8 @@
+CREATE TABLE humans (
+  id INTEGER PRIMARY KEY,
+  fname VARCHAR(255) NOT NULL,
+  lname VARCHAR(255) NOT NULL,
+  house_id INTEGER,
+
+  FOREIGN KEY(house_id) REFERENCES human(id)
+);

data/dynamic-archive/testing_database/migrations/play_times_migration.sql

@@ -0,0 +1,8 @@
+CREATE TABLE play_times (
+  id INTEGER PRIMARY KEY,
+  toy_id INTEGER NOT NULL,
+  cat_id INTEGER NOT NULL,
+
+  FOREIGN KEY(cat_id) REFERENCES cat(id),
+  FOREIGN KEY(toy_id) REFERENCES toy(id)
+);

data/dynamic-archive/testing_database/migrations/toys_migration.sql

@@ -0,0 +1,4 @@
+CREATE TABLE toys (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);

data/dynamic-archive/testing_database/schema.sql

@@ -0,0 +1,44 @@
+CREATE TABLE bats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);
+
+CREATE TABLE cats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);
+
+CREATE TABLE houses (
+  id INTEGER PRIMARY KEY,
+  address VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE humans (
+  id INTEGER PRIMARY KEY,
+  fname VARCHAR(255) NOT NULL,
+  lname VARCHAR(255) NOT NULL,
+  house_id INTEGER,
+
+  FOREIGN KEY(house_id) REFERENCES human(id)
+);
+
+CREATE TABLE play_times (
+  id INTEGER PRIMARY KEY,
+  toy_id INTEGER NOT NULL,
+  cat_id INTEGER NOT NULL,
+
+  FOREIGN KEY(cat_id) REFERENCES cat(id),
+  FOREIGN KEY(toy_id) REFERENCES toy(id)
+);
+
+CREATE TABLE toys (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);
+

data/dynamic-archive/testing_database/seed.sql

@@ -0,0 +1,44 @@
+INSERT INTO
+  houses (id, address)
+VALUES
+  (1, "26th and Guerrero"), (2, "Dolores and Market");
+
+INSERT INTO
+  humans (id, fname, lname, house_id)
+VALUES
+  (1, "Devon", "Watts", 1),
+  (2, "Matt", "Rubens", 1),
+  (3, "Ned", "Ruggeri", 2),
+  (4, "Catless", "Human", NULL);
+
+INSERT INTO
+  cats (id, name, owner_id)
+VALUES
+  (1, "Breakfast", 1),
+  (2, "Earl", 2),
+  (3, "Haskell", 3),
+  (4, "Markov", 3),
+  (5, "Stray Cat", NULL);
+
+INSERT INTO
+  toys (id, name)
+VALUES
+  (1, "fuzzy"),
+  (2, "stringy"),
+  (3, "mouse"),
+  (4, "ball"),
+  (5, "catnip"),
+  (6, "mystery");
+
+INSERT INTO
+  play_times (id, toy_id, cat_id)
+VALUES
+  (1, 1, 1),
+  (2, 2, 1),
+  (3, 3, 2),
+  (4, 4, 4),
+  (5, 5, 4),
+  (6, 6, 3),
+  (7, 1, 4),
+  (8, 2, 2),
+  (9, 4, 1);

data/lib/asset_server.rb

@@ -0,0 +1,28 @@
+class StaticAssetsServer
+  attr_reader :app, :res, :req
+
+  def initialize(app)
+    @app = app
+    @res = Rack::Response.new
+  end
+
+  def call(env)
+    @req = Rack::Request.new(env)
+    if req.path =~ /^\/public\/assets/
+      serve_asset
+    else
+      app.call(env)
+    end
+  end
+
+  private
+    def serve_asset
+      asset = File.read(File.join(PROJECT_ROOT, req.path))
+
+      file_type = req.path.match(/\..+$/)[0]
+      res["Content-Type"] = Rack::Mime::MIME_TYPES[file_type]
+
+      res.write(asset)
+      res.finish
+    end
+end

data/lib/cli.rb

@@ -0,0 +1,109 @@
+require 'thor'
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/inflector'
+
+$thor_runner ||= false
+
+module Trails
+  class Generate < Thor
+    desc "migration <name>", "adds a migration file to 'db/migrations'"
+    def migration(name)
+      file_name = name
+      timestamp = Time.now.to_i
+
+      path = File.join(PROJECT_ROOT, "db/migrations/#{timestamp}_#{file_name}.sql")
+      raise "Migration already created" if File.exist?(path)
+
+      File.new(path, "w")
+      puts "Migration #{file_name} can be found at #{path}"
+    end
+
+    desc "model <name>", "creates a model template file and a migration file"
+    def model(name)
+      model_path = File.join(PROJECT_ROOT, "app/models/#{name.underscore}.rb")
+      raise "Model already created" if File.exist?(model_path)
+
+      File.open(model_path, "w") do |file|
+        file.write("class #{name.camelize} < DynamicArchive::Base\n")
+        file.write("  self.finalize!\n")
+        file.write("end\n")
+      end
+
+      migration(name)
+      puts "Model #{name.camelize} can be found at #{model_path}"
+    end
+
+    desc "controller <name>", "creates a controller file and a view folder"
+    def controller(name)
+      file_name = name.pluralize.underscore
+      controller_name = "#{name.pluralize.camelize}Controller"
+      controller_path = File.join(PROJECT_ROOT, "app/controllers/#{file_name}_controller.rb")
+      view_dir = File.join(PROJECT_ROOT, "app/views/#{file_name}")
+      raise "Controller already created" if File.exist?(controller_path)
+
+      File.open(controller_path, "w") do |file|
+        file.write("class #{controller_name} < ApplicationController\n")
+        file.write("end\n")
+      end
+      Dir.mkdir(view_dir) unless Dir.exist?(view_dir)
+
+      puts "Controller #{controller_name} can be found at #{controller_path}"
+    end
+  end
+
+  class DB < Thor
+    desc "reset", "clears the database, runs all migrations, and re-seeds"
+    def reset
+      DBConnection.reset
+    end
+
+    desc "seed", "seeds the database"
+    def seed
+      DBConnection.seed
+    end
+
+    desc "migrate", "runs all pending migrations"
+    def migrate
+      DBConnection.migrate
+    end
+  end
+
+  class CLI < Thor
+    desc "generate COMMANDS ...ARGS", "generate new model, migration, or controller"
+    subcommand "generate", Generate
+
+    desc "g COMMANDS ...ARGS", "generate new model, migration, or controller"
+    subcommand "g", Generate
+
+    desc "db COMMANDS", "alter the database"
+    subcommand "db", DB
+
+    desc "server", "starts the trails server, default port: 3000"
+    option :port, :default => 3000
+    option :host, :default => "localhost"
+    def server
+      raise "Cannot find Trails App" unless PROJECT_ROOT
+      require_relative "#{PROJECT_ROOT}/config/routes"
+      require_relative '../bin/server'
+
+      server = TrailsServer.new(options[:port], options[:host])
+      server.start
+    end
+
+    desc "s", "starts the trails server, default port: 3000"
+    option :port, :default => 3000
+    option :host, :default => "localhost"
+    alias_method :s, :server
+
+    desc "new NAME", "creates a new Trails application skeleton in '/<name>'"
+    def new(name)
+      app_destination = File.join(Dir.pwd, name)
+      raise "Directory already exists at #{app_destination}" if Dir.exist?(app_destination)
+
+      FileUtils.copy_entry(TEMPLATE_PATH, app_destination)
+      Dir.mkdir(File.join(app_destination, "app/models"))
+      Dir.mkdir(File.join(app_destination, "db/migrations"))
+    end
+  end
+end