whales_orm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6c084707f2e641cd075958da2ef02421455542ec
+  data.tar.gz: 7eabd7d7e6bbc2c94731088fd77220ab099123f8
+SHA512:
+  metadata.gz: 4bb583a9beb51730b671a3d84148602229debb0793542eec35758f8f6844a75d90f2568ac7f589b3ef19a72b9a457f226e69fae2d6902e8e930992915b25c579
+  data.tar.gz: cda5a993b27bb98a7114e9a00647588bbcaf15dd3e40deebbae6c6e0094e404d6df0acd56e5bd0874db129ee30ac270a70319c92134b197fb0346422a9231c83

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem "sqlite3"
+gem "activesupport"

data/Gemfile.lock

@@ -0,0 +1,89 @@
+PATH
+  remote: .
+  specs:
+    whales_orm (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.4)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.6.4)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    listen (3.0.5)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    minitest (5.8.3)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rb-fsevent (0.9.6)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    shellany (0.0.1)
+    slop (3.6.0)
+    sqlite3 (1.3.11)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bundler (~> 1.10)
+  guard
+  guard-rspec
+  pry
+  rake (~> 10.0)
+  rspec
+  sqlite3
+  whales_orm!
+
+BUNDLED WITH
+   1.10.6

data/Guardfile

@@ -0,0 +1,11 @@
+guard :rspec, cmd: "bundle exec rspec" do
+  # watch /lib/ files
+  watch(%r{^lib/(.+).rb$}) do |m|
+    "spec/#{m[1]}_spec.rb"
+  end
+
+  # watch /spec/ files
+  watch(%r{^spec/(.+).rb$}) do |m|
+    "spec/#{m[1]}.rb"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 William Horton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'nested']
+end
+
+task :default => :spec

data/lib/associatable.rb

@@ -0,0 +1,118 @@
+module WhalesORM
+
+  class AssocOptions
+    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 < WhalesORM::AssocOptions
+    def initialize(name, options = {})
+      options.each do |k, v|
+        send("#{k}=", v)
+      end
+      @primary_key ||= :id
+      @foreign_key ||= "#{name}_id".to_sym
+      @class_name ||= name.to_s.camelcase
+    end
+
+  end
+
+  class HasManyOptions < WhalesORM::AssocOptions
+    def initialize(name, self_class_name, options = {})
+      options.each do |k, v|
+        send("#{k}=", v)
+      end
+      @primary_key ||= :id
+      @foreign_key ||= "#{self_class_name.underscore}_id".to_sym
+      @class_name ||= name.to_s.singularize.camelcase
+    end
+  end
+
+  module Associatable
+    def belongs_to(name, options = {})
+      opts = WhalesORM::BelongsToOptions.new(name.to_s, options)
+
+      define_method(name) do
+        foreign_key = send(opts.foreign_key)
+        opts.model_class.where(opts.primary_key => foreign_key).first
+      end
+
+      assoc_options[name] = opts
+    end
+
+    def has_many(name, options = {})
+      if options[:through]
+        has_one_or_many_through(name, options[:through], options[:source])
+      else
+        opts = WhalesORM::HasManyOptions.new(name.to_s, self.to_s, options)
+
+        define_method(name) do
+          primary_key_value = send(opts.primary_key)
+          where_clause = {opts.foreign_key => primary_key_value}
+          opts.model_class.where(where_clause)
+        end
+
+        assoc_options[name] = opts
+      end
+    end
+
+    def assoc_options
+      @assoc_options ||= {}
+    end
+
+    def has_one_through(name, through_name, source_name)
+      # unless [through_options, source_options].all? { |opt| opt.is_a?(BelongsToOptions) }
+      #   raise "has_one_through must use two belongs_to relations!"
+      # end
+
+        has_one_or_many_through(name, through_name, source_name, one: true)
+    end
+
+    private
+
+    def has_one_or_many_through(name, through_name, source_name, type = {})
+      keywords = ["primary", "foreign"]
+      keywords.sort! if type[:one]
+
+      define_method(name) do
+        through_options = self.class.assoc_options[through_name]
+        source_options = through_options.model_class.assoc_options[source_name]
+        opts = [through_options, source_options]
+
+        key_value = send(through_options.send("#{keywords[0]}_key"))
+        key_name = through_options.send("#{keywords[1]}_key")
+        src_table = source_options.table_name
+        thr_table = through_options.table_name
+
+        results = DBConnection.execute(<<-SQL, key_value)
+          SELECT
+            #{src_table}.*
+          FROM
+            #{src_table}
+          JOIN
+            #{thr_table}
+          ON
+            #{thr_table}.#{source_options.foreign_key} = #{src_table}.#{source_options.primary_key}
+          WHERE
+            #{thr_table}.#{key_name} = ?
+        SQL
+
+        return nil if results.nil? || results.empty?
+        send_opts = (type[:one] ? [:new, results.first] : [:parse_all, results])
+        source_options.model_class.send(*send_opts)
+      end
+    end
+  end
+
+end

