pgcrypto 0.3.6 → 0.4.1

data/spec/spec_helper.rb

@@ -1,24 +1,28 @@
+require 'rubygems'
+require 'simplecov'
+
 # Add lib/ to the load path
 $LOAD_PATH.unshift(File.expand_path(File.join('..', 'lib'), File.dirname(__FILE__)))
 
-# Load up our Gemfile
-require 'rubygems'
-require 'bundler/setup'
-Bundler.require(:default, :test)
-
-# Enable coverage reporting
-require 'simplecov'
+require 'database_cleaner'
+require 'pry'
 
-# Requier and configure PGCrypto
+gem 'activerecord', ENV.fetch('ACTIVE_RECORD_VERSION', '>= 4.0')
+require 'active_record'
 require 'pgcrypto'
 
 RSpec.configure do |config|
-  database_config = {:adapter => 'postgresql', :database => 'pgcrypto_test', :encoding => 'utf8', :host => 'localhost'}
+  database_config = {
+    adapter: 'pgcrypto',
+    database: '__pgcrypto_gem_test',
+    encoding: 'utf8',
+    host: 'localhost'
+  }
   postgres_config = database_config.merge(:database => 'postgres', :schema_search_path => 'public')
 
   # Set up the database to handle pgcrypto functions and the schema for
   # our tests
-  config.before :all do
+  config.before :suite do
     # Connect to the local postgres schema database
     ActiveRecord::Base.establish_connection(postgres_config)
 
@@ -30,44 +34,39 @@ RSpec.configure do |config|
 
     silence_stream(STDOUT) do
       # ...and load in the pgcrypto extension
-      ActiveRecord::Base.connection.execute(%[CREATE EXTENSION pgcrypto])
+      ActiveRecord::Base.connection.execute(%[CREATE EXTENSION pgcrypto]) rescue nil
 
       # ...and then set up the pgcrypto_columns and pgcrypto_test_models fun
       ActiveRecord::Schema.define do
-        create_table :pgcrypto_columns, :force => true do |t|
-          t.belongs_to :owner, :polymorphic => true
-          t.string :owner_table, :limit => 32
-          t.string :name, :limit => 64
-          t.binary :value
-        end
-
         create_table :pgcrypto_test_models, :force => true do |t|
           t.string :name, :limit => 32
+          t.binary :encrypted_text
         end
       end
     end
+
+    ActiveRecord::Base.establish_connection(database_config)
+
+    DatabaseCleaner.strategy = :transaction
   end
 
   config.before :each do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with :transaction
     DatabaseCleaner.start
 
-    ActiveRecord::Base.establish_connection(database_config)
-
     class PGCryptoTestModel < ActiveRecord::Base
       self.table_name = :pgcrypto_test_models
-      pgcrypto :test_column
+      has_encrypted_column :encrypted_text
     end
   end
 
-  config.after :all do
-    # Drop the database when we exist
+  config.after :each do
+    DatabaseCleaner.clean
+  end
+
+  config.after :suite do
+    # Drop the database when we exit
     ActiveRecord::Base.establish_connection(postgres_config)
     ActiveRecord::Base.connection.drop_database(database_config[:database]) rescue nil
   end
 
-  config.after :each do
-    DatabaseCleaner.clean
-  end
 end

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: pgcrypto
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.4.1
 platform: ruby
 authors:
 - Flip Sasser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-22 00:00:00.000000000 Z
+date: 2014-08-24 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activerecord
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-- !ruby/object:Gem::Dependency
-  name: big_spoon
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.2.1
 - !ruby/object:Gem::Dependency
   name: jeweler
   requirement: !ruby/object:Gem::Requirement
@@ -71,16 +43,28 @@ files:
 - README.markdown
 - Rakefile
 - VERSION
-- lib/generators/pgcrypto/install/USAGE
-- lib/generators/pgcrypto/install/install_generator.rb
-- lib/generators/pgcrypto/install/templates/initializer.rb
-- lib/generators/pgcrypto/install/templates/migration.rb
+- lib/active_record/connection_adapters/pgcrypto_adapter.rb
+- lib/active_record/connection_adapters/pgcrypto_adapter/rails_3.rb
+- lib/active_record/connection_adapters/pgcrypto_adapter/rails_4.rb
 - lib/pgcrypto.rb
-- lib/pgcrypto/active_record.rb
-- lib/pgcrypto/arel.rb
+- lib/pgcrypto/adapter.rb
 - lib/pgcrypto/column.rb
+- lib/pgcrypto/column_converter.rb
+- lib/pgcrypto/generators/base_generator.rb
+- lib/pgcrypto/generators/install/USAGE
+- lib/pgcrypto/generators/install/install_generator.rb
+- lib/pgcrypto/generators/install/templates/initializer.rb
+- lib/pgcrypto/generators/install/templates/migration.rb
+- lib/pgcrypto/generators/upgrade/USAGE
+- lib/pgcrypto/generators/upgrade/templates/migration.rb
+- lib/pgcrypto/generators/upgrade/upgrade_generator.rb
+- lib/pgcrypto/has_encrypted_column.rb
 - lib/pgcrypto/key.rb
+- lib/pgcrypto/key_manager.rb
+- lib/pgcrypto/railtie.rb
+- lib/pgcrypto/table.rb
 - lib/pgcrypto/table_manager.rb
+- lib/tasks/pgcrypto.rake
 - pgcrypto.gemspec
 - spec/lib/pgcrypto_spec.rb
 - spec/spec_helper.rb

data/lib/generators/pgcrypto/install/templates/migration.rb

@@ -1,17 +0,0 @@
-class InstallPgcrypto < ActiveRecord::Migration
-  def up
-    create_table :pgcrypto_columns do |t|
-      t.belongs_to :owner, :polymorphic => true
-      t.string :owner_table, :limit => 32
-      t.string :name, :limit => 32
-      t.binary :value
-    end
-    add_index :pgcrypto_columns, [:owner_id, :owner_type, :name], :name => :pgcrypto_type_finder
-    add_index :pgcrypto_columns, [:owner_id, :owner_table, :name], :name => :pgcrypto_table_finder
-    execute("CREATE EXTENSION IF NOT EXISTS pgcrypto")
-  end
-
-  def down
-    drop_table :pgcrypto_columns
-  end
-end

data/lib/pgcrypto/active_record.rb

