ds-kitsune 0.2.3

data/lib/kitsune/builder.rb

@@ -0,0 +1,236 @@
+module Kitsune
+  class TypeError < StandardError; end
+  class Builder
+        
+    TYPES = [:check_box, :datetime_select, :password_field, :text_area, :text_field, :wysiwyg, :collection_select]
+    def initialize(resource, &block)
+      @resource = resource
+      self.instance_eval &block
+    end
+    
+    def category category
+      @resource.kitsune_admin[:category] = category
+    end
+    
+    def name name
+      @resource.kitsune_admin[:name] = name
+    end
+    
+    def media media
+      @resource.kitsune_admin[:media] = media
+    end
+    
+    def on_edit &block
+      @resource.kitsune_admin[:on_edit] = block
+    end
+    
+    def on_new &block
+      @resource.kitsune_admin[:on_new] = block
+    end
+    
+    def before_save &block
+      @resource.kitsune_admin[:before_save] = block
+    end
+    
+		def no_menu
+			no_admin
+		end
+		
+		def order_by(order)
+		  order = {order => :asc} unless order.is_a?(Hash)
+		  @resource.kitsune_admin[:order_by] = order
+	  end
+		
+		def versioned
+		  @resource.send(:versioned)
+		  @resource.kitsune_admin[:versioned] = true
+	  end
+	  
+	  def add_faux_method method_name
+  	  @resource.kitsune_admin[:faux_methods] ||= []
+  	  @resource.kitsune_admin[:faux_methods]<<method_name
+    end
+    
+    def remove_faux_methods
+      if @resource.kitsune_admin[:faux_methods]
+        @resource.kitsune_admin[:faux_methods].each do |fm|
+          @resource.send(:remove_method, fm) if @resource.methods.include?(fm.to_sym)
+          if @resource.kitsune_admin[:edit][:fields]
+            @resource.kitsune_admin[:edit][:fields].delete fm.to_sym if @resource.kitsune_admin[:edit][:fields].include?(fm.to_sym)
+            @resource.kitsune_admin[:fields].delete fm.to_sym if @resource.kitsune_admin[:fields].keys.include?(fm)
+          end
+        end
+        @resource.kitsune_admin[:faux_methods].clear
+      end
+    end
+
+    def no_admin
+      @resource.kitsune_admin[:no_admin] = true
+    end
+    
+    def tabs(tabs)
+      @resource.kitsune_admin[:tabs] = tabs
+    end
+    
+    def self.generate(resource, &block)
+      Builder.new(resource, &block)
+    end
+    
+    def definitions
+      yield # should be it's own builder
+    end
+    
+    def columns(type = nil)
+      @resource.columns
+    end
+
+		def disable(*types)
+			types.each do |type|
+				@resource.kitsune_admin[:disabled] << type.to_sym
+			end
+		end
+    
+    def sortable(*fields)
+      @resource.kitsune_admin[:sortable] ||= []
+      fields.each do |field|
+        @resource.kitsune_admin[:sortable] << field.to_sym
+      end
+    end
+    
+    def always(*fields)
+      @resource.kitsune_admin[:always] ||= []
+      fields.each do |field|
+        @resource.kitsune_admin[:always] << field.to_sym
+      end
+    end
+    
+    def linked(*fields) # link to resource
+      @resource.kitsune_admin[:linked] ||= []
+      fields.each do |field|
+        @resource.kitsune_admin[:linked] << field.to_sym
+      end
+    end
+    
+    def file(field)
+      add :file_field, field
+      multipart
+    end
+    
+    def image(field)
+      add :image_field, field
+      multipart
+    end
+    
+    def multipart(value = true)
+      @resource.kitsune_admin[:multipart] = value
+    end
+    
+    def select(field, choices, options = {}, html_options = {})
+      add :select, field, {:options => [choices, options, html_options]}
+    end
+    
+    def collection_select(field, collection, value_method, text_method, options = {}, html_options = {})
+      add :collection_select, field, {:options => [collection, value_method, text_method, options, html_options]}
+    end
+    
+    def string(field)
+      add :text_field, field
+    end
+    
+    def text(field)
+      add :text_area, field
+    end
+    
+    def sti(field, options = {})
+      add :sti, field, {:options => options}
+      is_sti field
+    end
+    
+    def is_sti(field)
+      @resource.kitsune_admin[:is_sti] = true
+      @resource.kitsune_admin[:sti_column] = field
+    end
+    
+    def display_and_edit(*args)
+      display *args
+      edit *args
+    end
+    
+    def display(*fields)
+      fields.each do |field|
+        if field.is_a?(Hash)
+          field.each do |key, value|
+            set :display, key
+            set_attributes(key, value)
+          end
+        else
+          set :display, field
+        end
+      end
+    end
+    
+    def show(*fields)
+      fields.each do |field|
+        if field.is_a?(Hash)
+          field.each do |key, value|
+            set :show, key
+            set_attributes(key, value)
+          end
+        else
+          set :show, field
+        end
+      end
+    end
+    
+    def set_attributes(field, attributes)
+      [attributes].flatten.each do |attribute|
+        send(attribute.to_sym, field)
+      end
+    end
+    
+    def edit(*fields)
+      fields.each do |field|
+        if field.is_a?(Hash)
+          field.each do |key, value|
+            type = @resource.reflections[key.to_sym] ? :reflections : :edit
+            set(type, key)
+            set_attributes(key, value)
+          end
+        else
+          type = @resource.reflections[field.to_sym] ? :reflections : :edit
+          set type, field
+        end
+      end
+    end
+    
+    def no_edit(*fields)
+      set :no_edit, fields
+    end
+    
+    def method_missing(method, *args, &block)
+      if TYPES.include?(method)
+        add method, *args
+      else
+        raise Exception, "THIS IS WRONG@! #{method.to_s}"
+      end
+    end
+    
+    private
+    def add(type, field, options = {})
+      @resource.kitsune_admin[:fields] ||= {}
+      @resource.kitsune_admin[:fields][field] = options.merge(:type => type)
+    end
+    
+    def set(type, fields)
+      @resource.kitsune_admin[type] = {} unless @resource.kitsune_admin[type]
+      @resource.kitsune_admin[type][:fields] ||= []
+      [fields].flatten.each do |field|
+        unless field.is_a?(Hash)
+          @resource.kitsune_admin[type][:fields] << field unless @resource.kitsune_admin[type][:fields].include?(field)
+        else
+          @resource.kitsune_admin[type].merge!(field)
+        end
+      end
+    end
+  end
+end

