aliases.rb in spontaneous-0.2.0.alpha1

- old
+ new

@@ -1,58 +1,81 @@
 # encoding: UTF-8
 
 
 module Spontaneous::Plugins
   module Aliases
+    extend ActiveSupport::Concern
 
-    def self.configure(base)
-      base.many_to_one :target, :class => base, :reciprocal => :aliases
-      base.one_to_many :aliases, :class => base, :key => :target_id, :reciprocal => :target
-      base.add_association_dependencies :aliases => :destroy
+    included do
+      many_to_one :target, :class => self, :reciprocal => :aliases
+      one_to_many :aliases, :class => self, :key => :target_id, :reciprocal => :target
+      add_association_dependencies :aliases => :destroy
     end
+    # def self.configure(base)
+    # end
 
     module ClassMethods
-      def alias_of(*class_list)
+      def alias_of(*args)
+        options_list, class_list = args.partition { |e| e.is_a?(Hash) }
+        @alias_options = options_list.first || {}
         @alias_classes = class_list
         extend  ClassAliasMethods
         include AliasMethods
+        include PieceAliasMethods unless page?
         include PageAliasMethods if page?
       end
 
       alias_method :aliases, :alias_of
 
-      def targets
+      def targets(owner = nil, box = nil)
         targets = []
-        target_classes.each do |target_class|
-          targets += target_class.sti_subclasses_array
+        classes = []
+        proc_args = [owner, box].compact
+        @alias_classes.each do |source|
+          case source
+          when Proc
+            targets.concat(source[*proc_args])
+          else
+            classes.concat(source.to_s.constantize.sti_subclasses_array)
+          end
         end
-        S::Content.filter(sti_key => targets.map { |t| t.to_s }).all
+        query = S::Content.filter(sti_key => classes.map { |c| c.to_s })
+        if container_procs = @alias_options[:container]
+          containers = [container_procs].flatten.map { |p| p[*proc_args] }.flatten
+          params = []
+          containers.each do |container|
+            if container.is_page?
+              params << Sequel::SQL::BooleanExpression.new(:'=', :page_id, container.id)
+            else
+              box_params = [
+                [:box_sid, container.id],
+                [:owner_id, container.owner.id]
+              ]
+              params << Sequel::SQL::BooleanExpression.from_value_pairs(box_params, :AND)
+            end
+          end
+          container_query = params[1..-1].inject(params.first) { |q, expr| q = q | expr; q }
+          query = query.and(container_query)
+        end
+        targets.concat(query.all)
+        if filter = @alias_options[:filter] and filter.is_a?(Proc)
+          targets.select(&filter)
+        else
+          targets
+        end
       end
 
-      def target_classes
-        @target_classes ||= @alias_classes.map { |c| c.to_s.constantize }
+      def target_class(class_definition)
+
       end
 
       def alias?
         false
       end
-    end
+    end # ClassMethods
 
-    module InstanceMethods
-      def alias_title
-        fields[:title].to_s
-      end
 
-      def alias_icon_field
-        if field = fields.detect { |f| f.image? }
-          field
-        else
-          nil
-        end
-      end
-    end
-
     module ClassAliasMethods
       def alias?
         true
       end
     end
@@ -94,22 +117,25 @@
 
       def styles
         @styles ||= Spontaneous::Collections::PrototypeSet.new(target, :styles)
       end
 
-      def export
-        super.merge(:target => target.shallow_export, :alias_title => target.alias_title, :alias_icon => target.alias_icon_field.export)
+      def export(user = nil)
+        super.merge(:target => target.shallow_export(user), :alias_title => target.alias_title, :alias_icon => target.exported_alias_icon)
       end
+
     end
 
-    module PageAliasMethods
+    module PieceAliasMethods
       def path
-        @_path ||= [parent.path, target.slug].join(S::SLASH)
+        target.path
       end
+    end
 
-      def calculate_path
-        ""
+    module PageAliasMethods
+      def slug
+        target.slug
       end
 
       def layout
         # if this alias class has no layouts defined, then just use the one set on the target
         if self.class.layouts.empty?
@@ -121,8 +147,27 @@
       end
 
       def find_named_layout(layout_name)
         super or target.find_named_layout(layout_name)
       end
+    end
+
+    # InstanceMethods
+
+    def alias_title
+      fields[:title].to_s
+    end
+
+    def alias_icon_field
+      if field = fields.detect { |f| f.image? }
+        field
+      else
+        nil
+      end
+    end
+
+    def exported_alias_icon
+      return nil unless alias_icon_field
+      alias_icon_field.export
     end
   end
 end