simple_mysql_api 0.0.3 → 0.0.4

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.DS_Store

data/lib/simple_mysql_api.rb

@@ -1,7 +1,12 @@
-# require File.join(File.expand_path(File.dirname(__FILE__)), 'simple_mysql_api/version')
-# require File.join(File.expand_path(File.dirname(__FILE__)), 'simple_mysql_api/class_methods')
 require "simple_mysql_api/version"
-require "simple_mysql_api/class_methods"
+require "simple_mysql_api/class_methods.rb"
 module SimpleMysqlApi
-  # Your code goes here...
+  
+  # def self.connection_adapter
+  #      /mysql|pg/.match(ActiveRecord::Base.configurations[Rails.env]['adapter'].downcase).to_s
+  #   end
+  #   
+  #   # Add the class methods to the models
+  #   ActiveRecord::Base.send(:include, MySqlMethods) if SimpleMysqlApi.connection_adapter=="mysql"
+  #   ActiveRecord::Base.send(:include, PgMethods) if SimpleMysqlApi.connection_adapter=="pg"
 end

data/lib/simple_mysql_api/class_methods.rb

@@ -1,95 +1,174 @@
 module SimpleMysqlApi
+  
+  #To add the class methods to Models
   module SimpleMysqlApiMethods
+    
+    #Class methods for modles
     module ClassMethods
-      def all_belongs_to_tables
-        self.reflect_on_all_associations(:belongs_to).inject({}) do |r, e|
+      
+      # Returns the asscociated models with their table name, class name, forignkey
+      # eg. User.tables_by_relation(:has_many)
+      # returns {"City"=>{:t_name=>"cities", :f_key=>"user_id"}} 
+      def tables_by_relation(rel)
+        self.reflect_on_all_associations(rel).inject({}) do |r, e|
           r[e.class_name] = {:t_name=> e.table_name, :f_key=> e.foreign_key } 
           r
         end
       end
-    
-      def attributes
-        self.columns.inject({}) do |r,e|
-          r[e.name.to_sym]= e.type.to_s
+
+      # Returns the hash of attributes of the table and their type
+      # eg. User.attributes
+      # returns [{:attr=>"id", :type=>"integer", :param_name=>:id}, {:attr=>"name", :type=>"string", :param_name=>:name}]
+      def attributes(c_name=nil)
+        self.columns.inject([]) do |r,e|
+          r << {:attr=>e.name, :type=>e.type.to_s, :param_name => (c_name ? (c_name.downcase+ "_" + e.name) : e.name).to_sym }
           r
         end      
       end
-    
+      
+      # Returns the primary key
       def pri_key
         self.primary_key
       end
 
-      def searchable_attributes
-        self.attributes.delete_if{|k,v| (self.primary_key==k.to_s || self.foreign_keys.include?(k.to_s)) }
+      # returns all the attributes except primary keys and foreign keys
+      def searchable_attributes(c_name=nil)
+        self.attributes(c_name).delete_if{|v| (self.primary_key==v[:attr].to_s || self.foreign_keys.include?(v[:attr].to_s)) }
       end
-    
+      
+      # Adds the conditions for the attributes passed based on the attributes type
       def search_conditions(attributes,params,act_relation,t_type)
-        attributes.each do |attr, value|
-          case(value)
+        attributes.each do |value|
+          case(value[:type])
             when "string","text"
-              act_relation = text_search(attr,params,act_relation,t_type) if params[attr]
+              act_relation = text_search(value,params,act_relation,t_type) 
             when "integer","float"
-              act_relation = range_search(attr,params,act_relation,t_type) if params[attr]
+              act_relation = range_search(value,params,act_relation,t_type)
+            when "datetime"
+              act_relation = date_search(value,params,act_relation,t_type)
             when "boolean"
-              act_relation = boolean_search(attr,params,act_relation,t_type) if params[attr]
-          end
+              act_relation = boolean_search(value,params,act_relation,t_type)
+          end if params[value[:param_name]]
         end
         act_relation
       end
-    
+      
+      # for the text search if it contains the string
       def text_search(attr,params,act_relation,t_type)
-        obj = "%#{params[attr]}%"
-        act_relation.where(["LOWER(#{t_type.constantize.table_name}.#{attr}) like LOWER(?)",obj])
+        obj = "%#{params[attr[:param_name]].downcase}%"
+        act_relation.where(["LOWER(#{t_type.constantize.table_name}.#{attr[:attr]}) like ?",obj])
       end
-    
+
+      # for the integer, float attributes 
+      # eg. price="12"
+      # price="12-100"
+      # price="<100"
+      # price=">100"
       def range_search(attr,params,act_relation,t_type)
-        attr_opp =  /[-,<,>]/.match(params[attr]).to_s
-        table_name = "#{t_type.constantize.table_name}"
+        attr_opp =  /[-,<,>]/.match(params[attr[:param_name]]).to_s + /[=]/.match(params[attr[:param_name]]).to_s
+        table_name = "#{t_type.constantize.table_name}" 
         case(attr_opp)
           when "-"
