rmap 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rmap.gemspec
+gemspec
+
+gem 'mysql2'
+gem 'json'
+gem 'ripl'
+gem 'ripl-multi_line'
+

data/README.markdown

@@ -0,0 +1,124 @@
+
+# Rmap - a simple yet powerfull object relational mapper
+
+##Installation
+
+```
+gem install rmap
+```
+or add the following to your gem file:
+
+```
+gem 'rmap'
+```
+and then run bundle install from your shell.
+
+##Basic configuration
+
+```ruby
+require 'rmap'
+
+db = Rmap::Database.new :database => 'rmap', :username => 'root'
+```
+You can get more configuration options by going to the mysql2 gem documentation, as rmap wraps the mysql2 gem and simply passes through the conf hash to it:
+
+* https://github.com/brianmario/mysql2
+
+For instance a more advanced configuration might be:
+
+```ruby
+require 'rmap'
+
+db = Rmap::Database.new :database => 'rmap', :host => 'localhost', :username => 'root', :password => "secret"
+```
+
+## How to use
+
+The following will return a representation of the 'posts' table:
+
+```ruby
+db.posts
+```
+### Creating
+
+You can insert rows into the posts table by doing the following:
+
+```ruby
+db.posts.insert(:title => "Hello World", :body => "This is a test")
+```
+
+### Retrieval
+
+You can list all the posts by doing the following:
+
+```ruby
+db.posts.all.each do |post|
+  puts "title #{post.title}"
+end
+```
+
+You can list all the posts that contain the word apple by doing the following:
+
+```ruby
+db.posts.contains(:body, "apple").all.each do |post|
+  puts "title #{post.title}"
+end
+```
+
+You can list all the posts that contain the word apple or pear by doing the following:
+
+```ruby
+db.posts.contains(:body, ["apple", "pear"]).all.each do |post|
+  puts "title #{post.title}"
+end
+```
+
+You can retrieve a particular post (row) by doing the following:
+
+```ruby
+db.posts.eq(:id, 7).first
+```
+
+and then you can print the title to the screen:
+
+```ruby
+puts db.posts.eq(:id, 7).first.title
+```
+
+### Joins
+
+Joins are really easy. To retrieve all the posts by gmail users, you can do the following:
+
+```ruby
+db.users.contains(:email, "@gmail.com").posts.all
+```
+
+### Deleting
+
+You can delete all the posts by gmail users by doing the following:
+
+```ruby
+db.users.contains(:email, "@gmail.com").posts.delete
+```
+
+### Updating
+
+You can update all the posts by gmail users by doing the following:
+
+```ruby
+db.users.contains(:email, "@gmail.com").posts.update(:published => true, :last_published => Time.now)
+```
+
+or if you just want to update a column:
+
+```ruby
+db.users.contains(:email, "@gmail.com").posts.published = true
+```
+
+more coming soon....
+
+## License
+
+Rmap is released under the MIT license:
+
+* http://www.opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/rmap

@@ -0,0 +1,18 @@
+
+require 'rmap'
+require 'ripl'
+require 'ripl/multi_line'
+
+db = Rmap::Database.new
+
+current = Dir::getwd
+while current != '/'
+  if ::File.file? "#{current}/conf.rmap.rb"
+    db.run("#{current}/conf.rmap.rb")
+    break
+  end
+  current = ::File.expand_path('../',  current)
+end
+
+Ripl.start :binding => db.bindings
+

data/lib/rmap/database.rb

