sentiql 0.1.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+*.swp
+*~
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in sentiql.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,52 @@
+require 'bundler'
+require 'yaml'
+require 'logger'
+require 'active_record'
+
+Bundler::GemHelper.install_tasks
+
+
+MIGRATIONS_DIR = 'db/migrate'
+APP_PATH = File.join(File.dirname(__FILE__))
+
+namespace :db do
+
+  task :environment do
+    ENV['RACK_ENV'] ||= 'development'
+    @config = YAML.load_file('config/database.yml')[ENV['RACK_ENV']]
+    ActiveRecord::Base.establish_connection @config
+  end
+
+  desc 'Migrate the database (options: VERSION=x, VERBOSE=false).'
+  task :migrate => :environment do
+    ActiveRecord::Migration.verbose = true
+    ActiveRecord::Migrator.migrate MIGRATIONS_DIR, ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+  end
+
+  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n).'
+  task :rollback => :configure_connection do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    ActiveRecord::Migrator.rollback MIGRATIONS_DIR, step
+  end
+
+  desc "Retrieves the current schema version number"
+  task :version => :configure_connection do
+    puts "Current version: #{ActiveRecord::Migrator.current_version}"
+  end
+
+  namespace :test do
+
+    desc "Creates testing database by cloning main database"
+    task :load do
+      @config = YAML.load_file('config/database.yml')['test']
+      ActiveRecord::Base.establish_connection @config
+      tables = ActiveRecord::Base.connection.select_all("SHOW TABLES").map { |m| m.values.first }
+      tables.each do |table_name|
+        ActiveRecord::Base::connection.execute("DROP TABLE #{table_name}")
+      end
+      ActiveRecord::Migration.verbose = true
+      ActiveRecord::Migrator.migrate MIGRATIONS_DIR
+    end
+  end
+
+end

data/config/database.yml

@@ -0,0 +1,7 @@
+test:
+  adapter: mysql2
+  encoding: utf8
+  database: sentiql_test
+  username: root
+  password: salt
+  host: localhost 

data/db/migrate/20110515_test_tables.rb

@@ -0,0 +1,24 @@
+class TestTables < ActiveRecord::Migration
+
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.string :full_name
+      t.string :email
+      t.string :crypted_password
+      t.string :salt
+
+      t.timestamps
+    end
+
+    create_table :after_save do |t|
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :users
+    drop_table :after_save
+  end
+
+end

data/lib/sentiql/version.rb

@@ -0,0 +1,3 @@
+module SentiQL
+  VERSION = "0.1.2"
+end

data/lib/sentiql.rb

