simple-sql 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a64abeaf64f527b10d9381fcecbb47c712184ebc
+  data.tar.gz: 8ad02d882e3f281c4880af342c7b15c33e189e4f
+SHA512:
+  metadata.gz: fec8ff260a4551b5f5e73640291cf1db92792aa108fc73e218825e27890e8275028617c52fa9acde204373155bebad645d894515461bf09dc1f2ccac592efa7e
+  data.tar.gz: fb5648febf02c8a08e25c31e30602838bdaff934ddd1097d597291b3b09a03d8451218f1a9594a77ac0fe66be9b2366ce1406477e2b1fa3dc72e7ff30f5cf97e

data/.gitignore

@@ -0,0 +1,4 @@
+coverage
+rdoc
+pkg
+log/test.log

data/.rubocop.yml

@@ -0,0 +1,35 @@
+AllCops:
+  TargetRubyVersion: 2.3
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'bin/**/*'
+    - 'tasks/release.rake'
+    - '*.gemspec'
+    - 'Gemfile'
+    - 'Rakefile'
+
+Metrics/LineLength:
+  Max: 115
+
+Style/SpecialGlobalVars:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+  ConsistentQuotesInMultiline: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/MutableConstant:
+  Enabled: false

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,90 @@
+PATH
+  remote: .
+  specs:
+    simple-sql (0.1.3)
+      activerecord (~> 4)
+      pg_array_parser (~> 0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.10)
+      activesupport (= 4.2.10)
+      builder (~> 3.1)
+    activerecord (4.2.10)
+      activemodel (= 4.2.10)
+      activesupport (= 4.2.10)
+      arel (~> 6.0)
+    activesupport (4.2.10)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    arel (6.0.4)
+    ast (2.3.0)
+    builder (3.2.3)
+    concurrent-ruby (1.0.5)
+    database_cleaner (1.6.2)
+    diff-lcs (1.3)
+    docile (1.1.5)
+    factory_girl (4.8.0)
+      activesupport (>= 3.0.0)
+    i18n (0.9.1)
+      concurrent-ruby (~> 1.0)
+    json (2.1.0)
+    minitest (5.10.3)
+    parallel (1.10.0)
+    parser (2.4.0.2)
+      ast (~> 2.3)
+    pg (0.20.0)
+    pg_array_parser (0.0.9)
+    powerpack (0.1.1)
+    rainbow (2.2.2)
+      rake
+    rake (11.3.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+    rubocop (0.52.1)
+      parallel (~> 1.10)
+      parser (>= 2.4.0.2, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.9.0)
+    simplecov (0.15.1)
+      docile (~> 1.1.0)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+    thread_safe (0.3.6)
+    tzinfo (1.2.4)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 1)
+  factory_girl (= 4.8.0)
+  pg (= 0.20)
+  rake (~> 11)
+  rspec (~> 3.7)
+  rubocop (~> 0.52.1)
+  simple-sql!
+  simplecov (~> 0)
+
+BUNDLED WITH
+   1.13.6

data/README.md

