trails-mvc 0.1.0

data/dynamic-archive/lib/db_connection.rb

@@ -0,0 +1,151 @@
+require 'sqlite3'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+MIGRATION_FILES = Dir.glob("#{ENV['MIGRATIONS_FOLDER']}/*.sql").to_a
+
+class DBConnection
+  def self.open(db_file_name)
+    options = {
+      results_as_hash: true,
+      type_translation: true
+    }
+    @db = SQLite3::Database.new(db_file_name, options)
+
+    @db
+  end
+
+  def self.db
+    @db
+  end
+
+  def self.reset
+    `rm '#{ENV['DB_FILE']}'`
+    `rm '#{ENV['SCHEMA_FILE']}'`
+    self.open(ENV['DB_FILE'])
+
+    self.migrate
+    self.seed
+  end
+
+  def self.instance
+    self.open(ENV['DB_FILE']) if @db.nil?
+
+    @db
+  end
+
+  def self.execute(*args)
+    print_query(*args)
+    instance.execute(*args)
+  end
+
+  def self.execute2(*args)
+    print_query(*args)
+    instance.execute2(*args)
+  end
+
+  def self.execute_batch(statement)
+    print_query(statement)
+    instance.execute_batch(statement)
+  end
+
+  def self.last_insert_row_id
+    instance.last_insert_row_id
+  end
+
+  def self.migrate(resetting = false)
+    self.ensure_migrations_table
+    already_migrated = self.previous_migrations
+
+    MIGRATION_FILES.each do |migration_file|
+      migration_file_name = (/\/(\w+)\.sql$/).match(migration_file)[1]
+      next if already_migrated.include?(migration_file_name)
+
+      migration = IO.read(migration_file)
+      self.execute(migration)
+      `echo '#{migration}' >> '#{ENV['SCHEMA_FILE']}'`
+      self.record_migration(migration_file_name)
+    end
+
+    @db
+  end
+
+  def self.reset_schema
+    `rm '#{ENV['SCHEMA_FILE']}'`
+    self.execute(<<-SQL)
+      DROP TABLE IF EXISTS migrations
+    SQL
+    `touch '#{ENV['SCHEMA_FILE']}'`
+  end
+
+  def self.seed
+    seed_data = IO.read(ENV['SEED_FILE'])
+    self.execute_batch(seed_data)
+  end
+
+  private
+
+  def self.record_migration(file_name)
+    self.execute(<<-SQL, file_name)
+      INSERT INTO
+        migrations (file_name)
+      VALUES
+        (?)
+    SQL
+  end
+
+  def self.ensure_migrations_table
+    self.execute(<<-SQL)
+        CREATE TABLE IF NOT EXISTS migrations (
+          id INTEGER PRIMARY KEY,
+          file_name VARCHAR(255) NOT NULL
+        );
+    SQL
+  end
+
+  def self.previous_migrations
+  ensure_migrations_table
+    migrations = self.execute(<<-SQL)
+        SELECT
+          file_name
+        FROM
+          migrations
+    SQL
+
+    migrations.map do |migration|
+      migration["file_name"]
+    end
+  end
+
+  def self.create_table(table_name, columns = {})
+    column_text = columns.map { |name, options| "#{name} #{options}" }.join(", ")
+    self.execute(<<-SQL)
+      CREATE TABLE #{table_name} (
+        id INTEGER PRIMARY KEY,
+        #{column_text}
+      );
+    SQL
+  end
+
+  def self.add_column(table_name, column_name, column_type)
+    self.execute(<<-SQL)
+      ALTER TABLE #{table_name} ADD #{column_name} #{column_type};
+    SQL
+  end
+
+  def self.remove_column(table_name, column_name)
+    self.execute(<<-SQL)
+      ALTER TABLE #{table_name} DROP COLUMN #{column_name};
+    SQL
+  end
+
+  def self.print_query(query, *interpolation_args)
+    return unless PRINT_QUERIES
+
+    puts '--------------------'
+    puts query
+    unless interpolation_args.empty?
+      puts "interpolate: #{interpolation_args.inspect}"
+    end
+    puts '--------------------'
+  end
+end

data/dynamic-archive/lib/searchable.rb

@@ -0,0 +1,39 @@
+module DynamicArchive
+  module Searchable
+    def where(*args)
+      if args[0].is_a?(Hash)
+        # without 'LIKE', query cannot find ids correctly
+        where_line = args[0].map { |key, v| "#{key} LIKE ?"}.join(" AND ")
+        results = DBConnection.execute(<<-SQL, args[0].values)
+          SELECT
+            *
+          FROM
+            #{self.table_name}
+          WHERE
+            #{where_line}
+        SQL
+      else
+        results = sql_query_where(args)
+      end
+
+      self.parse_all(results)
+    end
+
+    def sql_query_where(args)
+      where_line = args[0]
+      DBConnection.execute(<<-SQL, args[1..-1])
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+        WHERE
+          #{where_line}
+      SQL
+    end
+
+    def find_by(params)
+      results = where(params)
+      results.first
+    end
+  end
+end

data/dynamic-archive/lib/validatable.rb