@@ -0,0 +1,136 @@
+require "mysql2"
+
+module SentiQL
+
+  class Base
+    attr_accessor :attrs, :errors
+
+    def initialize attrs={}
+      @attrs = {}
+      attrs.each_pair do |key, value|
+        @attrs[key.to_sym] = value
+      end
+    end
+
+    def [] key
+      @attrs ||= {}
+      @attrs[key]
+    end
+
+    def []=(key, value)
+      @attrs ||= {}
+      @attrs[key] = value
+    end
+
+
+    def save
+
+      filter_with :before_save_filters
+
+      if @attrs[:id]
+        i = @attrs.select { |k| self.class.schema.include?(k) }     
+        values = i.keys.map { |k| @attrs[k] }
+        values << @attrs[:id]
+
+        return self unless valid?
+
+        SentiQL::Base.execute "UPDATE #{self.class.table} SET #{i.keys.map{|m| "#{m.to_s}=?"}.join(",")} WHERE id=?", values
+
+      else
+
+        filter_with :before_create_filters
+
+        i = @attrs.select { |k| self.class.schema.include?(k) }
+        values = i.keys.map { |k| @attrs[k] }
+
+        return self unless valid?
+
+        id = SentiQL::Base.insert "INSERT INTO #{self.class.table} (#{i.keys.map{|k| k.to_s}.join(",")}) VALUES (#{i.map{|k| k="?"}.join(",")})", values
+        @attrs[:id] = id
+        
+        filter_with :after_create_filters
+      end
+      
+      filter_with :after_save_filters
+
+      return self
+    end
+
+    def filter_with filter
+      self.class.send(filter).each do |f|
+        self.send f
+      end
+    end
+
+    def method_missing method_id, *args
+      if @attrs.has_key? method_id
+        return @attrs[method_id.to_sym]
+      else
+        super
+      end
+    end
+
+    def valid?; true; end
+      
+    class << self
+      def connection; @@connection; end
+      def connection=(value); @@connection = value; end
+      
+      def set_schema *args; @schema = args; end
+      def schema; @schema; end
+
+      def before_save *args; @before_save_filters = args; end 
+      def before_save_filters; @before_save_filters ||={} ; end
+      def before_create *args; @before_create_filters = args; end 
+      def before_create_filters; @before_create_filters ||={}; end
+      def after_create *args; @after_create_filters = args; end 
+      def after_create_filters; @after_create_filters ||={}; end
+      def after_save *args; @after_save_filters= args; end 
+      def after_save_filters; @after_save_filters ||={}; end
+
+      def set_table name; @table= name.to_s; end
+      def table; @table.to_sym; end
+
+
+      def create hash
+        obj = self.new hash
+        return obj.save
+      end
+
+      def find_by hash
+        field_name = hash.keys.first.to_s
+        value = hash.values.first
+        r = first "SELECT * FROM #{self.table} WHERE #{field_name}=? LIMIT 1", [value]
+        return r ? self.new(r) : nil
+      end
+
+      def first sql, args=[]
+        results = self.execute sql, args
+        return results.nil? ? nil : results.first
+      end
+
+      def insert sql, args=[]
+        execute sql, args
+        connection.last_id
+      end
+
+      def execute sql, args=[]
+        esced = args.map { |v| connection.escape(v.to_s) }
+        ix = 0
+        escq = sql.gsub(/\?/) do |m|
+          raise Mysql2::Error.new("Not enough arguments for prepared statement") if ix >= esced.count
+          val = esced[ix]
+          ix += 1
+          "'#{val}'"
+        end
+        raise Mysql2::Error.new("Too many arguments for prepared statement (required: #{ix}, passed: #{esced.count})") if ix < esced.count
+        return connection.query escq     
+      end
+
+      alias :all :execute
+
+    end
+
+  end
+
+end

data/sentiql.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sentiql/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sentiql"
+  s.version     = SentiQL::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Martynas Miliauskas"]
+  s.email       = ["miliauskas@facebook.com"]
+  s.homepage    = ""
+  s.summary     = %q{A minimalistic Ruby wrapper for MySQL}
+  s.description = %q{This is a work in progress. SentiQL promotes use of SQL for data selection, OM for CUD operations and being as lean as possible.}
+
+  s.rubyforge_project = "sentiql"
+
+  s.add_runtime_dependency 'mysql2', '< 0.3'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'activerecord', '~> 3.0.5'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/sentiql_spec.rb