@@ -0,0 +1,107 @@
+# simple-sql
+
+## Installation
+
+The gem is available through our private gem host:
+
+```ruby
+gem 'simple-sql' # + version
+```
+
+## Usage
+
+This gem defines a module `Simple::SQL`, which you can use to execute SQL statements
+on the current ActiveRecord connection.
+
+Simple::SQL takes care of converting arguments back and forth.
+
+### Running a query
+
+`Simple::SQL.all` runs a query, with optional arguments, and returns the result. Usage example:
+
+    Simple::SQL.all "SELECT id, email FROM users WHERE id = ANY($1)", [1,2,3]
+
+If the SQL query returns rows with one column, this method returns an array of these values.
+Otherwise it returns an array of arrays.
+
+Examples:
+
+```ruby
+Simple::SQL.all("SELECT id FROM users")        # returns an array of id values, but
+Simple::SQL.all("SELECT id, email FROM users") # returns an array of arrays `[ <id>, <email> ]`.
+```
+
+If a block is passed to SQL.all, each row is yielded into the block:
+
+```ruby
+Simple::SQL.all "SELECT id, email FROM users" do |id, email|
+  # do something
+end
+```
+
+In this case SQL.all returns `self`, which lets you chain function calls. 
+
+### Getting the first result
+
+`Simple::SQL.ask` returns runs a query, with optional arguments, and returns the first result row.
+
+
+    Simple::SQL.ask "SELECT id, email FROM users WHERE id = ANY($1) LIMIT 1", [1,2,3]
+
+If the SQL query returns rows with one column, this method returns the column value of the first row; otherwise it returns an array (or `nil` if there was no result).
+
+Examples:
+
+```ruby
+Simple::SQL.ask "SELECT id FROM users WHERE email=$1", "foo@local"         # returns a number (or `nil`) and
+Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"  # returns an array `[ <id>, <email> ]` (or `nil`)
+```
+
+## Notes
+
+Remember that Postgresql uses $1, $2, etc. as placeholders; the following is correct:
+
+```ruby
+Simple::SQL.all "SELECT * FROM users WHERE email=$1", "foo@bar.local"
+```
+
+Also note that `IN(?)` is not supported by the Postgresql client library; instead you
+must use `= ANY`, for example:
+
+```ruby
+Simple::SQL.all "SELECT * FROM users WHERE id = ANY($1)", [1,2,3]
+```
+
+
+## Bugs and Limitations
+
+### 1. Multiple connections
+
+It is currently not possible to run SQL queries against a database which is not
+connected via ActiveRecord::Base.connection.
+
+### 2. Postgresql only
+
+Only Postgresql is supported.
+
+### 3. Limited support for types
+
+This gem does not use `pg`'s support for encoding and decoding types, since
+that might probably interfere with how ActiveRecord is setting up the `pg`
+gem.
+
+It therefore assumes ActiveRecord is used in the same project, which sets up
+pg to not decode data in any meaningful way, and provides some code to decode
+the data returned from the database. Only a handful of types is currently
+supported by the Decoder - it is fairly easy to add new types, though.
+
+### 4. text arrays
+
+The library used to parse array results seems to be buggy if the array contains
+strings containing the "`" character.
+
+## Test
+
+1. `createdb simple-sql-test`
+2. `bundle install`
+3. `bin/rspec`

data/Rakefile

@@ -0,0 +1,9 @@
+require "rubocop/rake_task"
+require "rspec/core/rake_task"
+
+Dir.glob("tasks/*.rake").each { |r| import r }
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]

data/bin/rake

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+                                           Pathname.new(__FILE__).realpath)
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/config/database.yml

@@ -0,0 +1,7 @@
+adapter: postgresql
+encoding: utf8
+host: '127.0.0.1'
+username: postgres
+pool: 5
+timeout: 5000
+database: simple-sql-test

data/lib/simple/sql.rb

