schofield 0.2.2 → 0.3.0

data/lib/generators/schofield/level.rb

@@ -1,27 +1,27 @@
 module Schofield
-  
+
   module Generators
 
     class Level
-      
+
       COLUMNS_TO_IGNORE = %w( ^created_at$ ^updated_at$ _content_type$ _file_size$ _updated_at$ _type$ ^type$ ^crypted_password$ ^password_salt$ ^persistence_token$ ^perishable_token$ ^login_count$ ^failed_login_count$ ^last_request_at$ ^current_login_at$ ^last_login_at$ ^current_login_ip$ ^last_login_ip$ )
-      
+
       class << self; attr_reader :columns_to_ignore end
-      
+
       def self.tables_to_ignore= tables
         @columns_to_ignore = ( COLUMNS_TO_IGNORE + tables.map{ |m| "^#{m.singularize}_id$" } )
       end
-        
-      
-      attr_reader :name, :parent_associations, :attributes, :superclass
+
+
+      attr_reader :model, :name, :parent_associations, :attributes, :superclass
       attr_accessor :child_associations, :subclasses
 
       delegate :validations,
                :validations?,
-               :attr_protecteds,
-               :attr_protecteds?,
-               :acts_as_markdowns,
-               :acts_as_markdowns?,
+               :attr_accessors,
+               :attr_accessors?,
+               :attr_accessibles,
+               :attr_accessibles?,
                :attachments?,
                :to_s_string,
                :attached_files,
@@ -41,135 +41,135 @@ module Schofield
         add_parent_associations
         add_attributes
       end
-      
-      
+
+
       # Inheritence
-      
+
       def subclass?
         @superclass.present?
       end
-      
+
       def superclass?
         @subclasses.any?
       end
-      
-      
+
+
       # Join table
-      
+
       def join?
         @join ||= @model.columns.select { |c| c.name.match(/_id$/) }.length == 2 && @model.columns.select { |c| !%w( id created_at updated_at position ).include?(c.name) }.length == 2
       end
-      
+
       def other_parent_name parent_name
         @parent_associations.find{ |a| a.parent_name != parent_name }.parent_name
       end
-        
-        
+
+
       # Polymorphism
-      
+
       def polymorphic?
         @polymorphic ||= polymorphic_name.present?
       end
-      
+
       def polymorphic_name
         match_data = nil
         @polymorphic_name ||= @model.columns.find { |c| match_data = c.name.match(/^(.+)_type$/) } ? match_data[1] : nil
       end
-      
-      
+
+
       # Nesting
-      
+
       def nested?
-        @parent_associations.find(&:nest?).present?
+        @parent_associations.any?(&:nest?)
       end
-      
+
       def nests?
-        @child_associations.find(&:nest?).present?
+        @child_associations.any?(&:nest?)
       end
-      
+
       def nested_associations
         if superclass? then []
         else
           associations = @child_associations + ( subclass? ? @superclass.child_associations : [] )
         end
       end
-      
+
       def nested_levels
         nested_associations.select(&:nest?).map(&:child)
       end
-      
-      
+
+
       # Associations and cardinality
-      
+
       def belongs_to?
         @parent_associations.any?
       end
-            
+
       def belongs_to_one_names
         @parent_associations.select(&:one_to_one?).map(&:parent_name)
       end
-            
+
       def belongs_to_one?
-        @parent_associations.find(&:one_to_one?).present?
+        @parent_associations.any?(&:one_to_one?)
       end
-      
+
       def has_ones?
-        @child_associations.find(&:one_to_one?).present?
+        @child_associations.any?(&:one_to_one?)
       end
-      
+
       def has_manies?
-        @child_associations.find(&:one_to_many?).present?
+        @child_associations.any?(&:one_to_many?)
       end
-      
+
       def has_ones
         @child_associations.select(&:one_to_one?).map(&:child)
       end
-      
+
       def has_manies
         @child_associations.select(&:one_to_many?).map(&:child)
       end