data/lib/base.rb

@@ -0,0 +1,144 @@
+require_relative 'db_connection'
+require_relative 'query_methods'
+require_relative 'include_relation'
+require_relative 'relation'
+require_relative 'associatable'
+
+require 'active_support/inflector'
+
+module WhalesORM
+  class Base
+    extend WhalesORM::QueryMethods
+    extend WhalesORM::Associatable
+
+    def self.method_missing(method, *args)
+      method = method.to_s
+      if method.start_with?("find_by")
+        columns = method[8..-1].split("_and_")
+        opts = {}
+        columns.each_with_index do |col, i|
+          opts[col] = args[i]
+        end
+        self.where(opts)
+      else
+        super
+      end
+    end
+
+    def self.columns
+      @columns ||= DBConnection.execute2("SELECT * FROM #{table_name} LIMIT 1")[0].map(&:to_sym)
+    end
+
+    def self.finalize!
+      columns.each do |col|
+        define_method(col) do
+          attributes[col]
+        end
+
+        define_method("#{col}=".to_sym) do |value|
+          attributes[col] = value
+        end
+
+      end
+    end
+
+    def self.table_name=(table_name)
+      @table_name = table_name
+    end
+
+    def self.table_name
+      @table_name ||= self.to_s.tableize
+    end
+
+    def self.all
+      results = DBConnection.execute(<<-SQL)
+        SELECT
+          #{table_name}.*
+        FROM
+          #{table_name}
+      SQL
+
+      parse_all(results)
+    end
+
+    def self.parse_all(results)
+      results.map { |result| self.new(result) }
+    end
+
+    def self.find(id)
+      result = DBConnection.instance.get_first_row(<<-SQL, id: id)
+        SELECT
+          #{table_name}.*
+        FROM
+          #{table_name}
+        WHERE
+          id = :id
+      SQL
+
+      result ? self.new(result) : nil
+    end
+
+    def initialize(params = {})
+      params.each do |k, v|
+        attr_name = k.to_sym
+
+        send("#{attr_name}=", v)
+      end
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def attribute_values
+      self.class.columns.map { |attr_name| send(attr_name) }
+    end
+
+    def insert
+      col_names = self.class.columns.drop(1).join(',')
+      question_marks = (["?"] * (self.class.columns.length - 1)).join(',')
+
+      DBConnection.execute(<<-SQL, *(attribute_values.drop(1)))
+        INSERT INTO
+          #{self.class.table_name} (#{col_names})
+        VALUES
+          (#{question_marks});
+      SQL
+
+      self.id = DBConnection.last_insert_row_id
+      self
+    end
+
+    def update
+      set_line = self.class.columns.map { |attr_name| "#{attr_name} = ?" }
+      set_line = set_line.join(', ')
+
+      DBConnection.execute(<<-SQL, *attribute_values, id)
+        UPDATE
+          #{self.class.table_name}
+        SET
+          #{set_line}
+        WHERE
+          id = ?
+      SQL
+
+      self
+    end
+
+    def save
+      id.nil? ? insert : update
+    end
+
+    def destroy
+      DBConnection.execute(<<-SQL, id)
+        DELETE FROM
+          #{self.class.table_name}
+        WHERE
+          id = ?
+      SQL
+
+      self
+    end
+
+  end
+end

data/lib/db_connection.rb

@@ -0,0 +1,46 @@
+require 'sqlite3'
+
+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 '#{DB_FILE}'",
+      "cat '#{SQL_FILE}' | sqlite3 '#{DB_FILE}'"
+    ]
+
+    commands.each { |command| `#{command}` }
+    DBConnection.open(DB_FILE)
+  end
+
+  def self.instance
+    DBConnection.open(DB_FILE) if @db.nil?
+
+    @db
+  end
+
+  def self.execute(*args)
+
+    instance.execute(*args)
+  end
+
+  def self.execute2(*args)
+
+    instance.execute2(*args)
+  end
+
+  def self.last_insert_row_id
+    instance.last_insert_row_id
+  end
+
+  private
+
+  def initialize(db_file_name)
+  end
+end

