wormy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 44ab7bc1fb2372bd0e89215a9f65bcd8dbd82288
+  data.tar.gz: a2adef7a24cf3bc38d12162d6cbf2680fc663a3e
+SHA512:
+  metadata.gz: 53e439ae8c3f49775e1a2ce39b2d1642ee3a8343352bc2792f7dd5256582d6e1bbc5885e159b01047a8973fe812a7d6f71d55cd1c399a61ad45020b879361775
+  data.tar.gz: '0797403ef2c5263d1d052ec4dbf504e50ebcae1b7fbe9fa72ccb10959ae9e18ec428498a6296f468416a49db9d3333bb3f53bbfc01c444ac68997a5ec542f8b2'

data/README.md

@@ -0,0 +1,63 @@
+# WORMY 🐛
+A lightweight Object-Relational Mapping (ORM) library for Ruby. Allows you to keep code DRY and easily perform database operations in an object-oriented manner.
+
+## Demo
+1. From the demo directory of this repo, open `pry` or `irb` in the console
+2. `load 'hp_demo.rb'`
+3. Use `hp_demo.rb` and the API section below as a reference to play around with the data
+
+## How to Use WORMY
+* Navigate to the folder in your directory where you would like your .db database file to be saved.
+* If you have an existing database.rb file you need to rewrite, run `rm database.db`
+* Run `cat '{YOUR_SQL_FILE_NAME}' | sqlite3 'database.db'` (replacing {YOUR_SQL_FILE_NAME} with your own .sql file)
+* Then, in your project, open a connection with `DBConnection.open('database.db')`
+
+## Libraries
+* SQLite3
+* ActiveSupport::Inflector
+
+## API
+Associations between models are defined by simple class methods, like so:
+```
+class Pet < WORMY::Base
+  belongs_to :owner,
+    class_name: "Wizard"
+
+  has_one_through :house, :owner, :house
+
+  finalize!
+end
+```
+
+Querying and updating the database is made easy with WORMY::Base's methods like:
+* `::all`
+* `::count`
+* `::destroy_all`
+* `::find`
+* `::first`
+* `::last`
+* `::where`
+* `#create`
+* `#save`
+* `#destroy`
+
+Perform custom model validations by adding a call to `validates` in your subclass definition:
+```
+class House < WORMY::Base
+  has_many :wizards
+  has_many_through :pets, :wizards, :pets
+  validates :house_name
+
+  def house_name
+    ["Gryffindor", "Slytherin", "Ravenclaw", "Hufflepuff"].include?(self.name)
+  end
+
+  finalize!
+end
+```
+
+
+## About WORMY
+WORMY opens a connection to a provided database file by instantiating a singleton of SQLite3::Database via DBConnection. DBConnection uses native SQLite3::Database methods (`execute`, `execute2`, `last_insert_row_id`) to allow WORMY to perform complex SQL queries using heredocs. The `Searchable` and `Associatable` modules extend WORMY::Base to provide an intuitive API.
+
+WORMY emphasizes convention over configuration by setting sensible defaults for associations, but also allows for easy overrides if desired.

data/lib/wormy.rb