data/lib/kitsune/extensions/routes.rb

@@ -0,0 +1,15 @@
+if defined?(ActionController::Routing::RouteSet)
+  class ActionController::Routing::RouteSet
+    def add_configuration_file_with_kitsune(file)
+      lib_path = File.dirname(__FILE__)
+      kitsune_routes = File.join(lib_path, *%w[.. .. .. config kitsune_routes.rb])
+      if configuration_files.include?(kitsune_routes)
+        self.configuration_files.delete(kitsune_routes)
+      end
+      add_configuration_file_without_kitsune(file)
+      add_configuration_file_without_kitsune(kitsune_routes)
+    end
+    
+    alias_method_chain :add_configuration_file, :kitsune
+  end
+end

data/lib/kitsune/faux_column.rb

@@ -0,0 +1,8 @@
+module Kitsune
+  class FauxColumn
+    attr_accessor :name, :type, :primary
+    def initialize(name, type, primary = false)
+      @name, @type, @primary = name, type, primary
+    end
+  end
+end

data/lib/kitsune/form_helper_ext.rb

@@ -0,0 +1,23 @@
+module ActionView
+  module Helpers
+    class FormBuilder
+      def wysiwyg(method, options={})
+        sanitized_object_name = @object_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
+        sanitized_method_name = method.to_s.sub(/\?$/,"")
+        id = "#{sanitized_object_name}_#{sanitized_method_name}"
+        if @object.kitsune_admin[:media]
+          @template.content_for(:head) do 
+            @template.capture do
+              "<script>
+              $(function() {
+                $('textarea.wysiwyg').upload_maker('#{@template.url_for({:id => @object.kitsune_admin[:media].keys.first.to_s.classify, :action=>"new", :controller=>"admin/kitsune/media"})}');
+              })
+              </script>"
+            end
+          end
+        end
+        @template.send('text_area', @object_name, method, objectify_options(options.merge({:class => 'wysiwyg'}))) + @template.content_tag('script', "tinyMCE.execCommand('mceAddControl', true, '#{id}');")
+      end
+    end
+  end
+end

