sql_mapper 1.0.1 → 1.0.2

data/lib/sql_mapper.rb

@@ -3,11 +3,25 @@ require 'active_record'
 
 module ActiveRecord
   module SqlMapper
+    def self.config(&block)
+      Context.instance.instance_exec &block
+    end
+
+    def self.fetch(opts={})
+      strategy = get_strategy_for(*sql_and_result_class_for(opts))
+      strategy.do_fetch
+      strategy.process_results
+    end
+
+    def self.fetch_one(opts={})
+      fetch(opts)[0]
+    end
+
     class Context
       include Singleton
       
       def initialize
-        @result_class = Struct
+        @default_result_class = Struct
         @queries = {}
       end
 
@@ -15,14 +29,18 @@ module ActiveRecord
         @queries.dup
       end
 
+      def named_query_exists?(sym)
+        @queries.include? sym
+      end
+
       def map(name, sql, result_class=nil)
         mapping = QueryMapping.new name, sql, result_class
         @queries[name] = mapping
       end
 
       def result_class(clazz=nil)
-        @result_class = clazz if not clazz.nil? and clazz.is_a? Class
-        @result_class
+        @default_result_class = clazz if not clazz.nil? and clazz.is_a? Class
+        @default_result_class
       end
     end
 
@@ -37,7 +55,7 @@ module ActiveRecord
       end
     end
 
-    class DefaultExecStrategy
+    class ObjectExecStrategy
       def initialize(sql, result_class)
         @sql = sql
         @result_class = result_class
@@ -48,19 +66,32 @@ module ActiveRecord
       end
 
       def process_results
-        @raw_results.rows.map{|row| @result_class.new *row}
+        @raw_results.rows.map &instantiate_result_using_row
+      end
+
+      private
+      def instantiate_result_using_row
+        lambda {|row| @result_class.new *row}
       end
     end
 
-    class StructExecStrategy < DefaultExecStrategy
+    class StructExecStrategy < ObjectExecStrategy
       def initialize(sql, result_class)
         super(sql, result_class)
       end
 
       def do_fetch
         @raw_results = ActiveRecord::Base.connection.exec_query(@sql)
-        col_names = @raw_results.columns.map{|c| c.to_sym}
-        @result_class = @result_class.new(*col_names)
+        @result_class = create_struct_instance_from_col_names(@raw_results)
+      end
+
+      private
+      def create_struct_instance_from_col_names(raw_results)
+        Struct.new *extract_col_names_from(raw_results)
+      end
+
+      def extract_col_names_from(raw_results)
+        raw_results.columns.map{|c| c.to_sym}
       end
     end
 
@@ -86,54 +117,65 @@ module ActiveRecord
 
     # Json execution strategy?
     EXEC_STRATEGIES = {
-      :default => DefaultExecStrategy,
+      :object => ObjectExecStrategy,
       Struct => StructExecStrategy,
       Hash => HashExecStrategy
     }
 
-    def self.config(&block)
-      Context.instance.instance_exec &block
+    private
+    def self.sql_and_result_class_for(opts={})
+      raise ":query option must be specified" if not opts.include? :query
+      sql, result_class = obtain_sql_and_result_class_for(opts[:query], opts[:result_class])
+      sql = inject_params_into(sql, opts[:params])
+      [sql, result_class]
     end
 
-    def self.fetch(opts={})
-      sql, result_class = construct_sql_for opts
-      strategy_class = (EXEC_STRATEGIES[result_class] || EXEC_STRATEGIES[:default])
-      strategy = strategy_class.new(sql, result_class)
-      strategy.do_fetch
-      strategy.process_results
+    def self.wrap_non_arrays_in_array(val)
+      if val.kind_of? Array
+        val
+      else
+        [val]
+      end
     end
 
-    def self.fetch_one(opts={})
-      results = fetch(opts)
-      results[0]
+    def self.get_strategy_for(sql, result_class)
+      get_strategy_class_for(result_class).new(sql, result_class)
     end
 
-    private
-    def self.construct_sql_for(opts={})
-      raise ":query option must be specified" if not opts.include? :query
-      sql = opts[:query]
+    def self.get_strategy_class_for(result_class)
+      (EXEC_STRATEGIES[result_class] || EXEC_STRATEGIES[:object])
+    end
 
-      result_class = opts[:result_class] || Context.instance.result_class
-      if opts[:query].kind_of? Symbol
-        mapping = Context.instance.queries[opts[:query]]
-        raise "No query named #{opts[:query]} found" if mapping.nil?
+    def self.obtain_sql_and_result_class_for(query, result_class)
+      if is_named_query(query)
+        mapping = Context.instance.queries[query]
         sql = mapping.sql
-        result_class = mapping.result_class || result_class
+        result_class = result_class || mapping.result_class || Context.instance.result_class
+      else
+        sql = query
+        result_class = result_class || Context.instance.result_class
       end
+      [sql, result_class]
+    end
 
-      if opts.include? :params
-        sql_array = [sql] + wrap_non_arrays_in_array(opts[:params])
-        sql = ActiveRecord::Base.send :sanitize_sql_array, sql_array
+    def self.is_named_query(query)
+      result = false
+      if query.kind_of? Symbol
+        if Context.instance.named_query_exists?(query)
+          result = true
+        else
+          raise "No query named #{query} found"
+        end
       end
-      [sql, result_class]
+      result
     end
 
-    def self.wrap_non_arrays_in_array(val)
-      if val.kind_of? Array
-        val
-      else
-        [val]
+    def self.inject_params_into(sql, params)
+      unless params.nil?
+        sql_array = [sql] + wrap_non_arrays_in_array(params)
+        sql = ActiveRecord::Base.send :sanitize_sql_array, sql_array
       end
+      sql
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sql_mapper
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors: