aura 0.0.1.pre10

data/lib/sequel/plugins/aura_hierarchy.rb

@@ -0,0 +1,82 @@
+# Sequel plugin: AuraHierarchy
+# Used on models that have children and parents.
+#
+# ## Description
+#    This automatically gives models parent/child support.
+#
+# #### How to use
+# Use `plugin :aura_hierarchy` in your model.
+#
+#     class Book < Sequel::Model
+#       plugin :aura_hierarchy
+#     end
+#
+# #### Database setup
+# Add `:parent_id` to your schema.
+#
+#     database.create_table :books do
+#       foreign_key :parent_id
+#       # ...
+#     end
+#
+# #### Example
+# Our `Book` class can now have parents and children.
+#
+#     book = Book[2]
+#
+#     # Traversion
+#     book.parent
+#     book.children
+#     book.siblings
+#
+module Sequel::Plugins::AuraHierarchy
+  def self.configure(model, options={})
+    model.many_to_one :parent, :class => model
+    model.one_to_many :children, :key => :parent_id, :class => model
+  end
+
+  module InstanceMethods
+    def parentable?
+      true
+    end
+
+    def siblings
+      if parent.nil?
+        self.class.filter(:parent_id => nil)
+      else
+        parent.children
+      end
+    end
+
+    def prev_sibling
+      siblings.each_cons(2) { |(other, item)| return item  if other.id == self.id }
+    end
+
+    def next_sibling
+      siblings.each_cons(2) { |(item, other)| return item  if other.id == self.id }
+    end
+
+    def nearest
+      children.any? ? children : siblings
+    end
+
+    def nearest_parent
+      children.any? ? self : parent
+    end
+
+    def crumbs
+      return [self]  if parent.nil?
+      parent.crumbs + [self]
+    end
+  end
+
+  module ClassMethods
+    def parentable?
+      true
+    end
+
+    def roots
+      filter(:parent_id => nil)
+    end
+  end
+end

data/lib/sequel/plugins/aura_model.rb

