yesql 0.1.5 → 0.2.1

data/lib/yesql/bindings/utils.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-module YeSQL
+module ::YeSQL
   module Bindings
     module Utils
+      include ::YeSQL::Utils::Read
+
       def statement_binds(extractor)
-        ::YeSQL::Utils::Read.statement(file_path, readable: true)
-                            .scan(::YeSQL::BIND_REGEX).map do |(bind)|
-          extractor[bind.to_sym][:bind].values_at(:vals, :vars)
-        end
+        statement(readable: true)
+          .scan(::YeSQL::BIND_REGEX)
+          .map(&:first)
+          .map { extractor[_1.to_sym][:bind].values_at(:vals, :vars) }
       end
     end
   end

data/lib/yesql/common/adapter.rb

@@ -1,25 +1,18 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+require "forwardable"
 
 module ::YeSQL
   module Common
     module Adapter
-      extend Forwardable
+      extend ::Forwardable
 
-      # `adapter` might be a complex object, but
-      # for the sake of brevity it's just a string
-      def adapter
-        ::ActiveRecord::Base.connection.adapter_name
-      end
+      def mysql? = adapter == "Mysql2"
+      def pg? = adapter == "PostgreSQL"
 
-      def mysql?
-        adapter == 'Mysql2'
-      end
+      private
 
-      def pg?
-        adapter == 'PostgreSQL'
-      end
+      def adapter = ::ActiveRecord::Base.connection.adapter_name
     end
   end
 end

data/lib/yesql/config/configuration.rb

@@ -3,20 +3,19 @@
 module ::YeSQL
   module Config
     class Configuration
-      attr_accessor :path
+      attr_accessor :connection, :path
 
-      DEFAULT_PATH = 'app/yesql'
+      DEFAULT_PATH = "app/yesql"
 
       def initialize
+        @connection = ""
         @path = DEFAULT_PATH
       end
     end
   end
 
   class << self
-    def config
-      @config ||= ::YeSQL::Configuration.new
-    end
+    def config = @config ||= ::YeSQL::Configuration.new
 
     def configure
       yield config if block_given?

data/lib/yesql/errors/file_path_does_not_exist_error.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
-module YeSQL
+module ::YeSQL
   module Errors
-    module FilePathDoesNotExistError
-      def validate_file_path_existence(file_path)
-        return if file_exists?(file_path)
+    class FilePathDoesNotExistError
+      def initialize(file_path)
+        @file_path = file_path
+      end
 
-        raise NotImplementedError, format(MESSAGE, available_files: available_files,
-                                                   file_path: file_path, path: ::YeSQL.config.path)
+      def validate_file_path_existence
+        return if file_exists?
+
+        raise(
+          ::NotImplementedError,
+          format(
+            MESSAGE,
+            available_files: available_files,
+            file_path: file_path,
+            path: ::YeSQL.config.path
+          )
+        )
       end
 
       private
 
+      attr_reader :file_path
+
       MESSAGE = <<~MSG
 
         SQL file "%<file_path>s" does not exist in %<path>s.
@@ -22,17 +35,9 @@ module YeSQL
       MSG
       private_constant :MESSAGE
 
-      def file_exists?(file_path)
-        path_files.any? { |filename| filename.include?("#{file_path}.sql") }
-      end
-
-      def available_files
-        path_files.map { |file| "- #{file}\n" }.join
-      end
-
-      def path_files
-        @path_files ||= Dir["#{::YeSQL.config.path}/**/*.sql"]
-      end
+      def file_exists? = path_files.any? { _1.include?("#{file_path}.sql") }
+      def path_files = @path_files ||= Dir["#{::YeSQL.config.path}/**/*.sql"]
+      def available_files = path_files.map { "- #{_1}\n" }.join
     end
   end
 end

data/lib/yesql/errors/no_bindings_provided_error.rb

@@ -1,18 +1,28 @@
 # frozen_string_literal: true
 
-module YeSQL
+require "yesql/utils/read"
+
+module ::YeSQL
   module Errors
-    module NoBindingsProvidedError
-      def validate_statement_bindings(binds, file_path)
-        return unless statement_binds(file_path).size.positive?
+    class NoBindingsProvidedError
+      include ::YeSQL::Utils::Read
 
