grails-mvc 0.1.0

data/grailedorm/attr_accessor_object.rb

@@ -0,0 +1,19 @@
+class AttrAccessorObject
+  def self.my_attr_accessor(*names)
+    # ...
+
+
+    names.each do |name|
+      define_method(name) do
+        instance_variable_get("@#{name}")
+      end
+
+      define_method("#{name}=") do |*args|
+        args.each do |arg|
+          instance_variable_set("@#{name}", arg)
+        end
+      end
+        # AttrAccessorObject.instance_variable_set(name)
+    end
+  end
+end

data/grailedorm/base.rb

@@ -0,0 +1,121 @@
+require_relative 'db_connection'
+require 'active_support/inflector'
+require_relative '02_searchable'
+
+
+module GrailedORM
+  class Base
+    extend GrailedORM::Searchable
+    extend GrailedORM::Associatable
+
+
+    def self.columns
+      @columns ||= DBConnection.execute2(<<-SQL).first.map(&:to_sym)
+      SELECT
+      *
+      FROM
+      #{self.table_name}
+      SQL
+    end
+
+    def self.finalize!
+      columns.each do |column|
+        define_method("#{column}=") { |val| attributes[column] = val }
+
+        define_method(column) { attributes[column]}
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name.tableize
+    end
+
+    def self.table_name
+      @table_name ||= self.to_s.downcase.pluralize
+    end
+
+    def self.all
+      results = DBConnection.execute(<<-SQL)
+      SELECT
+      *
+      FROM
+      #{self.table_name}
+      SQL
+
+      parse_all(results)
+    end
+
+    def self.parse_all(results)
+      results.map do |optionshash|
+        self.new(optionshash)
+      end
+    end
+
+    def self.find(id)
+      result = DBConnection.execute(<<-SQL, id)
+      SELECT
+      *
+      FROM
+      #{self.table_name}
+      WHERE
+      id = ?
+      LIMIT 1
+      SQL
+      parse_all(result).first
+    end
+
+    def initialize(params = {})
+      params.each do |attri, val|
+        if !self.class.columns.include?(attri.to_sym)
+          raise "unknown attribute '#{attri}'"
+        end
+        self.send("#{attri}=", val)
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      self.class.columns.map { |col| self.send(col) }
+    end
+
+    def insert
+      columns = self.class.columns.drop(1)
+      col_names = columns.map(&:to_s).join(", ")
+      questionmarks = (["?"] * columns.length).join(", ")
+
+      DBConnection.execute(<<-SQL, *attribute_values.drop(1))
+      INSERT INTO
+      #{self.class.table_name} (#{col_names})
+      VALUES
+      (#{questionmarks})
+      SQL
+      self.id = DBConnection.last_insert_row_id
+    end
+
+    def update
+      columns = self.class.columns.drop(1)
+      col_names = columns.map { |name| "#{name.to_s} = ?" }.join(", ")
+
+
+      DBConnection.execute(<<-SQL, *attribute_values.drop(1), self.id)
+      UPDATE
+      #{self.class.table_name}
+      SET
+      #{col_names}
+      WHERE
+      id = ?
+      SQL
+    end
+
+    def save
+      if self.id.nil?
+        insert
+      else
+        update
+      end
+    end
+  end
+end

data/grailedorm/db_connection.rb

@@ -0,0 +1,60 @@
+require 'sqlite3'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+# https://tomafro.net/2010/01/tip-relative-paths-with-file-expand-path
+ROOT_FOLDER = File.join(File.dirname(__FILE__), '..')
+CATS_SQL_FILE = File.join(ROOT_FOLDER, 'cats.sql')
+CATS_DB_FILE = File.join(ROOT_FOLDER, 'cats.db')
+
+class DBConnection
+  def self.open(db_file_name)
+    @db = SQLite3::Database.new(db_file_name)
+    @db.results_as_hash = true
+    @db.type_translation = true
+
+    @db
+  end
+
+  def self.reset
+    commands = [
+      "rm '#{CATS_DB_FILE}'",
+      "cat '#{CATS_SQL_FILE}' | sqlite3 '#{CATS_DB_FILE}'"
+    ]
+
+    commands.each { |command| `#{command}` }
+    DBConnection.open(CATS_DB_FILE)
+  end
+
+  def self.instance
+    reset 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.last_insert_row_id
+    instance.last_insert_row_id
+  end
+
+  private
+
+  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/grailedorm/searchable.rb

@@ -0,0 +1,27 @@
+require_relative 'db_connection'
+require_relative '01_sql_object'
+
+
+module GrailedORM
+  module Searchable
+    def where(params)
+      cols = params.keys
+      vals = params.values
+      where = cols.map { |name| "#{name.to_s} = ?"}.join(" AND ")
+      result = DBConnection.execute(<<-SQL, vals)
+      SELECT
+      *
+      FROM
+      #{self.table_name}
+      WHERE
+      #{where}
+      SQL
+      self.parse_all(result)
+    end
+
+    def find_by(params)
+      results = where(params)
+      results.first
+    end
+  end
+end

data/grailedorm/spec/associatable2_spec.rb

@@ -0,0 +1,79 @@
+require '04_associatable2'
+
+describe 'Associatable' do
+  before(:each) { DBConnection.reset }
+  after(:each) { DBConnection.reset }
+
+  before(:all) do
+    class Cat < SQLObject
+      belongs_to :human, foreign_key: :owner_id
+
+      finalize!
+    end
+
+    class Human < SQLObject
+      self.table_name = 'humans'
+
+      has_many :cats, foreign_key: :owner_id
+      belongs_to :house
+
+      finalize!
+    end
+
+    class House < SQLObject
+      has_many :humans
+
+      finalize!
+    end
+  end
+
+  describe '::assoc_options' do
+    it 'defaults to empty hash' do
+      class TempClass < SQLObject
+      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(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_one_through' do
+    before(:all) do
+      class Cat
+        has_one_through :home, :human, :house
+
+        self.finalize!
+      end
+    end
+
+    let(:cat) { Cat.find(1) }
+
+    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')
+    end
+  end
+end

data/grailedorm/spec/associatable_spec.rb

@@ -0,0 +1,165 @@
+require '03_associatable'
+
+describe 'AssocOptions' do
+  describe 'BelongsToOptions' do
+    it 'provides defaults' do
+      options = 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 = 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 'HasManyOptions' do
+    it 'provides defaults' do
+      options = 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 = 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 < SQLObject
+        self.finalize!
+      end
+
+      class Human < SQLObject
+        self.table_name = 'humans'
+
+        self.finalize!
+      end
+    end
+
+    it '#model_class returns class of associated object' do
+      options = BelongsToOptions.new('human')
+      expect(options.model_class).to eq(Human)
+
+      options = HasManyOptions.new('cats', 'Human')
+      expect(options.model_class).to eq(Cat)
+    end
+    
+    it '#table_name returns table name of associated object' do
+      options = BelongsToOptions.new('human')
+      expect(options.table_name).to eq('humans')
+
+      options = 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 < SQLObject
+      belongs_to :human, foreign_key: :owner_id
+
+      finalize!
+    end
+
+    class Human < SQLObject
+      self.table_name = 'humans'
+
+      has_many :cats, foreign_key: :owner_id
+      belongs_to :house
+
+      finalize!
+    end
+
+    class House < SQLObject
+      has_many :humans
+
+      finalize!
+    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
+end