@@ -0,0 +1,134 @@
+require_relative 'spec_helper'
+require 'date'
+
+class User < SentiQL::Base
+
+  set_schema :name, :full_name, :email, :crypted_password, :salt, :created_at, :updated_at
+  set_table :users
+
+  before_save :set_updated_at
+  before_create :set_created_at
+  after_create :touch_after_create
+  after_save :touch_after_save
+
+  class << self
+
+    def count
+      r = self.first "SELECT count(*) AS count FROM #{table}"
+      r[:count]
+    end
+
+  end
+
+  protected
+
+  def set_updated_at
+    self[:updated_at] = Time.now
+  end
+
+  def set_created_at
+    self[:created_at] = Time.now
+  end
+
+  def touch_after_create
+    self[:after_create_touched] = Time.now
+  end
+
+  def touch_after_save
+    self[:after_save_touched] = Time.now
+  end
+
+end
+
+
+describe SentiQL::Base do
+
+  describe User do
+
+    describe '.create' do
+      it 'creates a new record in DB' do
+        lambda { User.create :name=>'Natalie' }.should change(User, :count).by(1)
+      end
+
+      it 'returns and instance of User' do
+        u = User.create :name=>'Natalie'
+        u.should be_an_instance_of(User)
+      end
+
+      it 'sets :id of record in DB to an instance' do
+        u = User.create :name=>'Natalie'
+        u[:id].should_not be_nil
+      end
+    end
+
+    describe '.save' do
+      it "creates new record if instance is new" do
+        u = User.new :name=>'Natalie'
+        lambda{ u.save }.should change(User, :count).by(1)
+      end
+      
+      it "updates existing record if instance was already created" do
+        u = User.new :name=>'Natalie'
+        u.save
+        u[:full_name] = 'Natalie Portman'
+        lambda { u.save }.should_not change(User, :count)
+      end
+    end
+
+    describe 'filters' do
+
+      before do
+      end
+
+      it "executes before_save every time instance is saved" do
+        u = User.new :name=>'Natalie'
+        u.save
+        sleep(1)
+        lambda { u.save }.should change(u, :updated_at)
+      end
+
+      it "executes before_create filters only when record is created" do
+        u = User.new :name=>'Natalie'
+        u.save
+        sleep(1)
+        lambda { u.save }.should_not change(u, :created_at)
+      end
+      
+      it "executes after_create filters only after record is created" do
+        u = User.new :name=>'Natalie'
+        u.save
+        lambda { u.save }.should_not change(u, :after_create_touched)
+      end
+
+      it "executes after_save filters after everytime instance is saved" do
+        u = User.new :name=>'Natalie'
+        u.save
+        lambda { u.save }.should change(u, :after_save_touched)
+      end
+
+    end
+  end  
+
+  describe '.first' do
+    it 'returns nil when no records found' do
+      r = SentiQL.first 'SHOW TABLES LIKE ?', ['non_existing_tbl%']
+      r.should == nil
+    end
+
+    it 'returns a hash if record found with keys representing column values' do
+      r = SentiQL.first 'SELECT CONCAT(?,?) AS str', ['a','b']
+      r.should be_an_instance_of(Hash)
+      r[:str].should == 'ab'
+    end
+  end
+
+  describe '.all' do
+    it 'returns Mysql2::Result which holds data in Hashes' do
+      r = SentiQL.all 'SHOW OPEN TABLES'
+      r.should be_an_instance_of(Mysql2::Result)
+      r.first.should be_an_instance_of(Hash)
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'database_cleaner'
+require 'yaml'
+require 'rspec'
+require 'active_record'
+require 'mysql2'
+
+require 'sentiql'
+
+ROOT_PATH = File.dirname(__FILE__)
+
+
+@config = YAML.load_file(File.join(ROOT_PATH, '..', "config/database.yml"))['test']
+
+DB = Mysql2::Client.new( 
+      :host=>@config["host"], 
+      :username=>@config["username"], 
+      :password=>@config["password"], 
+      :database=>@config["database"]
+    )
+DB.query_options.merge!(:symbolize_keys=>true)
+SentiQL::Base.connection = DB
+
+ActiveRecord::Base.establish_connection @config
+
+RSpec.configure do |config|
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification 
+name: sentiql
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Martynas Miliauskas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-15 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - <
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.5
+  type: :development
+  version_requirements: *id004
+description: This is a work in progress. SentiQL promotes use of SQL for data selection, OM for CUD operations and being as lean as possible.
+email: 
+- miliauskas@facebook.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- config/database.yml
+- db/migrate/20110515_test_tables.rb
+- lib/sentiql.rb
+- lib/sentiql/version.rb
+- sentiql.gemspec
+- spec/sentiql_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: sentiql
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A minimalistic Ruby wrapper for MySQL
+test_files: []
+