@@ -0,0 +1,103 @@
+require_relative "sql/version.rb"
+require_relative "sql/decoder.rb"
+require_relative "sql/encoder.rb"
+
+module Simple
+  # The Simple::SQL module
+  module SQL
+    extend self
+
+    # execute one or more sql statements. This method does not allow to pass in
+    # arguments - since the pg client does not support this - but it allows to
+    # run multiple sql statements separated by ";"
+    extend Forwardable
+    delegate exec: :pg
+
+    # Runs a query, with optional arguments, and returns the result. If the SQL
+    # query returns rows with one column, this method returns an array of these
+    # values. Otherwise it returns an array of arrays.
+    #
+    # Example:
+    #
+    # - <tt>Simple::SQL.all("SELECT id FROM users")</tt> returns an array of id values
+    # - <tt>Simple::SQL.all("SELECT id, email FROM users")</tt> returns an array of
+    #         arrays `[ <id>, <email> ]`.
+    #
+    # Simple::SQL.all "SELECT id, email FROM users" do |id, email|
+    #   # do something
+    # end
+
+    def all(sql, *args, &block)
+      result  = connection.exec_params(sql, Encoder.encode_args(args))
+      decoder = Decoder.new(result)
+
+      enumerate(result, decoder, block)
+    end
+
+    # Runs a query and returns the first result row of a query.
+    #
+    # Examples:
+    #
+    # - <tt>Simple::SQL.ask "SELECT id FROM users WHERE email=$?", "foo@local"</tt>
+    #   returns a number (or +nil+)
+    # - <tt>Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"</tt>
+    #   returns an array <tt>[ <id>, <email> ]</tt> (or +nil+)
+    def ask(sql, *args)
+      catch(:ok) do
+        all(sql, *args) { |row| throw :ok, row }
+        nil
+      end
+    end
+
+    # Runs a query, with optional arguments, and returns the result as an
+    # array of Hashes.
+    #
+    # Example:
+    #
+    # - <tt>Simple::SQL.records("SELECT id, email FROM users")</tt> returns an array of
+    #         hashes { id: id, email: email }
+    #
+    # Simple::SQL.records "SELECT id, email FROM users" do |record|
+    #   # do something
+    # end
+
+    def records(sql, *args, into: Hash, &block)
+      result  = connection.exec_params(sql, Encoder.encode_args(args))
+      decoder = Decoder.new(result, :record, into: into)
+
+      enumerate(result, decoder, block)
+    end
+
+    # Runs a query and returns the first result row of a query as a Hash.
+    def record(sql, *args, into: Hash)
+      catch(:ok) do
+        records(sql, *args, into: into) { |row| throw :ok, row }
+        nil
+      end
+    end
+
+    private
+
+    def enumerate(result, decoder, block)
+      if block
+        result.each_row do |row|
+          block.call decoder.decode(row)
+        end
+        self
+      else
+        ary = []
+        result.each_row { |row| ary << decoder.decode(row) }
+        ary
+      end
+    end
+
+    def resolve_type(ftype, fmod)
+      @resolved_types ||= {}
+      @resolved_types[[ftype, fmod]] ||= connection.exec("SELECT format_type($1,$2)", [ftype, fmod]).getvalue(0, 0)
+    end
+
+    def connection
+      ActiveRecord::Base.connection.raw_connection
+    end
+  end
+end

data/lib/simple/sql/decoder.rb

