em-riak 0.2.0

data/.gitignore

@@ -0,0 +1,4 @@
+em-riak-*
+.gitignore
+OLD_README.md
+lib/example.rb

data/LICENSE.md

@@ -0,0 +1 @@
+MIT

data/README.md

@@ -0,0 +1,67 @@
+###What is this?
+It is a Riak ruby client design for eventmachine.
+
+### Concept
+I tried to implement em-riak with goals : Easy to use, ORM, Fast, Flexible, Hybrid.
+
+###### Easy To use
+I tried to use the same behaviors as active-record or sequel.  
+So when you use em-riak, you don't tackling the "Key Design".  
+Instead, just add an extension into your model, and everygthings goes fine.  
+
+###### ORM (ToDo)
+The same idea as upon, just add the plugins and you gain the ORM ability with NoSQL.  
+It only support Sequel gem currently.  
+
+###### Flexible
+Concurrency is one reasons to use nosql, we may face huge read / write in the same time but our sql hard to scale.  
+Riak provide easy to use script that you can install, add nodes easily.  
+Also, you can read/write data directly, or deferrable-aware.  
+With Deferrable-aware, you don't block & wait for your I/O.
+  
+
+<br/>
+### Getting Start
+	EmRiak::Connection.new({:bucket=>"member",:async=>false,:hosts=>["http://127.0.0.1:8091"]})
+	member=EmRiak.create("member1",{:name=>"Von",:age=>18})
+	
+	member.handsome=true    # or EmRaik.udpate("member1",{:handsome=>true})
+	member.save             # or EmRiak.save("member1")
+	member.destory
+	
+	member_two=EmRiak.create("member2",{:name=>"Jack",:age=>22})
+	member_two.add_tag(:interests,"programmer","backpacker","trader")
+	
+	member_three=EmRiak.create("member3",{:name=>"Lisa",:age=>17})
+	member_three.add_tag(:interests,"backpacker","delicious","cocktail","movie")
+	member_three.remove_tag(:interest,"delicious")
+	
+	EmRiak.search(:interests, "delicious")  #=> {} 
+	EmRiak.search(:interests, "movie")  #=> {:member=>["member3"]} 
+	EmRiak.search(:secondary_index, :interests, "backpacker") #=> same above
+	EmRiak.search(:interests, "backpacker","movie")   #=> {:member=>["member2","member3"]} 
+	
+	EmRiak::Util.clean_bucket("member")  #=> Clean all the data inside bucket
+	
+<br/>
+How to work with **Asynchornize** ?  
+With asynchornize, you just set following at anywhere : 
+
+    EmRiak.async=true
+
+And the code behind will become asynchornize.  
+Because callback still under development, so get object, and search will still reamin direct http.  
+
+
+### Write some map-reduce
+You can call **EmRiak::MapReduce.submit()** directly.  
+Since I just started to work on it, better interface & docs will coming soon…  
+
+
+### TO-DO
+Async with callback block support  
+Map/Reduce  
+Full Text Seacrh  
+Deployment & Management  
+Protocal Buffer Interface  
+ORM with Model  

data/em-riak.gemspec

@@ -0,0 +1,47 @@
+Gem::Specification.new do |s|
+  s.name        = 'em-riak'
+  s.version     = '0.2.0'
+  s.date        = '2012-12-01'
+  s.summary     = "Riak client for eventmachine"
+  s.description = "An extremely fast and convenient riak client for eventmachine."
+  s.authors     = ["Von"]
+  s.email       = 'von@vonstark.co'
+  s.files       = ["lib/em-riak.rb"]
+  s.homepage    = 'http://tech.vonstark.co'
+
+  includes = %W{
+    lib/**/*
+    spec/**/*
+    Gemfile
+    Rakefile
+    LICENSE*
+    RELEASE_NOTES*
+    README*
+    .gitignore
+    .document
+    .rspec
+    em-riak.gemspec
+  }
+
+  excludes = %W{
+    **/*.swp
+    **/#*
+    **/.#*
+    **/*~
+    **/*.rbc
+    **/.DS_Store
+    spec/support/test_server.yml
+  }
+
+  s.add_runtime_dependency "escape_utils"
+  s.add_runtime_dependency "yajl-ruby", "~>1.1.0"
+  s.add_runtime_dependency "httpi", "~>1.1.1"
+  s.add_runtime_dependency "eventmachine", "~>1.0.0.beta.4"
+  s.add_runtime_dependency "em-http-request", "~>1.0.2"
+
+  files = includes.map {|glob| Dir[glob] }.flatten.select {|f| File.file?(f) }.sort
+  files.reject! {|f| excludes.any? {|e| File.fnmatch?(e, f) } }
+
+  s.files = files
+  s.require_paths = ['lib']
+end

data/lib/em-riak/basic.rb

@@ -0,0 +1,325 @@
+# encoding: UTF-8
+require 'eventmachine'
+require 'em-http-request'
+require 'escape_utils'
+require 'escape_utils/html/rack'
+require 'httpi'
+require 'yajl'
+
+module EmRiak
+	attr_accessor :bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :replication, :debug
+	extend self
+
+	# A easy interface to create connections
+	class Connection
+		def initialize(*opts)
+			if opts && opts.length>0
+				opts=opts.first
+				methods=[:bucket, :interface, :adapter, :hosts, :cluster, :async, :http_client, :vector_lock, :repliaction, :debug]
+				opts.each{|key,opt|  EmRiak.send "#{key}=".to_sym, opt if opt && methods.index(key.to_sym)   }
+			else
+				EmRiak.bucket=RIAKBUCKET
+			end
+			EmRiak.debug=false if EmRiak.debug.nil?
+		end
+		def find; EmRiak.find(self); end
+	end
+
+	# -- CRUD
+	class StorageObject < Hash
+		def find; EmRiak.find(self); end
+		def save; EmRiak.save(self); end
+		def destroy; EmRiak.destroy(self); end
+		def add_tag(*args); EmRiak::SecondaryIndex.add_tag(self,args); end
+		def remove_tag(*args); EmRiak::SecondaryIndex.remove_tag(self,args); end
+		def save_as_key(); EmRiak::Grapher.save_object_as_key_name(self) ; end
+		def method_missing(name,*args)
+		    return self[name] if key? name
+		  	if name.to_s.index("=")
+		  		sym_name=name.to_s.gsub("=","").to_sym
+		  		self[sym_name]=args.first
+		  	else
+			    self.each { |k,v| return v if k.to_s.to_sym == name }
+			    super.method_missing name
+			end
+		end
+	end
+	def create(key,*opts)
+		data={:body=>{}}
+		data[:head], data[:query] = handle_options("save",opts)
+		opts.first.each{|key,value| data[:body][key]=value}  if opts && opts.count>0		
+
+		url="/buckets/#{bucket}/keys/#{key_handler(key)}"
+		http("put",key,url,data)
+	end
+	def find(key,*opts)
+		data={}; link=""
+		data[:head], data[:query] = handle_options("get",opts)
+		if data[:head][:link]
+			link=data[:head][:link]
+			data[:head].reject!{|o| o==:link}
+		end
+		
+	  	url="/buckets/#{bucket}/keys/#{key_handler(key)}#{link}"
+	  	http("get",key,url,data)
+	end
+	def save(obj,*opts)
+		data={:body=>{}}
+		obj.each{|key,value| data[:body][key]=value }
+		data[:head], data[:query] = handle_options("save",opts)
+		
+	  	url="/buckets/#{bucket}/keys/#{obj[:riak_key]}"
+	  	http("put",obj[:riak_key],url,data)
+	end
+	def destroy(key,*opts)
+		data={}
+		obj_key=defined?(obj) ? obj[:riak_key] :  (key.class==String ? key : key[:riak_key])
+		data[:head], data[:query] = handle_options("delete",opts)
+
+	  	url="/buckets/#{bucket}/keys/#{key_handler(obj_key)}"
+	  	http("put",obj_key,url,data)
+	  	key=nil
+	end
+
+	# -- Search
+	def search(*args)
+		return "you must provide search mode" if !SEARCH_SUPPORT.index(args[0])
+
+		method=args[0]
+		collect_data=if args[1].class==Hash
+						opts=args[1]
+						args[2..args.count]
+					else
+						args[1..args.count]
+					end
+
+		return "you must provide some vars to do search, for example, bucket name, bin name..." if !defined?(opts) && method!=:map_reduce || opts[:bin].nil? && method==:secondary_index
+
+		case method
+		when :secondary_index
+			bin=opts[:bin].to_s.index("_bin") ? opts[:bin] : "#{opts[:bin]}_bin"
+			mapper_key=collect_data.count>1 ? :secondary_index_multiple_query : :secondary_index_single_query
+
+			members={}
+			EmRiak::MapReduce.submit(mapper_key,{'bucket'=>opts[:bucket],'index'=>bin,'value'=>collect_data.join(',')}).each do |object| 
+				if object[1]["body"] 
+				 	members[object[0].to_sym]=object[1]["body"]
+				else 
+					members[object[0].to_sym]=[] if !members[object[0].to_sym]
+				 	members[object[0].to_sym] << object[1]
+				end if object[0]!=false
+			end
+			members
+		when :full_text # TODO : full-text search is still under implement...
+			[]
+		when :map_reduce
+			EmRiak::MapReduce.submit(collect_data[0])
+		end
+	end
+
+	def http(method,key,url,data,res=nil)		
+		self.async && ["delete","put","post"].index(method) && key!="mapred" ? em_http(method,key,url,data) : open_http(method,key,url,data)
+	end
+	def return_body_handler(string,hash_container,handle_type,handle_type_split_mapper={"hash"=>":","string"=>"=","common"=>","})
+		hash_container={} if !hash_container
+		
+		string=string.gsub("{","").gsub("}","") if handle_type!="hash"
+		split_by= hash_container.class==EmRiak::StorageObject ? "&" : ","
+		string.split(split_by).each do |vars|
+			key,value=vars.split(handle_type_split_mapper[handle_type])
+			value=return_body_handler(value,nil,"hash") if value && value.index("{")
+			value=json_decode("{#{value}}") if value && value.index(":") && value.index(",")
+			hash_container[key.to_sym]=value if value
+		end
+		hash_container
+	end
+
+	def open_http(method,key,url,data,res={})
+		has_http_instance?
+		data={:body=>{},:head=>{},:query=>{}} if !data
+
+		http_client.url     = generate_path(url)
+		http_client.headers = key!="mapred" ? convert_params_layers(data[:head],:to_s) : data[:head]
+		http_client.body    = key!="mapred" ? convert_params_layers(data[:body],:to_s) : data[:body]
+
+		res=HTTPI.request(method.to_sym,http_client)
+		res=res.body if res.class==HTTPI::Response
+
+		res=if !["2i","mapred"].index(key) && res && !["not found\n"].index(res) && ["get","put","post"].index(method)
+				obj=EmRiak::StorageObject.new()
+				if res && res!="not found\n"
+					if res.class==String
+						obj=return_body_handler(URI.unescape(res.force_encoding("UTF-8")).gsub("+"," ").gsub("=>",":"),obj,"string")
+					elsif res.class==Hash
+						res.each{|varkey,value| obj[varkey.to_sym]=value }
+					end
+
+					data.each{|k,v| obj[k]=v } if res.length<1
+					obj[:riak_key]=key if obj.length>0
+				end
+				obj
+			elsif key=="mapred"
+				res
+			else
+				nil
+			end
+		res=nil if res && res.class!=String && res.count<1
+
+		return res
+	end
+
+	def em_http(method,key,url,data)
+		data[:retry]=0 if !data[:retry]
+		begin
+			raise "Retry too much time" if data[:retry]>RETRY_TIMES
+			
+			#conn options
+			conn_options = {
+	          :connect_timeout => EM_REQUEST_TIMEOUT,        # default connection setup timeout
+	          :inactivity_timeout => EM_INACTIVITY_TIMEOUT,    # default connection inactivity (post-setup) timeout
+	      	}
+
+	      	#data[:body]=data[:body] if data[:body].class==Hash && data[:head]['Content-Type'] && data[:head]['Content-Type']=="application/json"
+	      	#request options
+	      	data[:query]="?returnbody=true"
+	      	request_options=data.reject{|k,v| k==:retry}
+
+	      	#do job
+	      	case method
+	      	when "post"
+	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).post request_options	
+	      	when "delete"
+	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).delete request_options	
+	      	when "get"
+	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).get request_options	
+	      	when "put"
+	      		riakHttp = EventMachine::HttpRequest.new(hosts[rand(hosts.count)]+url).put request_options	
+	      	end
+
+		  	riakHttp.errback{ #Error Callback
+		  		puts "#{method} - #{key} - riak callback error #{riakHttp.response}" if EmRiak.debug
+		  		data[:retry]+=1
+		  		http(method,key,url,data)
+		  	}
+
+		  	#Success Callback
+		  	riakHttp.callback{ puts "#{method} - #{url} - #{key} - riak response #{riakHttp.response}" if EmRiak.debug  }
+		rescue Exception => e
+			puts "em_http - #{method} - #{url} - #{key} error #{e}" if EmRiak.debug
+		end
+
+		# Return Response
+		res=if ["put","post"].index(method)
+			obj=EmRiak::StorageObject.new()
+			data.each{|k,v| obj[k]=v }
+			obj[:riak_key]=key if obj.length>0
+			obj
+		else
+			nil
+		end
+		res
+	end
+
+	def handle_options(action,opts,header={},query="")
+		#Load default header setting
+		case action
+		when "save"
+			header["Content-Type"]="application/json"
+		when "get"
+			header["Content-Type"]="application/json"
+		when "destroy"
+
+		when "add_link"
+			header["Content-Type"]="application/json"
+		when "remove_link"
+		# else
+		# 	header["Content-Type"]="application/json"
+		end
+		
+		if opts && opts.count>0
+			#Map & overwrite if header specisfic
+			opts=opts.first if opts.class==Array
+			opts.each{|k,v|
+				meta=METAMAPPER[k]	
+				if meta
+					header[meta[:key]] = meta[:value] 
+					opts.reject!{true}
+				end
+			}
+
+			# --- Handle the rest headers
+			# Link Walk
+			if opts[:links] && (["save"].index(action))
+				links=[]
+				opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
+				header['Link']= links.join(",")
+			elsif opts[:links] && (["add_link","remove_link"].index(action))
+				links=[]
+				opts[:links].each{|link| links << %Q[</buckets/#{bucket}/keys/#{link[:target]}>; riaktag="#{link[:tag]}"] }
+				header['Link']= links
+			elsif opts[:links] && action=="get"
+				header["Content-Type"]="multipart/mixed"
+				header["Accept"]="multipart/mixed"
+				header[:link]=""
+				keep=opts[:links][:keep] ? '1' : '0' #keep the result
+				opts[:links][:tag].each{|tag| header[:link]+= "/#{bucket},#{tag},#{keep}" }
+			end
+			# 2i
+			header["x-riak-index-#{opts[:bin].to_s}_bin"]=opts[:secondary_index].join(", ") if opts[:secondary_index]
+
+			# Replication, available configs : w, dw, pw
+			# read more at http://docs.basho.com/riak/latest/references/apis/http/HTTP-Store-Object/
+			replication.each{|key,value| hreader[key.to_s]=value} if replication
+
+			header["Content-Type"]=opts[:content_type] if opts[:content_type]
+			header["X-Riak-Vclock"]=opts[:vlock] if opts[:vlock]
+			header["ETag"]=opts[:etag] if opts[:etag]
+			header["Last-Modified"]=opts[:last_modified] if opts[:last_modified]
+			header["returnbody"]= "true" if !async
+			#header["unique"] = true if async=false
+			query="?returnbody=true"
+			opts[:query].each{|k,v| query+="&#{k}={v}" } if opts[:query]
+		end
+		[header,query]
+	end
+
+	def key_handler(key,map={"["=>"%5B","]"=>"%5D","+"=>"%2B","/"=>"%2F","("=>"%28",")"=>"%29",":"=>"%3A"})
+		# To match the key rule from Basho : If your field contains special characters, such as (‘+’,‘/’,‘[’,‘]’,‘(’,‘)’,‘:’ or space), then either surround the phrase in single quotes, or escape each special character with a backslash.
+		# map.each{|origin,value| key.gsub!(origin,value) }
+		EscapeUtils.escape_url(key.to_s.encode('UTF-8'))
+	end
+
+	def json_encode(obj,times=0)
+		y=Yajl::Encoder.new()
+		y.encode(obj)
+	rescue Exception => e
+		puts "json_encode error : #{e}" if EmRiak.debug
+		nil
+	end
+	def json_decode(obj,times=0)
+		y=Yajl::Parser.new()
+		y.parse(obj)
+	rescue Exception => e
+		puts "json_decode error : #{e}" if EmRiak.debug
+		nil
+	end
+
+	def convert_params_layers(origin,to_type,params={})
+	  origin.each{|key,value|
+	    converted=convert_params_layers(value,to_type) if value.class==Hash
+	    key=key.send(to_type)
+	    params[key]= converted ? converted : value
+	  } if origin
+	  params
+	end
+
+	private
+	def generate_path(url); EmRiak.hosts[rand(EmRiak.hosts.length)]+url; end
+	def has_http_instance?
+		if !EmRiak.http_client
+			HTTPI.log=false
+			HTTPI.adapter=:net_http
+			EmRiak.http_client=HTTPI::Request.new
+		end
+	end
+end

data/lib/em-riak/configurations.rb

@@ -0,0 +1,8 @@
+METAMAPPER={:sibling=>{"Accept"=>"multipart/mixed"}}
+SEARCH_SUPPORT=[:secondary_index,:full_text,:map_reduce,:key_filters]
+RETRY_TIMES=3
+EMMAX=2000
+EM_REQUEST_TIMEOUT=50
+EM_INACTIVITY_TIMEOUT=0
+RIAKBUCKET="test_bucket"
+DEBUG=true

data/lib/em-riak/grapher.rb

@@ -0,0 +1,58 @@
+module EmRiak
+	module Grapher
+		extend self
+
+		class LinkWalk
+			def add_link(key,*opts)
+				data={}
+				data[:head], data[:query] = EmRiak.handle_options("add_link",opts)
+				data[:query]= data[:query] && data[:query].length>0 ? data[:query]+"&returnbody=true" : "?returnbody=true"
+				
+			  	url="/buckets/#{EmRiak.bucket}/keys/#{key}"
+			  		  	
+			  	response=open("#{RIAKHOST[rand(RIAKHOST.count)]}/buckets/#{EmRiak.bucket}/keys/#{key}?returnbody=true")
+			  	body,links = rehandle_link_and_params(response)
+			  	
+			  	data[:head]['Link'].each{|link| links=links.gsub(link+", ","") }
+				data[:head]['Link']=data[:head]['Link'].join(", ")+", "+links if data[:head]['Link'].count>0
+			  	data[:body]=body
+
+			  	EmRiak.http("put",key,url,data)
+			end
+
+			def remove_link(key,*opts)
+				data={}
+				data[:head], data[:query] = EmRiak.handle_options("add_link",opts)
+				data[:query]= data[:query] && data[:query].length>0 ? data[:query]+"&returnbody=true" : "?returnbody=true"
+				
+			  	url="/buckets/#{EmRiak.bucket}/keys/#{key}"
+
+				response=open("#{RIAKHOST[rand(RIAKHOST.count)]}/buckets/#{EmRiak.bucket}/keys/#{key}?returnbody=true")
+			  	body,links = rehandle_link_and_params(response)	  	
+			  	
+
+			  	data[:body]=body
+
+			  	data[:head]['Link'].each{|link| links=links.gsub(link+", ","") }
+			  	data[:head]['Link']=links
+			  	EmRiak.http("put",key,url,data)
+			end
+
+			private
+			def rehandle_link_and_params(response,body={},links=[])
+				response.read.split("&").each{|params|
+			  		key=params.split("=")[0]
+			  		value=params.split("=")[1]
+			  		body[key.to_sym]=value
+			  	}
+			  	links=response.meta["link"]#.split(",")
+			  	#.each{|link|
+			  		#key=link.split(";")[0].split("/").last.gsub(">","")
+			  		#tag=link.split(";")[1].split("").gsub("\"","").gsub("\"","").gsub(" ","")
+			  		#links << {:target=>"key",:tag=>tag}
+			  	#}
+			  	[body,links]
+			end
+		end
+	end
+end

data/lib/em-riak/map_reduce.rb

@@ -0,0 +1,39 @@
+MRMAPPER={
+	:secondary_index_single_query=>"{\"inputs\" => {\"bucket\"=> \"@!bucket!@\",\"index\"=> \"@!index!@\", \"key\"=>\"@!value!@\"},
+								   \"query\"  => [{\"map\"=> {\"language\"=> \"javascript\",\"source\"=>\"function(riakObject){ var body={}; var body_arrays=riakObject.values[0].data.split('&head')[0].split('&'); for(i=0;i<body_arrays.length;i++){ body[body_arrays[i].split('=')[0]]=body_arrays[i].split('=')[1];}; return [[riakObject.key, body]]; }\"}  },
+						  		   				  {\"reduce\"=> {\"language\"=> \"erlang\", \"module\"=>\"riak_kv_mapreduce\", \"function\"=>\"reduce_identity\", \"keep\"=>true} }
+						  		   			     ]}",
+	:secondary_index_range_query=>"",
+	:secondary_index_multiple_query=>"{\"inputs\"=> {\"bucket\"=>\"@!bucket!@\",\"index\"=> \"@!index!@\",\"key_filters\"=>[[\"greater_than\",0]]},
+									  	\"query\" => [{\"map\"=> {\"language\"=>\"javascript\", \"source\"=>\"function(riakObject){var search_string='@!value!@';var search_values=search_string.split(',');var metadata=riakObject.values[0].metadata; var indexes=null; var match=false; if(metadata){ if(metadata.index){ indexes=metadata.index.@!index!@; var temp_index=indexes; if(typeof(indexes)!='object') indexes=[indexes];} if(indexes){ for(i=0;i<search_values.length; i++){if(indexes.indexOf(search_values[i])>0){match=true;break;};};};}; return (indexes && match) ? [[riakObject.bucket,riakObject.key]] : [[false,false]];}\" }},
+									  				{\"reduce\"=> {\"language\"=> \"erlang\", \"module\"=>\"riak_kv_mapreduce\", \"function\"=>\"reduce_set_union\", \"keep\"=>true} }
+									               ]}",
+	:full_text_query=>"",
+	:clean_bucket=>"{\"inputs\"=> {\"bucket\"=>\"@!bucket!@\",\"key_filters\"=>[[\"greater_than\",0]]},
+			  		 \"query\" => [{\"map\"=> {\"language\"=>\"javascript\", \"source\"=>\"function(riakObject){return [[riakObject.key]];}\"  }}
+			               		  ]}"
+}
+
+module EmRiak
+	module MapReduce
+		extend self
+		def submit(mode_or_string,params)
+			if mode_or_string.class==Symbol
+				map_reduce_work=MRMAPPER[mode_or_string]
+				map_reduce_work.gsub!(/@!(.{1,}?)!@/){|m| params[$1] }
+				map_reduce_work=eval(map_reduce_work)
+			end
+			url="/mapred"
+			map_reduce_json=EmRiak.json_encode(map_reduce_work)
+			data={:head=>{"Content-Type"=>"application/json"},:body=>map_reduce_json}
+			res=EmRiak.http("post","mapred",url,data)
+
+			if res.class==String
+				res=EscapeUtils.unescape_url(res.encode('UTF-8').gsub("+","")).gsub("=>",":").gsub("\"{","{").gsub("}\"","}").gsub("%20"," ")
+				res=EmRiak.json_decode(res)
+			end
+			res=EmRiak.convert_params_layers(res,:to_sym) if res.class==Hash
+			res
+		end
+	end
+end