-           attr_val = params[attr].split("-").inject([]){|r,e| r << e.to_f}
-           act_relation = act_relation.where(["CAST(#{table_name}.#{attr} AS DECIMAL) >= ? and CAST(#{table_name}.#{attr} AS DECIMAL) <= ?",attr_val[0],attr_val[1]]) if attr_val
-          when "<",">"
-           attr_val = params[attr].split(attr_opp)[1].to_f
-           act_relation = act_relation.where([" CAST(#{table_name}.#{attr} AS DECIMAL) #{attr_opp} ?",attr_val]) if attr_val
+           attr_val = params[attr[:param_name]].split("-").inject([]){|r,e| r << e.to_f}
+           act_relation = act_relation.where(["CAST(#{table_name}.#{attr[:attr]} AS DECIMAL) >= ? and CAST(#{table_name}.#{attr[:attr]} AS DECIMAL) <= ?",attr_val[0],attr_val[1]]) if attr_val
+          when "<",">","<=",">="
+           attr_val = params[attr[:param_name]].split(attr_opp)[1].to_f
+           act_relation = act_relation.where(["CAST(#{table_name}.#{attr[:attr]} AS DECIMAL) #{attr_opp} ?",attr_val]) if attr_val
           else
-           attr_val = params[attr].to_f
-           act_relation = act_relation.where(["CAST(#{table_name}.#{attr} AS DECIMAL) = ?",attr_val]) if attr_val
+           attr_val = params[attr[:param_name]].to_f
+           act_relation = act_relation.where(["CAST(#{table_name}.#{attr[:attr]} AS DECIMAL) = ?",attr_val]) if attr_val
+         end if attr_opp
+         act_relation
+      end
+      
+      # for the datetime
+      # eg. created_at ="2012-08-28 16:21:37 +0530"
+      # created_at = "2012-08-28 16:21:37 +0530..2012-09-28 16:21:37 +0530""
+      # created_at="<2012-08-28 16:21:37 +0530"
+      # created_at=">2012-08-28 16:21:37 +0530"
+      def date_search(attr,params,act_relation,t_type)
+        attr_opp =  /[<,>]/.match(params[attr[:param_name]]).to_s + /[=]/.match(params[attr[:param_name]]).to_s
+        attr_opp = params[attr[:param_name]].index("..") ? ".." : attr_opp
+        table_name = "#{t_type.constantize.table_name}" 
+        case(attr_opp)
+          when ".."
+            attr_val = params[attr[:param_name]].split("..").inject([]){|r,e| r << e}
+            act_relation = act_relation.where(["#{table_name}.#{attr[:attr]} >= ? and #{table_name}.#{attr[:attr]} <= ?",attr_val[0],attr_val[1]]) if attr_val
+          when "<",">","<=",">="
+            attr_val = params[attr[:param_name]].split(attr_opp)[1]
+            act_relation = act_relation.where(["#{table_name}.#{attr[:attr]} #{attr_opp} ?",attr_val]) if attr_val
+          else
+            attr_val = params[attr[:param_name]].split(attr_opp)[1]
+            act_relation = act_relation.where(["#{table_name}.#{attr[:attr]} = ?",attr_val]) if attr_val
          end if attr_opp
          act_relation
       end
 
+      # for any type
+      # eg. price="12"
       def equal_search(attr,params,act_relation,t_type)
-        act_relation = act_relation.where(["#{t_type.constantize.table_name}.#{attr} = ?",params[attr]])
+        act_relation = act_relation.where(["#{t_type.constantize.table_name}.#{attr[:attr]} = ?",params[attr[:param_name]]])
       end
-    
+
+      # for boolean type
+      # eg. price="true"
       def boolean_search(attr,params,act_relation,t_type)
-        val = params[attr].match(/(true|t|yes|y|1)$/i) != nil ? 1 : 0
-        act_relation = act_relation.where(["CAST(#{t_type.constantize.table_name}.#{attr} AS CHAR) = ?",val.to_s])
+        val = params[attr[:param_name]].match(/(true|t|yes|y|1)$/i) != nil ? 1 : 0
+        act_relation = act_relation.where(["CAST(#{t_type.constantize.table_name}.#{attr[:attr]} AS CHAR) = ?",val.to_s])
       end
-    
+      
+      # Returns all foreign keys of the model
       def foreign_keys
         self.reflect_on_all_associations.inject([]) do |r, e|
           r << e.foreign_key
           r
-        end
+        end.uniq
       end
-    
-      def search(params,search_params=nil)
+
+      # Main method:
+      # Used for search
+      # You have params= {name: "Joh", city: "New"}
+      # set has_many, belongs_to to true if you want to search for associated models
+      # Search: User.search({search_params: params, has_many: true, belongs_to: false})
+      def mysql_search(options={})
+        params = options[:search_params]
+        search_params = options[:custom_params] || nil
         act_relation = self