@@ -0,0 +1,114 @@
+# private
+module Simple::SQL::Decoder
+  extend self
+
+  def new(result, mode = nil, into: nil)
+    if mode == :record        then Record.new(result, into: into)
+    elsif result.nfields == 1 then SingleColumn.new(result)
+    else                      MultiColumns.new(result)
+    end
+  end
+
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/CyclomaticComplexity
+  # rubocop:disable Metrics/MethodLength
+  def decode_value(type, s)
+    case type
+    when :unknown                       then s
+    when :"character varying"           then s
+    when :integer                       then Integer(s)
+    when :bigint                        then Integer(s)
+    when :numeric                       then Float(s)
+    when :'integer[]'                   then s.scan(/-?\d+/).map { |part| Integer(part) }
+    when :"character varying[]"         then parse_pg_array(s)
+    when :"text[]"                      then parse_pg_array(s)
+    when :"timestamp without time zone" then ::Time.parse(s)
+    when :hstore                        then HStore.parse(s)
+    when :json                          then ::JSON.parse(s)
+    when :jsonb                         then ::JSON.parse(s)
+    else                                s # unknown value, we just return the string here.
+    end
+  end
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/CyclomaticComplexity
+  # rubocop:enable Metrics/MethodLength
+
+  require "pg_array_parser"
+  extend PgArrayParser
+
+  # HStore parsing
+  module HStore
+    module_function
+
+    # thanks to https://github.com/engageis/activerecord-postgres-hstore for regexps!
+
+    QUOTED_LITERAL    = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    UNQUOTED_LITERAL  = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    LITERAL           = /(#{QUOTED_LITERAL}|#{UNQUOTED_LITERAL})/
+    PAIR              = /#{LITERAL}\s*=>\s*#{LITERAL}/
+    NULL              = /\ANULL\z/i
+    DOUBLE_QUOTE      = '"'.freeze
+    ESCAPED_CHAR      = /\\(.)/
+
+    def parse(hstore)
+      hstore.scan(PAIR).each_with_object({}) do |(k, v), memo|
+        k = unpack(k)
+        k = k.to_sym
+        v = v =~ NULL ? nil : unpack(v)
+        memo[k] = v
+      end
+    end
+
+    def unpack(string)
+      string = string[1..-2] if string[0] == DOUBLE_QUOTE # remove quotes, if any
+      string.gsub ESCAPED_CHAR, '\1'                      # unescape, if necessary
+    end
+  end
+end
+
+class Simple::SQL::Decoder::MultiColumns
+  def initialize(result)
+    @field_types = 0.upto(result.fields.length - 1).map do |idx|
+      typename = ::Simple::SQL.send(:resolve_type, result.ftype(idx), result.fmod(idx))
+      typename.to_sym
+    end
+  end
+
+  def decode(row)
+    @field_types.zip(row).map do |field_type, value|
+      value && Simple::SQL::Decoder.decode_value(field_type, value)
+    end
+  end
+end
+
+class Simple::SQL::Decoder::SingleColumn < Simple::SQL::Decoder::MultiColumns
+  def initialize(result)
+    super
+    @field_type = @field_types.first
+  end
+
+  def decode(row)
+    value = row.first
+    value && Simple::SQL::Decoder.decode_value(@field_type, value)
+  end
+end
+
+class Simple::SQL::Decoder::Record < Simple::SQL::Decoder::MultiColumns
+  def initialize(result, into:)
+    super(result)
+
+    @into = into
+    @result = result
+    @field_names = @result.fields.map(&:to_sym)
+  end
+
+  def decode(row)
+    decoded_row = super(row)
+    hsh = Hash[@field_names.zip(decoded_row)]
+    if @into && @into != Hash
+      @into.new(hsh)
+    else
+      hsh
+    end
+  end
+end

data/lib/simple/sql/encoder.rb

@@ -0,0 +1,21 @@
+# private
+module Simple::SQL::Encoder
+  extend self
+  extend Forwardable
+
+  delegate connection: ::Simple::SQL
+
+  def encode_args(args)
+    args.map { |arg| encode_arg(arg) }
+  end
+
+  def encode_arg(arg)
+    return arg unless arg.is_a?(Array)
+
+    if arg.first.is_a?(String)
+      "{#{arg.map { |a| "\"#{connection.escape(a)}\"" }.join(',')}}"
+    else
+      "{#{arg.join(',')}}"
+    end
+  end
+end

data/lib/simple/sql/version.rb

@@ -0,0 +1,5 @@
+module Simple
+  module SQL
+    VERSION = "0.1.3"
+  end
+end

data/simple-sql.gemspec