data/lib/em-riak/secondary_index.rb

@@ -0,0 +1,68 @@
+module EmRiak
+	module SecondaryIndex
+		extend self
+		def add_tag(data_self,args)
+			data,opts=handle_data_and_options(data_self,args)
+			submit_work("add",data_self,data,opts)
+		end
+		
+		def remove_tag(data_self,args)		
+			data,opts=handle_data_and_options(data_self,args)
+			submit_work("remove",data_self,data,opts)
+		end
+
+		protected
+		def submit_work(submit_mode,data_self,data,opts,res={:status=>"success"})
+			self.send "#{submit_mode}_as_index",data_self,data,opts
+		end
+
+		def handle_data_and_options(data_self,args)
+			data={:head=>data_self[:head],:body=>data_self,:query=>{}}
+			data[:body].delete(:head)
+			args=args[0] if args[0].class==Array
+			opts={:bin=>args[0]}
+			opts[:secondary_index]= if args[1] && args[1].class==Hash
+										args[1].each{|key,value| opts[key]=value }
+										args[2..args.count]
+								    else 
+								    	args[1..args.count]
+								    end
+			[data, opts]
+		end
+		def merge_tag(new_heads,old_heads,res={})
+			return new_heads if !old_heads
+			new_heads.each do |key,value|
+				res[key]= key.match(/x-riak-index-/) && old_heads[key] ? value.split(", ").concat(old_heads[key].split(", ")).uniq.join(", ") : value
+			end
+			res
+		end
+
+		def add_as_index(data_self,data,opts)
+			temp_head, data[:query] = EmRiak.handle_options("post",opts)
+			data[:head]=merge_tag(temp_head,data[:head])
+			data_self[:head]=data[:head]
+
+			url="/buckets/#{EmRiak.bucket}/keys/#{data_self[:riak_key]}"
+			EmRiak.http("post","2i",url,data)
+		end
+		def destroy_tag(new_heads,old_heads)
+			return new_heads if !old_heads
+			new_heads.each do |key,value|
+				if key.match(/x-riak-index-/) && old_heads[key]
+					temp_head=old_heads[key].split(", ")
+					temp_head.delete(value)
+					old_heads[key]=temp_head.uniq.join(", ")
+				end
+			end
+			old_heads
+		end
+		def remove_as_index(data_self,data,opts)
+			temp_head, data[:query] = EmRiak.handle_options("post",opts)
+			data[:head]=destroy_tag(temp_head,data[:head])
+			data_self[:head]=data[:head]
+			
+			url="/buckets/#{EmRiak.bucket}/keys/#{data_self[:riak_key]}"
+			EmRiak.http("post","2i",url,data)
+		end
+	end
+end

