rails_lite 0.1.0

data/lib/scaffold/lib/model/associations/belongs_to_options.rb

@@ -0,0 +1,18 @@
+require_relative 'assoc_options'
+
+class BelongsToOptions < AssocOptions
+
+  def initialize(name, options = {})
+    default = {
+      foreign_key: "#{name}_id".to_sym,
+      class_name: name.to_s.capitalize, 
+      primary_key: :id,
+      optional: false
+    }
+
+    default.merge!(options)
+    @foreign_key = default[:foreign_key]
+    @class_name = default[:class_name]
+    @primary_key = default[:primary_key]
+  end
+end

data/lib/scaffold/lib/model/associations/has_many_options.rb

@@ -0,0 +1,17 @@
+require_relative 'assoc_options'
+
+class HasManyOptions < AssocOptions
+
+  def initialize(name, self_class_name, options = {})
+    default = {
+      foreign_key: "#{self_class_name.downcase}_id".to_sym,
+      class_name: name.to_s.capitalize.singularize,
+      primary_key: :id
+    }
+
+    default.merge!(options)
+    @foreign_key = default[:foreign_key]
+    @class_name = default[:class_name]
+    @primary_key = default[:primary_key]
+  end
+end

data/lib/scaffold/lib/model/db_connection.rb

@@ -0,0 +1,59 @@
+require 'sqlite3'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+ROOT_FOLDER = File.join(File.dirname(__FILE__), '..', '..')
+SQL_FILE = File.join(ROOT_FOLDER, 'db', 'database.sql')
+DB_FILE = File.join(ROOT_FOLDER, 'db', 'database.db')
+
+class DBConnection
+  def self.open(db_file_name)
+    @db = SQLite3::Database.new(db_file_name)
+    @db.results_as_hash = false
+    @db.type_translation = true
+
+    @db
+  end
+
+  def self.reset
+    commands = [
+      "rm '#{DB_FILE}'",
+      "cat '#{SQL_FILE}' | sqlite3 '#{DB_FILE}'"
+    ]
+
+    commands.each { |command| `#{command}` }
+    DBConnection.open(DB_FILE)
+  end
+
+  def self.instance
+    DBConnection.open(DB_FILE)
+
+    @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/lib/scaffold/lib/model/model_base.rb