@@ -0,0 +1,43 @@
+# This file is part of the sinatra-sse ruby gem.
+#
+# Copyright (c) 2016, 2017 @radiospiel, mediapeers Gem
+# Distributed under the terms of the modified BSD license, see LICENSE.BSD
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple/sql/version'
+
+Gem::Specification.new do |gem|
+  gem.name     = "simple-sql"
+  gem.version  = Simple::SQL::VERSION
+
+  gem.authors  = [ "radiospiel", "mediapeers GmbH" ]
+  gem.email    = "eno@radiospiel.org"
+  gem.homepage = "http://github.com/radiospiel/simple-sql"
+  gem.summary  = "SQL with a simple interface"
+
+  gem.description = "SQL with a simple interface. Postgres only."
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths =  %w(lib)
+
+  # executables are used for development purposes only
+  gem.executables   = []
+
+  gem.required_ruby_version = '~> 2.3'
+
+  gem.add_dependency 'activerecord', '~> 4'
+  gem.add_dependency 'pg_array_parser', '~> 0'
+
+  # optional gems (required by some of the parts)
+
+  # development gems
+  gem.add_development_dependency 'pg', '0.20'
+  gem.add_development_dependency 'rake', '~> 11'
+  gem.add_development_dependency 'rspec', '~> 3.7'
+  gem.add_development_dependency 'rubocop', '~> 0.52.1'
+  gem.add_development_dependency 'factory_girl', '4.8.0'
+  gem.add_development_dependency 'database_cleaner', '~> 1'
+  gem.add_development_dependency 'simplecov', '~> 0'
+end

data/spec/simple/sql/version_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe Simple::SQL do
+  describe "VERSION" do
+    it "defines a version string" do
+      # Note: this allows for 0.12.34beta
+      expect(Simple::SQL::VERSION).to match(/^\d+\.\d+\.\d+/)
+    end
+  end
+end

data/spec/simple/sql_ask_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "Simple::SQL.ask" do
+  USER_COUNT = 2
+
+  def expects(expected_result, sql, *args)
+    expect(Simple::SQL.ask(sql, *args)).to eq(expected_result)
+  end
+
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  it "calls the database" do
+    expect(User.count).to eq(2)
+
+    expects 2, "SELECT COUNT(*) FROM users"
+    expects 1, "SELECT COUNT(*) FROM users WHERE id=$1", users.first.id
+    expects 0, "SELECT COUNT(*) FROM users WHERE id=$1", -1
+  end
+end

data/spec/simple/sql_conversion_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe "Simple::SQL conversions" do
+  def expects(expected_result, sql, *args)
+    expect(Simple::SQL.ask(sql, *args)).to eq(expected_result)
+  end
+
+  describe "data conversions" do
+    it "returns arrays when asking for multiple columns" do
+      expects ["one", "two", 3.5], "SELECT 'one', 'two', 3.5"
+    end
+
+    it "converts text arrays" do
+      expects ["foo,bar"], "SELECT ARRAY[$1::varchar]", "foo,bar"
+      expects %w(foo bar), "SELECT $1::varchar[]", %w(foo bar)
+    end
+
+    it "converts integer arrays" do
+      expects [1, 2, 3], "SELECT ARRAY[1,2,3]"
+    end
+
+    it "converts weird strings properly" do
+      expects "foo,\"bar}", "SELECT $1::varchar", "foo,\"bar}"
+      expects ["one", "two", "3.5", "foo,\"bar}"], "SELECT ARRAY['one', 'two', '3.5', 'foo,\"bar}']"
+      expects ["foo", "foo,bar}"], "SELECT $1::varchar[]", ["foo", "foo,bar}"]
+    end
+
+    it "parses JSON as expected" do
+      expects({"a"=>1, "b"=>2}, 'SELECT \'{"a":1,"b":2}\'::json')
+      expects({"a"=>1, "b"=>2}, 'SELECT \'{"a":1,"b":2}\'::jsonb')
+    end
+
+    xit "fails sometimes w/ malformed array literal, pt. 1" do
+      expects  0, 'SELECT $1::varchar[]', [ "foo", 'foo,"bar}' ]
+    end
+
+    xit "fails sometimes w/ malformed array literal, pt. 2" do
+      expects  0, 'SELECT $1::varchar[]', [ "foo", 'foo,"bar}' ]
+    end
+  end
+end