-      
-      
+
+
       # Combos
-      
+
       def routes?
         !nested? && !superclass? && !belongs_to_one? && !join?
       end
-      
+
       def controllers?
         !superclass? && name != 'user' && !belongs_to_one?
       end
-      
+
       def views?
         controllers? && !join?
       end
-      
+
       def models?
         name != 'user'
       end
-      
+
       def tables?
         !belongs_to_one? && !superclass?
       end
-      
-      
-      
+
+
+
       # Sortable
-      
+
       def sortable?
         @sortable
       end
-      
-      
+
+
       # Form
-      
+
       def multipart?
-        attachments? || has_ones.find(&:attachments?).present?
+        attachments? || has_ones.any?(&:attachments?)
       end
-      
-      
+
+
       # Association ancestry
-      
+
       def ancestry
         level = self
         nested_ins = []
@@ -189,99 +189,99 @@ module Schofield
         nested_ins.reverse
       end
 
-      
+
       # Form fields
-      
+
       def attribute_of_nesting_parent? attribute
         attribute.model_name && parent_associations.select(&:nest?).map(&:parent_name).include?(attribute.model_name)
       end
-      
+
       def polymorphic_attribute? attribute
         polymorphic_name && attribute.model_name == polymorphic_name
       end
-      
+
       def form_field? attribute
-        attribute.name != 'position' && !polymorphic_attribute?(attribute) && !attribute_of_nesting_parent?(attribute)
+        !%w( position slug ).include?(attribute.name) && attribute.name !~ /_fingerprint$/ && !polymorphic_attribute?(attribute) && !attribute_of_nesting_parent?(attribute)
       end
-      
-      
-      
+
+
+
       private