-        format(MESSAGE, renderable_statement_binds(file_path)).tap do |message|
-          raise ArgumentError, message unless binds.is_a?(Hash) && !binds.empty?
-        end
+      def initialize(binds, file_path)
+        @binds = binds
+        @file_path = file_path
+      end
+
+      def validate_statement_bindings
+        return unless statement_binds.size.positive?
+        return if expected_binds?
+
+        raise ::ArgumentError, format(MESSAGE, renderable_statement_binds)
       end
 
       private
 
+      attr_reader :binds, :file_path
+
       MESSAGE = <<~MSG
 
         YeSQL invoked without bindings.
@@ -23,18 +33,9 @@ module YeSQL
       MSG
       private_constant :MESSAGE
 
-      def statement_binds(file_path)
-        ::YeSQL::Utils::Read.statement(file_path)
-                            .scan(::YeSQL::BIND_REGEX).tap do |scanned_binds|
-          break [] if scanned_binds.size.zero?
-
-          break scanned_binds.sort
-        end
-      end
-
-      def renderable_statement_binds(file_path)
-        statement_binds(file_path).flatten.map { |bind| "- `#{bind}`\n" }.join
-      end
+      def statement_binds = statement.scan(::YeSQL::BIND_REGEX).tap { break (_1 || []).sort }
+      def renderable_statement_binds = statement_binds.flatten.map { "- `#{_1}`\n" }.join
+      def expected_binds? = binds.is_a?(::Hash) && !binds.empty?
     end
   end
 end

data/lib/yesql/errors/output_argument_error.rb

@@ -1,14 +1,23 @@
 # frozen_string_literal: true
 
-module YeSQL
+module ::YeSQL
   module Errors
-    module OutputArgumentError
-      def validate_output_options(output)
+    class OutputArgumentError
+      def initialize(output)
+        @output = output
+      end
+
+      def validate_output_options
         return if output.nil?
+        return if OPTIONS.include?(output.to_sym)
 
-        raise ArgumentError, format(MESSAGE, output) unless OPTIONS.include?(output.to_sym)
+        raise ArgumentError, format(MESSAGE, output)
       end
 
+      private
+
+      attr_reader :output
+
       MESSAGE = <<~MSG
         Unsupported `output` option given `%s`. Possible values are:
           - `columns`: returns an array with the columns from the result.

data/lib/yesql/params/output.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "forwardable"
+
+module ::YeSQL
+  module Params
+    class Output
+      extend ::Forwardable
+
+      def initialize(output)
+        @output = output.to_s
+      end
+
+      def columns? = output == "columns"
+      def rows? = output == "rows"
+      def hash? = output == "hash"
+
+      def_delegator(:output, :to_sym)
+
+      private
+
+      attr_reader :output
+    end
+  end
+end

data/lib/yesql/query/performer.rb

@@ -1,88 +1,44 @@
 # frozen_string_literal: true
 
-require 'yesql'
-require 'forwardable'
-require 'yesql/bindings/utils'
-require 'yesql/common/adapter'
-
-module YeSQL
+require "yesql"
+require "yesql/bindings/utils"
+require "yesql/common/adapter"
+require "yesql/bindings/transformed"
+require "yesql/query/result"
+require "yesql/query/transform_result"
+require "yesql/params/output"
+
+module ::YeSQL
   module Query
     class Performer
-      extend Forwardable
-
       include ::YeSQL::Bindings::Utils
-      include ::YeSQL::Common::Adapter
 
-      # rubocop:disable Metrics/ParameterLists
-      def initialize(bind_statement:,
-                     bindings: {},
-                     cache: {},
-                     file_path:,
-                     output: :rows,
-                     prepare: false)
+      def initialize(bind_statement:, file_path:, bindings: {}, output: :rows, prepare: false)
         @bind_statement = bind_statement
-        @cache = cache
-        @cache_key = cache[:key] || file_path
-        @connection = ActiveRecord::Base.connection
-        @expires_in = cache[:expires_in]
         @file_path = file_path
         @named_bindings = bindings.transform_keys(&:to_sym)
-        @output = output
+        @output = ::YeSQL::Params::Output.new(output)
         @prepare = prepare
       end
-      # rubocop:enable Metrics/ParameterLists
-
-      def call
-        return modified_output if cache.empty?
 
-        Rails.cache.fetch(cache_key, expires_in: expires_in) { modified_output }
-      end
+      def call = ::YeSQL::Query::TransformResult.new(output: output, result: query_result).call
 
       private
 