@@ -0,0 +1,183 @@
+require 'active_support/inflector'
+require_relative './db_connection'
+require_relative './relations/searchable'
+require_relative './associations/associatable'
+require_relative './validations/validations'
+require_relative './relations/relation'
+require_relative './model_callbacks'
+
+class ModelBase
+  extend Searchable
+  extend Associatable
+  include Validations
+  include ModelCallbacks
+  
+  def self.columns
+    @columns ||= DBConnection.execute2(<<-SQL)
+      Select 
+        * 
+      FROM 
+        '#{self.table_name}' 
+      LIMIT 0
+    SQL
+    .first.map!(&:to_sym)
+  end
+
+  def self.finalize!
+    columns.each do |column|
+      define_method(column) do 
+        attributes[column]
+      end
+      
+      setter_name = column.to_s + "="
+      define_method(setter_name) do |val|
+        attributes[column] = val
+      end
+    end
+  end
+
+  def self.table_name=(table_name)
+    @table_name = table_name
+  end
+
+  def self.table_name
+    @table_name ||= self.name.underscore.pluralize
+  end
+
+  def self.all
+    results = DBConnection.execute("Select * FROM #{self.table_name}")
+    parse_all(results)
+  end
+
+  def self.first
+    results = DBConnection.execute("Select * FROM #{self.table_name} LIMIT 1")
+    parse_all(results).first
+  end
+
+  def self.last
+    all.last
+  end
+
+  def self.parse_all(results)
+    results.map do |arr|
+      params = {}
+      columns.each_with_index do |column, idx|
+        params[column] = arr[idx]
+      end
+
+      self.new(params)
+    end
+  end
+
+  def self.find(id)
+    results = DBConnection.execute(<<-SQL, id)
+      Select 
+        * 
+      FROM 
+        #{table_name}
+      WHERE 
+        id = ?
+    SQL
+
+    parse_all(results).first
+  end
+
+  def initialize(params = {})
+    self.class.finalize!
+
+    params.each do |attribute, val|
+      setter = attribute.to_s + "="
+      raise "Unknown attribute '#{k}'" unless self.class.method_defined?(setter.to_sym)
+      self.send(setter, val)
+    end
+  end
+
+  def update(params = {})
+    params.each do |attribute, val|
+      setter = attribute.to_s + "="
+      raise "Unknown attribute '#{k}'" unless self.class.method_defined?(setter.to_sym)
+      self.send(setter, val)
+    end
+
+    self
+  end
+
+  def update_attributes(params = {})
+    update(params)
+    save ? true : false
+  end
+
+  def attributes
+    @attributes ||= {}
+  end
+
+  def attribute_values
+    attributes.values
+  end
+
+  def save
+    if self.valid?
+      id ? update_database : insert
+      true
+    else
+      false
+    end
+  end
+
+  def save!
+    if self.valid?
+      id ? update_database : insert
+      self
+    else
+      raise self.errors.join(", ")
+    end
+  end
+  
+  def destroy
+    DBConnection.instance.execute(<<-SQL, id)
+      DELETE
+      FROM
+        #{self.class.table_name}
+      WHERE
+        id = ?
+    SQL
+  end
+
+  private
+  
+  def insert
+    raise "#{self} already in database" if self.id
+    db_connection = DBConnection.instance
+    db_connection.execute(<<-SQL, *attribute_values)
+      INSERT INTO
+        #{self.class.table_name} (#{column_names})
+      VALUES
+        (#{question_marks})
+    SQL
+    self.id = db_connection.last_insert_row_id
+    # self.id = DBConnection.execute("SELECT MAX(id) FROM #{self.class.table_name}").first.first
+  end
+  
+  def update_database
+    DBConnection.instance.execute(<<-SQL, *attribute_values, id)
+      UPDATE
+        #{self.class.table_name}
+      SET
+        #{update_string}
+      WHERE
+        id = ?
+    SQL
+  end
+  
+  def question_marks
+    (["?"] * attributes.count).join(", ")
+  end
+  
+  def column_names 
+    attributes.keys.map(&:to_s).join(", ")
+  end
+  
+  def update_string
+    attributes.keys.map { |attr| "#{attr} = ?" }.join(", ")
+  end
+end

data/lib/scaffold/lib/model/model_callbacks.rb

@@ -0,0 +1,46 @@
+require 'active_support/concern'
+
+module ModelCallbacks
+  extend ActiveSupport::Concern
+
+  def after_init
+    names = self.class.after_init_names[self.class]
+    names.each { |name| self.send(name) }
+  end
+
+  def self.included(klass)
+    class << klass
+      alias_method :__new, :new
+      def new(*args)
+        e = __new(*args)
+        e.after_init
+        e
+      end
+    end
+  end
+  
+  def before_valid
+    names = self.class.before_valid_names[self.class]
+    names.each { |name| self.send(name) }
+  end
+  
+  
+  module ClassMethods
+    
+    def before_valid_names
+      @@before_valid_names ||= Hash.new { |h, k| h[k] = [] }
+    end
+  
+    def after_init_names
+      @@after_init_names ||= Hash.new { |h, k| h[k] = [] }
+    end
+
+    def after_initialize(*names)
+      after_init_names[self] += names
+    end
+
+    def before_validation(*names)
+      before_valid_names[self] += names
+    end
+  end
+end

data/lib/scaffold/lib/model/relations/relation.rb

@@ -0,0 +1,151 @@
+class Relation
+  attr_reader(
+    :where_line,
+    :obj_class,
+    :where_vals,
+    :table_name,
+    :join_line,
+    :select_line
+  )
+
+  def initialize(options)
+    default = {
+      class: options[:table_name].singularize.capitalize.constantize,
+      select_line: "*",
+      table_name: "",
+      where_line: "",
+      where_vals: [],
+      join_line: ""
+    }
+
+    default.merge!(options)
+    @table_name = default[:table_name]
+    @where_line = default[:where_line]
+    @where_vals = default[:where_vals]
+    @obj_class = default[:class]
+    @join_line = default[:join_line]
+    @select_line = default[:select_line]
+  end
+
+  def select(*params)
+    if params.length == 1 && params.first.is_a?(String)
+      new_line = params.first
+    else
+      new_line = select_string(*params)
+    end
+
+    self.select_line = new_line
+    self
+  end
+
+  def where(params)
+    if params.is_a?(Hash)
+      new_line = params_string(params)
+      new_vals = params.values
+    else
+      new_line = params
+      new_vals = []
+    end
+    
+    if where_line.blank?
+      self.where_line = new_line
+    else
+      self.where_line = "#{where_line} AND #{new_line}"
+    end
+
+    self.where_vals = where_vals + new_vals
+    self
+  end
+
+  def includes(assoc)
+    result_array = []
+    result_hash = Hash.new { |h, k| h[k] = [] }
+    join_options = obj_class.assoc_options[assoc]
+    join_table_name = join_options.table_name
+    join_class = join_options.model_class
+    
+    left_joins(join_table_name)
+    data = query
+    obj_params_length = obj_class.columns.length
+
+    data.each do |el|
+      obj = parse_all([el.take(obj_params_length)]).first
+      join_arr = el.drop(obj_params_length)
+      join_obj = join_class.parse_all([join_arr]).first
+
+      result_array << obj if result_hash[obj.id].empty?
+      result_hash[obj.id] << join_obj unless join_arr.all?(&:nil?)
+    end
+
+    [result_array, result_hash]
+  end
+
+  def joins(name)
+    join_options = obj_class.assoc_options.values
+      .find { |options| options.table_name == name.to_s }
+
+    if join_options.is_a?(BelongsToOptions)
+      table_id = join_options.foreign_key
+      join_table_id = join_options.primary_key
+    else
+      table_id = join_options.primary_key
+      join_table_id = join_options.foreign_key
+    end
+
+    self.join_line = "JOIN #{join_options.table_name} on #{join_options.table_name}.#{join_table_id} = #{table_name}.#{table_id}"
+    self
+  end
+
+  def left_joins(name)
+    join_options = obj_class.assoc_options.values
+      .find { |options| options.table_name == name.to_s }
+      
+    if join_options.is_a?(BelongsToOptions)
+      table_id = join_options.foreign_key
+      join_table_id = join_options.primary_key
+    else
+      table_id = join_options.primary_key
+      join_table_id = join_options.foreign_key
+    end
+
+    self.join_line = "LEFT OUTER JOIN #{join_options.table_name} on #{join_options.table_name}.#{join_table_id} = #{table_name}.#{table_id}"
+    self
+  end
+
+  def method_missing(m, *args, &block)
+    parsed_query.send(m, *args, &block)
+  end
+
+  def parsed_query
+    parse_all(query)
+  end
+
+  def query
+    result = DBConnection.execute(<<-SQL, where_vals)
+      SELECT
+        #{select_line}
+      FROM
+        #{table_name}
+      #{join_line}
+      #{where_line.blank? ? "" : "WHERE"}
+        #{where_line}
+    SQL
+
+    result
+  end
+  
+  private
+  attr_writer :where_line, :where_vals, :join_line, :select_line
+  
+  def parse_all(results)
+    obj_class.parse_all(results)
+  end
+
+  def params_string(params)
+    params.keys.map { |key| "#{table_name}.#{key} = ?" }.join(" AND ")
+  end
+
+  def select_string(*params)
+    params.map { |column| "#{table_name}.#{column}" }.join(", ")
+  end
+end