spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/data_mapper/content_model.rb

@@ -0,0 +1,343 @@
+require 'spontaneous/data_mapper/content_model/column_accessors'
+require 'spontaneous/data_mapper/content_model/serialization'
+require 'spontaneous/data_mapper/content_model/timestamps'
+require 'spontaneous/data_mapper/content_model/instance_hooks'
+require 'spontaneous/data_mapper/content_model/associations'
+
+module Spontaneous
+  module DataMapper
+    module ContentModel
+      def self.extended(model)
+        model.send :include, InstanceMethods
+      end
+
+      def self.generate(mapper, &block)
+        Class.new do
+          extend Spontaneous::DataMapper::ContentModel
+          class_eval &block if block
+          self.mapper = mapper
+          include ColumnAccessors
+          include Serialization
+          include Timestamps
+          include InstanceHooks
+          include Associations::InstanceMethods
+        end
+      end
+
+      attr_reader :mapper
+      attr_writer :options
+
+      def inherited(subclass)
+        @mapper.inherited(self, subclass)
+        subclass.mapper  = @mapper
+        super
+      end
+
+      def mapper=(mapper)
+        @mapper = mapper
+      end
+
+      def restricted_columns
+        [:id, :type_sid]
+      end
+
+      def serialize_columns(*columns)
+        define_singleton_method(:serialized_columns) { columns }
+      end
+
+      def serialized_columns
+        []
+      end
+
+      def include_all_types
+        include_types()
+      end
+
+      def include_types(*types, &block)
+        if block_given?
+          define_singleton_method(:types, &block)
+        else
+          define_singleton_method(:types) { types }
+        end
+      end
+
+      def types
+        [self]
+      end
+
+      def subclasses
+        mapper.subclasses(self)
+      end
+
+      def columns
+        @columns ||= mapper.columns - restricted_columns
+      end
+
+      def db
+        mapper.db
+      end
+
+      def schema
+        mapper.schema
+      end
+
+      def get(id)
+        mapper.get(id)
+      end
+
+      alias_method :[], :get
+
+      def count
+        mapper.count(types)
+      end
+
+      def all
+        mapper.all(*types)
+      end
+
+      def all!(&block)
+        mapper.all!(&block)
+      end
+
+      def first(*args, &block)
+        mapper.first(types, *args, &block)
+      end
+
+      def first!(*args, &block)
+        mapper.first!(*args, &block)
+      end
+
+      def filter(*cond, &block)
+        mapper.filter(types, *cond, &block)
+      end
+
+      def filter!(*cond, &block)
+        mapper.filter!(*cond, &block)
+      end
+
+      def where(*cond, &block)
+        mapper.where(types, *cond, &block)
+      end
+
+      def where!(*cond, &block)
+        mapper.where!(*cond, &block)
+      end
+
+      def create(attrs = {})
+        self.new(attrs).save
+      end
+
+      def insert(attrs = {})
+        mapper.insert(attrs)
+      end
+
+      def update(attrs)
+        mapper.update(types, attrs)
+      end
+
+      def delete(&block)
+        mapper.delete(types, &block)
+      end
+
+      def order(*columns, &block)
+        mapper.order(types, *columns, &block)
+      end
+
+      def limit(l, o = (no_offset = true; nil))
+        mapper.limit(types, l, o)
+      end
+
+      def for_update
+        mapper.for_update
+      end
+
+      def select(*columns, &block)
+        mapper.select(types, *columns, &block)
+      end
+
+      def visible
+        mapper.visible.dataset(types)
+      end
+
+      def columns
+        mapper.columns
+      end
+
+      def primary_key
+        mapper.primary_key
+      end
+
+      def table_name
+        mapper.table_name
+      end
+
+      include Associations
+
+      module InstanceMethods
+
+        HOOKS = [ :create, :save, :update, :destroy ] unless defined?(HOOKS)
+
+        HOOKS.each do |hook|
+          module_eval "def before_#{hook}; end", __FILE__, __LINE__
+          module_eval "def after_#{hook} ; end", __FILE__, __LINE__
+        end
+
+        def initialize(attr = {}, from_db = false)
+          @modified = false
+          if from_db
+            @new = false
+            set_attributes!(attr)
+          else
+            @new = true
+            @modified = true
+            @attributes = {}
+            changed_columns.clear
+            set(attr)
+          end
+          trigger_hook(:after_initialize)
+        end
+
+        def after_initialize; end
+
+        def attributes
+          @attributes.dup
+        end
+
+        def mapper
+          model.mapper
+        end
+
+        def save
+          id = nil
+          saved = false
+          trigger_hook(:before_save) do
+            if new?
+              trigger_hook(:before_create) do
+                mapper.create(self)
+                @new  = false
+                saved = true
+                trigger_hook(:after_create)
+                self
+              end
+            else
+              trigger_hook(:before_update) do
+                mapper.save(self)
+                saved = true
+                changed_columns.clear
+                trigger_hook(:after_update)
+                self
+              end
+            end
+            return nil unless saved
+            trigger_hook(:after_save)
+          end
+          @modified = false
+          self
+        end
+
+        def trigger_hook(callback)
+          catch :halt do
+            send(callback)
+            return yield if block_given?
+            return self
+          end
+          nil
+        end
+
+        def mark_modified!(*columns)
+          if columns.empty?
+            @modified = true
+          else
+            _mark_columns_as_modified(*columns)
+          end
+        end
+
+        def modified?
+          @modified || !changed_columns.empty?
+        end
+
+        def reload
+          refresh
+        end
+
+        def _after_save_refresh
+          refresh
+        end
+
+        def refresh
+          changed_columns.clear
+          mapper.reload(self)
+          self
+        end
+
+        def destroy
+          deleted = false
+          trigger_hook(:before_destroy) do
+            delete
+            deleted = true
+            trigger_hook(:after_destroy)
+            self
+          end
+          return nil unless deleted
+          self
+        end
+
+        def delete
+          mapper.delete_instance(self)
+        end
+
+        def new?
+          @new
+        end
+
+        def id
+          @attributes[:id]
+        end
+
+        alias_method :pk, :id
+
+        def update(values)
+          set(values)
+          save
+        end
+
+        def set(values)
+          set_restricted(values)
+        end
+
+        def model
+          self.class
+        end
+
+        def set_restricted(attrs)
+          exclude = model.restricted_columns
+          attrs.each do |column, value|
+            send("#{column}=", value) unless exclude.include?(column.to_sym)
+          end
+        end
+
+        def set_attributes!(attributes)
+          @attributes = attributes
+        end
+
+        def set_attributes_after_save!(attributes)
+          set_attributes!(attributes)
+          changed_columns.clear
+          @new = false
+        end
+
+        def ==(obj)
+          eql?(obj)
+        end
+
+        def eql?(obj)
+          (obj.class == model) && (obj.attributes == @attributes)
+        end
+
+        def hash
+          [model, id.nil? ? @values.sort_by{|k,v| k.to_s} : id].hash
+        end
+      end
+    end
+  end
+end

data/lib/spontaneous/data_mapper/content_table.rb

@@ -0,0 +1,103 @@
+module Spontaneous
+  module DataMapper
+    class ContentTable
+      REVISION_PADDING = 5
+
+      def self.revision_table?(base_name, table_name)
+        /\A__r\d+_#{base_name}\z/ === table_name.to_s
+      end
+
+      def self.pad_revision_number(revision_number)
+        revision_number.to_s.rjust(REVISION_PADDING, "0")
+      end
+
+      def self.revision_table(base_name, revision_number)
+        return base_name if revision_number.nil?
+        "__r#{pad_revision_number(revision_number)}_#{base_name}".to_sym
+      end
+
+      # Extracts the revision number from a table name
+      #
+      #   revision_number :content, :__r00034_content
+      #   => 34
+      #
+      def self.revision_from_table(base_name, table_name)
+        return nil if base_name == table_name
+        return nil unless revision_table?(base_name, table_name)
+        if (match = /\A__r(\d+)_#{base_name}\z/.match(table_name.to_s))
+          rev = match[1]
+          return rev.to_i(10)
+        end
+        nil
+      end
+
+      attr_reader :name, :database
+
+      def initialize(name, database)
+        @name, @database = name, database
+      end
+
+      def columns
+        dataset.columns
+      end
+
+      def primary_key
+        :id
+      end
+
+      def dataset(revision = nil)
+        @database[revision_table(revision)]
+      end
+
+      def logger
+        @database.logger
+      end
+
+      def logger=(logger)
+        @database.logger = logger
+      end
+
+      alias_method :db, :database
+
+      def qualify(revision, col)
+        Sequel::SQL::QualifiedIdentifier.new(revision_table(revision), col)
+      end
+
+      def quote_identifier(identifier)
+        dataset.quote_identifier(identifier)
+      end
+
+      def revision_table(revision_number)
+        self.class.revision_table(@name, revision_number)
+      end
+
+      def revision_from_table(table)
+        self.class.revision_from_table(@name, table)
+      end
+
+      def revision_table?(table_name)
+        self.class.revision_table?(@name, table_name)
+      end
+
+      def pad_revision_number(revision_number)
+        self.class.pad_revision_number(revision_number)
+      end
+
+      def revision_history_table
+        :"spontaneous_#{@name}_history"
+      end
+
+      def revision_archive_table
+        :"spontaneous_#{@name}_archive"
+      end
+
+      def revision_history_dataset
+        @database[revision_history_table]
+      end
+
+      def revision_archive_dataset
+        @database[revision_archive_table]
+      end
+    end
+  end
+end

data/lib/spontaneous/data_mapper/dataset.rb

@@ -0,0 +1,194 @@
+module Spontaneous
+  module DataMapper
+    class Dataset
+      include Enumerable
+
+      def initialize(dataset, schema, identity_map)
+        @dataset, @schema, @identity_map = dataset, schema, identity_map
+      end
+
+      def count
+        @dataset.count
+      end
+
+      def get(id)
+        return get_all(id) if id.is_a?(Array)
+        if (instance = @identity_map[id])
+          instance
+        else
+          first(id: id)
+        end
+      end
+
+      # Gets all the instances for the list of ids and returns them
+      # in the id order of the list, rather than the db order.
+      def get_all(id_list)
+        # This pure-db solution is Postgresql only unfortunately...
+        #
+        # values = []
+        # id_list.each_with_index do |id, index|
+        #   values << ("(" << [id, index].join(",") << ")")
+        # end
+        # ds = @dataset.filter(:id => id_list).qualify.
+        # join(Sequel::LiteralString.new("(VALUES #{values.join(",")}) AS id_order (id, pos)"), {:id_order__id => :id}, {:qualify => true}).
+        # order(:id_order__pos)
+        order = Hash[id_list.each_with_index.map { |id, index| [id, index] }]
+        filter(:id => id_list).all.sort { |i1, i2|
+          order[i1.id] <=> order[i2.id]
+        }
+      end
+
+      def first(*args, &block)
+        load_instance @dataset.first(*args, &block)
+      end
+
+      def insert(*values, &block)
+        @dataset.insert(*values, &block)
+      end
+
+      def save(instance)
+        attributes = instance.modified_attributes
+        id = instance.id
+        return insert(instance) if id.nil?
+        return instance if attributes.empty?
+        @dataset.where(id: id).update(attributes)
+        instance
+      end
+
+      def update(columns)
+        @dataset.update(columns)
+      end
+
+      def create(instance)
+        id = @dataset.insert(attributes_for_insert(instance))
+        instance.set_attributes_after_save!(get_unfiltered_raw(id))
+        instance
+      end
+
+      def delete
+        @dataset.delete
+      end
+
+      def delete_instance(instance)
+        @dataset.unfiltered.filter(id: instance.id).delete
+      end
+
+      def destroy
+        @dataset.each do |row|
+          load_instance(row).destroy
+        end
+      end
+
+      def filter(*cond, &block)
+        @dataset.filter!(*cond, &block)
+        self
+      end
+
+      def where(*cond, &block)
+        @dataset.where!(*cond, &block)
+        self
+      end
+
+      def all
+        load_instances @dataset.all
+      end
+
+      def reload(instance)
+        attrs = get_raw(instance.id)
+        instance.set_attributes!(attrs)
+      end
+
+      def and(*cond, &block)
+        @dataset.and!(*cond, &block)
+        self
+      end
+
+      def or(*cond, &block)
+        @dataset.or!(*cond, &block)
+        self
+      end
+
+      def each
+        @dataset.each do |r|
+          yield load_instance(r)
+        end
+      end
+
+      def for_update
+        @dataset.for_update!
+        self
+      end
+
+      def order(*columns, &block)
+        @dataset.order!(*columns, &block)
+        self
+      end
+
+      def limit(l, o = (no_offset = true; nil))
+        @dataset.limit!(l, o)
+        self
+      end
+
+      def select(*columns, &block)
+        @dataset.select!(*columns, &block)
+        self
+      end
+
+      def qualify_to_first_source
+        @dataset = @dataset.qualify_to_first_source
+        self
+      end
+
+      def qualify(col)
+        SQL::QualifiedIdentifier.new(table, k)
+      end
+
+      def to_sql
+        @dataset.inspect
+      end
+
+      private
+
+      def get_raw(id)
+        @dataset.first(id: id)
+      end
+
+      def get_unfiltered_raw(id)
+        @dataset.unfiltered.first(id: id)
+      end
+
+      def attributes_for_insert(instance)
+        attributes_with_type_sid(instance.class, instance.attributes)
+      end
+
+      def attributes_with_type_sid(model, attributes)
+        attributes = attributes.dup
+        restricted = model.restricted_columns
+        restricted.each { |col| attributes.delete(col)}
+        attributes.update({
+          type_sid: @schema.to_id(model)
+        })
+      end
+
+      def load_instances(rows)
+        rows.map { |row| load_instance(row) }
+      end
+
+      def load_instance(attributes)
+        return nil if attributes.nil?
+        allocate_instance(attributes)
+      end
+
+      def allocate_instance(attributes)
+        return attributes if attributes[:type_sid].nil?
+        if (instance = @identity_map[attributes[:id]])
+          instance
+        else
+          model = @schema.to_class(attributes[:type_sid])
+          instance = model.new(attributes, true)
+          @identity_map[instance.id] = instance
+        end
+      end
+    end
+  end
+end