-        attributes = (search_params||self.attributes).delete_if{|k,v| ((self.foreign_keys.include? k.to_s)||self.primary_key==k.to_s) }
-        self.all_belongs_to_tables.each do |c_name,values|
+        attributes = (search_params||self.attributes).delete_if{|v| (self.primary_key==v[:attr].to_s || self.foreign_keys.include?(v[:attr].to_s)) }
+        act_relation = belongs_to_search(act_relation, params) if options[:belongs_to] && options[:belongs_to]==true
+        act_relation = has_many_search(act_relation, params) if options[:has_many] && options[:has_many]==true
+        act_relation = search_conditions(attributes,params,act_relation,self.to_s)
+        act_relation.select("DISTINCT #{self.table_name}.*")
+      end
+
+      # For joining belongs to relational models and searches their params
+      def belongs_to_search(act_relation, params)
+        self.tables_by_relation(:belongs_to).each do |c_name,values|
           act_relation = act_relation.joins("LEFT JOIN #{values[:t_name]} #{values[:t_name]} ON #{self.table_name}.#{values[:f_key]}=#{values[:t_name]}.#{c_name.constantize.pri_key}")
-          new_attributes = c_name.constantize.searchable_attributes
+          new_attributes = c_name.constantize.searchable_attributes(c_name)#c_name.constantize.searchable_attributes
           act_relation = search_conditions(new_attributes,params,act_relation,c_name)
         end
-        act_relation = search_conditions(attributes,params,act_relation,self.to_s)
         act_relation
       end
+
+      # For joining has many relational models and searches their params
+      def has_many_search(act_relation, params)
+        self.tables_by_relation(:has_many).each do |c_name,values|
+          act_relation = act_relation.joins("LEFT JOIN #{values[:t_name]} #{values[:t_name]} ON #{self.table_name}.#{self.pri_key}=#{values[:t_name]}.#{values[:f_key]}")
+          new_attributes = c_name.constantize.searchable_attributes(c_name)#c_name.constantize.searchable_attributes
+          act_relation = search_conditions(new_attributes,params,act_relation,c_name)
+        end
+        act_relation
+      end
+      
     end
+    
+    # includes as class methods for the Class
     def self.included(base)
       base.extend ClassMethods
     end
   end
+  
+  # Add the class methods to the models
   ActiveRecord::Base.send(:include, SimpleMysqlApiMethods)
 end

data/lib/simple_mysql_api/version.rb

@@ -1,3 +1,3 @@
 module SimpleMysqlApi
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/simple_mysql_api.gemspec

@@ -5,11 +5,13 @@ require 'simple_mysql_api/version'
 Gem::Specification.new do |gem|
   gem.name          = "simple_mysql_api"
   gem.version       = SimpleMysqlApi::VERSION
-  gem.authors       = ["jalendrabhanarkar"]
-  gem.email         = ["jalendra@sapnasolutions.com"]
-  gem.description   = "Used for basic api operations,like searching etc."
-  gem.summary       = "First gem to check the functionality."
-  gem.homepage      = ""
+  gem.authors       = ["Jalendra Bhanarkar"]
+  gem.email         = ["jbmyid@gmail.com"]
+  gem.description   = "Search the records by attributes of the same table or associated tables. Search: Ex.  User.search({search_params: {name: \"Alex\", city: \"New\"}, belongs_to: false, has_many: true}) will return the User active relation with conditioning name=Alex and city=new"
+  gem.summary       = "Search the records by attributes of the same table or associated tables."
+  gem.homepage      = "http://jbmyid.wordpress.com"
+  gem.add_dependency('rails', '>= 3.2')
+  # gem.add_dependency('ActiveRecord','>= 3.2')
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

metadata

@@ -1,19 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: simple_mysql_api
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
-- jalendrabhanarkar
+- Jalendra Bhanarkar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-04 00:00:00.000000000 Z
-dependencies: []
-description: Used for basic api operations,like searching etc.
+date: 2012-09-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &2151943920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2151943920
+description: ! 'Search the records by attributes of the same table or associated tables.
+  Search: Ex.  User.search({search_params: {name: "Alex", city: "New"}, belongs_to:
+  false, has_many: true}) will return the User active relation with conditioning name=Alex
+  and city=new'
 email:
-- jalendra@sapnasolutions.com
+- jbmyid@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -28,7 +42,7 @@ files:
 - lib/simple_mysql_api/class_methods.rb
 - lib/simple_mysql_api/version.rb
 - simple_mysql_api.gemspec
-homepage: ''
+homepage: http://jbmyid.wordpress.com
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -51,5 +65,5 @@ rubyforge_project:
 rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
-summary: First gem to check the functionality.
+summary: Search the records by attributes of the same table or associated tables.
 test_files: []