@@ -0,0 +1,271 @@
+# Sequel plugin: AuraModel
+# The base plugin for a model.
+#
+# ## Description
+#    All models use this plugin, and all methods it provides are available
+#    to all Aura/Sequel models.
+#
+module Sequel::Plugins::AuraModel
+  def self.configure(model)
+    model.plugin :validation_helpers
+  end
+
+  module InstanceMethods
+    # Method: parent (AuraModel)
+    # Returns the parent.
+    #
+    def parent
+      nil
+    end
+
+    def to_s
+      begin
+        title
+      rescue NoMethodError
+        @values[:title] || self.class.to_s.split('::').last
+      end
+    end
+
+    def validate!
+      raise Sequel::ValidationFailed(errors)  unless valid?
+    end
+
+    # Method: shown_in_menu? (AuraModel)
+    # Determines if the record should be shown to visitors in the site menus.
+    #
+    # ## Description
+    # This only affects the front-facing site, and has to influence as
+    # to whether it will be shown in the admin area.
+    #
+    # Override this.
+    #
+    def shown_in_menu?
+      false
+    end
+
+    def <=>(other)
+      self.sort_index <=> other.sort_index
+    end
+
+    # Method: sort_index (AuraModel)
+    # This is what they'll be sorted by.
+    #
+    # To enable sorting, implement a `position` field.
+    #
+    # You can reimplement this. Make sure it returns a tuple of an int and an int.
+    #
+    def sort_index
+      pos = nil
+      pos ||= self.position  if self.respond_to?(:position)
+      [pos || 9999, self.id]
+    end
+
+    # Method: set_fields (AuraModel)
+    # Sets the fields to the values in the hash.
+    #
+    # Overriding `set_fields` to make the 2nd param optional.
+    #
+    def set_fields(hash, keys=hash.keys)
+      super hash, keys
+    end
+
+    def templates_for(template)
+      self.class.templates_for template
+    end
+
+    # Method: menu_title (AuraModel)
+    # Returns the name of the record as it should appear on the menu.
+    #
+    # This defaults to whatever the title of the record is (`#to_s`).
+    # Have your model override this if you need to.
+    #
+    def menu_title
+      to_s
+    end
+
+    # Method: path (AuraModel)
+    # Returns the URL path for the record.
+    #
+    # ##  Example
+    #
+    #     Page[1].path  #=> '/products/cx-300'
+    #     User[1].path  #=> '/user/1' (because user is not sluggable.)
+    #   
+    #     Page[1].path(:edit)  # => '/products/cx-300/edit'
+    #
+    def path(*a)
+      ret = "/#{self.class.class_name}/#{self.id}"
+      ret += "/#{a.shift.to_s}"  if a.first.is_a?(String) || a.first.is_a?(Symbol)
+      ret += "?" + Aura::Utils.query_string(a.shift)  if a.first.is_a?(Hash)
+      ret
+    end
+
+    # Method: parentable? (AuraModel)
+    # Determines if the record can have children.
+    #
+    # This is reimplemented by {AuraHierarchy}.
+    #
+    def parentable?
+      false
+    end
+    
+    # Method: parent? (AuraModel)
+    # Determines if the record has a parent.
+    #
+    def parent?
+      ! parent.nil?
+    end
+
+    # Method: children (AuraModel)
+    # Returns the children of the record.
+    def children
+      Array.new
+    end
+
+    # Method: submenu (AuraModel)
+    # Returns a list of items for the submenu.
+    #
+    # ##  Example
+    #
+    #     <% item.submenu.each do %>
+    #       <li><% item.to_s %></li>
+    #     <% end %>
+    #
+    def submenu
+      children.select { |item| item.shown_in_menu? }.sort
+    end
+
+    # Method: crumbs (AuraModel)
+    # Returns an array of records of breadcrumb path of the record, starting from the root.
+    #
+    def crumbs
+      [self]
+    end
+
+    # Determines how far removed the record is from the root.
+    #
+    # ## Example
+    #
+    #     p = Page[1]
+    #     p.parent?  #=> false
+    #     p.depth    #=> 1
+    #
+    def depth
+      crumbs.size
+    end
+
+    def is_parent_of?(target)
+      target.crumbs.include?(self)
+    end
+  end
+
+  module ClassMethods
+    # Class method: content? (AuraModel)
+    # Returns if the model data is considered to be site content.
+    #
+    # ## Description
+    # The site is considered empty if all models that are content?
+    # are empty.
+    #
+    def content?
+      false
+    end
+
+    # Class method: roots (AuraModel)
+    # Returns a set of results of all records that don't have parents.
+    #
+    # Returns a Sequel dataset.
+    def roots
+      select
+    end
+
+    # Class method: seed (AuraModel)
+    # Ensures that the model has some bare essentials in it.
+    #
+    # This is called every time the application initializes.
+    # Override this if you need certain records to exist, like as
+    # how there is always one user.
+    #
+    # As this is called every application load, if you override this,
+    # it is your responsibility to check if the model is #empty? before
+    # writing anything.
+    #
+    # A parameter `type` may be given. If this is set to `:sample`, then
+    # load up some sample data.
+    #
+    def seed(type=nil, &b)
+    end
+
+    # Class method: seed! (AuraModel)
+    # Like `seed`, but empties the table first.
+    #
+    def seed!(type=nil, &b)
+      delete
+      seed type, &b
+    end
+
+    # Class method: parentable (AuraModel)
+    # Determines if the model can have children.
+    #
+    # Reimplemented by aura_hierarchy.
+    #
+    def parentable?
+      false
+    end
+
+    def templates_for(template)
+      [ :"#{class_name}/#{template}",
+        :"base/#{template}"
+      ]
+    end
+
+    # Class method: class_name (AuraModel)
+    # Returns a string of the model's name for use in URLs.
+    #
+    # ## Example
+    #
+    #     BlogPost.class_name #=> "blog_post"
+    #
+    def class_name
+      self.to_s.demodulize.underscore
+    end
+
+    # Class method: title (AuraModel)
+    # Returns a string of the model's name to appear on pages.
+    #
+    # ## Example
+    #
+    #     BlogPost.title #=> "Blog post"
+    #
+    def title
+      self.class_name.humanize
+    end
+
+    # Class method: title_plural (AuraModel)
+    # Returns a string of the model's name, pluralized, to appear on pages.
+    #
+    # ## Example
+    #
+    #     BlogPost.title_plural #=> "Blog posts"
+    #
+    def title_plural
+      self.title.pluralize
+    end
+
+    # Class method: path (AuraModel)
+    # Returns a URL path for an action for the model.
+    #
+    # ## Example
+    #
+    #     BlogPost.path               #=> /blog_post
+    #     BlogPost.path(:list)        #=> /blog_post/list
+    #     BlogPost.path(:list, :all)  #=> /blog_post/list/all
+    #
+    def path(*a)
+      ret = "/#{class_name}"
+      ret += "/#{a.shift}"  if a.first.is_a?(String) || a.first.is_a?(Symbol)
+      ret += "?" + Aura::Utils.query_string(a.shift)  if a.first.is_a?(Hash)
+      ret
+    end
+  end
+end