data/lib/kitsune/inspector.rb

@@ -0,0 +1,268 @@
+module Kitsune
+  # Inspector is a proxy for adding additional methods. These should only be
+  # available within the Kitsune admin.
+  
+  class Inspector
+    attr_reader :object
+    def initialize(object)
+      @object = object
+      @collection_label_methods = %w[to_label display_name full_name name title username login value to_s]
+    end
+    
+    def admin_name
+      kitsune_admin[:name] || @object.to_s.pluralize
+    end
+    
+    def order_by
+       order_by_hash ? order_by_hash.map{|k,v| "#{k} #{v}"}.join(' ') : nil
+    end
+    
+    def order_by_hash
+      kitsune_admin[:order_by] || nil
+    end
+    
+    def category
+      kitsune_admin[:category] || nil
+    end
+    
+    def versioned?
+      !!kitsune_admin[:versioned]
+    end
+
+		def disabled?(type)
+			kitsune_admin[:disabled].include?(type.to_sym)
+		end
+    
+    def run_hooks(type, *args)
+      kitsune_admin[type.to_sym].call(*args) if kitsune_admin[type.to_sym]
+    end
+    
+    def is_sti?
+      kitsune_admin[:is_sti]
+    end
+    
+    def is_sti_child?
+      if defined? ::ActiveRecord
+        @object.ancestors[1] != ::ActiveRecord::Base
+      else
+        false
+      end
+    end
+    
+    def sti_column
+      kitsune_admin[:sti_column]
+    end
+    
+    def tabs
+      kitsune_admin[:tabs]
+    end
+    
+    def object_class
+      @object.to_s
+    end
+    
+    def new_record(*args)
+      @object.new(*args)
+    end
+    
+    def columns(type = nil, include_pk = false)
+      unless type
+        kolumns = @object.columns.dup
+      else
+        kolumns = send("columns_for_#{type}") if respond_to?("columns_for_#{type}")
+      end
+      include_pk ? kolumns : (kolumns || []).reject{|c| c.primary }
+    end
+    
+    def columns_for_edit
+      kolumns = @object.columns.dup
+      if kitsune_admin[:no_edit] && kitsune_admin[:no_edit][:fields]
+        kolumns.reject{|c| kitsune_admin[:no_edit][:fields].include?(c.name.to_sym)}
+      elsif kitsune_admin[:edit] && kitsune_admin[:edit][:fields]
+        kolumns = kolumns.select{|c| kitsune_admin[:edit][:fields].include?(c.name.to_sym)}
+        kolumn_names = kolumns.map{|c| c.name.to_sym}
+        fields_to_add = kitsune_admin[:edit][:fields].reject{|f| kolumn_names.include?(f)}
+        fields_to_add.each do |field|
+          kolumns << Kitsune::FauxColumn.new(field, :string)
+        end
+        kolumns
+      else
+        kolumns
+      end
+    end
+    
+    def columns_for_display
+      columns = @object.columns.dup
+      if kitsune_admin[:display] && kitsune_admin[:display][:fields]
+        columns = columns.select{|c| kitsune_admin[:display][:fields].include?(c.name.to_sym)}
+        column_names = columns.map{|c| c.name.to_sym}
+        fields_to_add = kitsune_admin[:display][:fields].reject{|f| column_names.include?(f)}
+        fields_to_add.each do |field|
+          columns << Kitsune::FauxColumn.new(field, :string)
+        end
+        columns
+      else
+        columns
+      end
+    end
+    
+    def columns_for_show
+      columns = @object.columns.dup
+      if kitsune_admin[:show] && kitsune_admin[:show][:fields]
+        columns = columns.select{|c| kitsune_admin[:show][:fields].include?(c.name.to_sym)}
+        column_names = columns.map{|c| c.name.to_sym}
+        fields_to_add = kitsune_admin[:show][:fields].reject{|f| column_names.include?(f)}
+        fields_to_add.each do |field|
+          columns << Kitsune::FauxColumn.new(field, :string)
+        end
+        columns
+      else
+        columns
+      end
+    end
+    
+    def columns_for_reflections
+			if kitsune_admin[:reflections] && kitsune_admin[:reflections][:fields]
+				kitsune_admin[:reflections][:fields].map do |field|
+					Kitsune::FauxColumn.new(field, :string)
+				end
+			else
+				[]
+			end
+    end
+    
+    def column_sortable(column)
+      # move to column proxy
+      kitsune_admin[:sortable] && kitsune_admin[:sortable].include?(column.name.to_sym)
+    end
+    
+    def always?(column)
+      # move to column proxy
+      kitsune_admin[:always] && kitsune_admin[:always].include?(column.name.to_sym)
+    end
+    
+    def column_linked?(column)
+      # move to column proxy
+      kitsune_admin[:linked] && kitsune_admin[:linked].include?(column.name.to_sym)
+    end
+    
+    def method_missing(method, *args, &block)
+      @object.send(method, *args, &block)
+    end
+    
+    def form_type(column)
+      field = column.name
+      if type = field_type(column.name)
+        case type
+        when :sti
+          if (options = field_options(field)) && options[:classes]
+            :select
+          else
+            :text_field
+          end
+				when :image_field
+					:file_field
+        else
+          kitsune_admin[:fields][column.name.to_sym][:type]
+        end
+      elsif column.name =~ /._id$/
+        :select
+      else
+        case column.type
+          when :text then :text_area
+          when :datetime then :datetime_select
+          when :date then :date_select
+          when :time then :time_select
+          when :boolean then :check_box
+          else :text_field
+        end
+      end
+    end
+    
+    def detect_label(collection)
+      @collection_label_methods.each do |label_name|
+        return label_name if [collection].flatten.first.respond_to?(label_name)
+      end
+      'to_s'
+    end
+    
+    def find_association_class(column)
+      if @object.reflections[column.name.to_s.gsub(/_id$/,'').to_sym]
+        if @object.reflections[column.name.to_s.gsub(/_id$/,'').to_sym].options && @object.reflections[column.name.to_s.gsub(/_id$/,'').to_sym].options[:class_name]
+          @object.reflections[column.name.to_s.gsub(/_id$/,'').to_sym].options[:class_name].constantize
+        else
+          return column.name.to_s.gsub(/_id$/,'').classify.constantize
+        end
+      else
+        # foreign key
+        @object.reflections.each do |key, reflection|
+          if reflection.options && reflection.options[:foreign_key] && reflection.options[:foreign_key] == column.name.to_s
+            if reflection.options && reflection.options[:class_name]
+              reflection.options[:class_name].constantize
+            else
+              return key.to_s.classify.constantize
+            end
+          end
+        end
+      end
+    end
+    
+    def display_for(record, method, *args, &block)
+      if method.to_s =~ /._id$/
+        associated_record = record.send(method.to_s.gsub(/_id$/, '').to_sym, *args, &block)
+        label_method = detect_label(associated_record)
+        associated_record.send(label_method.to_sym)
+      else
+        record.send(method.to_sym, *args, &block)
+      end
+    end
+    
+    def form_options_for(record)
+      options = {:method => method_for_record(record)}
+      if kitsune_admin[:multipart]
+        options.merge!({:html => {:multipart => true}})
+      end
+      options
+    end
+    
+    def method_for_record(record)
+      record.new_record? ? :post : :put
+    end
+    
+    def options_for(column)
+      
+      field = column.name
+      
+      if field_type(field) == :select or field_type(field) == :collection_select
+        field_options(field)
+      elsif column.name =~ /._id$/
+        id = :id
+        collection = find_association_class(column).all
+        name = detect_label(collection)
+        [collection.map { |element| [ element.send(name), element.send(id) ] }, {:include_blank => true}]
+      elsif field_type(field) == :sti && (options = field_options(field)) && options[:classes]
+        [options[:classes].map {|element| [element.to_s, element.to_s]}, {:include_blank => true}]
+      else
+        options = field_options(field) || {}
+        options[:size] = '80x10' if [:text_area, :wysiwyg].include?(form_type(column))
+        [options]
+      end
+    end
+    
+    def field_type(field)
+      return kitsune_admin[:fields][field.to_sym][:type] if field_defined(field)
+      return nil
+    end
+
+    private
+    def field_defined(field)
+      !!kitsune_admin[:fields][field.to_sym]
+    end
+    
+    def field_options(field)
+      options = kitsune_admin[:fields][field.to_sym][:options] if field_defined(field)
+      return (options.is_a?(Proc) ? options.call : options) if options
+      return nil
+    end
+  end
+end

