aura 0.0.1.pre10

data/lib/aura/admin.rb

@@ -0,0 +1,41 @@
+# Module: Admin (Aura)
+# Admin stuff.
+#
+# ## Description
+# This is accessible via {Aura.admin}.
+#
+class Aura
+  module Admin
+    extend self
+
+    # Class method: menu (Aura::Admin)
+    # Usage: Aura.admin.menu
+    #
+    # Returns admin menu items.
+    #
+    def menu
+      @menu ||= Menu.new
+    end
+
+    # Class method: css (Aura::Admin)
+    # Usage: Aura.admin.css
+    #
+    # Returns the list of CSS files.
+    #
+    # ## Description
+    #    This allows you to customize the admin interface by adding your
+    #    own CSS files.
+    #
+    # #### Example
+    # This example adds a CSS file to the admin. This should be in your
+    # project's `app/init/`.
+    #
+    #     [/app/init/admin.rb (rb)]
+    #     Aura.admin.css << {:href => '/css/admin-ext.css', :media => 'screen'}
+    #
+    def css
+      @css ||= Array.new([ { :href => '/css/admin.css', :media => 'screen' } ])
+    end
+  end
+end
+

data/lib/aura/app.rb

@@ -0,0 +1,4 @@
+# Summon Aura::App aka Main
+require File.expand_path('../../aura', __FILE__)
+require Aura.gem_root('app/main')
+Aura::App

data/lib/aura/cli.rb

@@ -0,0 +1,19 @@
+require 'shake'
+
+# Class: CLI (Aura)
+# The CLI runner.
+#
+# ## Description
+#    This is a runner based on the [Shake 
+#    gem](http://github.com/rstacruz/shake).
+#
+class Aura
+  class CLI < Shake
+    autoload :Helpers, File.expand_path('../cli/helpers', __FILE__)
+
+    include Shake::Defaults
+    extend Helpers
+  end
+end
+
+require File.expand_path('../cli/base', __FILE__)

data/lib/aura/cli/base.rb

@@ -0,0 +1,89 @@
+class Aura::CLI
+  # TODO This looks stupid, refactor later
+  task :new do
+    require 'fileutils'
+    require 'aura/version'
+
+    if params.empty?
+      err "Usage: #{$0} new PROJECT_NAME"
+      pass
+    end
+
+    name = params.first
+    path = File.join(ENV['AURA_ROOT'], 'default')
+
+    if File.exists?(name)
+      err "That path already exists."
+      pass
+    end
+
+    FileUtils.mkdir name
+
+    # Copy everything over
+    Dir["#{path}/**/{.*,*}"].sort.each do |from|
+      base   = from.gsub(path, '')
+      fn     = File.basename(from)
+      target = File.join(name, base)
+
+      next if ['Gemfile.lock', '.rvmrc'].include?(fn)
+
+      if File.file?(from)
+        FileUtils.mkdir_p File.dirname(target)
+        FileUtils.cp from, target
+      end
+    end
+
+    # Edit the Gemfile
+    gemfile = File.read(File.join(name, 'Gemfile'))
+    version = Aura.prerelease? ? Aura.version : "~> #{Aura.version}"
+    gemfile.gsub!("AURA_GEM_VERSION", version)
+
+    File.open(File.join(name, 'Gemfile'), 'w') { |f| f.write gemfile }
+
+    show_tree name
+
+    puts ""
+    puts "Done! Get started now:"
+    puts ""
+    puts "  $ cd #{name}"
+    puts "  $ bundle install"
+    puts ""
+    puts "Then start it as a Rack app."
+    puts ""
+    puts "  $ rackup"
+    puts ""
+  end
+
+  task.description = "Starts a new project"
+  task.usage = "new NAME"
+
+  task :help do
+    err "Usage: #{executable} <command>"
+    err
+    err "Options:"
+    err "  -v, [--version]      Shows the Aura version number and quits"
+    err
+    err "Commands:"
+    tasks.each { |name, task| err "  %-20s %s" % [ name, task.description ] }
+    err
+    err "Description:"
+    err "  The '#{executable} new' command creates a new Aura application with"
+    err "  the default directory structure."
+    err
+    err "Example:"
+    err "  # This generates a new project in ./my_project."
+    err "  $ #{executable} new my_project"
+    err
+  end
+  task.description = "Shows this help screen"
+
+  def self.run(*a)
+    if %w(-v --version).include?(a.join(' '))
+      require 'aura/version'
+
+      puts "Aura #{Aura.version}"
+    else
+      super *a
+    end
+  end
+end

