sethyates-content_manager 0.4.0 → 1.0.0

data/lib/content/item_class_methods.rb

@@ -0,0 +1,71 @@
+module Content
+  module ItemClassMethods
+    def establish_connection(options = {})
+      conn_options = ::YAML::load_file('config/content.yml')[::RAILS_ENV]
+      conn_options.merge!(options) unless options.nil?
+      conn_type = conn_options[:type] || conn_options["type"] || :cabinet
+      $adapter = "content/adapters/#{conn_type}_adapter".camelize.constantize.new(conn_options)
+    end
+
+    def connection()
+      $adapter ||= establish_connection
+    end
+
+    def self_and_descendants_from_active_record#nodoc:
+      klass = self
+      classes = [klass]
+      while klass != klass.base_class  
+        classes << klass = klass.superclass
+      end
+      classes
+    rescue
+      [self]
+    end
+
+    def human_name(options = {})
+      defaults = self_and_descendants_from_active_record.map do |klass|
+        :"#{klass.name.underscore}"
+      end 
+      defaults << name
+      defaults.shift.to_s.humanize
+    end
+
+    def human_attribute_name(attr_name)
+      attr_name.to_s.humanize
+    end
+
+    def create(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| create(attr, &block) }
+      else
+        object = new(attributes)
+        yield(object) if block_given?
+        object.save
+        object
+      end
+    end
+
+    def update(id, attributes)
+      if id.is_a?(Array)
+        idx = -1
+        id.collect { |one_id| idx += 1; update(one_id, attributes[idx]) }
+      else
+        object = find(id)
+        object.update_attributes(attributes)
+        object
+      end
+    end
+
+    def destroy(id)
+      if id.is_a?(Array)
+        id.map { |one_id| destroy(one_id) }
+      else
+        find(id).destroy
+      end
+    end
+
+    def delete(id)
+      destroy id
+    end
+  end
+end

data/lib/content/item_dirty_methods.rb