-      
+
       def add_attributes
         @attributes = Attributes.new
         @model.columns.each do |column|
           add_attribute(column) unless ignore?(column) || (polymorphic? && column.name =~ /^#{polymorphic_name}_id$/)
         end
       end
-  
+
       def add_attribute column
         attribute = @attributes.new_attribute(column, belongs_to_one_names.include?(column.name.gsub(/_id$/, '')))
         set_sortable if attribute.name == 'position'
       end
-      
+
       def set_sortable
         unless superclass?
           @sortable = true
           Levels.sortable = @name
         end
       end
-      
+
       # Nesting refers to nested routes, embedding refers to nested_attributes_for
       # Assuming that a polymorphic model has no parents other than it's polymorphically associated parents
       # If model has a one-to-one relationship with a parent, no nesting will occur as child will be embedded in parent
       # Only allowing child to be nested under one parent or if polymorphic, the polymorphically associated parents
       def add_parent_associations
-        
+
         if polymorphic?
-          
+
           answer = Responses.get("Which models are #{polymorphic_name}?")
           answer.split(/[^\w]+/).map(&:underscore).each do |parent_name|
             @parent_associations << Association.new(self, parent_name, one_to_one?(polymorphic_name), polymorphic_name)
           end
-        
+
         else
-        
+
           any_one_to_ones = false
           @model.columns.each do |column|
-            if (match_data = column.name.match(/^(.+)_id$/)).present?
+            if (match_data = column.name.match(/^(.+)_id$/)).present? && Levels.exists?(match_data[1])
               parent_name = match_data[1]
               is_one_to_one = one_to_one?(parent_name)
               any_one_to_ones = true if is_one_to_one
               @parent_associations << Association.new(self, parent_name, is_one_to_one)
             end
           end
-          
+
           if @parent_associations.any? && !any_one_to_ones
             @parent_associations.length == 1 ? ask_if_nested : ask_where_to_nest
           end
         end
       end
-      
+
       def one_to_one? parent_name
         @one_to_one ||= %w( y yes ).include?(Responses.get("#{parent_name.gsub('_', ' ')} HAS ONE #{@human_name}? [N]").downcase)
       end
-      
+
       def ask_if_nested
         question = "Do you wish to nest #{@human_name} in #{@parent_associations.first.parent_name}? [yes]"
         @parent_associations.first.nest = true unless %w( n no ).include?(Responses.get(question).downcase.strip)
-      end    
-  
+      end
+
       def ask_where_to_nest
         question = "Where do you wish to nest #{@human_name}? nowhere(n), "
         question += @parent_associations.enum_with_index.map{ |n,i| "#{n.parent_name.gsub('_', ' ')}(#{i})" }.join(', ') + ' [n]'
         answer = Responses.get(question)
         @parent_associations[answer.to_i].nest = true unless answer == 'n' || answer.blank?
       end
-      
+
       def ignore? column
         self.class.columns_to_ignore.each do |string|
           return true if column.name.match(/#{string}/)
         end
         column.primary
       end
-  
+
     end
-    
+
   end
 end

data/lib/generators/schofield/levels.rb

@@ -1,18 +1,19 @@
 module Schofield
-  
+
   module Generators
 
     class Levels
-      
+
       class << self; attr_reader :all, :hierarchy, :sortables end
-      
+
       @all       = []
       @names     = {}
       @sortables = {}
-      
-      
-      
+
+
+
       def self.models= models
+        @model_names = models.map{ |m| m.name.underscore }
         models.each do |model|
           if polymorphic_model?(model)
             superclass = add_level(model)
@@ -25,28 +26,32 @@ module Schofield
           end
         end
       end
-      
+
       def self.sortables
         @sortables.keys
       end
-  
+
       def self.sortable=sortable
         @sortables[sortable] = true
       end
-      
+
       def self.find name
         @all[@names[name]]
       end
 
-      
-      
+      def self.exists? name
+        @model_names.include?(name.to_s)
+      end
+
+
+
       private
-      
-      
+
+
       def self.polymorphic_model? model
         model.columns.find { |c| c.name == 'type' }.present?
       end
-      
+
       def self.subclasses model
         begin
           answer = Responses.get "Which models extend #{model.name}?"
@@ -61,14 +66,14 @@ module Schofield
         end
         subclasses
       end
-        
+
       def self.add_level model, superclass=nil
         level = Level.new(model, superclass)
         @all << level
         @names[model.name.underscore] = @all.length - 1
         level
       end
-      
+
     end
   end
 end

data/lib/generators/schofield/navigation.rb

@@ -0,0 +1,17 @@
+module Schofield
+
+  module Generators
+
+    class Navigation
+
+      def self.generate
+        Levels.all.select(&:routes?).inject("\n    %ul\n      %li.toplevel") do |memo, level|
+          memo += "\n\n      - if permitted_to?(:read, :#{level.name.pluralize})"
+          memo += "\n        %li{ :class => nav_classes('#{level.model.name}') }= link_to '#{level.model.name.titleize.pluralize}', admin_#{level.name.pluralize}_path"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/generators/schofield/responses.rb

@@ -1,14 +1,14 @@
 module Schofield
-  
+
   module Generators
-    
+
     class Responses
-      
+
       class << self; attr_accessor :generator, :re_ask end
-      
+
       @file = File.join(Rails.root, 'tmp', 'answers.txt')
-      
-      
+
+
       def self.get question
         @question = question
         if re_ask || (answer = past_answer).nil?
@@ -16,31 +16,31 @@ module Schofield
         end
         answer || ''
       end
-      
+
       def self.ask
         re_ask = true
         answer = generator.ask(@question)
         @answers ||= {}
         @answers[@question] = answer || ''
       end
-      
+
       def self.past_answer
         self.past_answers[@question]
       end
-          
+
       def self.past_answers
         @answers ||= File.exists?(@file) ? File.open(@file, 'rb') { |f| Marshal.load(f) } : {}
       end
-      
+
       def self.save
         File.open(@file, 'wb') { |io| Marshal.dump(@answers, io) }
       end
-      
+
       def self.say string
         generator.say(string)
       end
-      
+
     end
-    
+
   end
 end