perpetuity-postgres 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ae601e3900e9e24c2bb98c63eb6d8817b6f06b1b
+  data.tar.gz: abf781e103cb6292df35a779388bf8a662ecbce5
+SHA512:
+  metadata.gz: 8ff4c1bbd74e6baec79e9db3000644eecc08b5270ba5df5b822eec79792e35dedce562e00d7cdcc2e3f30ccd97e7c5e5745dec67dc95bb869ae500df2dfb5811
+  data.tar.gz: 429991a3ec80b543567a581e600aa30918fae13b7d7d75a3bc7ee3ebab2bef9ea64ea5d25a8f4db6c845b4bb4ec6bbc6649039f96fd8a3aa792f52e946d3f25c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jamie Gaskins
+
+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,34 @@
+# Perpetuity::Postgres
+
+This is the PostgreSQL adapter for [Perpetuity](https://github.com/jgaskins/perpetuity), a Data Mapper-pattern persistence gem. The Data Mapper pattern puts persistence logic into mapper objects and keeps it out of your domain models. This keeps your domain models lightweight and focused.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'perpetuity-postgres'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install perpetuity-postgres
+
+## Usage
+
+To configure Perpetuity to use your PostgreSQL database, you can use the same parameters as you would with the MongoDB adapter, except substitute `:postgres` in for `:mongodb`:
+
+```ruby
+require 'perpetuity-postgres' # Unnecessary if using Rails
+Perpetuity.data_source :postgres, 'my_perpetuity_database'
+```
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/perpetuity/postgres/boolean_value.rb

@@ -0,0 +1,17 @@
+module Perpetuity
+  class Postgres
+    class BooleanValue
+      def initialize value
+        @value = value
+      end
+
+      def to_s
+        if @value
+          'TRUE'
+        else
+          'FALSE'
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/connection.rb

@@ -0,0 +1,78 @@
+require 'pg'
+
+module Perpetuity
+  class Postgres
+    class Connection
+      attr_reader :options
+
+      def initialize options={}
+        @options = sanitize_options(options)
+      end
+
+      def db
+        options[:dbname]
+      end
+
+      def pg_connection
+        @pg_connection ||= connect
+      end
+
+      def connect
+        @pg_connection = PG.connect(options)
+        use_uuid_extension
+
+        @pg_connection
+      rescue PG::ConnectionBad => e
+        tries ||= 0
+        conn = PG.connect
+        conn.exec "CREATE DATABASE #{db}"
+        conn.close
+
+        if tries.zero?
+          retry
+        else
+          raise e
+        end
+      end
+
+      def active?
+        !!@pg_connection
+      end
+
+      def execute sql
+        pg_connection.exec sql
+      end
+
+      def tables
+        sql = "SELECT table_name FROM information_schema.tables "
+        sql << "WHERE table_schema = 'public'"
+
+        result = execute(sql)
+        result.to_a.map { |r| r['table_name'] }
+      end
+
+      def sanitize_options options
+        options = options.dup
+        db = options.delete(:db)
+        username = options.delete(:username)
+
+        if db
+          options[:dbname] = db
+        end
+
+        if username
+          options[:user] = username
+        end
+
+        options
+      end
+
+      private
+      def use_uuid_extension
+        @pg_connection.exec 'CREATE EXTENSION "uuid-ossp"'
+      rescue PG::DuplicateObject
+        # Ignore. It just means the extension's already been loaded.
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/connection_pool.rb

@@ -0,0 +1,39 @@
+require 'perpetuity/postgres/connection'
+require 'thread'
+
+module Perpetuity
+  class Postgres
+    class ConnectionPool
+      attr_reader :connections, :size
+
+      def initialize options={}
+        @connections = Queue.new
+        @size = options.delete(:pool_size) { 5 }
+        @size.times do
+          connections << Connection.new(options)
+        end
+      end
+
+      def lend_connection
+        if block_given?
+          connection = connections.pop
+          result = yield connection
+          connections << connection
+          result
+        end
+      end
+
+      def execute sql
+        lend_connection do |connection|
+          connection.execute sql
+        end
+      end
+
+      def tables
+        lend_connection do |connection|
+          connection.tables
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/expression.rb

@@ -0,0 +1,21 @@
+module Perpetuity
+  class Postgres
+    class Expression
+      def initialize string
+        @string = string
+      end
+
+      def to_sql
+        @string
+      end
+
+      def to_s
+        @string
+      end
+
+      def == other
+        other.is_a?(self.class) && to_sql == other.to_sql
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/json_array.rb

@@ -0,0 +1,31 @@
+require 'perpetuity/postgres/numeric_value'
+require 'perpetuity/postgres/json_string_value'
+require 'perpetuity/postgres/json_hash'
+
+module Perpetuity
+  class Postgres
+    class JSONArray
+      def initialize value
+        @value = value
+      end
+
+      def to_s
+        "'[#{serialize_elements}]'"
+      end
+
+      def serialize_elements
+        @value.map do |element|
+          if element.is_a? Numeric
+            NumericValue.new(element)
+          elsif element.is_a? String
+            JSONStringValue.new(element)
+          elsif element.is_a? Hash
+            JSONHash.new(element, :inner)
+          elsif element.is_a? JSONHash
+            JSONHash.new(element.to_hash, :inner)
+          end
+        end.join(',')
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/json_hash.rb

@@ -0,0 +1,55 @@
+require 'perpetuity/postgres/json_string_value'
+require 'perpetuity/postgres/numeric_value'
+
+module Perpetuity
+  class Postgres
+    class JSONHash
+      def initialize value, location=:outer
+        @value = value
+        @location = location
+      end
+
+      def to_s
+        if @location == :outer
+          "'{#{serialize_elements}}'"
+        else
+          "{#{serialize_elements}}"
+        end
+      end
+
+      def to_hash
+        @value
+      end
+
+      def serialize_elements
+        @value.map do |key, value|
+          string = ''
+          string << JSONStringValue.new(key) << ':'
+
+          string << if value.is_a? Numeric
+                      NumericValue.new(value)
+          elsif value.is_a? String
+            JSONStringValue.new(value)
+          elsif value.is_a? Hash
+            JSONHash.new(value, :inner)
+          elsif value.is_a? Class
+            JSONStringValue.new(value.to_s)
+          elsif [true, false].include? value
+            value.to_s
+          else
+            value
+          end
+        end.join(',')
+      end
+
+      def to_str
+        to_s
+      end
+
+      def == other
+        other.is_a? self.class and
+        other.to_hash == to_hash
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/json_string_value.rb

@@ -0,0 +1,17 @@
+module Perpetuity
+  class Postgres
+    class JSONStringValue
+      def initialize value
+        @value = value
+      end
+
+      def to_s
+        %Q{"#{@value}"}
+      end
+
+      def to_str
+        to_s
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/negated_query.rb

@@ -0,0 +1,21 @@
+require 'perpetuity/postgres/query'
+
+module Perpetuity
+  class Postgres
+    class NegatedQuery
+      attr_reader :query
+
+      def initialize &block
+        @query = Query.new(&block)
+      end
+
+      def to_db
+        "NOT (#{query.to_db})"
+      end
+
+      def to_s
+        to_db
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/nil_query.rb

@@ -0,0 +1,9 @@
+module Perpetuity
+  class Postgres
+    class NilQuery
+      def to_db
+        'TRUE'
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/null_value.rb

@@ -0,0 +1,9 @@
+module Perpetuity
+  class Postgres
+    class NullValue
+      def to_s
+        'NULL'
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/numeric_value.rb

@@ -0,0 +1,17 @@
+module Perpetuity
+  class Postgres
+    class NumericValue
+      def initialize value
+        @value = value
+      end
+
+      def to_s
+        @value.to_s
+      end
+
+      def to_str
+        to_s
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/query.rb

@@ -0,0 +1,34 @@
+require 'perpetuity/postgres/query_attribute'
+require 'perpetuity/postgres/nil_query'
+
+module Perpetuity
+  class Postgres
+    class Query
+      attr_reader :query, :klass
+
+      def initialize &block
+        if block_given?
+          @query = block
+        else
+          @query = proc { NilQuery.new }
+        end
+      end
+
+      def to_db
+        query.call(self).to_db
+      end
+
+      def to_str
+        to_db
+      end
+
+      def to_s
+        to_db
+      end
+
+      def method_missing name
+        QueryAttribute.new(name)
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/query_attribute.rb

@@ -0,0 +1,33 @@
+require 'perpetuity/postgres/query_expression'
+
+module Perpetuity
+  class Postgres
+    class QueryAttribute
+      attr_reader :name
+
+      def initialize name
+        @name = name
+      end
+
+      %w(!= <= < == > >= =~).each do |comparator|
+        eval <<METHOD
+        def #{comparator} value
+          QueryExpression.new self, :#{comparator}, value
+        end
+METHOD
+      end
+
+      def in collection
+        QueryExpression.new self, :in, collection
+      end
+
+      def nil?
+        QueryExpression.new self, :==, nil
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/query_expression.rb

@@ -0,0 +1,90 @@
+require 'perpetuity/postgres/query_union'
+require 'perpetuity/postgres/query_intersection'
+require 'perpetuity/postgres/sql_value'
+
+module Perpetuity
+  class Postgres
+    class QueryExpression
+      attr_accessor :attribute, :comparator, :value
+      def initialize attribute, comparator, value
+        @attribute = attribute
+        @comparator = comparator
+        @value = value
+      end
+
+      def to_db
+        if value.nil?
+          if comparator == :==
+            "#{attribute} IS NULL"
+          elsif comparator == :!=
+            "#{attribute} IS NOT NULL"
+          end
+        else
+          public_send comparator
+        end
+      end
+
+      def sql_value value=self.value
+        if value.is_a? String or value.is_a? Symbol
+          SQLValue.new(value)
+        elsif value.is_a? Regexp
+          "'#{value.to_s.sub(/\A\(\?i?-mi?x\:/, '').sub(/\)\z/, '')}'"
+        elsif value.is_a? Time
+          SQLValue.new(value)
+        elsif value.is_a? Array
+          value.map! do |element|
+            sql_value(element)
+          end
+          "(#{value.join(',')})"
+        else
+          value
+        end
+      end
+
+      def ==
+        "#{attribute} = #{sql_value}"
+      end
+
+      def <
+        "#{attribute} < #{sql_value}"
+      end
+
+      def <=
+        "#{attribute} <= #{sql_value}"
+      end
+
+      def >
+        "#{attribute} > #{sql_value}"
+      end
+
+      def >=
+        "#{attribute} >= #{sql_value}"
+      end
+
+      def !=
+        "#{attribute} != #{sql_value}"
+      end
+
+      def in
+        "#{attribute} IN #{sql_value}"
+      end
+
+      def =~
+        regexp_comparator = if value.casefold?
+                              '~*'
+                            else
+                              '~'
+                            end
+        "#{attribute} #{regexp_comparator} #{sql_value}"
+      end
+
+      def | other
+        QueryUnion.new(self, other)
+      end
+
+      def & other
+        QueryIntersection.new(self, other)
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/query_intersection.rb

@@ -0,0 +1,26 @@
+require 'perpetuity/postgres/query_union'
+
+module Perpetuity
+  class Postgres
+    class QueryIntersection
+      attr_reader :lhs, :rhs
+
+      def initialize lhs, rhs
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def to_db
+        "(#{lhs.to_db} AND #{rhs.to_db})"
+      end
+
+      def & other
+        QueryIntersection.new(self, other)
+      end
+
+      def | other
+        QueryUnion.new(self, other)
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/query_union.rb

@@ -0,0 +1,26 @@
+require 'perpetuity/postgres/query_intersection'
+
+module Perpetuity
+  class Postgres
+    class QueryUnion
+      attr_reader :lhs, :rhs
+
+      def initialize lhs, rhs
+        @lhs = lhs
+        @rhs = rhs
+      end
+
+      def to_db
+        "(#{lhs.to_db} OR #{rhs.to_db})"
+      end
+
+      def | other
+        QueryUnion.new(self, other)
+      end
+
+      def & other
+        QueryIntersection.new(self, other)
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/serialized_data.rb

@@ -0,0 +1,63 @@
+require 'perpetuity/postgres/text_value'
+
+module Perpetuity
+  class Postgres
+    class SerializedData
+      include Enumerable
+      attr_reader :column_names, :values
+      def initialize column_names, *values
+        @column_names = column_names.map(&:to_s)
+        @values = values
+      end
+
+      def to_s
+        value_strings = values.map { |data| "(#{data.join(',')})" }.join(',')
+        "(#{column_names.join(',')}) VALUES #{value_strings}"
+      end
+
+      def []= column, value
+        value = TextValue.new(value)
+        if column_names.include? column
+          index = column_names.index(column)
+          values.first[index] = value
+        else
+          column_names << column
+          values.first << value
+        end
+      end
+
+      def + other
+        combined = dup
+        combined.values << other.values
+
+        combined
+      end
+
+      def any?
+        values.any?
+      end
+
+      def each
+        data = values.first
+        column_names.each_with_index { |column, index| yield(column, data[index]) }
+        self
+      end
+
+      def - other
+        values = self.values.first
+        modified_values = values - other.values.first
+        modified_columns = column_names.select.with_index { |col, index|
+          values[index] != other.values.first[index]
+        }
+
+        SerializedData.new(modified_columns, modified_values)
+      end
+
+      def == other
+        other.is_a? SerializedData and
+        other.column_names == column_names and
+        other.values == values
+      end
+    end
+  end
+end