@@ -1,88 +0,0 @@
-require 'active_record/connection_adapters/postgresql_adapter'
-
-ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
-  unless instance_methods.include?(:to_sql_without_pgcrypto) || instance_methods.include?('to_sql_without_pgcrypto')
-    alias :to_sql_without_pgcrypto :to_sql
-  end
-
-  def to_sql(arel, *args)
-    case arel
-    when Arel::InsertManager
-      pgcrypto_tweak_insert(arel)
-    when Arel::SelectManager
-      pgcrypto_tweak_select(arel)
-    when Arel::UpdateManager
-      pgcrypto_tweak_update(arel)
-    end
-    to_sql_without_pgcrypto(arel, *args)
-  end
-
-  private
-  def pgcrypto_tweak_insert(arel)
-    if arel.ast.relation.name.to_s == PGCrypto::Column.table_name.to_s
-      return unless key = PGCrypto.keys[:public]
-      arel.ast.columns.each_with_index do |column, i|
-        if column.name == 'value'
-          value = arel.ast.values.expressions[i]
-          quoted_value = quote_string(value)
-          encryption_instruction = %[pgp_pub_encrypt(#{quoted_value}, #{key.dearmored})]
-          arel.ast.values.expressions[i] = Arel::Nodes::SqlLiteral.new(encryption_instruction)
-        end
-      end
-    end
-  end
-
-  def pgcrypto_tweak_select(arel)
-    return unless key = PGCrypto.keys[:private]
-    # We start by looping through each "core," which is just
-    # a SelectStatement and correcting plain-text queries
-    # against an encrypted column...
-    joins = []
-    table_name = nil
-    arel.ast.cores.each do |core|
-      # Yeah, I'm lazy. Whatevs.
-      next unless core.is_a?(Arel::Nodes::SelectCore)
-
-      encrypted_columns = PGCrypto[table_name = core.source.left.name]
-      next if encrypted_columns.empty?
-
-      # We loop through each WHERE specification to determine whether or not the
-      # PGCrypto column should be JOIN'd upon; in which case, we, like, do it.
-      core.wheres.each do |where|
-        # Now loop through the children to encrypt them for the SELECT
-        where.children.each do |child|
-          next unless encrypted_columns[child.left.name.to_s]
-          joins.push(child.left.name.to_s) unless joins.include?(child.left.name.to_s)
-          child.left = Arel::Nodes::SqlLiteral.new(%[
-            pgp_pub_decrypt("#{PGCrypto::Column.table_name}_#{child.left.name}"."value", pgcrypto_keys.#{key.name}#{key.password?})
-          ])
-        end if where.respond_to?(:children)
-      end
-    end
-    if joins.any?
-      arel.join(Arel::Nodes::SqlLiteral.new("CROSS JOIN (SELECT #{key.dearmored} AS #{key.name}) AS pgcrypto_keys"))
-      joins.each do |column|
-        column = quote_string(column)
-        as_table = "#{PGCrypto::Column.table_name}_#{column}"
-        arel.join(Arel::Nodes::SqlLiteral.new(%[
-          JOIN "#{PGCrypto::Column.table_name}" AS "#{as_table}" ON "#{as_table}"."owner_id" = "#{table_name}"."id" AND "#{as_table}"."owner_table" = '#{quote_string(table_name)}' AND "#{as_table}"."name" = '#{column}'
-        ]))
-      end
-    end
-  end
-
-  def pgcrypto_tweak_update(arel)
-    if arel.ast.relation.name.to_s == PGCrypto::Column.table_name.to_s
-      # Loop through the assignments and make sure we take care of that whole
-      # NULL value thing!
-      value = arel.ast.values.select{|value| value.respond_to?(:left) && value.left.name == 'value' }.first
-      if value.right.nil?
-        value.right = Arel::Nodes::SqlLiteral.new('NULL')
-      elsif key = PGCrypto.keys[:public]
-        quoted_right = quote_string(value.right)
-        encryption_instruction = %[pgp_pub_encrypt('#{quoted_right}', #{key.dearmored})]
-        value.right = Arel::Nodes::SqlLiteral.new(encryption_instruction)
-      end
-    end
-  end
-end

data/lib/pgcrypto/arel.rb

@@ -1,24 +0,0 @@
-require 'arel/visitors/postgresql'
-
-# We override some fun stuff in the PostgreSQL visitor class inside of Arel.
-# This is the _most_ direct approach to tweaking the SQL to INSERT, SELECT,
-# and UPDATE values as encrypted. Unfortunately, the visitor API doesn't
-# give us access to managers as well as nodes, so we have use the public
-# Arel API via the connection adapter's to_sql method. Then we tweak the
-# more specific bits here!
-
-Arel::Visitors::PostgreSQL.class_eval do
-  unless instance_methods.include?(:visit_Arel_Nodes_Assignment_without_pgcrypto) || instance_methods.include?('visit_Arel_Nodes_Assignment_without_pgcrypto')
-    alias :visit_Arel_Nodes_Assignment_without_pgcrypto :visit_Arel_Nodes_Assignment
-  end
-
-  def visit_Arel_Nodes_Assignment(assignment)
-    # Hijack the normally inoccuous assignment that happens, seeing as how
-    # Arel normally forwards this shit to someone else and I hate it. 
-    if assignment.left.relation.name == PGCrypto::Column.table_name && assignment.left.name == 'value'
-      "#{visit(assignment.left)} = #{visit(assignment.right)}"
-    else
-      visit_Arel_Nodes_Assignment_without_pgcrypto(assignment)
-    end
-  end
-end