predefined 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d326c7094088f2bd75bca4da0142c213c9a17ce
+  data.tar.gz: 6d85ccf0c4bc7a30e3db7c177761e0445fc307a8
+SHA512:
+  metadata.gz: 380223845dadba62611409069b8e155c262b713271dee3287e9c2d68561c55d456d8b621e8cd78a0e951b4bbd3aed13fa1aee7c24387da1e809cb9d23ba44ae3
+  data.tar.gz: 937d20bc196b89fabcd6066281b6fb4103bd2d83f1a75d6487fe62f7ef9d06ab70d99e928f02a53f7dc102b9af088d5cc6d131b2b6a95639aee4ef1802cc7887

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in predefined.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Paul Barry
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# Predefined
+
+Predefined is a library for writing parameterized SQL queries, executing them and mapping the result to on to objects.
+
+## Installation
+
+To use in a [Rails][rails] app, add this line to your application's Gemfile:
+
+```ruby
+gem 'predefined', require: 'predefined/rails'
+```
+
+To use in a Ruby app with [Sequel][sequel], app this line your application's Gemfile:
+
+```ruby
+gem 'predefined', require: 'predefined/sequel'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install predefined
+
+## Usage
+
+The basic concept of Predefined is that you will write SQL queries and save them into a file. For example, if you have a Rails app with a users table, you would create a file `app/queries/users/get.sql` that would look like this:
+
+```sql
+SELECT
+  *
+FROM
+  users
+WHERE
+  id = :id
+```
+
+Then to execute the query and return the results, you would write code like this:
+
+```ruby
+Predefined::ActiveRecordQuery.new('users/get').select_one(id: id)
+```
+
+This will replace `:id` in your SQL statement with the actual value you pass in, then run the query and return the results as a Hash.
+
+To make the syntax a bit cleaner, include the module `Predefined::ActiveRecordHelpers` in your base classes like `ApplicationController`, then you can simply run this code:
+
+```ruby
+select_one 'users/get', id: id
+```
+
+There are several methods you can use to execute a query:
+
+### `select_one(template_file, params)`
+
+This method take the name of the query and the parameters for the query and returns a Hash with the keys as Symbols and the values are type casted, meaning if the database column is an Integer, you will get a Integer instead of a String.
+
+### `select_all(template_file, params)`
+
+This method takes the name of the query and the parameters for the query and returns an Array of Hashes, one Hash for each row in the result of the query. The keys of the Hashes are Symbols and the values are type casted.
+
+### `select_rows(template_file, params)`
+
+This method will return an Array of Arrays of type casted values, one Array for each row in the result of the query.
+
+### `select_values(template_file, params)`
+
+This method will return an Array of type casted values, using the first column from the result of the query.
+
+### `select_values(template_file, params)`
+
+This method will return a type casted value, the first column in the first row of the result
+
+### `select_object(template_file, klass, params)`
+
+This method is like `select_one`, but it will also pass the Hash an an argument to the class's new method and return the object instance. This:
+
+```ruby
+select_object 'thing', Thing, id: 1
+```
+
+is equivalent to
+
+```ruby
+Thing.new(select_one('thing', id: 1))
+```
+
+### `select_objects(template_file, klass, params)`
+
+This is like `select_object` except that it creates an object for every row in the result of the query and returns the Array of objects
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/predefined/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+[rails]: http://rubyonrails.org/
+[sequel]: http://sequel.jeremyevans.net/

data/Rakefile

@@ -0,0 +1,11 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib", "test"]
+  t.test_files = FileList["test/*_test.rb"]
+end
+
+task :default => :test

data/lib/predefined.rb

@@ -0,0 +1,5 @@
+require "predefined/version"
+
+module Predefined
+  # Your code goes here...
+end

data/lib/predefined/active_record.rb

@@ -0,0 +1,68 @@
+require 'predefined/query'
+
+module Predefined
+  class ActiveRecordQuery < Query
+    class Database < ActiveRecord::Base
+      self.abstract_class = true
+    end
+
+    def connection
+      Database.connection
+    end
+
+    def to_sql(params=nil)
+      Database.send(:sanitize_sql, [template, params])
+    end
+
+    def select_all(params=nil)
+      result_to_rows(connection.select_all(to_sql(params), name))
+    end
+
+    def select_one(params=nil)
+      select_all(params).first
+    end
+
+    def select_rows(params=nil)
+      connection.select_rows(to_sql(params), name)
+    end
+
+    def select_values(params=nil)
+      connection.select_values(to_sql(params), name)
+    end
+
+    def select_value(params=nil)
+      connection.select_value(to_sql(params), name)
+    end
+
+    def select_object(klass, params=nil)
+      record = connection.select_one(to_sql(params), name)
+      if record
+        klass.new(record)
+      end
+    end
+
+    def select_objects(klass, params=nil)
+      connection.select_all(to_sql(params), name).map do |row|
+        klass.new(row)
+      end
+    end
+
+    # TODO: Is there a way to do this built-in to ActiveRecord?
+    def result_to_rows(result)
+      result.rows.map do |row|
+        typed_row = result.columns.zip(row).map do |column_name, value|
+          typed_value = result.column_types[column_name].send(:type_cast, value)
+          [column_name.to_sym, typed_value]
+        end
+        Hash[typed_row]
+      end
+    end
+  end
+
+  module ActiveRecordHelpers
+    include Helpers
+    def predefined_helper_query_class
+      ActiveRecordQuery
+    end
+  end
+end

data/lib/predefined/adapter_interface.rb

@@ -0,0 +1,35 @@
+module Predefined
+  module AdapterInterface
+    def to_sql(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_all(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_one(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_rows(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_values(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_value(params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_object(klass, params=nil)
+      raise "Not Implemented"
+    end
+
+    def select_objects(klass, parmas=nil)
+      raise "Not Implemented"
+    end
+  end
+end

data/lib/predefined/query.rb

@@ -0,0 +1,91 @@
+require 'predefined/adapter_interface'
+
+module Predefined
+  class Query
+    include Predefined::AdapterInterface
+    class Error < RuntimeError; end
+    class MissingTemplateError < Error; end
+
+    attr_reader :name
+
+    def self.template_paths
+      if defined? @template_paths
+        @template_paths
+      elsif superclass.respond_to?(:template_paths)
+        superclass.template_paths
+      else
+        @template_paths ||= []
+      end
+    end
+
+    def self.template_paths=(paths)
+      @template_paths = Array(paths)
+    end
+
+    def self.template(name)
+      @template ||= begin
+        template_paths.each do |path|
+          file = template_file(path, name)
+          if File.exists?(file)
+            return format_query(File.read(file))
+          end
+        end
+        template_missing(name)
+      end
+    end
+
+    def self.template_file(path, name)
+      File.join(path, "#{name}.sql")
+    end
+
+    def self.template_missing(name)
+      raise MissingTemplateError.new("Could not find template for query #{name.inspect} in #{template_paths.inspect}")
+    end
+
+    def self.format_query(sql)
+      sql.to_s.split(/\n/).map(&:strip).join(' ')
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    def template
+      self.class.template(name)
+    end
+  end
+
+  module Helpers
+    def predefined_helper_query_class
+      raise "Not Implemented"
+    end
+
+    def select_all(template_name, params=nil)
+      predefined_helper_query_class.new(template_name).select_all(params)
+    end
+
+    def select_one(template_name, params=nil)
+      predefined_helper_query_class.new(template_name).select_one(params)
+    end
+
+    def select_rows(template_name, params=nil)
+      predefined_helper_query_class.new(template_name).select_rows(params)
+    end
+
+    def select_values(template_name, params=nil)
+      predefined_helper_query_class.new(template_name).select_values(params)
+    end
+
+    def select_value(template_name, params=nil)
+      predefined_helper_query_class.new(template_name).select_value(params)
+    end
+
+    def select_object(template_name, klass, params=nil)
+      predefined_helper_query_class.new(template_name).select_object(klass, params)
+    end
+
+    def select_objects(template_name, klass, params=nil)
+      predefined_helper_query_class.new(template_name).select_objects(klass, params)
+    end
+  end
+end

data/lib/predefined/rails.rb

@@ -0,0 +1,9 @@
+require 'predefined/active_record'
+
+module Predefined
+  class Railtie < Rails::Railtie
+    initializer "predefined.configure_template_paths" do
+      Predefined::Query.template_paths = Rails.root.join('app/queries')
+    end
+  end
+end

data/lib/predefined/sequel.rb

@@ -0,0 +1,44 @@
+require 'predefined/query'
+
+module Predefined
+  class SequelQuery < Query
+    def to_sql(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_all(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_one(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_rows(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_values(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_value(params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_object(klass, params=nil)
+      raise "TODO: Implement Me"
+    end
+
+    def select_objects(klass, parmas=nil)
+      raise "TODO: Implement Me"
+    end
+  end
+
+  module SequelHelpers
+    include Helpers
+    def predefined_helper_query_class
+      SequelQuery
+    end
+  end
+end

data/lib/predefined/version.rb

@@ -0,0 +1,3 @@
+module Predefined
+  VERSION = "0.0.1"
+end

data/predefined.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'predefined/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "predefined"
+  spec.version       = Predefined::VERSION
+  spec.authors       = ["Paul Barry"]
+  spec.email         = ["mail@paulbarry.com"]
+  spec.summary       = %q{a library for writing parameterized SQL queries, executing them and mapping the result to on to objects.}
+  spec.homepage      = "http://github.com/pjb3/predefined"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/test/queries/users/find_by_status.sql

@@ -0,0 +1,6 @@
+SELECT
+  username, first_name, last_name, email
+FROM
+  users
+WHERE
+  status = :status

data/test/query_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class QueryTest < Minitest::Test
+  def test_template
+    query = Predefined::Query.new("users/find_by_status")
+    assert_equal "SELECT username, first_name, last_name, email FROM users WHERE status = :status",
+      query.template
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,4 @@
+require 'minitest/autorun'
+require 'predefined/query'
+
+Predefined::Query.template_paths << File.expand_path('queries', File.dirname(__FILE__))

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: predefined
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paul Barry
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- mail@paulbarry.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/predefined.rb
+- lib/predefined/active_record.rb
+- lib/predefined/adapter_interface.rb
+- lib/predefined/query.rb
+- lib/predefined/rails.rb
+- lib/predefined/sequel.rb
+- lib/predefined/version.rb
+- predefined.gemspec
+- test/queries/users/find_by_status.sql
+- test/query_test.rb
+- test/test_helper.rb
+homepage: http://github.com/pjb3/predefined
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: a library for writing parameterized SQL queries, executing them and mapping
+  the result to on to objects.
+test_files:
+- test/queries/users/find_by_status.sql
+- test/query_test.rb
+- test/test_helper.rb