data/lib/em-riak/utils.rb

@@ -0,0 +1,22 @@
+module EmRiak
+	module Util
+		extend self
+		def clean_bucket(bucket_name)
+			keys=EmRiak::MapReduce.submit(:clean_bucket,{"bucket"=>bucket_name})
+			if keys
+				if !(keys.class==Hash && keys[:error]) 
+					keys=keys[0] if keys.class==Array && keys.count==1
+					keys.each{|key| 
+						key=key[0].gsub("\\","\/")
+						EmRiak.destroy(URI.escape(key[0]).to_s)
+					}
+					puts "clean done" 
+				else 
+					puts "Something went wrong." if EmRiak.debug
+				end
+			else
+				puts "key empty" 
+			end
+		end
+	end
+end

data/lib/em-riak/version.rb

@@ -0,0 +1,3 @@
+module EmRiak
+  VERSION = "0.2.0"
+end

data/lib/em-riak.rb

@@ -0,0 +1,5 @@
+require 'em-riak/configurations'
+require 'em-riak/basic'
+require 'em-riak/secondary_index'
+require 'em-riak/map_reduce'
+require 'em-riak/utils'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: em-riak
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Von
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: escape_utils
+  requirement: &70187287663420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70187287663420
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70187287662160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70187287662160
+- !ruby/object:Gem::Dependency
+  name: httpi
+  requirement: &70187287655840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *70187287655840
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70187287655260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta.4
+  type: :runtime
+  prerelease: false
+  version_requirements: *70187287655260
+- !ruby/object:Gem::Dependency
+  name: em-http-request
+  requirement: &70187287654660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70187287654660
+description: An extremely fast and convenient riak client for eventmachine.
+email: von@vonstark.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE.md
+- README.md
+- Rakefile
+- em-riak.gemspec
+- lib/em-riak.rb
+- lib/em-riak/basic.rb
+- lib/em-riak/configurations.rb
+- lib/em-riak/eventmachine.rb
+- lib/em-riak/full_text_search.rb
+- lib/em-riak/grapher.rb
+- lib/em-riak/luwak.rb
+- lib/em-riak/map_reduce.rb
+- lib/em-riak/secondary_index.rb
+- lib/em-riak/utils.rb
+- lib/em-riak/version.rb
+homepage: http://tech.vonstark.co
+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: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Riak client for eventmachine
+test_files: []
+has_rdoc: