aura 0.0.1.pre10

data/lib/aura/menu.rb

@@ -0,0 +1,142 @@
+class Aura
+  # Class: Menu (Aura)
+  # A menu.
+  #
+  # #### Accessing the singleton
+  # Doing Aura.admin.menu will get you the single instance of Aura::Menu.
+  #
+  #     m = Aura.admin.menu    #=> #<Aura::Menu ...>
+  #
+  # #### Adding menu items
+  # Use {Aura::Menu#add}.
+  #
+  #     Aura.admin.menu.add "hello",
+  #       :name => "Hello",
+  #       :href => '/admin/lol',
+  #       :icon => 'settings'
+  #
+  # #### Adding submenu items
+  # Add sub items by using the dot notation on the name.
+  #
+  #     Aura.admin.menu.add "hello.subitem",
+  #       :name => "Subitem",
+  #       :href => '/admin/lol/sub',
+  #       :icon => 'settings'
+  #
+  # #### Retrieving menu items
+  # Use {Aura::Menu.items}.
+  #
+  #     Aura.admin.menu.items    #=> Array of MenuItems
+  #
+  #     item = Aura.admin.menu.get('hello')
+  #     item.name
+  #     item.href
+  #     item.icon
+  #     item.items    # List of sub items
+  #
+  class Menu
+    # Method: add (Aura::Menu)
+    # Adds a menu item.
+    #
+    # ##  Usage
+    #     Aura.admin.menu.add 'key',
+    #       :name => 'name',
+    #       :href => '/url',
+    #       :icon => 'icon_name'     # <= optional
+    #
+    def add(key, options={})
+      path = key.to_s.split('.')
+      last = path.pop
+      node = root
+
+      path.each do |segment|
+        node = (node.raw_items[segment] ||= MenuItem.new)
+      end
+
+      node.raw_items[last] = MenuItem.new(options.merge(:path => path, :key => last))
+    end
+
+    # Method: items (Aura::Menu)
+    # Returns the root menu items.
+    #
+    # ##  Usage
+    #     Aura.admin.menu.items
+    #
+    # ## Description
+    #    Returns instances of {Aura::MenuItem}.
+    #
+    def items
+      root.items
+    end
+
+    # Method: get (Aura::Menu)
+    # Returns a menu item of a given key.
+    #
+    # ##  Usage
+    #     Aura.admin.menu.get(keyname)
+    #
+    # ##  Example
+    #
+    # #### Get and set
+    # Use {Aura::Menu#add} to add, then `get` to get.
+    #
+    #     Aura.admin.menu.add "hello",
+    #       :name => "Hello",
+    #       :href => '/admin/lol',
+    #       :icon => 'settings'
+    #
+    #     item = Aura.admin.menu.get('hello')  #=> #<MenuItem>
+    #     item.name                             #=> "Hello"
+    #     item.icon                             #=> "settings"
+    #
+    def get(key='')
+      path = key.to_s.split('.')
+      node = root
+      path.each { |segment| node = node.raw_items[segment] }
+      node
+    end
+
+  protected
+    def root
+      @root ||= MenuItem.new
+    end
+  end
+
+  # Class: MenuItem (Aura)
+  # A menu item.
+  #
+  # ## Description
+  #    This is an OpenStruct.
+  #
+  #    It will always have `.path` and `.key`.
+  #    Optional items are `.name`, `.href`, and `.position`.
+  #
+  #    Methods such as {Aura::Menu.items} and {Aura::Menu.get} return menu items.
+  #
+  class MenuItem < OpenStruct
+    def initialize(hash={})
+      super
+      self.items = Hash.new
+    end
+
+    def name
+      @table[:name] || self.key.capitalize
+    end
+
+    def raw_items
+      @table[:items]
+    end
+
+    def items
+      @table[:items].values.sort_by { |item| item.position.to_s || item.key }
+    end
+
+    def href
+      @table[:href].try(:call) || @table[:href] || R(:admin, *path.split('.'))
+    end
+  end
+end
+
+#Aura.admin.menu.add 'settings.db', :name => "Settings", :href => "/settings"
+#Aura.admin.menu.get('settings') # list of MenuItems
+#Aura.admin.menu.items

data/lib/aura/models.rb