data/lib/aura/cli/helpers.rb

@@ -0,0 +1,32 @@
+module Aura::CLI::Helpers
+  def color(what, n=32)
+    "\033[0;#{n}m#{what}\033[0;m"
+  end
+
+  def status(what, message)
+    puts "%s  %s" % [ color("%12s" % [what], 32), message ]
+  end
+
+  def show_tree(path, what=:create)
+    explore = lambda { |*a| #path, depth=0
+      path, depth = a
+      depth ||= 0
+
+      files = Dir["#{path}/{.*,*}"]
+
+      dirs  = files.select { |f| File.directory?(f) && !%w(. ..).include?(File.basename(f)) }
+      files = files.select { |f| File.file?(f) }
+
+      dirname = File.basename(path)
+      status :create, path + '/'
+
+      files.each { |f|
+        status '', (path + '/' + color(File.basename(f), 30))
+      }
+
+      dirs.each  { |d| explore[d, depth+1] }
+    }
+
+    explore[path]
+  end
+end

data/lib/aura/editor.rb

@@ -0,0 +1,30 @@
+# Module: Editor (Aura)
+# Editor stuff.
+#
+# ## Description
+# This is accessible via {Aura.editor}.
+#
+class Aura
+  module Editor
+    # Class method: roots (Aura::Editor)
+    # Returns the root nodes to be shown on the editor sidebar.
+    #
+    # ## Usage
+    #     Aura.editor.roots
+    #
+    # ## Description
+    #    Returns instances of `Sequel::Model` as an array of hashes 
+    #    (HashArray).
+    #
+    def roots
+      models = Aura.models.all.select { |m| m.try(:editable?) }
+
+      models.inject(HashArray.new) do |hash, model|
+        hash << { model => model.roots }
+        hash
+      end
+    end
+
+    module_function :roots
+  end
+end

data/lib/aura/extension.rb