data/lib/kitsune/layout.rb

@@ -0,0 +1,15 @@
+module Kitsune
+  class Layout
+    def initialize(layout_file)
+      data = File.read(layout_file)
+      @content_areas = data.scan(/yield\s+:(\w+)\s+/i).flatten.uniq
+    end
+    
+    def content_areas
+      @content_areas
+    end
+    
+    def method_missing(method, *arg, &block)
+    end
+  end
+end

data/lib/kitsune/mongo_mapper.rb

@@ -0,0 +1,49 @@
+require 'kitsune/builder'
+
+module Kitsune
+  module MongoMapper  
+    def setup_admin
+      self.class_eval do
+        class_inheritable_hash :kitsune_admin
+        self.kitsune_admin = {
+          :no_admin => false, 
+          :multipart => false, 
+          :display => {}, 
+          :edit => {}, 
+          :reflections => {},
+          :fields => {}, 
+          :tabs => {},
+          :is_sti => false,
+					:disabled => [],
+					:versioned => false,
+					:order_by => nil,
+					:media => nil # class to store images into
+        }
+      end
+    end
+  
+    def admin &block
+      setup_admin unless self.respond_to?(:kitsune_admin)
+      Kitsune::Builder.generate(self, &block) unless self.kitsune_admin[:no_admin]
+    end
+  
+    def no_admin
+      setup_admin
+      self.kitsune_admin[:no_admin] = true
+    end
+    TRANSPOSE = {String => :string}
+    def columns
+      self.keys.map do |key, value|
+        FauxColumn.new(key, TRANSPOSE[value.type], key == '_id')
+      end
+    end
+    
+    def reflections
+      {}
+    end
+    
+    def class_name
+      self.to_s
+    end
+  end
+end