data/spec/simple/sql_record_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe "Simple::SQL.record" do
+  USER_COUNT = 2
+
+  def expects(expected_result, sql, *args)
+    expect(Simple::SQL.record(sql, *args)).to eq(expected_result)
+  end
+
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  before do
+    expect(User.count).to eq(2)
+  end
+
+  it "calls the database" do
+    r = Simple::SQL.record("SELECT COUNT(*) AS count FROM users")
+    expect(r).to eq({count: 2}) 
+  end
+
+  it "supports the into: option" do
+    r = Simple::SQL.record("SELECT COUNT(*) AS count FROM users", into: OpenStruct)
+    expect(r).to be_a(OpenStruct)
+    expect(r).to eq(OpenStruct.new(count: 2))
+  end
+
+  it "supports the into: option even with parameters" do
+    r = Simple::SQL.record("SELECT $1::integer AS count FROM users", 2, into: OpenStruct)
+    expect(r).to be_a(OpenStruct)
+    expect(r).to eq(OpenStruct.new(count: 2))
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+%w(auth authentication authorization).each do |library_name|
+  path = File.expand_path("../../#{library_name}/lib", __FILE__)
+  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+end
+
+ENV["RACK_ENV"] = "test"
+ENV["RAILS_ENV"] = "test"
+
+require "rspec"
+
+Dir.glob("./spec/support/**/*.rb").sort.each { |path| load path }
+
+require "simple/sql"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run focus: (ENV["CI"] != "true")
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.include FactoryGirl::Syntax::Methods
+  config.order = "random"
+end

data/spec/support/001_database.rb

@@ -0,0 +1,35 @@
+# connect to the database and setup the schema
+require "active_record"
+
+ActiveRecord::Base.establish_connection(YAML.load_file("config/database.yml"))
+
+# Remove after migration to Rails 5
+ActiveRecord::Base.raise_in_transactional_callbacks = true
+
+ActiveRecord::Base.logger = Logger.new("log/test.log")
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  execute "DROP SCHEMA public CASCADE;"
+  execute "CREATE SCHEMA public;"
+  execute "CREATE EXTENSION IF NOT EXISTS hstore;"
+
+  execute <<-SQL
+    DROP TYPE IF EXISTS access_level;
+    CREATE TYPE access_level AS ENUM (
+        'private',
+        'company',
+        'viewable',
+        'accessible'
+    );
+  SQL
+
+  create_table :users, force: true do |t|
+    t.integer   :role_id
+    t.string    :first_name
+    t.string    :last_name
+    t.hstore    :meta_data
+    t.column    :access_level, :access_level
+  end
+end

data/spec/support/002_database_cleaner.rb

@@ -0,0 +1,14 @@
+require "database_cleaner"
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.around(:each) do |example|
+    DatabaseCleaner.cleaning do
+      example.run
+    end
+  end
+end

data/spec/support/003_factories.rb

@@ -0,0 +1,3 @@
+require "factory_girl"
+
+# factories are loaded from support/factories automatically

data/spec/support/004_simplecov.rb

@@ -0,0 +1,13 @@
+require "simplecov"
+
+SimpleCov.start do
+  # add_filter do |src|
+  #   # paths = %w(auth authentication authorization).map do |library_name|
+  #   #   File.expand_path("../../#{library_name}/lib", __FILE__)
+  #   # end
+  #
+  #   !paths.any? { |path| src.filename =~ /^#{Regexp.escape(path)}/ }
+  # end
+
+  minimum_coverage 96
+end

data/spec/support/factories/user_factory.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :user do
+    role_id         123
+    first_name      "Uni"
+    last_name       "Corn"
+    access_level    "viewable"
+  end
+end

data/spec/support/model/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/tasks/release.rake

