aura 0.0.1.pre10

data/app/helpers/template_helpers.rb

@@ -0,0 +1,94 @@
+class Main
+  module TemplateHelpers
+    # Makes a template extend upon another template.
+    #
+    # Example:
+    #
+    #   -# Should be the first line.
+    #   != extends :'base/edit', options
+    #
+    #   - content_for! :body do
+    #     This will override the body of the base/edit template
+    #
+    def extends(name, locals={})
+      partial name, locals
+    end
+
+    # Template helper: partial (Helpers)
+    # Renders a partial.
+    #
+    def partial(template, *args) #locals={}, options={}
+      if template.respond_to?(:templates_for)
+        template = template.templates_for(args.shift || 'index')
+      end
+
+      locals  = args.shift || {}
+      options = args.shift || {}
+
+      layout, @layout = @layout, nil
+      out = show template, {:layout => false}.merge(options), locals
+      @layout = layout
+      out
+    end
+
+    # Template helper: has_content? (Helpers)
+    # Checks if a given content block is defined.
+    #
+    def has_content?(key)
+      return false  unless content_blocks.keys.include?(key.to_sym)
+      content_blocks[key.to_sym].any?
+    end
+
+    # Template helper: content_for! (Helpers)
+    # Like content_for, but overwrites any blocks.
+    #
+    def content_for!(key, &blk)
+      content_blocks[key.to_sym] = Array.new
+      content_for key, &blk
+    end
+
+    # Template helper: content_for? (Helpers)
+    # Synonym of has_content?
+    #
+    def content_for?(key)
+      (content_blocks[key.to_sym] || Array.new).any?
+    end
+
+    # Template helper: yield_content_of (Helpers)
+    # Loads a given template and yields a certain content block of it.
+    #
+    # ##  Usage
+    #     yield_content_of(template, section[, locals])
+    #     yield_content_of(model, template, section[, locals])
+    #
+    def yield_content_of(template, *args) #section, locals={}
+      if template.respond_to?(:templates_for)
+        template = template.templates_for(args.shift || :index)
+      end
+
+      section = args.shift || :content
+      locals  = args.shift || {}
+
+      custom_activate!
+
+      show template, { :layout => false }, locals
+      ret = yield_content(section)
+
+      custom_deactivate!
+      ret
+    end
+
+  protected
+    def custom_activate!
+      @old_content_blocks ||= Array.new
+      @old_content_blocks << @content_blocks
+      @content_blocks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def custom_deactivate!
+      @content_blocks = @old_content_blocks.pop
+    end
+  end
+
+  helpers TemplateHelpers
+end

data/app/helpers/user_helpers.rb

@@ -0,0 +1,45 @@
+class Main
+  module UserHelpers
+    # User helper: logged_in? (Helpers)
+    # Checks if there is a user logged in or not.
+    #
+    def logged_in?
+      !! current_user
+    end
+
+    # User helper: current_user (Helpers)
+    # Returns the current user as an instance of {Aura::Models::User}.
+    #
+    def current_user
+      authenticated(User)
+    end
+
+    # User helper: require_login (Helpers)
+    # Ensures that a route is only accessible to logged in users.
+    #
+    def require_login
+      redirect R(:login)  unless logged_in?
+    end
+
+    # Overridden in aura to track last login time.
+    # This is called when a user logs in.
+    #
+    def redirect_to_return_url(session_key = :return_to, default = '/admin')
+      u = current_user
+      first_login = u.last_login.nil?
+
+      u.last_login = Time.now
+      u.save
+
+      # On a user's first login, go to a admin welcome page
+      # where they can change their password.
+      if first_login
+        redirect R(:admin, :welcome)
+      end
+
+      redirect session.delete(:return_to) || default
+    end
+  end
+
+  helpers UserHelpers
+end

data/app/init/admin.rb

@@ -0,0 +1,34 @@
+Aura.admin.menu.tap { |m|
+  m.add "settings",
+    :name => "Settings",
+    :href => Rtopia.R(:admin, :settings),
+    :icon => 'settings'
+
+  m.add "settings.database",
+    :name => "Database",
+    :href => Rtopia.R(:admin, :settings, :database)
+
+  m.add "settings.your_account",
+    :name => "Your account",
+    :href => Rtopia.R(:user, :me, :edit)
+  
+  m.add "settings.users",
+    :name => "Users",
+    :href => Rtopia.R(:user, :list)
+}
+
+Main.register Sinatra::CompressedJS
+
+path = Main.root_path(%w(public js))
+
+Main.serve_compressed_js :admin_js,
+  :prefix => '/js',
+  :root   => path,
+  :path   => '/admin/script.js',
+  :files  =>
+    Dir["#{path}/jquery.*.js"].sort +
+    Dir["#{path}/lib.*.js"].sort +
+    Dir["#{path}/admin.js"].sort +
+    Dir["#{path}/admin.*.js"].sort
+
+ 

data/app/init/extensions.rb

@@ -0,0 +1,18 @@
+# Load extensions
+Aura::Extension.active.each { |ext| ext.load! }
+
+seed_file = Main.approot('config/seed.yml')
+
+# If the file config/seed.yml is present, use that to initialize the DB.
+# Only if the DB is pristine, though!
+if File.exists?(seed_file) and Main.database.tables.empty?
+  puts "Note: Restoring sample data from config/seed.yml."
+  Aura.db_restore YAML::load_file(seed_file)
+
+# ..otherwise, setup the database: do migrations and put in fresh data.
+else
+  Aura.run_migrations!
+  Main.seed
+end
+
+Aura::Extension.active.each { |ext| ext.init }

data/app/init/pistol.rb

@@ -0,0 +1,11 @@
+# Reloading
+class Main
+  unless production?
+    FileUtils.mkdir_p Aura.root('tmp/')
+    FileUtils.touch Aura.root('tmp/restart.txt')
+
+    use(Pistol, app_files + [Aura.root('tmp/restart.txt')]) {
+      reset! and load(ENV['APP_FILE'])
+    }
+  end
+end

data/app/init/sequel.rb

@@ -0,0 +1,11 @@
+Sequel::Model.plugin :aura_model
+Sequel::Model.plugin :validation_helpers
+Sequel::Model.plugin :hook_class_methods
+Sequel.extension :inflector
+
+class Sequel::Model
+  def self.inherited(klass)
+    Aura.models.all << klass
+    super
+  end
+end

data/app/main.rb

@@ -0,0 +1,106 @@
+root = Aura.method(:gem_root)
+approot = Aura.method(:root)
+
+$:.unshift *Dir[root["/vendor/*/lib"]]
+require "sinatra/base"
+require "sinatra/support"
+require "rtopia"
+require "sequel"
+require "sinatra/content_for"
+require "sinatra/sequel"
+require "pistol"
+require "json"
+require "yaml"
+require "shield"
+require "ostruct"
+require "fileutils"
+
+# Helpers
+require root['lib/core/hasharray']
+require root['lib/core/object_ext']
+
+# Aura proper
+require root['lib/aura']
+require root['lib/terra']
+require root['lib/terra/ext']
+
+if defined?(::Encoding)
+  Encoding.default_external = 'utf-8'
+end
+
+# Class: Main
+# The main Sinatra application.
+#
+# ## Description
+#    This is the main application. It is also accessible as `Aura::App`.
+#
+class Main < Sinatra::Base
+  set      :root, lambda { |*args| File.join(ENV['AURA_ROOT'], *args) }
+  set      :root_path, lambda { |*args| root *args }
+  set      :approot, lambda { |*args| File.join(ENV['APP_ROOT'] || root, *args) }
+
+  set      :haml, :escape_html => true
+  set      :haml, :escape_html => true, :ugly => true  if production?
+
+  enable   :raise_errors
+
+  use      Rack::Session::Cookie
+  use      Rack::Deflater  if production?
+
+  register Aura::Public
+  register Aura::Rendering
+  register Aura::Seeder
+  register Sinatra::SequelExtension
+
+  helpers  Rtopia
+  helpers  Sinatra::ContentFor
+  helpers  Sinatra::UserAgentHelpers
+  helpers  Shield::Helpers
+
+  # Load all, but load defaults first
+  ( Dir[root('config/*.rb')].sort +
+    Dir[approot('config/*.rb')].sort
+  ).uniq.each { |f| load f }
+
+  register Sinatra::CompassSupport
+
+  set :login_success_message, nil
+
+  set :multi_views,     [root('app/views')]
+  set :app_files,       [ENV['APP_FILE']] + Dir[root('**/*.rb')] + Dir[approot('**/*.rb')]
+  set :extensions_path, [root('extensions'), approot('extensions')]
+
+  # Heroku - override the DB config with this env var.
+  set :database_url, ENV['DATABASE_URL']  unless ENV['DATABASE_URL'].nil?
+
+  add_public approot('public')
+
+  def self.restart!
+    require 'fileutils'
+    FileUtils.touch approot('tmp', 'restart.txt')
+  end
+
+  # Connect to db
+  database
+end
+
+# Initializers
+require root['app/init/pistol.rb']
+require root['app/init/admin.rb']
+require root['app/init/sequel.rb']
+
+# Bootstrap Aura
+Dir[root['app/{models,helpers,routes}/**/*.rb']].each { |f| require f }
+
+# Extensions
+require root['app/init/extensions.rb']
+
+# Load app/
+if File.directory?(Main.approot('app'))
+  Aura::Extension.new(Main.approot('app')).load!
+end
+
+Aura::App = Main
+
+Main.set :port, ENV['PORT'].to_i  unless ENV['PORT'].nil?
+Main.run!  if ENV['APP_FILE'] == $0

data/app/migrations/page.rb