@@ -0,0 +1,61 @@
+
+module Rmap
+  class Database
+    
+    def initialize(conf={:username => 'root'})
+      @conf = conf
+    end
+    
+    def client
+      if @client.nil?
+        @client = Mysql2::Client.new(@conf)
+      end
+      @client
+    end
+    
+    def host(host)
+      @conf[:host] = host
+    end
+    
+    def username(username)
+      @conf[:username] = username
+    end
+    
+    def database(database)
+      @conf[:database] = database
+    end
+    
+    def bindings
+      binding
+    end
+    
+    def run(file_path)
+      instance_eval(::File.open(file_path).read, file_path)
+    end
+    
+    def table?(name)
+      table_names.include?(name.to_s)
+    end
+    
+    def method_missing name, *args
+      if table_names.include? name.to_s
+        Table.new(self, name)
+      else
+        super(name, *args)
+      end
+    end
+    
+    def create(name)
+      @table_names = nil
+      client.query("create table `#{name}`(id int unsigned not null auto_increment primary key)")
+    end
+    
+    def table_names
+      if @table_names.nil?
+        @table_names = client.query("show tables", :as => :array).map{|a| a[0]}
+      end
+      @table_names
+    end
+    
+  end
+end

data/lib/rmap/row.rb

@@ -0,0 +1,44 @@
+
+require 'json'
+
+module Rmap
+  class Row
+  
+    attr_accessor :id
+    
+    def initialize(database, table_name, id)
+      @database = database
+      @table_name = table_name
+      @id = id
+    end
+    
+    def fetch(*args)
+      @database.client.query("select #{(args.map { |field| "`#{@database.client.escape(field.to_s)}`"}).join(', ')} from `#{@table_name}` where id = '#{id}'", :as => :array).first
+    end
+    
+    def update(hash)
+      @database.client.query("update `#{@table_name}` set #{(hash.map{|k,v| "`#{k}`='#{@database.client.escape(v)}'"}).join(', ')} where id = '#{id}'")
+    end
+    
+    def delete
+      @database.client.query("delete from `#{@table_name}` where id = '#{id}'")
+    end
+    
+    def method_missing name, *args
+      if @database.table? name
+        Table.new(@database, name).join(Table.new(@database, @table_name).eq(:id, @id), *args)
+      elsif name.match(/\A.*=\Z/) && @database.method_missing(@table_name).column?(name.to_s.sub(/=\Z/, ""))
+        update(name[/\A(.*)=\Z/, 1] => args[0])
+      elsif @database.method_missing(@table_name).column? name
+        fetch(name).first
+      else
+        super
+      end
+    end
+    
+    def to_s
+      @database.client.query("select * from `#{@table_name}` where id = '#{id}'", :as => :hash).first.to_json
+    end
+    
+  end
+end

data/lib/rmap/table.rb

