bloc_record 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbb82ba853b6d915d4868349bbc263eaec960c6e
+  data.tar.gz: d94682d9e695a4860f9926adf8b684779f983acd
+SHA512:
+  metadata.gz: f9aae1a6d31f0d23edf0e16f51857859dc99806bd38a021e3bb26248f8bf103a2f23bb00c66b12a98c5f0c3739f8495e6d96eee2895ec25c8a4adb1fe09e5a9d
+  data.tar.gz: 354f204cd1abfb07cbf3589834d28fab8bec0388775a77e70f80931c8d499a3ce13bb8d1cdf521081315bb37c9b1a156a3e87763bf21151e158dae1c21bfa409

data/README.md

@@ -0,0 +1,28 @@
+(under construction)
+
+How to use:
+
+1) Clone and bundle install
+
+2) Use with [AddressBlocWithDB](https://github.com/Bloc/address-bloc-with-db). It's already got the database ready to go. Then write a driver file like:
+
+```ruby
+require_relative 'models/address_book'
+require_relative 'models/entry'
+require 'bloc_record'
+
+BlocRecord.connect_to("db/address_bloc.db")
+
+AddressBook.create(name: "My Addressbook")
+
+entry = Entry.new(name: "ben neely", phone: "208-350-8855", email: "Ben@bloc.io")
+entry.save!
+
+book = AddressBook.new
+book.name = "BLAAAA"
+book.save!
+
+
+p Entry.find(entry.id)
+p AddressBook.take(5)
+```

data/bloc_record.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name          = 'bloc_record'
+  s.version       = '0.0.0'
+  s.date          = '2015-12-02'
+  s.summary       = 'An ActiveRecord-esque ORM adaptor'
+  s.description   = 'An ActiveRecord-esque ORM adaptor'
+  s.authors       = ['Ben Neely']
+  s.email         = 'ben@bloc.io'
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+  s.homepage      =
+    'http://rubygems.org/gems/bloc_record'
+  s.license       = 'MIT'
+  s.add_runtime_dependency 'sqlite3', '~> 1.3'
+  s.add_runtime_dependency 'activesupport'
+end

data/lib/bloc_record/associations.rb

@@ -0,0 +1,39 @@
+require 'sqlite3'
+require 'active_support/inflector'
+
+module Associations
+  def has_many(association)
+    self.send(:define_method, association) do
+      rows = self.class.connection.execute <<-SQL
+        SELECT * FROM #{association.to_s.singularize}
+        WHERE #{self.class.table}_id = #{self.id}
+      SQL
+
+      class_name = association.to_s.classify.constantize
+      collection = BlocRecord::Collection.new
+
+      rows.each do |row|
+        collection << class_name.new(Hash[class_name.columns.zip(row)])
+      end
+      
+      collection
+    end
+  end
+
+  def belongs_to(association)
+    self.send(:define_method, association) do
+      association_name = association.to_s
+      row = self.class.connection.get_first_row <<-SQL
+        SELECT * FROM #{association_name}
+        WHERE id = #{self.send(association_name + "_id")}
+      SQL
+
+      class_name = association_name.classify.constantize
+
+      if row
+        data = Hash[class_name.columns.zip(row)]
+        class_name.new(data)
+      end
+    end
+  end
+end

data/lib/bloc_record/base.rb

@@ -0,0 +1,26 @@
+require 'bloc_record/utility'
+require 'bloc_record/schema'
+require 'bloc_record/persistence'
+require 'bloc_record/selection'
+require 'bloc_record/connection'
+require 'bloc_record/collection'
+require 'bloc_record/associations'
+
+module BlocRecord
+  class Base
+    include Persistence
+    extend Selection
+    extend Schema
+    extend Connection
+    extend Associations
+
+    def initialize(options={})
+      options = BlocRecord::Utility.convert_keys(options)
+
+      self.class.columns.each do |col|
+        self.class.send(:attr_accessor, col)
+        self.instance_variable_set("@#{col}", options[col])
+      end
+    end
+  end
+end

data/lib/bloc_record/collection.rb

@@ -0,0 +1,13 @@
+module BlocRecord
+  class Collection < Array
+    def update_all(updates)
+      ids = self.map(&:id)
+      self.any? ? self.first.class.update(ids, updates) : false
+    end
+
+    def group(*args)
+      ids = self.map(&:id)
+      self.any? ? self.first.class.group_by_ids(ids, args) : false
+    end
+  end
+end

data/lib/bloc_record/connection.rb

@@ -0,0 +1,7 @@
+require 'sqlite3'
+
+module Connection
+  def connection
+    @connection ||= SQLite3::Database.new(BlocRecord.databese_filename)
+  end
+end

data/lib/bloc_record/persistence.rb

@@ -0,0 +1,115 @@
+require 'sqlite3'
+require 'bloc_record/schema'
+
+module Persistence
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def create(attrs)
+      attrs = BlocRecord::Utility.convert_keys(attrs)
+      attrs.delete "id"
+      vals = attributes.map { |key| BlocRecord::Utility.sql_strings(attrs[key]) }
+
+      connection.execute(
+        "INSERT INTO #{table} (#{attributes.join(",")}) VALUES (?)",
+        vals.join(",")
+      )
+
+      data = Hash[attributes.zip attrs.values]
+      data["id"] = connection.execute("SELECT last_insert_rowid();")[0][0]
+      new(data)
+    end
+
+    def update(ids, updates)
+      updates = BlocRecord::Utility.convert_keys(updates)
+      updates.delete "id"
+      updates_array = updates.keys.map { |key| "#{key} = ?" }
+      if ids.class == Fixnum
+        where_clause = "WHERE id = #{ids};"
+      elsif ids.class == Array
+        where_clause = ids.empty? ? ";" : "WHERE id IN (#{ids.join(",")});"
+      else
+        where_clause = ";"
+      end
+
+      connection.execute(
+        "UPDATE #{table} SET #{updates_array.join(", ")} #{where_clause}",
+        updates.values
+      )
+
+      true
+    end
+
+    def update_all(updates)
+      update(nil, updates)
+    end
+
+    def destroy(*id)
+      if id.length > 1
+        where_clause = "WHERE id IN (#{id.join(",")});"
+      else
+        where_clause = "WHERE id = #{id.first};"
+      end
+
+      connection.execute <<-SQL
+        DELETE FROM #{table} #{where_clause}
+      SQL
+
+      true
+    end
+
+    def destroy_all(conditions_hash=nil)
+      if conditions_hash && !conditions_hash.empty?
+        conditions_hash = BlocRecord::Utility.convert_keys(conditions_hash)
+        conditions = conditions_hash.keys.map { |key| "#{key} = ?" }.join(" and ")
+
+        connection.execute(
+          "DELETE FROM #{table} WHERE #{conditions};",
+          conditions_hash.values
+        )
+      else
+        connection.execute <<-SQL
+          DELETE FROM #{table}
+        SQL
+      end
+
+      true
+    end
+  end
+
+  def save!
+    unless self.id
+      self.id = self.class.create(BlocRecord::Utility.instance_variables_to_hash(self)).id
+      BlocRecord::Utility.reload_obj(self)
+      return true
+    end
+
+    fields = self.class.attributes.map { |col| "#{col}=#{BlocRecord::Utility.sql_strings(self.instance_variable_get("@#{col}"))}" }.join(",")
+
+    self.class.connection.execute <<-SQL
+      UPDATE #{self.class.table}
+      SET #{fields}
+      WHERE id = #{self.id};
+    SQL
+
+    true
+  end
+
+  def save
+    self.save! rescue false
+  end
+
+  def update_attribute(attribute, value)
+    self.class.update(self.id, { attribute => value })
+  end
+
+  def update_attributes(updates)
+    self.class.update(self.id, updates)
+  end
+
+  def destroy
+    self.class.destroy(self.id)
+  end
+end

data/lib/bloc_record/schema.rb

@@ -0,0 +1,32 @@
+require 'sqlite3'
+require 'bloc_record/utility'
+
+module Schema
+  def table
+    BlocRecord::Utility.underscore(name)
+  end
+
+  def columns
+    schema.keys
+  end
+
+  def attributes
+    columns - ["id"]
+  end
+
+  def schema
+    unless @schema
+      @schema = {}
+      connection.table_info(table) do |col|
+        @schema[col["name"]] = col["type"]
+      end
+    end
+    @schema
+  end
+
+  def count
+    connection.execute(<<-SQL)[0][0]
+      SELECT COUNT(*) FROM #{table}
+    SQL
+  end
+end

data/lib/bloc_record/selection.rb

@@ -0,0 +1,199 @@
+require 'sqlite3'
+
+module Selection
+  def find(*ids)
+
+    if ids.length == 1
+      find_one(ids.first)
+    else
+      rows = connection.execute <<-SQL
+        SELECT #{columns.join ","} FROM #{table}
+        WHERE id IN (#{ids.join(",")});
+      SQL
+
+      rows_to_array(rows)
+    end
+  end
+
+  def find_one(id)
+    row = connection.get_first_row <<-SQL
+      SELECT #{columns.join ","} FROM #{table}
+      WHERE id = #{id};
+    SQL
+
+    init_object_from_row(row)
+  end
+
+  def find_by(attribute, value)
+    row = connection.get_first_row(
+      "SELECT #{columns.join ","} FROM #{table} WHERE #{attribute} = ?;",
+      BlocRecord::Utility.sql_strings(value)
+    )
+
+    init_object_from_row(row)
+  end
+
+  def take(num=1)
+    if num > 1
+      rows = connection.execute(
+        "SELECT #{columns.join ","} FROM #{table} ORDER BY random() LIMIT ?;",
+        num
+      )
+
+      rows_to_array(rows)
+    else
+      take_one
+    end
+  end
+
+  def take_one
+    row = connection.get_first_row <<-SQL
+      SELECT #{columns.join ","} FROM #{table}
+      ORDER BY random()
+      LIMIT 1;
+    SQL
+
+    init_object_from_row(row)
+  end
+
+  def first
+    row = connection.get_first_row <<-SQL
+      SELECT #{columns.join ","} FROM #{table}
+      ORDER BY id
+      ASC LIMIT 1;
+    SQL
+
+    init_object_from_row(row)
+  end
+
+  def last
+    row = connection.get_first_row <<-SQL
+      SELECT #{columns.join ","} FROM #{table}
+      ORDER BY id
+      DESC LIMIT 1;
+    SQL
+
+    init_object_from_row(row)
+  end
+
+  def all
+    rows = connection.execute <<-SQL
+      SELECT #{columns.join ","} FROM #{table};
+    SQL
+
+    rows_to_array(rows)
+  end
+
+  def where(*args)
+    if args.count > 1
+      expression = args.shift
+      params = args
+    else
+      case args.first
+      when String
+        expression = "?"
+        params = args.first
+      when Hash
+        params = BlocRecord::Utility.convert_keys(args.first)
+        expression = params.keys.map {|key| "#{key}=:#{key}"}.join(" and ")
+      end
+    end
+
+    sql = <<-SQL
+      SELECT #{columns.join ","} FROM #{table}
+      WHERE #{expression};
+    SQL
+
+    rows = connection.execute(sql, params)
+    rows_to_array(rows)
+  end
+
+  def order(*args)
+    if args.count > 1
+      order = args.join(",")
+    else
+      order = args.first.to_s
+    end
+    rows = connection.execute(
+      "SELECT * FROM #{table} ORDER BY ?;",
+      order
+    )
+    rows_to_array(rows)
+  end
+
+  def join(*args)
+    if args.count > 1
+      joins = args.map { |arg| "INNER JOIN #{arg} ON #{arg}.#{table}_id = #{table}.id"}.join(" ")
+      rows = connection.execute <<-SQL
+        SELECT * FROM #{table} #{joins}
+      SQL
+    else
+      case args.first
+      when String
+        rows = connection.execute <<-SQL
+          SELECT * FROM #{table} #{BlocRecord::Utility.sql_strings(args.first)};
+        SQL
+      when Symbol
+        rows = connection.execute <<-SQL
+          SELECT * FROM #{table}
+          INNER JOIN #{args.first} ON #{args.first}.#{table}_id = #{table}.id
+        SQL
+      end
+    end
+    rows_to_array(rows)
+  end
+
+  def select(*fields)
+    rows = connection.execute(
+      "SELECT ? FROM #{table};",
+      fields.join(", ")
+    )
+    collection = BlocRecord::Collection.new
+    rows.each { |row| collection << new(Hash[fields.zip(row)]) }
+    collection
+  end
+
+  def limit(value, offset=0)
+    rows = connection.execute(
+      "SELECT * FROM #{table} LIMIT ? OFFSET ?;",
+      [value, offset]
+    )
+    rows_to_array(rows)
+  end
+
+  def group(*args)
+    group_by_ids(nil, args)
+  end
+
+  def group_by_ids(ids, args)
+    if args.count > 1
+      conditions = args.join(", ")
+    else
+      conditions = args.first
+    end
+
+    where_clause = ids.nil? ? "" : "WHERE id IN (#{ids.join(",")})"
+
+    rows = connection.execute(
+      "SELECT * FROM #{table} #{where_clause} GROUP BY ?;",
+      conditions.to_s
+    )
+
+    rows_to_array(rows)
+  end
+
+  private
+
+  def init_object_from_row(row)
+    if row
+      data = Hash[columns.zip(row)]
+      new(data)
+    end
+  end
+
+  def rows_to_array(rows)
+    collection = BlocRecord::Collection.new
+    rows.each { |row| collection << new(Hash[columns.zip(row)]) }
+    collection
+  end
+end

data/lib/bloc_record/utility.rb

@@ -0,0 +1,39 @@
+module BlocRecord
+  module Utility
+    extend self
+
+    def underscore(camel_cased_word)
+       string = camel_cased_word.gsub(/::/, '/')
+       string.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+       string.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+       string.tr!("-", "_")
+       string.downcase
+    end
+    def sql_strings(value)
+      case value
+      when String
+        "'#{value}'"
+      when Numeric
+        value.to_s
+      else
+        "null"
+      end
+    end
+
+    def convert_keys(options)
+      options.keys.each {|k| options[k.to_s] = options.delete(k) if k.kind_of?(Symbol)}
+      options
+    end
+
+    def instance_variables_to_hash(obj)
+      Hash[obj.instance_variables.map{ |var| ["#{var.to_s.delete('@')}", obj.instance_variable_get(var.to_s)]}]
+    end
+
+    def reload_obj(dirty_obj)
+      persisted_obj = dirty_obj.class.find_one(dirty_obj.id)
+      dirty_obj.instance_variables.each do |instance_variable|
+        dirty_obj.instance_variable_set(instance_variable, persisted_obj.instance_variable_get(instance_variable))
+      end
+    end
+  end
+end

data/lib/bloc_record.rb

@@ -0,0 +1,9 @@
+module BlocRecord
+  def self.connect_to(filename)
+    @database_filename = filename
+  end
+
+  def self.databese_filename
+    @database_filename
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: bloc_record
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Ben Neely
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An ActiveRecord-esque ORM adaptor
+email: ben@bloc.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bloc_record.gemspec
+- lib/bloc_record.rb
+- lib/bloc_record/associations.rb
+- lib/bloc_record/base.rb
+- lib/bloc_record/collection.rb
+- lib/bloc_record/connection.rb
+- lib/bloc_record/persistence.rb
+- lib/bloc_record/schema.rb
+- lib/bloc_record/selection.rb
+- lib/bloc_record/utility.rb
+homepage: http://rubygems.org/gems/bloc_record
+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.4.6
+signing_key: 
+specification_version: 4
+summary: An ActiveRecord-esque ORM adaptor
+test_files: []