@@ -0,0 +1,71 @@
+module DynamicArchive
+  module Validatable
+    def validates(*args)
+      validated_attrs = []
+      options = {}
+      args.each do |arg|
+        if arg.is_a?(Hash)
+          options = arg
+        else
+          validated_attrs << arg
+        end
+      end
+
+      validated_attrs.each do |attr|
+        validations[attr] = validations[attr].merge(options)
+      end
+    end
+
+    def is_valid?(instance)
+      instance.errors.clear
+      valid = true
+      columns.each do |attr|
+        validations[attr].each do |validation, value|
+          validated = send(validation, instance, attr, value)
+          unless validated
+            instance.errors << "#{attr} did not pass #{validation} validation"
+            valid = false
+          end
+        end
+      end
+
+      valid
+    end
+
+    def length(instance, attr, value)
+      min = value[:minimum] || 0
+      max = value[:maximum]
+      if max
+        instance.send(attr).length.between?(min, max)
+      else
+        instance.send(attr).length >= min
+      end
+    end
+
+    def presence(instance, attr, value)
+      if value
+        !!instance.send(attr)
+      else
+        !instance.send(attr)
+      end
+    end
+
+    def uniqueness(instance, attr, value)
+      if value == true
+        if instance.id
+          return !instance.class
+            .where("#{attr} = (?) AND id != (?)", instance.send(attr), instance.id).first
+        else
+          return !instance.class
+            .where({ attr => instance.send(attr) }).first
+        end
+      end
+
+      true
+    end
+
+    def validations
+      @validations ||= Hash.new { |h, k| h[k] = {} }
+    end
+  end
+end

data/dynamic-archive/spec/associatable_spec.rb

@@ -0,0 +1,294 @@
+require_relative '../testing_database/database'
+require 'associatable'
+
+describe 'AssocOptions' do
+  describe 'DynamicArchive::BelongsToOptions' do
+    it 'provides defaults' do
+      options = DynamicArchive::BelongsToOptions.new('house')
+
+      expect(options.foreign_key).to eq(:house_id)
+      expect(options.class_name).to eq('House')
+      expect(options.primary_key).to eq(:id)
+    end
+
+    it 'allows overrides' do
+      options = DynamicArchive::BelongsToOptions.new('owner',
+                                     foreign_key: :human_id,
+                                     class_name: 'Human',
+                                     primary_key: :human_id
+      )
+
+      expect(options.foreign_key).to eq(:human_id)
+      expect(options.class_name).to eq('Human')
+      expect(options.primary_key).to eq(:human_id)
+    end
+  end
+
+  describe 'DynamicArchive::HasManyOptions' do
+    it 'provides defaults' do
+      options = DynamicArchive::HasManyOptions.new('cats', 'Human')
+
+      expect(options.foreign_key).to eq(:human_id)
+      expect(options.class_name).to eq('Cat')
+      expect(options.primary_key).to eq(:id)
+    end
+
+    it 'allows overrides' do
+      options = DynamicArchive::HasManyOptions.new('cats', 'Human',
+                                   foreign_key: :owner_id,
+                                   class_name: 'Kitten',
+                                   primary_key: :human_id
+      )
+
+      expect(options.foreign_key).to eq(:owner_id)
+      expect(options.class_name).to eq('Kitten')
+      expect(options.primary_key).to eq(:human_id)
+    end
+  end
+
+  describe 'AssocOptions' do
+    before(:all) do
+      class Cat < DynamicArchive::Base
+        self.finalize!
+      end
+
+      class Human < DynamicArchive::Base
+        self.table_name = 'humans'
+
+        self.finalize!
+      end
+    end
+
+    it '#model_class returns class of associated object' do
+      options = DynamicArchive::BelongsToOptions.new('human')
+      expect(options.model_class).to eq(Human)
+
+      options = DynamicArchive::HasManyOptions.new('cats', 'Human')
+      expect(options.model_class).to eq(Cat)
+    end
+
+    it '#table_name returns table name of associated object' do
+      options = DynamicArchive::BelongsToOptions.new('human')
+      expect(options.table_name).to eq('humans')
+
+      options = DynamicArchive::HasManyOptions.new('cats', 'Human')
+      expect(options.table_name).to eq('cats')
+    end
+  end
+end
+
+describe 'Associatable' do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  before(:all) do
+    class Cat < DynamicArchive::Base
+      belongs_to :human, foreign_key: :owner_id
+      has_many :play_times
+
+      finalize!
+    end
+
+    class Human < DynamicArchive::Base
+      self.table_name = 'humans'
+
+      has_many :cats, foreign_key: :owner_id
+      belongs_to :house
+
+      finalize!
+    end
+
+    class House < DynamicArchive::Base
+      has_many :humans
+
+      finalize!
+    end
+
+    class Toy < DynamicArchive::Base
+      has_many :play_times
+    end
+
+    class PlayTime < DynamicArchive::Base
+      belongs_to :toy
+      belongs_to :cat
+    end
+  end
+
+  describe '#belongs_to' do
+    let(:breakfast) { Cat.find(1) }
+    let(:devon) { Human.find(1) }
+
+    it 'fetches `human` from `Cat` correctly' do
+      expect(breakfast).to respond_to(:human)
+      human = breakfast.human
+
+      expect(human).to be_instance_of(Human)
+      expect(human.fname).to eq('Devon')
+    end
+
+    it 'fetches `house` from `Human` correctly' do
+      expect(devon).to respond_to(:house)
+      house = devon.house
+
+      expect(house).to be_instance_of(House)
+      expect(house.address).to eq('26th and Guerrero')
+    end
+
+    it 'returns nil if no associated object' do
+      stray_cat = Cat.find(5)
+      expect(stray_cat.human).to eq(nil)
+    end
+  end
+
+  describe '#has_many' do
+    let(:ned) { Human.find(3) }
+    let(:ned_house) { House.find(2) }
+
+    it 'fetches `cats` from `Human`' do
+      expect(ned).to respond_to(:cats)
+      cats = ned.cats
+
+      expect(cats.length).to eq(2)
+
+      expected_cat_names = %w(Haskell Markov)
+      2.times do |i|
+        cat = cats[i]
+
+        expect(cat).to be_instance_of(Cat)
+        expect(cat.name).to eq(expected_cat_names[i])
+      end
+    end
+
+    it 'fetches `humans` from `House`' do
+      expect(ned_house).to respond_to(:humans)
+      humans = ned_house.humans
+
+      expect(humans.length).to eq(1)
+      expect(humans[0]).to be_instance_of(Human)
+      expect(humans[0].fname).to eq('Ned')
+    end
+
+    it 'returns an empty array if no associated items' do
+      catless_human = Human.find(4)
+      expect(catless_human.cats).to eq([])
+    end
+  end
+
+  describe '::assoc_options' do
+    it 'defaults to empty hash' do
+      class TempClass < DynamicArchive::Base
+      end
+
+      expect(TempClass.assoc_options).to eq({})
+    end
+
+    it 'stores `belongs_to` options' do
+      cat_assoc_options = Cat.assoc_options
+      human_options = cat_assoc_options[:human]
+
+      expect(human_options).to be_instance_of(DynamicArchive::BelongsToOptions)
+      expect(human_options.foreign_key).to eq(:owner_id)
+      expect(human_options.class_name).to eq('Human')
+      expect(human_options.primary_key).to eq(:id)
+    end
+
+    it 'stores options separately for each class' do
+      expect(Cat.assoc_options).to have_key(:human)
+      expect(Human.assoc_options).to_not have_key(:human)
+
+      expect(Human.assoc_options).to have_key(:house)
+      expect(Cat.assoc_options).to_not have_key(:house)
+    end
+  end
+
+  describe '#has_many_through' do
+    before(:all) do
+      class House
+        has_many_through :cats, :humans, :cats
+
+        self.finalize!
+      end
+
+      class Toy
+        has_many_through :cats, :play_times, :cat
+
+        self.finalize!
+      end
+
+      class Cat
+        has_many_through :toys, :play_times, :toy
+
+        self.finalize!
+      end
+    end
+
+    let(:house) { House.find(1) }
+    let(:breakfast) { Cat.find(1) }
+    let(:stringy) { Toy.find(2) }
+
+    it 'adds getter method' do
+      expect(house).to respond_to(:cats)
+    end
+
+    it 'fetches associated `cats` for a `house`' do
+      cats = house.cats
+
+      expect(cats).to be_instance_of(Array)
+      expect(cats.length).to eq(2)
+      expect(cats[0]).to be_instance_of(Cat)
+
+      expect(cats[0].name).to eq('Breakfast')
+      expect(cats[1].name).to eq('Earl')
+    end
+
+    it 'fetches associated `toys` for a `cat`' do
+      toys = breakfast.toys
+
+      expect(toys).to be_instance_of(Array)
+      expect(toys.length).to eq(3)
+      expect(toys[0]).to be_instance_of(Toy)
+
+      expect(toys[0].name).to eq('fuzzy')
+      expect(toys[1].name).to eq('stringy')
+    end
+
+    it 'fetches associated `cats` for a `toy`' do
+      cats = stringy.cats
+
+      expect(cats).to be_instance_of(Array)
+      expect(cats.length).to eq(2)
+      expect(cats[0]).to be_instance_of(Cat)
+
+      expect(cats[0].name).to eq('Breakfast')
+      expect(cats[1].name).to eq('Earl')
+    end
+  end
+
+  describe '#has_one_through' do
+    before(:all) do
+      class Cat
+        has_one_through :home, :human, :house
+
+        self.finalize!
+      end
+    end
+
+    let(:cat) { Cat.find(1) }
+    let(:cat2) { Cat.find(4) }
+
+    it 'adds getter method' do
+      expect(cat).to respond_to(:home)
+    end
+
+    it 'fetches associated `home` for a `Cat`' do
+      house = cat.home
+
+      expect(house).to be_instance_of(House)
+      expect(house.address).to eq('26th and Guerrero')
+
+      house2 = cat2.home
+
+      expect(house2.address).to eq('Dolores and Market')
+    end
+  end
+end