@@ -0,0 +1,164 @@
+require 'active_support/inflector'
+require 'wormy/db_connection'
+require 'wormy/searchable'
+require 'wormy/associatable'
+
+module WORMY
+  class Base
+    extend Searchable
+    extend Associatable
+
+    def self.all
+      results = DBConnection.execute(<<-SQL)
+        SELECT
+          *
+        FROM
+          #{table_name}
+      SQL
+
+      parse_all(results)
+    end
+
+    def self.columns
+      @columns ||= DBConnection.execute2(<<-SQL)
+        SELECT
+          *
+        FROM
+          #{self.table_name}
+      SQL
+      .first.map(&:to_sym)
+    end
+
+    def self.count(params)
+      where(params).count
+    end
+
+    def self.destroy_all(params)
+      self.where(params).each(&:destroy)
+    end
+
+    def self.finalize!
+      # make sure to call finalize! at the end of any class that inherits from WORMY::Base
+      columns.each do |col|
+        define_method(col) { attributes[col] }
+        define_method("#{col}=") { |new_attr| attributes[col] = new_attr }
+      end
+    end
+
+    def self.find(id)
+      result = DBConnection.execute(<<-SQL, id)
+        SELECT
+          *
+        FROM
+          #{table_name}
+        WHERE
+          #{table_name}.id = ?
+      SQL
+
+      parse_all(result).first
+    end
+
+    def self.first
+      all.first
+    end
+
+    def self.last
+      all.last
+    end
+
+    def self.parse_all(results)
+      # create new instances of self from the query results
+      results.map { |options| self.new(options) }
+    end
+
+    def self.table_name
+      @table_name ||= self.to_s.tableize
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.validates(*methods)
+      @validations = methods
+    end
+
+    def self.validations
+      @validations ||= []
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      # look at all the columns and get the values for this instance
+      self.class.columns.map { |col| self.send(col) }
+    end
+
+    def initialize(params = {})
+      params.each do |key, value|
+        raise "unknown attribute '#{key}'" unless self.class.columns.include?(key.to_sym)
+        send("#{key}=", value)
+      end
+    end
+
+    def destroy
+      if self.class.find(id)
+        DBConnection.execute(<<-SQL)
+          DELETE
+          FROM
+            #{self.class.table_name}
+          WHERE
+            id = #{id}
+        SQL
+
+        self
+      end
+    end
+
+    def insert
+      col_names = self.class.columns.join(", ")
+      question_marks = ["?"] * self.class.columns.count
+
+      DBConnection.execute(<<-SQL, *attribute_values)
+        INSERT INTO
+          #{self.class.table_name} (#{col_names})
+        VALUES
+          (#{question_marks.join(',')})
+      SQL
+
+      self.id = DBConnection.last_insert_row_id
+    end
+
+    def save
+      self.class.validations.each do |method|
+        raise "Validation error" unless self.send(method)
+      end
+
+      # if it alredy exists then update it, otherwise insert it
+      id ? update : insert
+    end
+
+    def update
+      set = self.class.columns.map { |col_name| "#{col_name} = ?" }.drop(1).join(", ")
+
+      DBConnection.execute(<<-SQL, *attribute_values.rotate)
+        UPDATE
+          #{self.class.table_name}
+        SET
+          #{set}
+        WHERE
+          id = ?
+      SQL
+    end
+
+    def valid?
+      self.class.validations.each do |method|
+        return false unless self.send(method)
+      end
+
+      true
+    end
+  end
+end

data/lib/wormy/associatable.rb

@@ -0,0 +1,113 @@
+require_relative 'searchable'
+require 'active_support/inflector'
+
+class AssociationOptions
+  attr_accessor(
+    :foreign_key,
+    :class_name,
+    :primary_key
+  )
+
+  def model_class
+    class_name.constantize
+  end
+
+  def table_name
+    model_class.table_name
+  end
+end
+
+class BelongsToOptions < AssociationOptions
+  def initialize(name, options = {})
+    @foreign_key = options[:foreign_key] || "#{name.to_s.underscore}_id".to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.camelcase
+  end
+end
+
+class HasManyOptions < AssociationOptions
+  def initialize(name, self_class_name, options = {})
+    @foreign_key = options[:foreign_key] || "#{self_class_name.to_s.underscore}_id".to_sym
+    @primary_key = options[:primary_key] || :id
+    @class_name = options[:class_name] || name.to_s.singularize.camelcase
+  end
+end
+
+module Associatable
+  def association_options
+    @association_options ||= {}
+  end
+
+  def belongs_to(name, options = {})
+    options = BelongsToOptions.new(name, options)
+
+    define_method(name) do
+      key_value = self.send(options.foreign_key)
+      options.model_class.where(options.primary_key => key_value).first
+    end
+
+    self.association_options[name] = options
+  end
+
+  def has_many(name, options = {})
+    options = HasManyOptions.new(name, self, options)
+
+    define_method(name) do
+      options.model_class.where(options.foreign_key => self.id)
+    end
+
+    self.association_options[name] = options
+  end
+
+  def has_one_through(association_name, through:, source:)
+    define_method(association_name) do
+      through_options = self.class.association_options[through]
+      source_options = through_options.model_class.association_options[source]
+
+      source_table = source_options.table_name
+      through_table = through_options.table_name
+      key_value = self.send(through_options.foreign_key)
+
+      results = WORMY::DBConnection.execute(<<-SQL, key_value)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{through_table}.#{source_options.foreign_key} = #{source_table}.#{source_options.primary_key}
+        WHERE
+          #{through_table}.#{through_options.primary_key} = ?
+      SQL
+
+      source_options.model_class.parse_all(results).first
+    end
+  end
+
+  def has_many_through(association_name, through:, source:)
+    define_method(association_name) do
+      through_options = self.class.association_options[through]
+      source_options = through_options.model_class.association_options[source]
+
+      source_table = source_options.table_name
+      through_table = through_options.table_name
+
+      results = WORMY::DBConnection.execute(<<-SQL, self.id)
+        SELECT
+          #{source_table}.*
+        FROM
+          #{through_table}
+        JOIN
+          #{source_table}
+        ON
+          #{source_table}.#{source_options.foreign_key} = #{through_table}.#{source_options.primary_key}
+        WHERE
+          #{through_table}.#{through_options.foreign_key} = ?
+      SQL
+
+      source_options.model_class.parse_all(results)
+    end
+  end
+
+end

data/lib/wormy/db_connection.rb

@@ -0,0 +1,67 @@
+require 'sqlite3'
+
+PRINT_QUERIES = ENV['PRINT_QUERIES'] == 'true'
+ROOT_FOLDER = File.join(File.dirname(__FILE__), '..')
+
+module WORMY
+  class DBConnection
+    attr_accessor :seed_file, :db_file
+
+    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 '#{DB_FILE}'",
+        "cat '#{SQL_FILE}' | sqlite3 '#{DB_FILE}'"
+      ]
+
+      commands.each { |command| `#{command}` }
+      DBConnection.open(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
+
+
+    def configure(seed_file, db_file)
+      @seed_file = seed_file
+      @db_file = db_file
+    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
+end

data/lib/wormy/searchable.rb

@@ -0,0 +1,24 @@
+require_relative 'db_connection'
+require 'wormy'
+
+module Searchable
+  def where(params = {})
+    return all if params == {}
+
+    search_results = []
+    where_line = params.keys.map { |key| "#{key} = ?" }.join(" AND ")
+
+    results = WORMY::DBConnection.execute(<<-SQL, *params.values)
+      SELECT
+        *
+      FROM
+        #{table_name}
+      WHERE
+        #{where_line}
+    SQL
+
+    results.each { |result| search_results << self.new(result) }
+
+    search_results
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: wormy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mallory Bulkley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-04 00:00:00.000000000 Z
+dependencies: []
+description: A lightweight Object-Relational Mapping (ORM) library for Ruby. Allows
+  you to keep code DRY and easily perform database operations in an object-oriented
+  manner.
+email: mallorybulkley@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/wormy.rb
+- lib/wormy/associatable.rb
+- lib/wormy/db_connection.rb
+- lib/wormy/searchable.rb
+homepage: https://github.com/mallorybulkley/WORM
+licenses:
+- MIT
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Lightweight Ruby ORM
+test_files: []