@@ -0,0 +1,189 @@
+require 'yaml'
+require 'ostruct'
+
+class Aura
+  ExtensionNotFound = Class.new(StandardError)
+
+  # Class: Extension (Aura)
+  # A class representing an extension in Aura.
+  # 
+  # #### Lookup
+  # Get an Extension instance by passing an extension name.
+  #
+  #     ext = Aura::Extension['base']
+  #
+  # #### Loading extensions
+  #
+  #     ext.active?          #=> false (probably)
+  #     ext.load!
+  #     ext.active?          #=> true
+  #
+  # #### Getting extension info
+  # These are loaded from an extension's YAML file.
+  #
+  #     ext.info             #=> #<OStruct>
+  #     ext.info.author
+  #
+  # #### Getting paths
+  # Use {Aura::Extension#path}.
+  #
+  #     ext.path             #=> ~/aura/extensions/base
+  #     ext.path('init.rb')  #=> ~/aura/extensions/base/init.rb
+  #
+  #     Aura::Extension.active  # Active extensions (Array of #<Extension>)
+  #     Aura::Extension.all     # All extensions (Array of #<Extension>)
+  #
+  # #### Manual instanciation
+  # You can pass a path to the constructor.
+  #
+  #     ext = Aura::Extension.new('/path/to/ext')
+  #
+  class Extension
+    attr_reader :name
+
+    # Returns an extension with the given ext name/path.
+    # Returns nil if it's not found.
+    def self.[](name)
+      self.new(name)
+    rescue ExtensionNotFound
+      nil
+    end
+
+    # Returns an extension with the given ext name/path.
+    # Raises ExtensionNotFound if it's not found.
+    def initialize(name)
+      @path, @name = nil
+
+      if File.directory?(name)
+        @path, @name = name, File.basename(name)
+
+      elsif Main.respond_to?(:extensions_path)
+        @name = name
+        [Main.extensions_path].flatten.each do |dir|
+          next  unless @path.nil?
+          @path = File.join(dir, name)
+          @path = nil  unless File.directory?(@path)
+        end
+      end
+
+      raise ExtensionNotFound  unless File.directory?(@path.to_s)
+    end
+
+    # Method: path (Aura::Extension)
+    # Returns the path of the extension.
+    #
+    # ## Description
+    #    If arguments are given, they are joined into the extension's path.
+    #    nil will be returned if the path does not exist.
+    #
+    # ## Example
+    #
+    #     Aura::Extension['base'].path             #=> ~/aura/extensions/base
+    #     Aura::Extension['base'].path('init.rb')  #=> ~/aura/extensions/base/init.rb
+    #
+    def path(*a)
+      return @path  if a.empty?
+      ret = File.join(@path, *(a.map { |arg| arg.to_s }))
+      ret = File.expand_path(ret) # Try to fix some heroku issues (?)
+      File.exists?(ret) ? ret : nil
+    end
+
+    # Method: load! (Aura::Extension)
+    # Loads an extension.
+    #
+    def load!
+      # TODO Don't load a module that's already loaded
+
+      # Load the main file
+      fname = path("#{name}.rb")
+      require fname  unless fname.nil?
+
+      # Load the basic things usually autoloaded.
+      Dir["#{@path}/{init,models,routes,helpers}/*.rb"].each { |f| require f }
+
+      # Ensure public/ works
+      public_path = path(:public)
+      Main.add_public(public_path)  unless public_path.nil?
+
+      # Add the view path, if it has
+      if path(:views)
+        paths = [path(:views)]
+        paths += Main.multi_views  if Main.respond_to?(:multi_views)
+        Main.set :multi_views, paths
+      end
+    end
+
+    # Method: active? (Aura::Extension)
+    # Determines if the given extension is currently active in the config.
+    #
+    def active?
+      self.class.active_names.include?(@name)
+    end
+
+    # Initializes an extension after it's already loaded.
+    # This is done after all extensions are loaded.
+    #
+    def init
+      fname = path("init.rb")
+      load fname  unless fname.nil?
+    end
+
+    # Method: info (Aura::Extension)
+    # Returns an OpenStruct of information on the extension.
+    #
+    # ##  Example
+    #
+    #     Aura::Extension['default_theme'].info
+    #     Aura::Extension['default_theme'].info.author
+    #
+    def info
+      return @info  unless @info.nil?
+
+      fname = path('info.yml')
+      return nil  if fname.nil?
+
+      @info ||= OpenStruct.new(YAML::load_file(fname).merge({:path => @path}))
+    end
+
+    alias to_s name
+
+    # Class method: active (Aura::Extension)
+    # Returns all the extensions that are loaded in the config.
+    #
+    # ## See also
+    #  * {Aura::Extension.all}
+    #
+    def self.active
+      self.active_names.map { |ext| self[ext] }.compact
+    end
+
+    # Class method: active_names (Aura::Extension)
+    # Returns all names of the extensions that are loaded in the config.
+    #
+    # ## Description
+    #    Returns an array of strings.
+    #
+    def self.active_names
+      exts  = Array.new
+      exts += Main.additional_extensions  if Main.respond_to?(:additional_extensions)
+      exts
+    end
+
+    # Class method: all (Aura::Extension)
+    # Returns all extensions (not just the ones loaded).
+    #
+    # ## Description
+    #    Returns an array of {Aura::Extension} instances.
+    #
+    # ## See also
+    #  * {Aura::Extension.active}
+    #
+    def self.all
+      return @all  unless @all.nil?
+
+      paths = Main.extensions_path.map { |path| Dir["#{path}/*"] }.flatten
+
+      @all ||= paths.uniq.map { |path| self.new(path) }.compact
+    end
+  end
+end

data/lib/aura/files.rb

@@ -0,0 +1,38 @@
+# Module: Files (Aura)
+# Files stuff.
+#
+# ## Description
+# This is accessible via {Aura.files}.
+#
+# These functions checks for files in:
+#
+#  * Aura's default app stuff (`(aura gem)/app/`)
+#  * Each of the active extensions's folders (`(extension)/`)
+#  * Your applications (`(application)/app/`)
+#
+class Aura
+  module Files
+    # Method [] (Aura::Files)
+    # Finds a file's path.
+    #
+    def self.[](fname)
+      try = lambda { |f| f if File.exists?(f) }
+
+      re   = try[Aura.gem_root("app/#{fname}")]
+      Extension.active.each { |e| re ||= try["#{e.path}/#{fname}"] }
+      re ||= try[Aura.root("app/#{fname}")]
+    end
+
+    # Method: glob (Aura::Files)
+    # Finds files with the given spec.
+    #
+    def self.glob(spec)
+      paths = Array.new
+      paths << Aura.gem_root("app/#{spec}")
+      paths += Extension.active.map { |e| "#{e.path}/#{spec}" }
+      paths << Aura.root("app/#{spec}")
+
+      paths.compact.map { |spec| Dir[spec].sort }.flatten.uniq
+    end
+  end
+end