@@ -0,0 +1,171 @@
+module Content
+  # Track unsaved attribute changes.
+  #
+  # A newly instantiated object is unchanged:
+  #   person = Person.find_by_name('uncle bob')
+  #   person.changed?       # => false
+  #
+  # Change the name:
+  #   person.name = 'Bob'
+  #   person.changed?       # => true
+  #   person.name_changed?  # => true
+  #   person.name_was       # => 'uncle bob'
+  #   person.name_change    # => ['uncle bob', 'Bob']
+  #   person.name = 'Bill'
+  #   person.name_change    # => ['uncle bob', 'Bill']
+  #
+  # Save the changes:
+  #   person.save
+  #   person.changed?       # => false
+  #   person.name_changed?  # => false
+  #
+  # Assigning the same value leaves the attribute unchanged:
+  #   person.name = 'Bill'
+  #   person.name_changed?  # => false
+  #   person.name_change    # => nil
+  #
+  # Which attributes have changed?
+  #   person.name = 'bob'
+  #   person.changed        # => ['name']
+  #   person.changes        # => { 'name' => ['Bill', 'bob'] }
+  #
+  # Before modifying an attribute in-place:
+  #   person.name_will_change!
+  #   person.name << 'by'
+  #   person.name_change    # => ['uncle bob', 'uncle bobby']
+  module ItemDirtyMethods
+    DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
+
+    def self.included(base)
+#      base.attribute_method_suffix *DIRTY_SUFFIXES
+      base.alias_method_chain :write_attribute, :dirty
+      base.alias_method_chain :save,            :dirty
+      base.alias_method_chain :save!,           :dirty
+      base.alias_method_chain :update,          :dirty
+#      base.alias_method_chain :reload,          :dirty
+
+      base.send(:extend, ClassMethods)
+    end
+
+    # Do any attributes have unsaved changes?
+    #   person.changed? # => false
+    #   person.name = 'bob'
+    #   person.changed? # => true
+    def changed?
+      !changed_attributes.empty?
+    end
+
+    # List of attributes with unsaved changes.
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ['name']
+    def changed
+      changed_attributes.keys
+    end
+
+    # Map of changed attrs => [original value, new value].
+    #   person.changes # => {}
+    #   person.name = 'bob'
+    #   person.changes # => { 'name' => ['bill', 'bob'] }
+    def changes
+      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
+    end
+
+    # Attempts to +save+ the record and clears changed attributes if successful.
+    def save_with_dirty(*args) #:nodoc:
+      if status = save_without_dirty(*args)
+        changed_attributes.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+    def save_with_dirty!(*args) #:nodoc:
+      status = save_without_dirty!(*args)
+      changed_attributes.clear
+      status
+    end
+
+    # <tt>reload</tt> the record and clears changed attributes.
+    def reload_with_dirty(*args) #:nodoc:
+      record = reload_without_dirty(*args)
+      changed_attributes.clear
+      record
+    end
+
+    private
+      # Map of change <tt>attr => original value</tt>.
+      def changed_attributes
+        @changed_attributes ||= {}
+      end
+
+      # Handle <tt>*_changed?</tt> for +method_missing+.
+      def attribute_changed?(attr)
+        changed_attributes.include?(attr)
+      end
+
+      # Handle <tt>*_change</tt> for +method_missing+.
+      def attribute_change(attr)
+        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+      end
+
+      # Handle <tt>*_was</tt> for +method_missing+.
+      def attribute_was(attr)
+        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+      end
+
+      # Handle <tt>*_will_change!</tt> for +method_missing+.
+      def attribute_will_change!(attr)
+        changed_attributes[attr] = clone_attribute_value(:read_attribute, attr)
+      end
+    
+      def clone_attribute_value(method, attr)
+        val = __send__(method, attr)
+        val.dup unless val.nil?
+      end
+
+      # Wrap write_attribute to remember original attribute value.
+      def write_attribute_with_dirty(attr, value)
+        # The attribute already has an unsaved change.
+        if changed_attributes.include?(attr)
+          old = changed_attributes[attr]
+          changed_attributes.delete(attr) unless field_changed?(attr, old, value)
+        else
+          old = clone_attribute_value(:read_attribute, attr)
+          changed_attributes[attr] = old if field_changed?(attr, old, value)
+        end
+
+        # Carry on.
+        write_attribute_without_dirty(attr, value)
+      end
+
+      def update_with_dirty
+        if partial_updates?
+          # Serialized attributes should always be written in case they've been
+          # changed in place.
+          update_without_dirty(changed | self.class.serialized_attributes.keys)
+        else
+          update_without_dirty
+        end
+      end
+
+      def field_changed?(attr, old, value)
+        old != value
+      end
+
+    module ClassMethods
+      def self.extended(base)
+        base.metaclass.alias_method_chain(:alias_attribute, :dirty)
+      end
+
+      def alias_attribute_with_dirty(new_name, old_name)
+        alias_attribute_without_dirty(new_name, old_name)
+        DIRTY_SUFFIXES.each do |suffix|
+          module_eval <<-STR, __FILE__, __LINE__+1
+            def #{new_name}#{suffix}; self.#{old_name}#{suffix}; end  # def subject_changed?; self.title_changed?; end
+          STR
+        end
+      end
+    end
+  end
+end

data/lib/content/item_finder_class_methods.rb

@@ -0,0 +1,203 @@
+module Content
+  module ItemFinderClassMethods
+    # Find operates with four different retrieval approaches:
+    #
+    # * Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    #   If no record can be found for all of the listed ids, then RecordNotFound will be raised.
+    # * Find first - This will return the first record matched by the options used. These options can either be specific
+    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+    #   <tt>Model.find(:first, *args)</tt> or its shortcut <tt>Model.first(*args)</tt>.
+    # * Find last - This will return the last record matched by the options used. These options can either be specific
+    #   conditions or merely an order. If no record can be matched, +nil+ is returned. Use
+    #   <tt>Model.find(:last, *args)</tt> or its shortcut <tt>Model.last(*args)</tt>.
+    # * Find all - This will return all the records matched by the options used.
+    #   If no records are found, an empty array is returned. Use
+    #   <tt>Model.find(:all, *args)</tt> or its shortcut <tt>Model.all(*args)</tt>.
+    #
+    # All approaches accept an options hash as their last parameter.
+    #
+    # ==== Parameters
+    #
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
+    # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
+    # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
+    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5, it would skip rows 0 through 4.
+    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, for example, want to do a join but not
+    #   include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
+    #
+    # ==== Examples
+    #
+    #   # find by id
+    #   Person.find(1)       # returns the object for ID = 1
+    #   Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6)
+    #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
+    #   Person.find([1])     # returns an array for the object with ID = 1
+    #   Person.find(1, :conditions => "administrator = 1", :order => "created_on DESC")
+    #
+    # Note that returned records may not be in the same order as the ids you
+    # provide since database rows are unordered. Give an explicit <tt>:order</tt>
+    # to ensure the results are sorted.
+    #
+    # ==== Examples
+    #
+    #   # find first
+    #   Person.find(:first) # returns the first object fetched by SELECT * FROM people
+    #   Person.find(:first, :conditions => [ "user_name = ?", user_name])
+    #   Person.find(:first, :conditions => [ "user_name = :u", { :u => user_name }])
+    #   Person.find(:first, :order => "created_on DESC", :offset => 5)
+    #
+    #   # find last
+    #   Person.find(:last) # returns the last object fetched by SELECT * FROM people
+    #   Person.find(:last, :conditions => [ "user_name = ?", user_name])
+    #   Person.find(:last, :order => "created_on DESC", :offset => 5)
+    #
+    #   # find all
+    #   Person.find(:all) # returns an array of objects for all the rows fetched by SELECT * FROM people
+    #   Person.find(:all, :conditions => [ "category IN (?)", categories], :limit => 50)
+    #   Person.find(:all, :conditions => { :friends => ["Bob", "Steve", "Fred"] }
+    #   Person.find(:all, :offset => 10, :limit => 10)
+    #   Person.find(:all, :include => [ :account, :friends ])
+    #   Person.find(:all, :group => "category")
+    #
+    def find(*args)
+      options = {}
+      which = args.shift
+      if which.is_a? Symbol
+        given_options = args.shift
+        options.merge!(given_options) unless given_options.nil?
+      else
+        id = which
+        which = :first
+        given_options = args.shift
+        options.merge!(given_options) unless given_options.nil?
+      end
+
+      options[:limit] = 1 if which == :first
+
+      if id.nil?
+        wrap_result which, connection.run_query(self, options)
+      elsif id.is_a? Array
+        id.collect {|one_id| find_by_id one_id}.compact
+      elsif options.keys.length == 0
+        find_by_id id
+      else
+        if options.has_key? :conditions
+          options[:conditions].merge!(:__id => id)
+        else
+          options[:conditions] = {:__id => id}
+        end
+        wrap_result which, connection.run_query(self, options)
+      end
+    end
+
+    def count(options)
+      connection.count(self, options)
+    end
+    
+    def paginate(*args)
+      options = args.first.dup
+      options[:conditions] = (options[:conditions] || {}).merge(:content_type => name)
+      options[:limit] = (options[:per_page] || 25)
+      options[:offset] = ((options[:page] || 1) - 1) * options[:limit]
+      options.delete :page
+      options.delete :per_page
+      find(:all, options)
+    end
+
+    def find_by_id(id)
+      wrap_result :first, connection.get_record_by_id(self, id.to_i)
+    end
+    
+    def find_each(options)
+      #TODO - run the query
+      if block_given?
+        #each ... yield(row)
+      end
+    end
+
+    def all
+      if name == "Content::Item"
+        find :all
+      else
+        find_all_by_content_type name
+      end
+    end
+
+    def first
+      if name == "Content::Item"
+        find :first
+      else
+        find_by_content_type name
+      end
+    end
+
+    def last
+      all.last
+    end
+
+    def method_missing(name, *arguments, &block)
+      name_s = name.to_s
+      if name_s =~ /^find_all(_by)?_(.+)$/
+        obj = polymorphic_finder :all, $2, arguments
+      elsif name_s =~ /^find_by_(.+)$/
+        obj = polymorphic_finder :first, $1, arguments
+      elsif name_s =~ /^find_last(_by)?_(.+)$/
+        obj = polymorphic_finder :last, $2, arguments
+      elsif name_s =~ /^find_or_create_by_(.+)$/
+        obj = polymorphic_finder :first, $1, arguments
+        if obj.nil?
+          self.create(arguments, &block)
+        end
+      elsif name_s =~ /^paginate_by_(.+)$/
+        obj = polymorphic_pager $1, arguments
+      else
+        obj = super
+      end
+      yield(obj) if !obj.nil? and block_given?
+      obj
+    end
+
+  protected
+    def hash_zip(keys, values, default=nil, &block)
+      hash = block_given? ? Hash.new(&block) : Hash.new(default)
+      keys.zip(values) { |k,v| hash[k]=v }
+      hash
+    end
+
+    def polymorphic_finder(which, name, arguments)
+      find which, :conditions => hash_zip(name.split(/_and_/), arguments)
+    end
+
+    def polymorphic_pager(name, arguments)
+      names = name.split(/_and_/)
+      options = arguments.length > names.length ? arguments.last : {}
+      if options.has_key? :conditions
+        options[:conditions].merge! hash_zip(names, arguments)
+      else
+        options.merge!({:conditions => hash_zip(names, arguments)})
+      end
+      paginate options
+    end
+
+    def create_item(attrs)
+      if attrs.nil?
+        nil
+      elsif !attrs[:content_type].nil?
+        attrs[:content_type].to_s.camelize.constantize.new(attrs)
+      elsif self == Content::Item
+        Content::Item.new(attrs)
+      end
+    end
+
+    def wrap_result(which, attrs)
+      unless attrs.nil?
+        attrs = [attrs] unless attrs.is_a?(Array)
+        case which
+        when :first then create_item attrs.first
+        when :last then create_item attrs.last
+        else attrs.collect { |item| create_item(item) }.compact
+        end
+      end
+    end
+	end
+end

data/lib/content/manager.rb

@@ -0,0 +1,105 @@
+module Content
+  module Manager
+    def self.load_content_item(params)
+      url = params["content_item_url"]
+      unless url.nil?
+        if url.is_a? Array
+          url = "/#{url.join('/')}"
+        end
+        if url.match(/^(.+)\.([a-z]+)$/i)
+          params[:format] = $2
+          url = $1
+        end
+        params["content_item_url"] = url
+        Content::Item.find_by_url(url)
+      end
+    end
+
+    def show
+      render404 and return if current_content_item.nil? or current_content_item.template.nil? or current_content_item.template.sublayout.nil?
+      respond_to do |format|
+        format.html { prerender_containers and render :template => "sublayouts/#{current_content_item.template.sublayout}", :layout => false }
+        format.xml  { render :xml => current_content_item }
+      end
+    end
+
+  protected
+    def prerender_containers
+      begin
+        sublayout = Content::Sublayout.find_by_path(current_content_item.template.sublayout)
+        sublayout.containers.each {|name| content_for name, render_container(name) }
+      rescue RuntimeError => err
+        render500(err) and return false
+      end
+      true
+    end
+
+    def content_for(name, content)
+      name = "layout" if name.to_s == "contents"
+      ivar = "@content_for_#{name}"
+      instance_variable_set(ivar, "#{instance_variable_get(ivar)}#{content}")
+    end
+
+    #
+    # Renders the given component
+    #
+    # url_options the options that would be passed to url_for
+    #
+    def render_component(url_options)
+      url = url_for(url_options)
+      querystring = URI.parse(url).query
+
+      env = {
+        "rack.version" => [0, 1],
+        "rack.input" => StringIO.new(""),
+        "rack.errors" => $stderr,
+        "rack.url_scheme" => "http",
+        "rack.run_once" => false,
+        "rack.multithread" => false,
+        "rack.multiprocess" => false,
+        "QUERY_STRING" => querystring,
+        "REQUEST_METHOD" => "GET",
+        "PATH_INFO" => url,
+        "REQUEST_PATH" => url,
+        "REQUEST_URI" => url
+      }
+
+      %w(SERVER_SOFTWARE HTTP_USER_AGENT HTTP_ACCEPT_ENCODING HTTP_ACCEPT_CHARSET
+        HTTP_ACCEPT_LANGUAGE HTTP_KEEP_ALIVE HTTP_COOKIE HTTP_VERSION SERVER_PROTOCOL HTTP_HOST
+        SERVER_NAME SERVER_PORT REMOTE_ADDR SCRIPT_NAME).each { |key| env[key] = request.env[key] }
+
+      resp = ActionController::Routing::Routes.call(env)
+      raise resp[2].body unless resp[0] == 200
+      resp[2].body
+    end
+
+    #
+    # Renders a container
+    #
+    # name the name of the container to render
+    #
+    def render_container(name)
+      unless current_content_item.nil? or current_content_item.template.nil? or current_content_item.template[name].nil?
+        current_content_item.template.get_container(name).collect {|component|
+          render_component(:controller => "components/#{component.keys.first.to_s.pluralize}", :action => "show", :id => component.values.first)
+        }
+      end
+    end
+
+    def render404
+      respond_to do |format| 
+        format.html { render :template => "errors/error_404", :status => 404 } 
+        format.all  { render :nothing => true, :status => 404 } 
+      end
+      true
+    end
+
+    def render500(err)
+      respond_to do |format| 
+        format.html { render :text => err, :layout => false, :status => 500 } 
+        format.all  { render :nothing => true, :status => 500 } 
+      end
+      true
+    end
+  end
+end