@@ -0,0 +1,29 @@
+class Main
+  migration "Aura v0.0.1 - page" do
+    database.create_table :pages do
+      # aura_hierarchy
+      primary_key :id
+      foreign_key :parent_id, :pages
+
+      String :title
+      String :body, :text => true
+      String :custom, :text => true
+
+      # aura_sluggable
+      String :slug
+
+      # aura_subtyped
+      String :subtype
+
+      String :author_name #unused
+
+      String :meta_keywords
+      String :meta_description
+
+      Boolean :shown_in_menu
+
+      Time :created_at
+      Time :modified_at
+    end
+  end
+end

data/app/migrations/settings.rb

@@ -0,0 +1,11 @@
+class Main
+  migration "Aura v0.0.1 - settings" do
+    database.create_table :settings do
+      primary_key :id
+
+      String :key
+      String :value, :text => true
+      index :key
+    end
+  end
+end

data/app/migrations/user.rb

@@ -0,0 +1,13 @@
+class Main
+  migration "Aura v0.0.1 - user" do
+    database.create_table :users do
+      primary_key :id
+
+      String :email
+      String :slug
+      String :crypted_password
+      Time :last_login
+    end
+  end
+end
+

data/app/models/page.rb

@@ -0,0 +1,116 @@
+# Model: Page
+# Inherits: {AuraModel} {AuraSluggable} {AuraRenderable} {AuraEditable} {AuraHierarchy} {AuraSubtyped}
+# The page model.
+#
+# ## Inherits from
+#  * {AuraModel}
+#  * {AuraSluggable}
+#  * {AuraRenderable}
+#  * {AuraEditable}
+#  * {AuraHierarchy}
+#  * {AuraSubtyped}
+#
+class Page < Sequel::Model
+  plugin :aura_sluggable      # Accessible via slug: /about-us/services
+  plugin :aura_renderable     # Can show a page when accessed by that URL
+  plugin :aura_editable       # Editable in the admin area
+  plugin :aura_hierarchy      # Can have children
+  plugin :aura_subtyped       # Has subtypes
+
+  plugin :timestamps
+  plugin :serialization, :yaml, :custom
+
+  form do
+    # title (show it big), main-title (use it on the page heading)
+    text :title, "Page title", :class => 'title main-title no-label assert required'
+    html :body,  "Body text", :class => 'long no-label'
+    text :slug,  "Slug", :class => 'compact hide'
+
+    # fieldset(:meta, "Metadata") do
+    #   text :meta_keywords, "Keywords", :class => 'compact-top'
+    #   text :meta_description, "Description", :class => 'compact-bottom'
+    # end
+  end
+
+  def initialize(*a)
+    super
+    self.shown_in_menu = true  if self.shown_in_menu.nil?
+  end
+
+  def shown_in_menu?
+    !! self.shown_in_menu
+  end
+  
+  # Method: child_subtypes (Page)
+  # Returns an array of Subtypes allowed for its children.
+  def child_subtypes
+    types = self.class.subtypes
+    types.select! { |t| self.subtype.allowed_subtypes.include? t.id.to_sym }  if self.try(:subtype).try(:allowed_subtypes).is_a?(Array)
+    types
+  end
+
+  # Method: subtypes (Page)
+  # Returns an array of Subtypes allowed for this page.
+  def subtypes
+    parent? ? parent.child_subtypes : self.class.subtypes
+  end
+
+  # Method: parentable? (Page)
+  # Checks if a given page can have children from the admin interface.
+  def parentable?
+    return false  if self.subtype && self.subtype.parentable? == false
+    true
+  end
+
+  # Method: deletable? (Page)
+  # Checks if a given page can be deleted from the admin interface.
+  def deletable?
+    return false  if self.subtype && self.subtype.deletable? == false
+    true
+  end
+
+  def validate
+    super
+    validates_presence :title
+  end
+
+  # Returns the *other* form that depends on the subtype.
+  def subform
+    return nil  if subtype.nil?
+    self.class.form subtype._id
+  end
+
+  # Class method: custom_field (Page)
+  # Creates a custom field and adds getters/setters for it.
+  #
+  # ##  Example
+  #
+  # #### Creating custom fields
+  #
+  #     [app/models/page-ext.rb (rb)]
+  #     class Page
+  #       custom_field :recipe
+  #     end
+  #
+  #     p = Page.new
+  #     p.recipe = "Chili Con Carne"
+  #
+  def self.custom_field(name)
+    name = name.to_sym
+    self.send(:define_method, name) do
+      self.custom[name]  if self.custom.is_a? Hash
+    end
+
+    self.send(:define_method, :"#{name}=") do |v|
+      self.custom ||= Hash.new
+      self.custom[name] = v
+    end
+  end
+
+  def self.content?; true; end
+  def self.show_on_sidebar?; true; end
+
+  # Class method: root_creatable? (Page)
+  # Returns 'true' if the "Add new page" should be shown.
+  def self.root_creatable?; true; end
+end