perpetuity-postgres 0.0.1

data/lib/perpetuity/postgres/serializer.rb

@@ -0,0 +1,179 @@
+require 'perpetuity/postgres/sql_value'
+require 'perpetuity/postgres/serialized_data'
+require 'perpetuity/postgres/value_with_attribute'
+require 'perpetuity/postgres/json_array'
+require 'perpetuity/postgres/json_hash'
+require 'perpetuity/data_injectable'
+require 'json'
+
+module Perpetuity
+  class Postgres
+    class Serializer
+      include DataInjectable
+
+      SERIALIZABLE_CLASSES = [Fixnum, Float, String, Time, TrueClass, FalseClass, NilClass]
+      attr_reader :mapper, :mapper_registry
+
+      def initialize mapper
+        @mapper = mapper
+        @mapper_registry = mapper.mapper_registry if mapper
+      end
+
+      def serialize object
+        attrs = mapper.attribute_set.map do |attribute|
+          attr_name = attribute.name.to_s
+          value = ValueWithAttribute.new(attribute_for(object, attr_name), attribute)
+          serialize_attribute(value)
+        end
+        column_names = mapper.attributes
+
+        SerializedData.new(column_names, attrs)
+      end
+
+      def unserialize data
+        if data.is_a? Array
+          data.map do |datum|
+            object = mapper.mapped_class.allocate
+            datum.each do |attribute_name, value|
+              attribute = mapper.attribute_set[attribute_name.to_sym]
+              deserialized_value = unserialize_attribute(attribute, value)
+              inject_attribute object, attribute_name, deserialized_value
+            end
+
+            object
+          end
+        else
+          unserialize([data]).first
+        end
+      end
+
+      def unserialize_attribute attribute, value
+        if value
+          if possible_json_value?(value)
+            value = JSON.parse(value) rescue value
+            if value.is_a? Array
+              value = value.map { |v| unserialize_attribute(attribute, v) }
+            end
+          end
+          if foreign_object? value
+            value = unserialize_foreign_object value
+          end
+          if attribute
+            if attribute.type == Integer
+              value = value.to_i
+            elsif attribute.type == Time
+              value = TimestampValue.from_sql(value).to_time
+            end
+          end
+
+          value
+        end
+      end
+
+      def possible_json_value? value
+        value.is_a?(String) && %w([ {).include?(value[0])
+      end
+
+      def foreign_object? value
+        value.is_a?(Hash) && value.has_key?('__metadata__')
+      end
+
+      def unserialize_foreign_object data
+        metadata = data.delete('__metadata__')
+        klass = Object.const_get(metadata['class'])
+        if metadata.has_key? 'id'
+          id = metadata['id']
+          return unserialize_reference(klass, id)
+        end
+
+        serializer = serializer_for(klass)
+        serializer.unserialize(data)
+      end
+
+      def unserialize_reference klass, id
+        Reference.new(klass, id)
+      end
+
+      def serializer_for klass
+        Serializer.new(mapper_registry[klass])
+      end
+
+      def attribute_for object, attr_name
+        object.instance_variable_get("@#{attr_name}")
+      end
+
+      def serialize_attribute object
+        value = object.value rescue object
+
+        if SERIALIZABLE_CLASSES.include? value.class
+          SQLValue.new(value)
+        elsif value.is_a? Array
+          serialize_array(object)
+        elsif !object.embedded?
+          serialize_reference(value)
+        elsif object.embedded?
+          serialize_with_foreign_mapper(value)
+        end.to_s
+      end
+
+      def serialize_array object
+        value = object.value rescue object
+        array = value.map do |item|
+          if SERIALIZABLE_CLASSES.include? item.class
+            item
+          elsif object.embedded?
+            serialize_with_foreign_mapper item
+          else
+            serialize_reference item
+          end
+        end
+
+        JSONArray.new(array)
+      end
+
+      def serialize_to_hash value
+        Hash[
+          mapper.attribute_set.map do |attribute|
+            attr_name = attribute.name
+            attr_value = attribute_for(value, attr_name)
+            [attr_name, attr_value]
+          end
+        ]
+      end
+
+      def serialize_reference value
+        klass = if value.is_a? Reference
+                  value.klass
+                else
+                  value.class
+                end
+
+        unless mapper.persisted? value
+          mapper_registry[value.class].insert value
+        end
+
+        json = {
+          __metadata__: {
+            class: klass,
+            id: mapper.id_for(value)
+          }
+        }
+
+        JSONHash.new(json)
+      end
+
+      def serialize_with_foreign_mapper value
+        mapper = mapper_registry[value.class]
+        serializer = Serializer.new(mapper)
+        attr = serializer.serialize_to_hash(value)
+        attr.merge!('__metadata__' => { 'class' => value.class })
+
+        JSONHash.new(attr)
+      end
+
+      def serialize_changes modified, original
+        serialize(modified) - serialize(original)
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/sql_select.rb

@@ -0,0 +1,71 @@
+require 'perpetuity/postgres/table_name'
+
+module Perpetuity
+  class Postgres
+    class SQLSelect
+      attr_reader :selection, :table, :where, :group_by, :order, :limit, :offset
+
+      def initialize *args
+        @selection = if args.one?
+                       '*'
+                     else
+                       args.shift
+                     end
+        options = args.first
+        @table = options.fetch(:from)
+        @where = options[:where]
+        @group_by = options[:group]
+        @order = options[:order]
+        @limit = options[:limit]
+        @offset = options[:offset]
+      end
+
+      def to_s
+        "SELECT #{selection} FROM #{TableName.new(table)}" << where_clause.to_s <<
+                                                              group_by_clause.to_s <<
+                                                              order_clause.to_s <<
+                                                              limit_clause.to_s <<
+                                                              offset_clause.to_s
+      end
+
+      def where_clause
+        if where
+          " WHERE #{where}"
+        end
+      end
+
+      def group_by_clause
+        if group_by
+          " GROUP BY #{group_by}"
+        end
+      end
+
+      def order_clause
+        order = Array(self.order)
+        order.map! do |(attribute, direction)|
+          if direction
+            "#{attribute} #{direction.to_s.upcase}"
+          else
+            attribute
+          end
+        end
+
+        unless order.empty?
+          " ORDER BY #{order.join(',')}"
+        end
+      end
+
+      def limit_clause
+        if limit
+          " LIMIT #{limit}"
+        end
+      end
+
+      def offset_clause
+        if offset
+          " OFFSET #{offset}"
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/sql_update.rb

@@ -0,0 +1,28 @@
+require 'perpetuity/postgres/table_name'
+require 'perpetuity/postgres/sql_value'
+
+module Perpetuity
+  class Postgres
+    class SQLUpdate
+      attr_reader :klass, :id, :attributes
+
+      def initialize klass, id, attributes
+        @class = klass
+        @id = id
+        @attributes = attributes
+      end
+
+      def to_s
+        sql = "UPDATE #{TableName.new(@class)}"
+        if attributes.any?
+          sql << " SET "
+          sql << attributes.map do |name, value|
+            value = SQLValue.new(value) if attributes.is_a? Hash
+            "#{name} = #{value}"
+          end.join(',')
+        end
+        sql << " WHERE id = #{SQLValue.new(id)}"
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/sql_value.rb

@@ -0,0 +1,40 @@
+require 'perpetuity/postgres/text_value'
+require 'perpetuity/postgres/timestamp_value'
+require 'perpetuity/postgres/numeric_value'
+require 'perpetuity/postgres/null_value'
+require 'perpetuity/postgres/boolean_value'
+
+module Perpetuity
+  class Postgres
+    class SQLValue
+      attr_reader :value
+
+      def initialize value
+        @value = case value
+                 when String, Symbol
+                   TextValue.new(value)
+                 when Time
+                   TimestampValue.new(value)
+                 when Fixnum, Float
+                   NumericValue.new(value)
+                 when nil
+                   NullValue.new
+                 when true, false
+                   BooleanValue.new(value)
+                 end.to_s
+      end
+
+      def to_s
+        value
+      end
+
+      def == other
+        if other.is_a? String
+          value == other
+        else
+          value == other.value
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/table/attribute.rb

@@ -0,0 +1,60 @@
+module Perpetuity
+  class Postgres
+    class Table
+      class Attribute
+        attr_reader :name, :type, :max_length
+
+        NoDefaultValue = Module.new
+        UUID = Module.new
+
+        def initialize name, type, options={}
+          @name = name
+          @type = type
+          @max_length = options[:max_length]
+          @primary_key = options.fetch(:primary_key) { false }
+          @default = options.fetch(:default) { NoDefaultValue }
+        end
+
+        def sql_type
+          if type == String
+            if max_length
+              "VARCHAR(#{max_length})"
+            else
+              'TEXT'
+            end
+          elsif type == Integer
+            'INTEGER'
+          elsif type == UUID
+            'UUID'
+          elsif type == Time
+            'TIMESTAMPTZ'
+          else
+            'JSON'
+          end
+        end
+
+        def sql_declaration
+          if self.default.is_a? String
+            default = "'#{self.default}'"
+          else
+            default = self.default
+          end
+
+          sql = "#{name} #{sql_type}"
+          sql << ' PRIMARY KEY' if primary_key?
+          sql << " DEFAULT #{default}" unless self.default == NoDefaultValue
+
+          sql
+        end
+
+        def primary_key?
+          !!@primary_key
+        end
+
+        def default
+          @default
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/table.rb

@@ -0,0 +1,36 @@
+require 'perpetuity/postgres/table/attribute'
+require 'perpetuity/postgres/expression'
+require 'perpetuity/postgres/table_name'
+
+module Perpetuity
+  class Postgres
+    class Table
+      attr_reader :name, :attributes
+      def initialize name, attributes
+        @name = TableName.new(name)
+        @attributes = attributes.to_a
+
+        generate_id_attribute unless has_id_attribute?
+      end
+
+      def create_table_sql
+        sql = "CREATE TABLE IF NOT EXISTS #{name} ("
+        sql << attributes.map(&:sql_declaration).join(', ')
+        sql << ')'
+      end
+
+      def has_id_attribute?
+        attributes.any? { |attr| attr.name.to_s == 'id' }
+      end
+
+      def generate_id_attribute
+        id = Attribute.new('id', Attribute::UUID, primary_key: true, default: Expression.new('uuid_generate_v4()'))
+        attributes.unshift id
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/table_name.rb

@@ -0,0 +1,21 @@
+module Perpetuity
+  class Postgres
+    class TableName
+      def initialize name
+        @name = name.to_s
+      end
+
+      def to_s
+        @name.to_s.inspect
+      end
+
+      def == other
+        if other.is_a? String
+          other == @name
+        else
+          to_s == other.to_s
+        end
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/text_value.rb

@@ -0,0 +1,14 @@
+module Perpetuity
+  class Postgres
+    class TextValue
+      def initialize value
+        @value = value.to_s.gsub("'") { "''" }
+      end
+
+      def to_s
+        "'#{@value}'"
+      end
+    end
+  end
+end
+

data/lib/perpetuity/postgres/timestamp_value.rb

@@ -0,0 +1,68 @@
+require 'perpetuity/postgres/text_value'
+
+module Perpetuity
+  class Postgres
+    class TimestampValue
+      attr_reader :time
+      def initialize time
+        @time = time
+      end
+
+      def self.from_sql sql_value
+        date, time = sql_value.split(/ /)
+        year, month, day = date.split(/-/)
+        hour, minute, seconds_with_offset = time.split(/:/)
+        second = seconds_with_offset[/\d+\.\d+/].to_f
+        offset = seconds_with_offset[/(\+|\-)\d+/] + ':00'
+
+        new Time.new(year, month, day, hour, minute, second, offset)
+      end
+
+      def to_time
+        time
+      end
+
+      def value
+        time
+      end
+
+      def year
+        time.year
+      end
+
+      def month
+        zero_pad(time.month)
+      end
+
+      def day
+        zero_pad(time.day)
+      end
+
+      def hour
+        zero_pad(time.hour)
+      end
+
+      def minute
+        zero_pad(time.min)
+      end
+
+      def second
+        '%02d.%06d' % [time.sec, time.usec]
+      end
+
+      def offset
+        time.strftime('%z')
+      end
+
+      def to_s
+        string = TextValue.new("#{year}-#{month}-#{day} #{hour}:#{minute}:#{second}#{offset}").to_s
+        "#{string}::timestamptz"
+      end
+
+      private
+      def zero_pad n
+        '%02d' % n
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/value_with_attribute.rb

@@ -0,0 +1,19 @@
+module Perpetuity
+  class Postgres
+    class ValueWithAttribute
+      attr_reader :value, :attribute
+      def initialize value, attribute
+        @value = value
+        @attribute = attribute
+      end
+
+      def type
+        attribute.type
+      end
+
+      def embedded?
+        attribute.embedded?
+      end
+    end
+  end
+end

data/lib/perpetuity/postgres/version.rb

@@ -0,0 +1,5 @@
+module Perpetuity
+  class Postgres
+    VERSION = "0.0.1"
+  end
+end