@@ -0,0 +1,80 @@
+# Class: Models (Aura)
+# Models.
+#
+# #### Finding models
+# `Aura.models` returns a Models instance, which is enumerable.
+#
+#     Aura.models    #=> #<Aura::Models>
+#     Aura.models.map { |m| m.name }
+#
+# #### Find by name
+# Use {Aura.models.get} or Ruby's `const_get`.
+#
+#     Aura.models.get('contact_form')       #=> ContactForm
+#     Aura.models.const_get(:ContactForm)   #=> ContactForm
+#
+class Aura
+  class Models
+    include Enumerable
+
+    def each(&blk)
+      all.each &blk
+    end
+
+    # Class method: all (Aura::Models)
+    # Returns an array of all model classes.
+    #
+    # ##  Example
+    #     Aura.models.all.each do |m|
+    #       # ...
+    #     end
+    #
+    def all
+      @@all ||= Array.new
+    end
+
+    # Class method: get (Aura::Models)
+    # Returns a given model.
+    #
+    # ## Usage
+    #     Aura::Models.get(name)
+    #
+    # ## Description
+    #   Looks up the model `name` and returns the model class, or `nil`
+    #   if it's not found.
+    #
+    # ##  Example
+    #     Aura::Models.get('contact_form') #=> Aura::Model::ContactForm
+    #
+    def get(name)
+      name = camelize(name)  if name.downcase == name
+      begin
+        Object.const_get(name)
+      rescue NameError
+        nil
+      end
+    end
+
+    # Class method: reload! (Aura::Models)
+    # Ensures that models will get new columns the next time it's loaded.
+    #
+    def reload!
+      Aura.models.each { |m| m.send :set_columns, nil }
+    end
+
+    # Puts models in the global namespace.
+    # Don't use me.
+    #
+    def unpack
+      all.each do |model|
+        klass = model.name.split('::').last
+        Kernel.const_set(klass, model)  unless Kernel.const_defined?(klass)
+      end
+    end
+
+  protected
+    def camelize(str)
+      str.split('_').map { |s| s.capitalize }.join('')
+    end
+  end
+end

data/lib/aura/public.rb

@@ -0,0 +1,68 @@
+# Sinatra plugin: Public (Aura)
+# Allows apps to use more than one public folder.
+#
+# ## Description
+#    This is used by the {Main} application.
+#    This is a general-purpose plugin that can be used in other Sinatra
+#    projects.
+#
+# ##  Usage
+#     class MyApp < Sinatra::Base
+#       register Aura::Public
+#
+#       add_public path
+#       add_public path[, :prefix => PREFIX]
+#     end
+#
+# ##  Example
+#
+# #### Add a public dir
+# Just pass a path to `add_public`.
+#
+#     class MyApp < Sinatra::Base
+#       add_public "#{root}/app/public"
+#     end
+#
+# #### Accessing
+# This may be used to access `app/public/script.js`.
+#
+#     $ curl http://localhost:4567/script.js
+#
+# #### Prefix
+# Here's how you add a prefix.
+#
+#      add_public "#{root}/js", :prefix => "javascripts/"
+#      $ curl http://localhost:4567/javascripts/app.js
+#
+class Aura
+  module Public
+    def self.registered(app)
+      app.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Class method: add_public (Aura::Public)
+      # Adds a new public dir.
+      #
+      # ## Description
+      # See {Aura::Public} for usage and examples.
+      #
+      def add_public(dir, options={})
+        return  unless File.directory?(dir)
+        prefix = options.delete(:prefix)
+
+        get "#{prefix}*" do |path|
+          begin
+            fname = File.join(dir, path)
+            pass  unless File.file?(fname)
+            pass  unless Utils.in_dir?(fname, dir)
+
+            send_file fname
+          rescue Errno::ENOENT => e
+            pass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aura/rendering.rb