@@ -0,0 +1,89 @@
+require 'bundler'
+Bundler.setup
+
+GEM_ROOT = File.expand_path('../../', __FILE__)
+GEM_SPEC = "simple-sql.gemspec"
+
+require 'simple/sql/version'
+VERSION_FILE_PATH = 'lib/simple/sql/version.rb'
+
+class VersionNumberTracker
+  class << self
+    def update_version_file(old_version_number, new_version_number)
+      old_line = "VERSION = \"#{old_version_number}\""
+      new_line = "VERSION = \"#{new_version_number}\""
+      update = File.read(VERSION_FILE_PATH).gsub(old_line, new_line)
+      File.open(VERSION_FILE_PATH, 'w') { |file| file.puts update }
+      new_version_number
+    end
+
+    def auto_version_bump
+      old_version_number = Simple::SQL::VERSION
+      old = old_version_number.split('.')
+      current = old[0..-2] << old[-1].next
+      new_version_number = current.join('.')
+
+      update_version_file(old_version_number, new_version_number)
+    end
+
+    def manual_version_bump
+      update_version_file(Simple::SQL::VERSION, ENV['VERSION'])
+    end
+
+    def update_version_number
+      @version = ENV['VERSION'] ? manual_version_bump : auto_version_bump
+    end
+
+    attr_reader :version
+  end
+end
+
+namespace :release do
+  task :version do
+    VersionNumberTracker.update_version_number
+  end
+
+  task :build do
+    Dir.chdir(GEM_ROOT) do
+      sh("gem build #{GEM_SPEC}")
+    end
+  end
+
+  desc "Commit changes"
+  task :commit do
+    Dir.chdir(GEM_ROOT) do
+      version = VersionNumberTracker.version
+      sh("git add #{VERSION_FILE_PATH}")
+      sh("git commit -m \"bump auth to v#{version}\"")
+      sh("git tag -a v#{version} -m \"Tag\"")
+    end
+  end
+
+  desc "Push code and tags"
+  task :push do
+    sh('git push origin master')
+    sh('git push --tags')
+  end
+
+  desc "Cleanup"
+  task :clean do
+    Dir.glob(File.join(GEM_ROOT, '*.gem')).each { |f| FileUtils.rm_rf(f) }
+  end
+
+  desc "Push Gem to gemfury"
+  task :push_to_rubygems do
+    Dir.chdir(GEM_ROOT) { sh("gem push #{Dir.glob('*.gem').first}") }
+  end
+
+  task default: [
+    'version',
+    'clean',
+    'build',
+    'commit',
+    'push',
+    'push_to_rubygems'
+  ]
+end
+
+desc "Clean, build, commit and push"
+task release: 'release:default'

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: simple-sql
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- radiospiel
+- mediapeers GmbH
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: pg_array_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.52.1
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.8.0
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: SQL with a simple interface. Postgres only.
+email: eno@radiospiel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/rake
+- config/database.yml
+- lib/simple/sql.rb
+- lib/simple/sql/decoder.rb
+- lib/simple/sql/encoder.rb
+- lib/simple/sql/version.rb
+- log/.gitkeep
+- simple-sql.gemspec
+- spec/simple/sql/version_spec.rb
+- spec/simple/sql_ask_spec.rb
+- spec/simple/sql_conversion_spec.rb
+- spec/simple/sql_record_spec.rb
+- spec/spec_helper.rb
+- spec/support/001_database.rb
+- spec/support/002_database_cleaner.rb
+- spec/support/003_factories.rb
+- spec/support/004_simplecov.rb
+- spec/support/factories/user_factory.rb
+- spec/support/model/user.rb
+- tasks/release.rake
+homepage: http://github.com/radiospiel/simple-sql
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: SQL with a simple interface
+test_files:
+- spec/simple/sql/version_spec.rb
+- spec/simple/sql_ask_spec.rb
+- spec/simple/sql_conversion_spec.rb
+- spec/simple/sql_record_spec.rb
+- spec/spec_helper.rb
+- spec/support/001_database.rb
+- spec/support/002_database_cleaner.rb
+- spec/support/003_factories.rb
+- spec/support/004_simplecov.rb
+- spec/support/factories/user_factory.rb
+- spec/support/model/user.rb