enquo-core 0.7.0.2.gb37f667-x86_64-linux → 0.8.0-x86_64-linux

data/lib/enquo/field.rb

@@ -1,173 +0,0 @@
-require "date"
-
-module Enquo
-	class Field
-		def self.new(*_)
-			raise RuntimeError, "Enquo::Field cannot be instantiated directly; use Enquo::Crypto#field instead"
-		end
-
-		def encrypt_boolean(b, ctx, safety: true, no_query: false)
-			unless b.is_a?(TrueClass) || b.is_a?(FalseClass)
-				raise ArgumentError, "Enquo::Field#encrypt_boolean can only encrypt booleans (got an instance of #{b.class})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_boolean(b, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_boolean(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_boolean can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_boolean can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_boolean(data, ctx)
-		end
-
-		def encrypt_i64(i, ctx, safety: true, no_query: false)
-			unless i.is_a?(Integer)
-				raise ArgumentError, "Enquo::Field#encrypt_i64 can only encrypt integers (got an instance of #{i.class})"
-			end
-
-			unless i >= -2 ** 63 && i < 2 ** 63
-				raise RangeError, "Enquo::Field#encrypt_i64 can only encrypt integers between -2^63 and 2^63-1 (got #{i})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_i64(i, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_i64(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_i64 can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_i64 can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_i64(data, ctx)
-		end
-
-		def encrypt_date(d, ctx, safety: true, no_query: false)
-			unless d.is_a?(Date)
-				raise ArgumentError, "Enquo::Field#encrypt_date can only encrypt Dates (got an instance of #{d.class})"
-			end
-
-			unless d.year >= -2 ** 15 && d.year < 2 ** 15 - 1
-				raise RangeError, "Enquo::Field#encrypt_date can only encrypt dates where the year is between -32,768 and 32,767 (got #{d.year})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_encrypt_date(d.year, d.month, d.day, ctx, no_query ? :no_query : safety == :unsafe ? :unsafe : :default)
-		end
-
-		def decrypt_date(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_date(data, ctx)
-		end
-
-		def encrypt_text(t, ctx, safety: true, no_query: false, order_prefix_length: nil)
-			unless t.is_a?(String)
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt Strings (got an instance of #{t.class})"
-			end
-
-			unless [Encoding::UTF_8, Encoding::US_ASCII].include?(t.encoding)
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt UTF-8 strings (got a string encoding of #{t.encoding})"
-			end
-
-			unless t.valid_encoding?
-				raise ArgumentError, "Enquo::Field#encrypt_string can only encrypt validly-encoded strings"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			unless order_prefix_length.nil?
-				unless safety == :unsafe
-					raise ArgumentError, "Ordering is only supported when the text field is marked unsafe"
-				end
-
-				unless order_prefix_length.is_a?(Integer)
-					raise ArgumentError, "Ordering prefix length must be an integer (got an instance of #{order_prefix_length.class})"
-				end
-
-				unless (1..255).include?(order_prefix_length)
-					raise ArgumentError, "Ordering prefix length must be between 1 and 255 inclusive (got #{order_prefix_length})"
-				end
-			end
-
-			mode = if no_query
-				:no_query
-			elsif !order_prefix_length.nil?
-				:orderable
-			elsif safety == :unsafe
-				:unsafe
-			else
-				:default
-			end
-
-			_encrypt_text(t, ctx, mode, order_prefix_length)
-		end
-
-		def decrypt_text(data, ctx)
-			unless data.is_a?(String)
-				raise ArgumentError, "Enquo::Field#decrypt_text can only decrypt from a string (got an instance of #{data.class})"
-			end
-
-			unless data.encoding == Encoding::UTF_8 && data.valid_encoding?
-				raise ArgumentError, "Enquo::Field#decrypt_date can only decrypt validly-encoded UTF-8 strings (got #{data.encoding})"
-			end
-
-			unless ctx.is_a?(String)
-				raise ArgumentError, "Encryption context must be a string (got an instance of #{ctx.class})"
-			end
-
-			_decrypt_text(data, ctx)
-		end
-
-		def encrypt_text_length_query(len)
-			unless len.is_a?(Integer)
-				raise ArgumentError, "Enquo::Field#encrypt_text_length_query can only encrypt integers (got an instance of #{len.class})"
-			end
-
-			unless len >= 0 && len < 2 ** 32
-				raise ArgumentError, "Enquo::Field#encrypt_text_length_query can only encrypt integers between 0 and 2^32-1 (got #{len})"
-			end
-
-			_encrypt_text_length_query(len)
-		end
-	end
-end

data/lib/enquo/root.rb

@@ -1,28 +0,0 @@
-module Enquo
-	class Root
-		def self.new(key)
-			case key
-			when RootKey::Static
-				_new_from_static_root_key(key)
-			else
-				raise ArgumentError, "key must be a root key provider object (got a #{key.class})"
-			end.tap do |k|
-				# DIRTY HACK ALERT: take a reference to the key so it doesn't get GC'd
-				# If someone can come up with a better way to acheive this, I'm all ears
-				k.instance_variable_set(:@_key, key)
-			end
-		end
-
-		def field(relation, name)
-			if relation.is_a?(Symbol)
-				relation = relation.to_s
-			end
-
-			if name.is_a?(Symbol)
-				name = name.to_s
-			end
-
-			_field(relation, name)
-		end
-	end
-end

data/lib/enquo/root_key/static.rb

@@ -1,27 +0,0 @@
-module Enquo
-	module RootKey
-		class Static
-			def self.new(k)
-				unless k.is_a?(String)
-					raise ArgumentError, "An Enquo static root key must be passed a string"
-				end
-
-				key = if k.encoding == Encoding::BINARY
-					unless k.bytesize == 32
-						raise ArgumentError, "An Enquo static root key must be a 32 byte binary string"
-					end
-
-					k
-				else
-					unless k =~ /\A\h{64}\z/
-						raise ArgumentError, "An Enquo static root key must be a 64 byte hex string"
-					end
-
-					[k].pack("H*")
-				end
-
-				_new(key)
-			end
-		end
-	end
-end

data/lib/enquo/root_key.rb

@@ -1 +0,0 @@
-require_relative "./root_key/static"