@@ -0,0 +1,328 @@
+
+module Rmap
+  class Table
+    BINARY_FILTER_METHODS = {
+      'eq' => lambda {|left,right| "#{left} = #{right}"},
+      'ne' => lambda {|left,right| "#{left} != #{right}"}, 
+      'lt' => lambda {|left,right| "#{left} < #{right}"}, 
+      'gt' => lambda {|left,right| "#{left} > #{right}"}, 
+      'le' => lambda {|left,right| "#{left} <= #{right}"}, 
+      'ge' => lambda {|left,right| "#{left} >= #{right}"}, 
+      'contains' => lambda {|left,right| "#{left} like concat('%', #{right}, '%')"}, 
+      'begins_with' => lambda {|left,right| "#{left} like concat('%', #{right})"}, 
+      'ends_with' => lambda {|left,right| "#{left} like concat(#{right}, '%')"},
+      'year_eq' => lambda {|left,right| "year(#{left}) = #{right}"},
+      'year_ne' => lambda {|left,right| "year(#{left}) != #{right}"}, 
+      'year_lt' => lambda {|left,right| "year(#{left}) < #{right}"}, 
+      'year_gt' => lambda {|left,right| "year(#{left}) > #{right}"}, 
+      'year_le' => lambda {|left,right| "year(#{left}) <= #{right}"}, 
+      'year_ge' => lambda {|left,right| "year(#{left}) >= #{right}"},
+      'month_eq' => lambda {|left,right| "month(#{left}) = #{right}"},
+      'month_ne' => lambda {|left,right| "month(#{left}) != #{right}"}, 
+      'month_lt' => lambda {|left,right| "month(#{left}) < #{right}"}, 
+      'month_gt' => lambda {|left,right| "month(#{left}) > #{right}"}, 
+      'month_le' => lambda {|left,right| "month(#{left}) <= #{right}"}, 
+      'month_ge' => lambda {|left,right| "month(#{left}) >= #{right}"},
+      'day_eq' => lambda {|left,right| "day(#{left}) = #{right}"},
+      'day_ne' => lambda {|left,right| "day(#{left}) != #{right}"}, 
+      'day_lt' => lambda {|left,right| "day(#{left}) < #{right}"}, 
+      'day_gt' => lambda {|left,right| "day(#{left}) > #{right}"}, 
+      'day_le' => lambda {|left,right| "day(#{left}) <= #{right}"}, 
+      'day_ge' => lambda {|left,right| "day(#{left}) >= #{right}"},
+      'hour_eq' => lambda {|left,right| "hour(#{left}) = #{right}"},
+      'hour_ne' => lambda {|left,right| "hour(#{left}) != #{right}"}, 
+      'hour_lt' => lambda {|left,right| "hour(#{left}) < #{right}"}, 
+      'hour_gt' => lambda {|left,right| "hour(#{left}) > #{right}"}, 
+      'hour_le' => lambda {|left,right| "hour(#{left}) <= #{right}"}, 
+      'hour_ge' => lambda {|left,right| "hour(#{left}) >= #{right}"},
+      'minute_eq' => lambda {|left,right| "minute(#{left}) = #{right}"},
+      'minute_ne' => lambda {|left,right| "minute(#{left}) != #{right}"}, 
+      'minute_lt' => lambda {|left,right| "minute(#{left}) < #{right}"}, 
+      'minute_gt' => lambda {|left,right| "minute(#{left}) > #{right}"}, 
+      'minute_le' => lambda {|left,right| "minute(#{left}) <= #{right}"}, 
+      'minute_ge' => lambda {|left,right| "minute(#{left}) >= #{right}"},
+      'second_eq' => lambda {|left,right| "second(#{left}) = #{right}"},
+      'second_ne' => lambda {|left,right| "second(#{left}) != #{right}"}, 
+      'second_lt' => lambda {|left,right| "second(#{left}) < #{right}"}, 
+      'second_gt' => lambda {|left,right| "second(#{left}) > #{right}"}, 
+      'second_le' => lambda {|left,right| "second(#{left}) <= #{right}"}, 
+      'second_ge' => lambda {|left,right| "second(#{left}) >= #{right}"},
+    }
+    
+    attr_accessor :name
+    
+    def initialize(database, name)
+      @database = database
+      @name = name
+      @binary_filter_methods_args = {}
+      Table::BINARY_FILTER_METHODS.each {|name, block| @binary_filter_methods_args[name] = []}
+      @join_list = []
+      @order_by_list = []
+    end
+  
+    Table::BINARY_FILTER_METHODS.each do |name,block|
+      define_method name do |left, right|
+        @binary_filter_methods_args[name].push([left,right])
+        self
+      end
+    end
+    
+    def join(table, options = {})
+      @join_list.push({:table => table, :options => options});
+      self
+    end
+    
+    def order_by(sql_exression, desc = false)
+      @order_by_list.push([sql_exression, desc])
+      self
+    end
+    
+    def column?(name)
+      @database.client.query("describe #{@name} `#{name}`").count > 0
+    end
+    
+    def method_missing name, *args
+      if @database.table? name
+        Table.new(@database, name).join(self, *args)
+      elsif column? name
+        all.map{|row| row.fetch(name).first}
+      elsif column?(name.to_s.sub(/=\Z/, "")) && name.match(/\A(.*)=\Z/)
+        all.each{|row| row.update($1 => args[0])}
+      else
+        super
+      end
+    end
+    
+    def format_sql(sql)
+      out_buffer = []
+      sql = sql.to_s
+      while sql.length > 0
+        if sql.match(/\A(\s+|\d+\.\d+|\d+|\w+\()(.*)/)
+          out_buffer.push($1)
+          sql = $2
+        elsif sql.match(/\A(\w+)\.(\w+)(.*)/)
+          out_buffer.push("`#{$1}`.`#{$2}`")
+          sql = $3
+        elsif sql.match(/\A(\w+)(.*)/)
+          out_buffer.push("`#{@name}`.`#{$1}`")
+          sql = $2
+        else
+          sql.match(/\A(.)(.*)/)
+          out_buffer.push($1)
+          sql = $2
+        end
+      end 
+      out_buffer.join
+    end
+    
+    def quote(data)
+      "'" + @database.client.escape(data.to_s) +  "'"
+    end
+    
+    def generate_filter_conditions_sql
+      and_sql = []
+      Table::BINARY_FILTER_METHODS.each do |name, block|
+        @binary_filter_methods_args[name].each do |args|
+          or_sql = []
+          if args[0].class.name == 'Array'
+            args[0].each do |left|
+              or_sql.push(block.call(format_sql(left.to_s), quote(args[1])))
+            end
+          elsif args[1].class.name == 'Array'
+            args[1].each do |right|
+              or_sql.push(block.call(format_sql(args[0].to_s), quote(right)))
+            end
+          else
+            or_sql.push(block.call(format_sql(args[0].to_s), quote(args[1])))
+          end
+          and_sql.push("(" + or_sql.join(' or ') + ")")
+        end
+      end
+      @join_list.each do |join|
+        and_sql.push(join[:table].generate_filter_conditions_sql)
+      end
+      and_sql.join(' and ')
+    end
+    
+    def generate_table_list_sql
+      out = []
+      out.push(name)
+      @join_list.each do |join|
+        table_list_sql = join[:table].generate_table_list_sql
+        if table_list_sql != ''
+          out.push(table_list_sql)
+        end
+      end
+      out.join(', ')
+    end
+    
+    def generate_from_sql
+      "from " + generate_table_list_sql
+    end
+    
+    def generate_join_condition_sql(table1, table2, foreign_key)
+      if !foreign_key.nil?
+        if table2.column? foreign_key
+          "#{table1.name}.id = #{table2.name}.#{foreign_key}"
+        else
+          "#{table1.name}.#{foreign_key} = #{table2.name}.id"
+        end
+      else
+        if table2.column? "#{table1.name}_id"
+          "#{table1.name}.id = #{table2.name}.#{table1.name}_id"
+        else
+          "#{table1.name}.#{table2.name}_id = #{table2.name}.id"
+        end
+      end
+    end
+    
+    def generate_inner_join_conditions_sql
+      out = []
+      @join_list.each do |join|
+        out.push(generate_join_condition_sql(self, join[:table], join[:options][:using]))
+        inner_join_conditions_sql = join[:table].generate_inner_join_conditions_sql
+        if inner_join_conditions_sql != ''
+          out.push(inner_join_conditions_sql)
+        end
+      end
+      out.join(" and ")
+    end
+    
+    def generate_where_sql
+      out = []
+      inner_join_conditions_sql = generate_inner_join_conditions_sql
+      if inner_join_conditions_sql != ''
+        out.push inner_join_conditions_sql
+      end
+      filter_conditions_sql = generate_filter_conditions_sql
+      if filter_conditions_sql != ''
+        out.push filter_conditions_sql
+      end
+      out = out.join(' and ')
+      if out != ''
+        out = "where #{out}"
+      end
+      out
+    end
+    
+    def generate_group_by_sql
+      if @join_list.count > 0
+        "group by #{name}.id"
+      end
+    end
+    
+    def generate_order_by_sql
+      out = []
+      @order_by_list.each do |order_by|
+        (sql_expression, desc) = order_by
+        if desc
+          out.push "#{format_sql(sql_expression)} desc"
+        else
+          out.push "#{format_sql(sql_expression)} asc"
+        end
+      end
+      @join_list.each do |join|
+        order_by_sql = join[:table].generate_order_by_sql
+        if order_by_sql != ''
+          out.push(order_by_sql)
+        end
+      end
+      out = out.join(', ')
+      if out != ''
+        out = "order by #{out}"
+      end
+      out
+    end
+    
+    def generate_select_sql(expression_list_sql, limit = nil)
+      if !limit.nil?
+        limit_sql = "limit #{limit}"
+      else 
+        limit_sql = ''
+      end
+      "select #{format_sql(expression_list_sql)} #{generate_from_sql} #{generate_where_sql} #{generate_group_by_sql} #{generate_order_by_sql} #{limit_sql}"
+    end
+    
+    def count(limit = nil)
+      @database.client.query(generate_select_sql('id', limit)).count
+    end
+    
+    def all(limit = nil)
+      out = []
+      @database.client.query(generate_select_sql('id', limit), :as => :hash).each do |row|
+        out.push(Row.new(@database, @name, row['id']))
+      end
+      out
+    end
+    
+    def each &block
+      all.each &block
+      nil
+    end
+    
+    def first
+      all(1).first
+    end
+    
+    def update(hash)
+      all.each {|row| row.update(hash)}
+    end
+    
+    def delete
+      each {|row| row.delete}
+    end
+    
+    def insert(hash)
+      @database.client.query("insert into `#{@name}`(#{(hash.map{|k,v| "`#{k}`"}).join(', ')}) values(#{(hash.map{|k,v| quote(v)}).join(', ')})")
+    end
+    
+    def sum(sql_expression, limit = nil)
+      out = 0
+      @database.client.query(generate_select_sql("sum(#{sql_expression})", limit), :as => :array).each{|row| out += row.first}
+      out
+    end
+    
+    def drop
+      eval("@table_names = nil", @database.bindings)
+      @database.client.query("drop table `#{@name}`")
+    end
+    
+    def add(name, type, options = {})
+      case type
+      when :string
+        @database.client.query("alter table `#{@name}` add `#{name}` varchar(255) not null")
+      when :text
+        @database.client.query("alter table `#{@name}` add `#{name}` longtext not null")
+      when :binary
+        @database.client.query("alter table `#{@name}` add `#{name}` longblob not null")
+      when :integer
+        @database.client.query("alter table `#{@name}` add `#{name}` int signed not null")
+      when :foreign_key
+        @database.client.query("alter table `#{@name}` add `#{name}` int unsigned not null")
+        @database.client.query("alter table `#{@name}` add index(`#{name}`)")
+      when :date
+        @database.client.query("alter table `#{@name}` add `#{name}` date not null")
+      when :datetime
+        @database.client.query("alter table `#{@name}` add `#{name}` datetime not null")
+      when :boolean
+        @database.client.query("alter table `#{@name}` add `#{name}` enum('true', 'false') not null")
+      when :decimal
+        @database.client.query("alter table `#{@name}` add `#{name}` decimal not null")
+      end
+    end
+    
+    def remove(name)
+      @database.client.query("alter table `#{@name}` drop `#{name}`")
+    end
+    
+    
+    def column_names
+      @database.client.query("describe `#{@name}`", :as => :hash).map {|row| row['Field']}
+    end
+    
+    def to_s
+      all.to_s
+    end
+    
+  end
+end

data/lib/rmap/version.rb

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

data/lib/rmap.rb

@@ -0,0 +1,10 @@
+
+require 'mysql2'
+
+require 'rmap/version'
+require 'rmap/database'
+require 'rmap/table'
+require 'rmap/row'
+
+module Rmap
+end

data/rmap.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rmap/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rmap"
+  s.version     = Rmap::VERSION
+  s.authors     = ["Jody Salt"]
+  s.email       = ["jody@jodysalt.com"]
+  s.homepage    = "https://github.com/jodysalt/rmap"
+  s.summary     = "A simple yet powerful object relational mapper (ORM)."
+
+  s.rubyforge_project = "rmap"
+
+  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"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: rmap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jody Salt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-10 00:00:00.000000000Z
+dependencies: []
+description: 
+email:
+- jody@jodysalt.com
+executables:
+- rmap
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- bin/rmap
+- lib/rmap.rb
+- lib/rmap/database.rb
+- lib/rmap/row.rb
+- lib/rmap/table.rb
+- lib/rmap/version.rb
+- rmap.gemspec
+homepage: https://github.com/jodysalt/rmap
+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: rmap
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple yet powerful object relational mapper (ORM).
+test_files: []