data/lib/sequel/plugins/aura_renderable.rb

@@ -0,0 +1,42 @@
+# Models that can be viewed by a URL.
+# Supports templating and stuff.
+#
+# Assumptions:
+#
+# - Your data table must have `String :template`. (optional;
+#   Aura guesses the template name if it's not available.)
+#
+module Sequel
+  module Plugins
+    module AuraRenderable
+      module InstanceMethods
+        # Returns the templates to be tried for the item, listed
+        # in order of priority.
+        #
+        # Example:
+        #
+        #     [ "product/mofo", "base/mofo", "product/default", "base/default" ]
+        #
+        def page_templates
+          klass = self.class.class_name # blog_post
+
+          [ :"#{klass}/#{template}",
+            :"base/#{template}",
+            :"#{klass}/show",
+            :"base/show"
+          ].map { |s| s.to_sym }.uniq
+        end
+
+        # Returns the template to be used when it's displayed.
+        # Overridden by AuraSubtyped.
+        def template
+          'show'
+        end
+
+        def renderable?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/aura_sluggable.rb

@@ -0,0 +1,103 @@
+# Sequel plugin: AuraSluggable
+# Implemented for models that are to be accessible via a slug URL.
+#
+# ## Description
+#    This automatically gives models the ability to be accessed via a
+#    slug URL (like `/products/boots`).
+#
+# #### How to use
+# Use `plugin :aura_sluggable`.
+#
+#     class Book < Sequel::Model
+#       plugin :aura_sluggable
+#
+#       # ...
+#     end
+#
+# #### Database setup
+# Add `String :slug` to your schema.
+#
+#     database.create_table :books do
+#       String :slug
+#       # ...
+#     end
+#
+module Sequel
+  module Plugins
+    module AuraSluggable
+      def self.configure(model, opts={})
+        Aura.slugs.register(model)
+      end
+
+      module InstanceMethods
+        def sluggable?
+          true
+        end
+
+        # Method: path (AuraSluggable)
+        # Returns the URL path.
+        #
+        def path(*a)
+          return super  if slug.nil?
+          ret = '/' + (slug.to_s)
+          ret = "#{parent.path}#{ret}"  if respond_to?(:parent) && parent.respond_to?(:path)
+          ret += "/#{a.shift.to_s}"  if a.first.is_a?(String) || a.first.is_a?(Symbol)
+          ret += "?" + Aura::Utils.query_string(a.shift)  if a.first.is_a?(Hash)
+          ret
+        end
+
+        # Method: slugify (AuraSluggable)
+        # Returns a unique slug for the item.
+        #
+        # ##  Example
+        #     b = Book.new
+        #     b.title = 'Darkly Dreaming Dexter'
+        #     
+        #     b.slugify                       #=> "darkly-dreaming-dexter"
+        #     b.slugify("Dexter by Design")   #=> "dexter-by-design"
+        #
+        def slugify(str=title)
+          str = str.to_s
+          str = str.scan(/[A-Za-z0-9]+/).join('-').downcase
+          i = 1
+
+          loop do
+            slug = str
+            slug = "#{str}-#{i}"  if i>1
+
+            item = self.class.find(:slug => slug)
+            return slug  if item.nil? || item == self
+            i += 1
+          end
+        end
+
+        def validate
+          self.slug = self.slugify  if self.slug.nil? or self.slug.empty?
+          super
+        end
+      end
+
+      module ClassMethods
+        def sluggable?
+          true
+        end
+
+        # Class method: get_by_slug (AuraSluggable)
+        # Finds an item by a given slug.
+        #
+        # ##  Example
+        #     b = Book.get_by_slug('darkly-dreaming-dexter')
+        #
+        def get_by_slug(slug, parent=nil)
+          pid = parent.nil? ? nil : parent.id
+
+          if columns.include?(:parent_id)
+            find(:slug => slug, :parent_id => pid)
+          else
+            find(:slug => slug)
+          end
+        end
+      end
+    end
+  end
+end