noodall-core 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,22 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+.bundle
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+
+gem 'mongo_mapper', '~> 0.8.4'
+gem 'bson_ext', '~> 1.0.9'
+gem 'ramdiv-mongo_mapper_acts_as_tree', '~> 0.1.1'
+gem 'canable', '~> 0.1.1'
+gem 'ruby-stemmer'
+gem 'i18n'
+
+group :development do
+  gem 'jeweler', '~> 1.4.0'
+  gem "rspec", "~> 2.0.0.beta.22"
+  gem "database_cleaner", "~> 0.5.2"
+  gem "factory_girl", "~> 1.3.2"
+  gem "faker", "~> 0.3.1"
+  gem "rake"
+end
+

data/Gemfile.lock

@@ -0,0 +1,62 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.0.0)
+    bson (1.0.9)
+    bson_ext (1.0.9)
+    canable (0.1.1)
+    database_cleaner (0.5.2)
+    diff-lcs (1.1.2)
+    factory_girl (1.3.2)
+    faker (0.3.1)
+    gemcutter (0.6.1)
+    git (1.2.5)
+    i18n (0.4.1)
+    jeweler (1.4.0)
+      gemcutter (>= 0.1.0)
+      git (>= 1.2.5)
+      rubyforge (>= 2.0.0)
+    jnunemaker-validatable (1.8.4)
+      activesupport (>= 2.3.4)
+    json_pure (1.4.6)
+    mongo (1.0.9)
+      bson (>= 1.0.5)
+    mongo_mapper (0.8.4)
+      activesupport (>= 2.3.4)
+      jnunemaker-validatable (~> 1.8.4)
+      plucky (~> 0.3.5)
+    plucky (0.3.5)
+      mongo (~> 1.0.8)
+    rake (0.8.7)
+    ramdiv-mongo_mapper_acts_as_tree (0.1.1)
+      mongo_mapper (>= 0.6.8)
+    rspec (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+      rspec-mocks (= 2.0.0.beta.22)
+    rspec-core (2.0.0.beta.22)
+    rspec-expectations (2.0.0.beta.22)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.0.beta.22)
+      rspec-core (= 2.0.0.beta.22)
+      rspec-expectations (= 2.0.0.beta.22)
+    ruby-stemmer (0.8.2)
+    rubyforge (2.0.4)
+      json_pure (>= 1.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bson_ext (~> 1.0.9)
+  canable (~> 0.1.1)
+  database_cleaner (~> 0.5.2)
+  factory_girl (~> 1.3.2)
+  faker (~> 0.3.1)
+  i18n
+  jeweler (~> 1.4.0)
+  mongo_mapper (~> 0.8.4)
+  rake
+  ramdiv-mongo_mapper_acts_as_tree (~> 0.1.1)
+  rspec (~> 2.0.0.beta.22)
+  ruby-stemmer

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Steve England
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= noodall (Node-All) core
+
+Noodal is a CMS using Mongo(mapper/id). It is nice.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Steve England. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,36 @@
+require "bundler"
+Bundler.setup(:default, :development)
+require "rspec/core/rake_task"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "noodall-core"
+    gem.summary = %Q{Core data objects for Noodall}
+    gem.description = %Q{Core data objects for Noodall}
+    gem.email = "steve@wearebeef.co.uk"
+    gem.homepage = "http://github.com/beef/noodall-core"
+    gem.authors = ["Steve England"]
+    gem.add_dependency('mongo_mapper', '0.8.4')
+    gem.add_dependency('ramdiv-mongo_mapper_acts_as_tree', '0.1.1')
+    gem.add_dependency('canable', '0.1.1')
+    gem.add_dependency('ruby-stemmer')
+    
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/noodall-core.rb

@@ -0,0 +1,24 @@
+require 'mongo_mapper'
+require 'mongo_mapper_acts_as_tree'
+require 'canable'
+require 'noodall/global_update_time'
+require 'noodall/multi_parameter_attributes'
+require 'noodall/search'
+require 'noodall/tagging'
+require 'noodall/permalink'
+require 'noodall/indexer'
+require 'noodall/component'
+require 'noodall/node'
+
+
+# Ruby 1.8 Compatibilty
+class Object
+  unless defined?(define_singleton_method)
+    puts "Redefining 'define_singleton_method' to work with Ruby1.8"
+    def define_singleton_method(sym, &block)
+      singleton_class.instance_eval do
+        define_method sym, block
+      end
+    end
+  end
+end

data/lib/noodall/component.rb

@@ -0,0 +1,45 @@
+module Noodall
+  class Component
+    include MongoMapper::EmbeddedDocument
+    
+    key :_type, String
+    key :style, String
+  
+    embedded_in :node
+  
+    module ClassMethods
+      def possible_slots
+        Node.possible_slots
+      end
+
+      def allowed_positions(*args)
+        @allowed_positions = args.reject{|a| !Node.possible_slots.include?(a) }.uniq
+      end
+  
+      def positions
+        @allowed_positions || []
+      end
+  
+      def positions_classes(position)
+        classes = []
+        ObjectSpace.each_object(Class) do |c|
+          next unless c.ancestors.include?(Component) and (c != Component) and c.positions.include?(position)
+          classes << c
+        end
+        classes
+      end
+  
+      def positions_names(position)
+        positions_classes(position).collect{|c| c.name.titleize }
+      end
+  
+      # Allow us to set the component to nil if we get a blank
+      def to_mongo(value)
+        return nil if value.blank?
+        super
+      end
+  
+    end
+    extend ClassMethods
+  end  
+end

data/lib/noodall/global_update_time.rb

@@ -0,0 +1,27 @@
+module Noodall
+  module GlobalUpdateTime
+    class Stamp
+      def self.read
+        Rails.cache.read('global_update_time') if defined?(Rails)
+      end
+  
+      def self.update!
+        Rails.cache.write('global_update_time', Time.zone.now.utc) if defined?(Rails)
+      end
+    end
+  
+    def self.configure(model)
+      model.class_eval do
+        after_save :global_updated!
+        after_destroy :global_updated!
+      end
+    end
+  
+    module InstanceMethods
+      # Cache the updated time
+      def global_updated!
+        GlobalUpdateTime::Stamp.update!
+      end
+    end
+  end
+end

data/lib/noodall/indexer.rb

@@ -0,0 +1,11 @@
+module Noodall
+  module Indexer
+    module ClassMethods
+      def ensure_index(spec, options={})
+        #collection.create_index(spec, options)
+        # TODO: something clever here as runtime indexing is bad
+      end
+    end
+  end
+end
+

data/lib/noodall/multi_parameter_attributes.rb

@@ -0,0 +1,83 @@
+module Noodall
+  module MultiParameterAttributes
+    module InstanceMethods
+      def attributes=(attrs)
+        multi_parameter_attributes = []
+        attrs.each do |name, value|
+          return if attrs.blank?
+          if name.to_s.include?("(")
+            multi_parameter_attributes << [ name, value ]
+          else
+            writer_method = "#{name}="
+            if respond_to?(writer_method)
+              self.send(writer_method, value)
+            else
+              self[name.to_s] = value
+            end
+          end
+        end
+  
+        assign_multiparameter_attributes(multi_parameter_attributes)
+      end
+  
+      def assign_multiparameter_attributes(pairs)
+        execute_callstack_for_multiparameter_attributes(
+          extract_callstack_for_multiparameter_attributes(pairs)
+        )
+      end
+  
+      def execute_callstack_for_multiparameter_attributes(callstack)
+        callstack.each do |name, values_with_empty_parameters|
+          # in order to allow a date to be set without a year, we must keep the empty values.
+          # Otherwise, we wouldn't be able to distinguish it from a date with an empty day.
+          values = values_with_empty_parameters.reject(&:blank?)
+  
+          if values.any?
+            key = self.class.keys[name]
+            raise ArgumentError, "Unknown key #{name}" if key.nil?
+            klass = key.type
+  
+            value = if Time == klass
+              Time.zone.local(*values.map(&:to_i))
+            elsif Date == klass
+              begin
+                values = values_with_empty_parameters.collect do |v| v.nil? ? 1 : v end
+                Date.new(*values)
+              rescue ArgumentError => ex # if Date.new raises an exception on an invalid date
+                Time.zone.local(*values).to_date # we instantiate Time object and convert it back to a date thus using Time's logic in handling invalid dates
+              end
+            else
+              klass.new(*values)
+            end
+          else
+            value = nil
+          end
+          writer_method = "#{name}="
+          if respond_to?(writer_method)
+            self.send(writer_method, value)
+          else
+            self[name.to_s] = value
+          end
+        end
+      end
+  
+      def extract_callstack_for_multiparameter_attributes(pairs)
+        attributes = { }
+  
+        for pair in pairs
+          multiparameter_name, value = pair
+          attribute_name = multiparameter_name.split("(").first
+          attributes[attribute_name] = [] unless attributes.include?(attribute_name)
+  
+          attributes[attribute_name] << [ find_parameter_position(multiparameter_name), value ]
+        end
+  
+        attributes.each { |name, values| attributes[name] = values.sort_by{ |v| v.first }.collect { |v| v.last } }
+      end
+  
+      def find_parameter_position(multiparameter_name)
+        multiparameter_name.scan(/\(([0-9]*).*\)/).first.first
+      end
+    end
+  end
+end

data/lib/noodall/node.rb

@@ -0,0 +1,350 @@
+module Noodall
+  class Node
+    include MongoMapper::Document
+    include MongoMapper::Acts::Tree
+    include Canable::Ables
+  
+    plugin MultiParameterAttributes
+    plugin Indexer
+    plugin Search
+    plugin Tagging
+    plugin GlobalUpdateTime
+  
+    key :title, String, :required => true
+    key :link_name, String
+    key :description, String
+    key :body, String
+    key :position, Integer, :default => nil
+    key :_type, String
+    key :published_at, Time
+    key :published_to, Time
+    key :updatable_groups, Array
+    key :destroyable_groups, Array
+    key :publishable_groups, Array
+    key :permalink, Permalink, :required => true, :index => true
+    
+    timestamps!
+    userstamps!
+  
+    alias_method :keywords, :tag_list
+    alias_method :keywords=, :tag_list=
+  
+    attr_accessor :publish, :hide #for publishing
+  
+    acts_as_tree :order => "position"
+  
+    searchable_keys :title, :description, :keywords, :body
+  
+    validates_true_for :template, :message => "cannot be changed as sub content is not allowed in this template", :logic => lambda { children.reject{|c| self._type.constantize.template_classes.include?(c.class)}.empty? }
+  
+    def published_children
+      self.children.select{|c| c.published? }
+    end
+  
+    # Allow parent to be set to none using a string. Allows us to set the parent to nil easily via forms
+    def parent=(var)
+      self[parent_id_field] = nil
+      var == "none" ? super(nil) : super
+    end
+  
+    def template
+      self.class.name.titleize
+    end
+  
+    def template=(template_name)
+      self._type = template_name.gsub(' ','') unless template_name.blank?
+    end
+  
+    def published?
+      !published_at.nil? and published_at <= current_time and (published_to.nil? or published_to >= current_time)
+    end
+  
+    def pending?
+      published_at.nil? or published_at >= current_time
+    end
+  
+    def expired?
+      !published_to.nil? and published_to <= current_time
+    end
+  
+    def first?
+      position == 0
+    end
+  
+    def last?
+      position == self.class.count(:_id => {"$ne" => self._id}, parent_id_field => self[parent_id_field])
+    end
+    def move_lower
+      sibling = self.class.first(:position => {"$gt" => self.position}, parent_id_field => self[parent_id_field], :order => 'position ASC')
+  
+      tmp = sibling.position
+      sibling.position = self.position
+      self.position = tmp
+  
+      self.class.collection.update({:_id => self._id}, self.to_mongo)
+      self.class.collection.update({:_id => sibling._id}, sibling.to_mongo)
+      
+      global_updated!
+    end
+    def move_higher
+      sibling = self.class.first(:position => {"$lt" => self.position}, parent_id_field => self[parent_id_field], :order => 'position DESC')
+  
+      tmp = sibling.position
+      sibling.position = self.position
+      self.position = tmp
+  
+      self.class.collection.update({:_id => self._id}, self.to_mongo)
+      self.class.collection.update({:_id => sibling._id}, sibling.to_mongo)
+      
+      global_updated!
+    end
+  
+    def run_callbacks(kind, options = {}, &block)
+      self.class.send("#{kind}_callback_chain").run(self, options, &block)
+      self.embedded_associations.each do |association|
+        self.send(association.name).each do |document|
+          document.run_callbacks(kind, options, &block)
+        end
+      end
+      self.embedded_keys.each do |key|
+        self.send(key.name).run_callbacks(kind, options, &block) unless self.send(key.name).nil?
+      end
+    end
+  
+    def slots
+      slots = []
+      for slot_type in self.class.possible_slots.map(&:to_s)
+        self.class.main_slots_count.to_i.times do |i|
+          slots << self.send("#{slot_type}_slot_#{i}")
+        end
+      end
+      slots.compact
+    end
+  
+    ## CANS
+    def all_groups
+      updatable_groups | destroyable_groups | publishable_groups
+    end
+  
+    %w( updatable destroyable publishable ).each do |permission|
+      define_method("#{permission}_by?") do |user|
+        user.admin? or send("#{permission}_groups").empty? or user.groups.any?{ |g| send("#{permission}_groups").include?(g) }
+      end
+  
+      define_method("#{permission}_groups_list") do
+        send("#{permission}_groups").join(', ')
+      end
+  
+      define_method("#{permission}_groups_list=") do |groups_string|
+        send("#{permission}_groups=", groups_string.split(',').map{|g| g.blank? ? nil : g.strip }.compact.uniq)
+      end
+    end
+  
+    def creatable_by?(user)
+      parent.nil? or parent.updatable_by?(user)
+    end
+  
+    # tree method that allow oprions to be passed
+    def siblings(options = {})
+      self.class.all(options.merge(:_id => {"$ne" => self._id}, parent_id_field => self[parent_id_field], :order => tree_order))
+    end
+  
+    def self_and_siblings(options = {})
+      self.class.all(options.merge(parent_id_field => self[parent_id_field], :order => tree_order))
+    end
+  
+    def children(options = {})
+      self.class.all(options.merge(parent_id_field => self._id, :order => tree_order))
+    end
+  
+  private
+
+    def current_time
+      self.class.current_time
+    end
+  
+    before_validation :set_permalink
+    def set_permalink
+      self.permalink = Permalink.new(*(ancestors << self).map{ |a| a.title.parameterize }) if permalink.blank? and not title.blank?
+    end
+  
+    before_save :set_position
+    def set_position
+      write_attribute :position, siblings.size if position.nil?
+    end
+  
+    before_save :clean_slots
+  
+    # This method removes any uneeded modules from the object
+    # modules that would otherwise remain hidden
+    # if the objects class was changed
+    def clean_slots
+  
+      # TODO: spec this
+  
+      slot_types = self.class.possible_slots.map(&:to_s)
+      # collect all of the slot attributes
+      #    (so we don't have to loop through the whole object each time)
+      slots = self.attributes.select{|k,v| k =~ /^(#{slot_types.join('|')})_slot_\d+$/ }
+  
+      # for each type of slot
+      for slot_type in slot_types
+        # get the number of slots of this type in the (possibly new) class
+        slot_count = self._type.constantize.send("#{slot_type}_slots_count").to_i
+  
+        # loop through all of the slot attributes for this type
+        slots.select{|k,v| k =~ /^#{slot_type}_slot_\d+$/ }.each do |key, slot|
+  
+          index = key[/#{slot_type}_slot_(\d+)$/, 1].to_i
+  
+          logger.debug "Deleting #{key} #{self.send(key).inspect}" if index >= slot_count
+          # set the slot to nil
+          write_attribute(key.to_sym, nil) if index >= slot_count
+        end
+      end
+    end
+  
+    before_save :set_path
+    def set_path
+      write_attribute :path, parent.path + [parent._id] unless parent.nil?
+    end
+  
+    before_create :inherit_permisions
+    def inherit_permisions
+      unless parent.nil?
+        self.updatable_groups  = parent.updatable_groups
+        self.destroyable_groups = parent.destroyable_groups
+        self.publishable_groups = parent.publishable_groups
+      end
+    end
+  
+    after_save :order_siblings
+    def order_siblings
+      if position_changed?
+        self.class.collection.update({:_id => {"$ne" => self._id}, :position => {"$gte" => self.position}, parent_id_field => self[parent_id_field]}, { "$inc" => { :position => 1 }}, { :multi => true })
+        self_and_siblings.each_with_index do |sibling, index|
+          unless sibling.position == index
+            sibling.position = index
+            self.class.collection.save(sibling.to_mongo, :safe => true)
+          end
+        end
+      end
+    end
+  
+    before_save :set_published
+    def set_published
+      if publish
+        write_attribute :published_at, current_time if published_at.nil?
+        write_attribute :published_to, 10.years.from_now if published_to.nil?
+      end
+      if hide
+        write_attribute :published_at, nil
+        write_attribute :published_to, 10.years.from_now
+      end
+    end
+  
+    module ClassMethods
+      @@slots = []
+  
+      # Set the names of the slots that will be avaiable to fill with components
+      # For each name new methods will be created;
+      #   
+      #   <name>_slots(count)
+      #   This allow you to set the number of slots available in a template
+      #   <name>_slots_count(count)
+      #   Reads back the count you set 
+      def slots(*args)
+        @@slots = args.map(&:to_sym).uniq
+
+        @@slots.each do |slot|
+          puts "Noodall::Node Defined slot: #{slot}"
+          define_singleton_method("#{slot}_slots") do |count|
+            instance_variable_set("@#{slot}_slots_count", count)
+            count.times do |i|
+              key "#{slot}_slot_#{i}", Noodall::Component
+              validates_each "#{slot}_slot_#{i}", :logic => lambda { errors.add("#{slot}_slot_#{i}", "is not allowed in a #{slot} slot") unless send("#{slot}_slot_#{i}").nil? or Noodall::Component.positions_classes(slot).include?(send("#{slot}_slot_#{i}").class) } # TODO: Nicer message please
+              validates_associated "#{slot}_slot_#{i}"
+            end
+          end
+          define_singleton_method("#{slot}_slots_count") { instance_variable_get("@#{slot}_slots_count") }
+        end
+      end
+
+      def slots_count
+        @@slots.inject(0) { |total, slot| total + send("#{slot}_slots_count").to_i }
+      end
+
+      def possible_slots
+        @@slots
+      end
+
+      def roots(options = {})
+        self.all(options.merge(parent_id_field => nil, :order => tree_order))
+      end
+  
+      def find_by_permalink(permalink)
+        node = find_one(:permalink => permalink.to_s, :published_at => { :$lte => current_time })
+        raise MongoMapper::DocumentNotFound if node.nil? or node.expired?
+        node
+      end
+  
+      def template_classes
+        return @template_classes if @template_classes
+        classes = []
+        ObjectSpace.each_object(Class) do |c|
+          next unless c.ancestors.include?(Noodall::Node) and (c != Noodall::Node) and c.root_template?
+          classes << c
+        end
+        @template_classes = classes
+      end
+  
+      def template_names
+        template_classes.collect{|c| c.name.titleize}.sort
+      end
+ 
+      def all_template_classes
+        templates = []
+        template_classes.each do |template|
+          templates << template
+          templates = templates + template.template_classes
+        end
+        templates.uniq.collect{ |c| c.name.titleize }.sort
+      end
+  
+      def sub_templates(*arr)
+        @template_classes = arr
+      end
+  
+      def root_template!
+        @root_template = true
+      end
+  
+      def root_template?
+        @root_template
+      end
+
+      def single_collection_inherited?
+        false
+      end
+  
+      # Returns a list of classes that can have this model as a child
+      def parent_classes
+        classes = []
+        ObjectSpace.each_object(Class) do |c|
+          next unless c.ancestors.include?(Noodall::Node) and (c != Noodall::Node) and c.template_classes.include?(self)
+          classes << c
+        end
+        classes
+      end
+    
+      # If rails style time zones are unavaiable fallback to standard now 
+      def current_time
+        Time.zone ? Time.zone.now : Time.now 
+      end
+    end
+    extend ClassMethods
+  
+  
+  end
+
+end