data/lib/include_relation.rb

@@ -0,0 +1,20 @@
+module WhalesORM
+  class IncludeRelation < BasicObject
+    def initialize(class_name, sym_to_include, association)
+      @query = <<-SQL
+        SELECT
+          #{class_name.table_name}.*
+        FROM
+          #{class_name.table_name}
+        LEFT OUTER JOIN
+          #{association.table_name}
+        ON
+          #{class_name.table_name}.#{association.primary_key} = #{association.table_name}.#{association.foreign_key}
+      SQL
+    end
+
+    def execute
+
+    end
+  end
+end

data/lib/query_methods.rb

@@ -0,0 +1,14 @@
+module WhalesORM
+  module QueryMethods
+    def where(params)
+      WhalesORM::Relation.new(params, self)
+    end
+
+    def includes(sym_to_include)
+      association = self.assoc_options[sym_to_include]
+      if association
+        WhalesORM::IncludeRelation.new(self, sym_to_include, association)
+      end
+    end
+  end
+end

data/lib/relation.rb

@@ -0,0 +1,42 @@
+require_relative './db_connection.rb'
+
+module WhalesORM
+  class Relation < BasicObject
+
+    def initialize(params, class_name)
+      @params = params
+      @class_name = class_name
+    end
+
+    def where(params)
+      @params.merge(params)
+    end
+
+    def where_line
+      @params.keys.map { |key| "#{key} = ?" }.join(" AND ")
+    end
+
+    def method_missing(method, *args, &blk)
+      results = self.execute
+      results.send(method, *args, &blk)
+    end
+
+    def load
+      execute
+    end
+
+    def execute
+      query = <<-SQL
+        SELECT
+          *
+        FROM
+          #{@class_name.table_name}
+        WHERE
+          #{where_line}
+      SQL
+
+      results = ::DBConnection.execute(query, *@params.values)
+      @class_name.parse_all(results)
+    end
+  end
+end

data/lib/whales_orm/version.rb

@@ -0,0 +1,3 @@
+module WhalesORM
+  VERSION = "0.1.0"
+end

data/lib/whales_orm.rb

@@ -0,0 +1 @@
+require_relative 'base'

data/test_db/cats.sql

@@ -0,0 +1,70 @@
+CREATE TABLE cats (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  owner_id INTEGER,
+
+  FOREIGN KEY(owner_id) REFERENCES human(id)
+);
+
+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 houses (
+  id INTEGER PRIMARY KEY,
+  address VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE dogs (
+  id INTEGER PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE walkings (
+  id INTEGER PRIMARY KEY,
+  dog_id INTEGER NOT NULL,
+  human_id INTEGER NOT NULL
+);
+
+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
+  dogs (id, name)
+VALUES
+  (1, "Rover"),
+  (2, "Fido"),
+  (3, "Rex"),
+  (4, "Phoebe");
+
+INSERT INTO
+  walkings (id, dog_id, human_id)
+VALUES
+  (1, 1, 1),
+  (2, 2, 1),
+  (3, 3, 1),
+  (4, 1, 2);

data/whales_orm.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'whales_orm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "whales_orm"
+  spec.version       = WhalesORM::VERSION
+  spec.authors       = ["William Horton"]
+  spec.email         = ["wdt.horton@gmail.com"]
+  spec.summary       = %q{The ORM for the Whales Framework}
+  spec.homepage      = "https://github.com/wdhorton/whales/tree/master/whales_actions"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: whales_orm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- William Horton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- wdt.horton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/associatable.rb
+- lib/base.rb
+- lib/db_connection.rb
+- lib/include_relation.rb
+- lib/query_methods.rb
+- lib/relation.rb
+- lib/whales_orm.rb
+- lib/whales_orm/version.rb
+- test_db/cats.db
+- test_db/cats.sql
+- whales_orm.gemspec
+homepage: https://github.com/wdhorton/whales/tree/master/whales_actions
+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.5.0
+signing_key: 
+specification_version: 4
+summary: The ORM for the Whales Framework
+test_files: []
+has_rdoc: