spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/data_mapper/scope.rb

@@ -0,0 +1,195 @@
+module Spontaneous
+  module DataMapper
+    class Scope
+
+      def initialize(revision, visible, table, schema)
+        @revision, @visible  = revision, visible
+        @table, @schema      = table, schema
+        @identity_map        = {}
+      end
+
+      def count(types = nil)
+        dataset(types).count
+      end
+
+      # A type free version of #count
+      def count!
+        count(nil)
+      end
+
+      def filter(types, *cond, &block)
+        dataset(types).filter(*cond, &block)
+      end
+
+      # A type free version of #filter
+      def filter!(*cond, &block)
+        filter(nil, *cond, &block)
+      end
+
+      def where(types, *cond, &block)
+        dataset(types).where(*cond, &block)
+      end
+
+      # A type free version of #where
+      def where!(*cond, &block)
+        where(nil, *cond, &block)
+      end
+
+      def first(types, *args, &block)
+        dataset(types).first(*args, &block)
+      end
+
+      # A type free version of #first
+      def first!(*args, &block)
+        first(nil, *args, &block)
+      end
+
+      def all(*types, &block)
+        instances = dataset(types).all
+        instances.each(&block) if block_given?
+        instances
+      end
+
+      # A type free version of #all
+      def all!(&block)
+        all(nil, &block)
+      end
+
+      # Get doesn't need typing as it retrieves a single instance by direct
+      # id reference.
+      def get(id)
+        dataset.get(id)
+      end
+
+      alias_method :[], :get
+
+      def insert(*values, &block)
+        dataset.insert(*values, &block)
+      end
+
+      def instance(model, attributes)
+        model.create(attributes)
+      end
+
+      def update(types, columns)
+        dataset(types).update(columns)
+      end
+
+      # A type free version of #update
+      def update!(columns)
+        update(nil, columns)
+      end
+
+      def for_update
+        dataset.for_update
+      end
+
+      def delete(types)
+        dataset(types).delete
+      end
+
+      def delete_instance(instance)
+        dataset.delete_instance(instance)
+      end
+
+      def reload(instance)
+        dataset.reload(instance)
+      end
+
+      def create(instance)
+        dataset.create(instance)
+      end
+
+      def save(instance)
+        dataset.save(instance)
+      end
+
+      def order(types, *columns, &block)
+        dataset(types).order(*columns, &block)
+      end
+
+      def limit(types, l, o = (no_offset = true; nil))
+        dataset(types).limit(l, o)
+      end
+
+      def select(types, *columns, &block)
+        dataset(types).select(*columns, &block)
+      end
+
+      def schema_uid(id_string)
+        @schema.uids[id_string]
+      end
+
+      def columns
+        @table.columns
+      end
+
+      def qualify_column(col)
+        @table.qualify(@revision, col)
+      end
+
+      def each(&block)
+        dataset.each(&block)
+      end
+
+      def with_cache(key, &block)
+        if @identity_map.key?(key)
+          @identity_map[key]
+        else
+          @identity_map[key] = block.call
+        end
+      end
+
+      def pk
+        @table.pk
+      end
+
+      def table_name
+        naked_dataset.first_source_alias
+      end
+
+      def logger
+        @table.logger
+      end
+
+      def logger=(logger)
+        @table.logger = logger
+      end
+
+      def revision
+        self
+      end
+
+      def visible_only?
+        @visible || false
+      end
+
+      def dataset(types = nil)
+        Dataset.new(table_dataset(types), @schema, @identity_map)
+      end
+
+      private
+
+      def table_dataset(types)
+        naked_dataset.filter(conditions(types))
+      end
+
+      def naked_dataset
+        @table.dataset(@revision)
+      end
+
+      def conditions(types)
+        cond = type_conditions(types)
+        cond[:hidden] = false if @visible
+        cond
+      end
+
+      def type_conditions(types)
+        return {} if types.nil?
+        types = Array(types)
+        return {} if types.empty?
+        { :type_sid => types.flatten.map { |model| @schema.to_id(model) } }
+      end
+    end
+  end
+end

data/lib/spontaneous/data_mapper.rb

@@ -0,0 +1,161 @@
+require "spontaneous/data_mapper/scope"
+require "spontaneous/data_mapper/dataset"
+require "spontaneous/data_mapper/content_model"
+require "spontaneous/data_mapper/content_table"
+
+module Spontaneous
+  module DataMapper
+
+    def self.Model(table_name, database, schema, &block)
+      table  = ::Spontaneous::DataMapper::ContentTable.new(table_name, database)
+      mapper = ScopingMapper.new(table, schema)
+      Spontaneous::DataMapper::ContentModel.generate(mapper, &block)
+    end
+
+    def self.new(table, schema)
+      ScopingMapper.new(table, schema)
+    end
+
+    class ScopingMapper
+      extend Forwardable
+
+      attr_reader :schema
+
+      def initialize(table, schema)
+        @table, @schema = table, schema
+        name = table.name
+        @keys = {
+          :visible  => :"#{name}_mapper_visibility",
+          :revision => :"#{name}_mapper_revision",
+          :dataset => :"#{name}_mapper_dataset"
+        }
+      end
+
+      def_delegators :dataset,
+        :filter, :where,
+        :filter!, :where!,
+        :count, :count!,
+        :order, :limit,
+        :all, :get, :[], :first,
+        :all!, :first!,
+        :reload,
+        :instance,
+        :create, :save, :insert,
+        :update, :update!,
+        :delete, :delete_instance,
+        :for_update, :select,
+        :columns, :table_name,
+        :qualify_column, :quote_identifier,
+        :with_cache,
+        :logger=, :logger
+
+      def_delegators :@schema,
+        :subclasses, :inherited
+
+      def_delegators :@table,
+        :db, :primary_key,
+        :revision_table, :revision_table?, :revision_from_table,
+        :revision_history_table, :revision_archive_table,
+        :revision_history_dataset, :revision_archive_dataset,
+        :quote_identifier
+
+      def visible(visible_only = true, &block)
+        scope(current_revision, visible_only, &block)
+      end
+
+      def visible!(visible_only = true, &block)
+        scope!(current_revision, visible_only, &block)
+      end
+
+      def revision(r = current_revision, &block)
+        scope(r, visible_only?, &block)
+      end
+
+      def revision!(r = current_revision, &block)
+        scope!(r, visible_only?, &block)
+      end
+
+      def editable(&block)
+        revision(nil, &block)
+      end
+
+      def editable!(&block)
+        revision!(nil, &block)
+      end
+
+      def scope(revision, visible, &block)
+        if use_current_scope?(revision, visible)
+          if block_given?
+            yield
+          else
+            dataset
+          end
+        else
+          scope!(revision, visible, &block)
+        end
+      end
+
+      def scope!(revision, visible, &block)
+        if block_given?
+          r, v, d  = @keys.values_at(:revision, :visible, :dataset)
+          thread   = Thread.current
+          state    = [thread[r], thread[v], thread[d]]
+          begin
+            thread[r] = to_revision(revision)
+            thread[v] = visible
+            thread[d] = current_scope
+            yield
+          ensure
+            thread[r], thread[v], thread[d] = state
+          end
+        else
+          scope_for(revision, visible)
+        end
+      end
+
+      def dataset
+        Thread.current[@keys[:dataset]] || current_scope
+      end
+
+      def cached_dataset?
+        !Thread.current[@keys[:dataset]].nil?
+      end
+
+      def use_current_scope?(revision, visible)
+        cached_dataset? &&
+          (current_revision == to_revision(revision)) &&
+          ((visible || false) == visible_only?)
+      end
+
+      def to_revision(r)
+        r.nil? ? nil : r.to_i
+      end
+
+      def current_revision
+        Thread.current[@keys[:revision]]
+      end
+
+      def visible_only?
+        Thread.current[@keys[:visible]] || false
+      end
+
+      def base_table
+        @table.name
+      end
+
+      def schema_uid(id_string)
+        @schema.uids[id_string]
+      end
+
+      private
+
+      def current_scope
+        scope_for(current_revision, visible_only?)
+      end
+
+      def scope_for(revision, visibility)
+        Scope.new(revision, visibility, @table, @schema)
+      end
+    end
+  end
+end

data/lib/spontaneous/facet.rb

@@ -37,12 +37,12 @@ module Spontaneous
     end
 
     def config
-      Site.instance.config
+      Spontaneous::Site.instance.config
     end
 
     def load_config!
       paths.expanded(:config).each do |config_path|
-        Site.config.load(config_path)
+        Spontaneous::Site.config.load(config_path)
       end
     end