@@ -0,0 +1,134 @@
+# Sinatra plugin: Rendering (Aura)
+# Allows rendering from multiple engines or renderers.
+#
+# ## Usage
+#
+# #### Registering
+#
+#     class Main < Sinatra::Base
+#       register Aura::Rendering
+#
+#       # These two settings are optional.
+#       set :multi_views,   [ './views', './skin/default' ]
+#       set :multi_engines, [ :erb, :haml ]
+#
+# #### Using show
+# Using #show will automatically find the appropriate template, trying the
+# following variations.
+#
+#       get '/' do
+#         show :home
+#       end
+#     end
+#
+#     # ./views/home.erb
+#     # ./views/home.haml
+#     # ./skin/default/home.erb
+#     # ./skin/default/home.haml
+#
+module Aura::Rendering
+  def self.registered(app)
+    views = app.views || './views'
+
+    app.set :multi_engines, Tilt.mappings.keys  unless app.respond_to?(:template_engines)
+    app.set :multi_views,   views               unless app.respond_to?(:multi_views)
+
+    app.helpers Helpers
+  end
+
+  module Helpers
+    # Helper: layout (Helpers)
+    # Defines a layout to use.
+    def layout(what=nil)
+      @layout = what  if what
+      @layout
+    end
+
+    # Helper: show (Helpers)
+    # Shows a given template.
+    #
+    # ##  Usage
+    #     show(template[, options[, locals])
+    #     show(model, template[, options[, locals])
+    #
+    # ## Options
+    #   You may pass +options[:engine]+ to specify which engines you will want
+    #   to limit the search to. This defaults to +App.multi_engines+, or Tilt's
+    #   supported engines if that's not defined.
+    #   
+    #   You may pass +options[:views]+ to specify which directories to scour.
+    #   This defaults to +Main.multi_views+, or +Main.views+.
+    #
+    # #### Show a template
+    #
+    #     show :home
+    #
+    # #### Show a model's view
+    # This example looks at `:'page/index'` and `:'base/index'`, using
+    # whichever it finds first
+    #
+    #     page = Page['/about']
+    #     show page, :index
+    #
+    # #### Limiting engines
+    #
+    #     # HAML only
+    #     show :home, engine: :haml
+    #
+    #     # HAML or ERB, favoring HAML first
+    #     show :home, engine: [:haml, :erb]
+    #
+    # #### Only certain paths
+    # Only look at certain paths
+    #
+    #    show :home, views: [ './views', './skins/default' ]
+    #
+    def show(templates, *args, &block)
+      if templates.respond_to?(:templates_for)
+        templates = templates.templates_for(args.shift || 'index')
+      end
+
+      options = args.shift || {}
+      locals  = args.shift || {}
+
+      paths     = [*(options[:views]  || settings.multi_views)].join(',')
+      engines   = [*(options[:engine] || settings.multi_engines)].join(',')
+
+      @layout = options.delete(:layout)
+
+      get_engine = lambda { |template|
+        spec = "{#{paths}}/#{template}.{#{engines}}"
+        template = Dir[spec].first
+        return nil  unless template
+
+        ext      = File.extname(template)[1..-1].to_sym
+        options  = settings.send(ext).merge(options)  if settings.respond_to?(ext)
+
+        eng = Tilt[ext]  or raise "Template engine not found: #{ext}"
+        [ template, eng ]
+      }
+
+      t = @template_cache.fetch templates, options do
+        template, engine = [*templates].inject(nil) do |e, t|
+          e ||= get_engine[t]
+        end
+
+        raise Errno::ENOENT.new(templates.inspect)  unless template
+
+        engine.new(template, 0, options)
+      end
+
+      if t
+        out = t.render(self, locals, &block)
+
+        if @layout
+          layout, @layout = @layout, nil
+          out = show(layout, :layout => false) { out }
+        end
+
+        out
+      end
+    end
+  end
+end
+

data/lib/aura/seeder.rb

@@ -0,0 +1,38 @@
+# Sinatra plugin: Seeder (Aura)
+# To be refactored--this sucks
+module Aura::Seeder
+  def self.registered(app)
+    app.extend ClassMethods
+  end
+
+  module ClassMethods
+    def flush!(&blk)
+      blk = lambda { |*a| }  unless block_given?
+
+      tables = self.database.tables
+
+      tables.each do |table|
+        blk.call(:drop_table, table)
+        self.database.drop_table table
+      end
+    end
+
+    def seed(type=nil, &blk)
+      blk = lambda { |*a| }  unless block_given?
+
+      Aura.models.each { |m|
+        blk.call :seed, m.title_plural
+        m.seed(type, &blk)
+      }
+    end
+
+    def seed!(type=nil, &blk)
+      blk = lambda { |*a| }  unless block_given?
+
+      Aura.models.each { |m|
+        blk.call :seed, m.title_plural
+        m.seed!(type, &blk)
+      }
+    end
+  end
+end