-      attr_reader :bind_statement,
-                  :cache,
-                  :cache_key,
-                  :connection,
-                  :expires_in,
-                  :file_path,
-                  :named_bindings,
-                  :output,
-                  :prepare,
-                  :rows
-
-      def_delegator(:query_result, :columns)
-      private :columns
-      def_delegator(:query_result, :rows)
-      private :rows
-
-      def modified_output
-        @modified_output ||=
-          begin
-            return query_result.public_send(output) if %w[columns rows].include?(output.to_s)
-
-            columns.map(&:to_sym).tap { |cols| break rows.map { |row| cols.zip(row).to_h } }
-          end
-      end
+      attr_reader :bind_statement, :file_path, :named_bindings, :output, :prepare
 
       def query_result
-        @query_result ||= connection.exec_query(bind_statement, file_path, binds, prepare: prepare)
+        @query_result ||= ::YeSQL::Query::Result.new(binds: binds,
+                                                     bind_statement: bind_statement,
+                                                     file_path: file_path,
+                                                     prepare: prepare).call
       end
 
-      def extractor
-        ::YeSQL::Bindings::Extractor.new(bindings: named_bindings).call
-      end
-
-      # TODO: move this somewhere else.
       def binds
-        statement_binds(extractor)
-          .sort_by { |_, position| position.to_s.tr('$', '').to_i }
-          .tap { |x| break(mysql? ? x : x.uniq) }
-          .map(&:first)
-          .flatten
-          .each_slice(2)
-          .to_a
+        ::YeSQL::Bindings::Transformed.new(statement_binds: statement_binds(extractor)).call
       end
+
+      def extractor = ::YeSQL::Bindings::Extractor.new(bindings: named_bindings).call
     end
   end
 end

data/lib/yesql/query/result.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "forwardable"
+require "yesql/common/adapter"
+
+module ::YeSQL
+  module Query
+    class Result
+      extend ::Forwardable
+
+      include ::YeSQL::Common::Adapter
+
+      def initialize(bind_statement:, file_path:, prepare:, binds: [])
+        @binds = binds
+        @bind_statement = bind_statement
+        @file_path = file_path
+        @prepare_option = prepare
+      end
+
+      def call
+        return view_result if view?
+        return rails5_result if ::ActiveRecord::VERSION::MAJOR == 5 && mysql?
+
+        exec_query(bound, file_path, binds, prepare: prepare_option)
+      end
+
+      private
+
+      attr_reader :binds, :bind_statement, :file_path, :prepare_option
+
+      def_delegators(:bind_statement, :bound, :to_s, :view?)
+      def_delegators(:connection, :exec_query, :raw_connection)
+      def_delegators(:raw_connection, :prepare)
+
+      def view_result =  exec_query(bound)
+      def rails5_result = prepare(bound).execute(*binds)
+      def connection = @connection ||= ActiveRecord::Base.connection
+    end
+  end
+end

data/lib/yesql/query/transform_result.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "yesql"
+require "yesql/common/adapter"
+require "forwardable"
+
+module ::YeSQL
+  module Query
+    class TransformResult
+      extend ::Forwardable
+
+      include ::YeSQL::Common::Adapter
+
+      def initialize(output:, result:)
+        @output = output
+        @result = result
+      end
+
+      def call
+        if rails_5? && mysql?
+          return columns if columns?
+          return rows_values if rows?
+          return array_of_symbol_hashes if hash?
+        end
+
+        return result.public_send(output.to_sym) if columns? || rows?
+
+        to_a.map(&:symbolize_keys)
+      end
+
+      private
+
+      attr_reader :output, :result
+
+      def_delegators(:result, :fields, :rows, :to_a)
+      def_delegators(:output, :columns?, :hash?, :rows?)
+
+      def array_of_symbol_hashes
+        to_a.tap { break hashed_rows(_1) if rails_5? }.map { _1&.symbolize_keys || _1 }
+      end
+
+      def columns = fields || result.columns
+      def rows_values = to_a.map { _1.respond_to?(:values) ? _1.values : _1 }
+      def hashed_rows(rows) = rows.map { columns.zip(_1).to_h }
+      def rails_5? = ::ActiveRecord::VERSION::MAJOR == 5
+    end
+  end
+end