data/lib/kitsune/page.rb

@@ -0,0 +1,70 @@
+module Kitsune
+  module Page
+    def self.included(model)
+      model.class_eval do
+        admin do
+          display :title, :layout, :parent_id, :url
+          edit :title, :url, :body, :layout, :parent_id
+          wysiwyg :body
+          select :layout, [Dir.glob(File.join(RAILS_ROOT, 'app', 'views', 'layouts', '*.html.*')).map{|f| File.basename(f).split('.').first}]
+          
+          on_new do |page|
+            remove_faux_methods
+          end
+          
+          on_edit do |page|
+            Kitsune::Layout.new(Dir.glob(File.join(RAILS_ROOT, 'app', 'views', 'layouts', "#{page.layout}.html.*")).first).content_areas.each do |area|
+              page.class.send(:define_method, area, Proc.new{ self.data ||= {}; self.data[:content_for] ||= {}; self.data[:content_for][area.to_sym]})
+              edit area.to_sym => :text
+              add_faux_method area
+            end
+          end
+          
+          before_save do |page|
+            Kitsune::Layout.new(Dir.glob(File.join(RAILS_ROOT, 'app', 'views', 'layouts', "#{page.layout}.html.*")).first).content_areas.each do |area|
+              page.class.send(:define_method, "#{area}=", Proc.new{|value| self.data ||= {}; self.data[:content_for] ||= {}; self.data[:content_for][area.to_sym] = value})
+              add_faux_method "#{area}="
+            end
+          end
+          
+        end
+        
+        before_save :update_url
+        belongs_to :page, :foreign_key => "parent_id"
+        belongs_to :parent, :class_name => 'Page'
+        validate :must_be_kitsune_route
+        validates_uniqueness_of :url
+        serialize :data
+        
+        
+        def after_save
+          ActionController::Routing::Routes.reload!
+        end
+        
+        def after_destroy
+          ActionController::Routing::Routes.reload!
+        end
+        
+        def title_for_url
+          CGI.escape(title.downcase.gsub(/\s+/, '-')).squeeze('-')
+        end
+        
+        def url_for_page
+          parent ? parent.url_for_page + '/' + title_for_url : '/' + title_for_url
+        end
+        
+        def update_url
+          write_attribute :url, (url.present? ? url : url_for_page)
+        end
+        
+        def must_be_kitsune_route
+          unless ActionController::Routing::Routes.recognize_path(url.present? ? url : url_for_page, :method => :get)[:controller] == 'kitsune'
+            errors.add_to_base("URL is already being used")
+          end
+        rescue
+        end
+        
+      end
+    end
+  end
+end