aura 0.0.1.pre10

data/lib/terra/fieldset.rb

@@ -0,0 +1,93 @@
+# Class: Fieldset (Terra)
+# A fieldset.
+#
+# ## Description
+# See {Terra} for information on how to use the form builder.
+#
+module Terra
+  class Fieldset
+    def initialize(form, id, name=nil, options={})
+      @form   = form
+      @id     = id
+      @name   = name
+      @fields = Array.new
+    end
+
+    # Method: field (Terra::Fieldset)
+    # Add (or get?) a field.
+    #
+    def field(type, id=nil, title=nil, options={})
+      return @fields.detect { |f| f.name == type }  if id.nil?
+      @fields << Field.create(self, type, id, title, options)
+    end
+
+    # Attribute: name (Terra::Fieldset)
+    # The name of the field.
+    #
+    # ## Description
+    #    This is also callable as `#to_s`.
+    #
+    def name
+      @name || @id.to_s.capitalize
+    end
+
+    alias to_s name
+
+    def clear
+      @fields = Array.new
+    end
+
+    def inspect
+      "#<Fieldset #{@id.inspect} [fields: #{fields.inspect}]>"
+    end
+
+    # Method: default? (Terra::Fieldset)
+    # Returns true if the fieldset is the default fieldset of the form.
+    def default?
+      @id == :default
+    end
+
+    # Method: to_html (Terra::Fieldset)
+    # Returns the HTML code for the entire fieldset.
+    #
+    # ## Description
+    # This calls puts together {Terra::Fieldset#legend_html} and
+    # {Terra::Fieldset#fields_html} inside a `<fieldset>` tag.
+    #
+    def to_html(item=nil)
+      [ "<fieldset name='#{id}'>",
+        legend_html, fields_html(item),
+        "</fieldset>" ].compact.join("\n")
+    end
+
+    # Method: fields_html (Terra::Fieldset)
+    # Returns the HTML code for the fields in the fieldset.
+    def fields_html(item=nil)
+      fields.map { |f| f.to_html(item.try(f.name.to_sym), item) }.join("\n")
+    end
+
+    # Method: legend_html (Terra::Fieldset)
+    # Returns the HTML code for the fields in the fieldset.
+    def legend_html
+      "<h3 class='legend'>#{self.to_s}</h3>"  unless default?
+    end
+
+    # Attribute: fields (Terra::Fieldset)
+    # The list of fields.
+    attr_reader :fields
+
+    # Attribute: id (Terra::Fieldset)
+    # The symbol name of the field.
+    attr_reader :id
+
+    # Attribute: form (Terra::Fieldset)
+    # The parent Form.
+    attr_reader :form
+
+    # Shortcuts for text, textarea, password..
+    def method_missing(meth, *args, &blk)
+      super  unless Fields.all.include?(meth)
+      field meth, *args
+    end
+  end
+end

data/lib/terra/form.rb

@@ -0,0 +1,111 @@
+# Class: Form (Terra)
+# Terra is an HTML form generator.
+#
+# ## Description
+# See {Terra} for information on how to use the form builder.
+#
+module Terra
+  class Form
+    def initialize
+      @fieldsets = Hash.new
+      fieldset(:default) { }
+    end
+
+    # Method: configure (Terra::Form)
+    # Usage:  form.configure { ... }
+    #
+    # Adds fields to a form.
+    #
+    def configure(*a, &blk)
+      instance_eval *a, &blk
+      self
+    end
+
+    # Method: fieldset (Terra::Form)
+    # Usage:  fieldset(id, name=nil, options={}, &block)
+    #
+    # Defines a fieldset.
+    #
+    def fieldset(id, name=nil, options={}, &block)
+      return @fieldsets[id]  unless block_given?
+
+      @fieldsets[id] ||= Fieldset.new(self, id, name, options)
+      @fieldsets[id].clear
+      @fieldsets[id].instance_eval &block
+    end
+
+    # Method: field (Terra::Form)
+    # Usage:  field name, options
+    # Defines a field.
+    #
+    # See {Terra::Fieldset.field} for details on how to use this.
+    #
+    def field(name, *a)
+      if a.empty?
+        set = fieldsets.detect { |set| set.field(name) }
+        set.field(name)  unless set.nil?
+      else
+        fieldset(:default).field name, *a
+      end
+    end
+
+    def method_missing(meth, *args, &blk)
+      super  unless Fields.all.include?(meth)
+      field meth, *args
+    end
+
+    # Method: name_root (Terra::Form)
+    # Usage:  name_root str
+    #
+    # Changes the root name to the given string.
+    #
+    # ## Description
+    # The root name is the prefix for the `name` attributes.
+    #
+    #  * When invoked with a string, it changes the root name.
+    #    Example: (`root_name 'editor'` => `<input name='editor[name]'>`)
+    #
+    #  * When invoked with an array, it changes the root names.
+    #    Example: (`root_name %w(form user)` => `<input name='form[user][name]'>`)
+    #
+    #  * When invoked without arguments, it returns the root name.
+    #
+    def root_name(str=nil)
+      @root_name ||= Array.new
+
+      if str.is_a?(Array)
+        @root_name = str
+      elsif !str.nil?
+        @root_name = [str]
+      end
+
+      @root_name
+    end
+
+    # Method: name_for (Terra::Form)
+    # Usage:  name_for(string)
+    #
+    # Returns the name for a given field name.
+    #
+    # ##  Example
+    #     root_name 'editor'
+    #     name_for('email')    #=> 'editor[email]'
+    #
+    def name_for(str)
+      names = (root_name + [*str])
+      one = names[0]
+      two = names[1..-1].map { |s| "[#{s}]" }.join('')
+
+      "#{one}#{two}"
+    end
+
+    # Method: fieldsets (Terra::Form)
+    # Usage:  fieldsets
+    #
+    # Returns an array of fieldsets.
+    #
+    def fieldsets
+      @fieldsets.values.sort_by { |fs| fs.to_s }
+    end
+  end
+end

data/manual/configuration.md

@@ -0,0 +1,42 @@
+title: Configuration
+page_type: section
+--
+
+## Application configuration
+
+#### Configuration
+Configuration is done by Sinatra's app configuration on `Main`.
+
+    Main.set :host, "Heroku"
+    Main.get(:host)             #=> "Heroku"
+    Main.host                   #=> "Heroku"
+    Main.host?                  #=> true
+
+#### The config folder
+Configuration is usually stored in your app's `config/` folder as
+plain `.rb` files.
+
+    [config/database.rb (ruby)]
+    Main.configure do |m|
+      m.set :database_url, "sqlite://db/database.db"
+    end
+
+    # Just for the test environment
+    Main.configure(:test) do |m|
+      m.set :database_url, "sqlite://db/test.db"
+    end
+
+## Dynamic configuration
+
+Aura has a small settings system for user-settable things that is separate from above.
+All of these are stored in the database.
+
+#### Using set and get
+Use `Aura.set` and `Aura.get`. The value supports strings, integers, arrays
+and hashes. (They are stored as YAML in the database.)
+
+    Aura.set "site.name", "Jenny's Diary"
+    Aura.set "site.description", "Thoughts of a 17-year-old"
+
+    Aura.get("site.name")
+

data/manual/extensions.md

@@ -0,0 +1,45 @@
+title: Extensions
+page_type: section
+--
+(TODO: Update this to be easier to read)
+
+You may package your entire `app/` folder as an extension by copying it into
+`extensions/my_extension/`. You may then redistribute it for using in other
+Aura apps.
+
+(All files and folders above are optional. Just use what you need!)
+
+ - Each extension can have `models/`, `routes/` and `helpers/` and
+   all Ruby files inside them are autoloaded.
+ - You may also have a YAML file called `info.yml`, which hosts metadata
+   about your extension.
+ - The directories described above are all optional.
+
+## Extensions
+
+Custom extensions go into `extensions/<extension_name>/`.
+Here's what happens when the extension is loaded:
+
+- After everything is set up, `extension_name.rb` is loaded.
+- `init.rb` is called after all extensions are loaded.
+- All Ruby files are loaded from `init/`, `models/`, `helpers/`, and `routes/`.
+
+## Metadata
+
+#### Defining metadata
+Use `info.yml` in your extension.
+
+    [extensions/twitter/info.yml (yaml)]
+    name: Twitter integration
+    author: Rico Sta. Cruz
+    description: Shows twitter feeds in the home page.
+
+## Loading extensions
+
+#### Loading extensions
+Edit `config/extensions.rb` of your app.
+
+    [config/extensions.rb (ruby)]
+    Main.configure do |m|
+      m.set :additional_extensions, %w(default_theme)
+    end

data/manual/files.md

@@ -0,0 +1,70 @@
+title: File structure
+page_type: section
+--
+This is what your default project looks like when you use `aura new`.
+
+#### Structure
+Your project looks like this. Most it's guts will be in `app/`.
+
+    [(text)]
+    project/
+     |- app/
+     |  |- css/          #  CSS files
+     |  |- js/           #  JS files
+     |  |
+     |  |- models/       #  Models
+     |  |- helpers/      #  Helpers
+     |  |- routes/       #  Sinatra Routes
+     |  |- views/        #  View files
+     |  |
+     |  |- init/         #  Ruby files to be ran on app init
+     |  |- migrations/   #  Data migration files
+     |
+     |- config/          #  User config
+     |- public/          #  Public files
+     |
+     |- config.ru
+     |- Gemfile
+     |- init.rb
+     |- Rakefile
+     |- README.md
+
+## app/
+
+#### app/css/
+This contains your CSS files. Anything here will be accessible via `/css`.
+
+    app/css/style.css
+    app/css/theme/screen.sass
+    app/css/theme/print.css
+
+#### app/js/
+JavaScript files. They will be accessible via `/js`.
+
+    app/js/application.js
+
+#### app/models/
+Models here. All Ruby files here will be loaded on app init.
+
+    app/models/page.rb
+    app/models/book.rb
+    app/models/movie.rb
+
+#### app/helpers/
+Helpers here. All Ruby files here will be loaded on app init.
+
+    app/helpers/page_helpers.rb
+    app/helpers/time_helpers.rb
+
+#### app/routes/
+Sinatra routes here. All Ruby files here will be loaded on app init.
+
+    app/routes/store.rb
+    app/routes/background.rb
+
+    # Example:
+    class Main
+      get '/foo' do
+        show :foo
+      end
+    end

data/manual/helpers.md

@@ -0,0 +1,39 @@
+title: Helpers
+page_type: section
+--
+Helpers are defined and used exactly as how you would in Sinatra.
+
+#### Defining helpers
+Create a file in the `app/helpers/` folder of your app.
+
+    [app/helpers/my_helpers.rb (rb)]
+    class Main
+      module MyHelpers
+        def who_is_awesome
+          "You are!"
+        end
+      end
+
+      helpers MyHelpers
+    end
+
+#### Using helpers in views
+You can then use it in views.
+
+    [app/views/index.haml (haml)]
+    %div.question
+      Who is awesome?
+
+    %div.answer
+      = who_is_awesome
+
+#### Using helpers in routes
+Yeah, you can.
+
+    [app/routes/foo.rb (rb)]
+    class Main
+      get '/who_is_awesome' do
+        @who = who_is_awesome
+        show :index
+      end
+    end

data/manual/index.md

@@ -0,0 +1,65 @@
+title: Aura
+--
+Aura lets you build CMS-powered sites in Ruby.
+
+#### Installation
+Assuming you have Ruby installed (at least 1.8.7), just install the gem.
+
+    $ gem install aura --pre
+
+    $ aura
+
+Getting started
+---------------
+
+#### Start a new project
+Start a new project using [aura new](aura_new.html). This creates a folder with a simple bare-bone Aura project.
+
+    $ aura new myproject
+       create  myproject/
+       create  myproject/config.ru
+       create  myproject/init.rb
+       create  myproject/app/
+       create  myproject/app/models/
+       create  myproject/app/models/page.rb.example
+       ...
+
+#### Install the needed gems
+Using Bundler, this is pretty easy.
+
+    $ cd myproject/
+    $ bundle install
+      ...
+
+#### Configure a database (optional)
+Sequel uses Sqlite by default. To point it to another database, edit the `config/database.rb.example` file.
+
+    [config/database.rb (rb)]
+    Main.configure do |m|
+      m.set :database_url, "mysql://root:pickles@localhost/db_name"
+    end
+
+
+#### Start it up
+Your app is a Rack app. Visit *http://localhost:4833* to see it. (Default user is `test@sinefunc.com`/`password`)
+
+    $ thin start
+    * Starting server...
+    >> Thin web server (v1.2.11 codename Bat-Shit Crazy)
+    >> Maximum connections set to 1024
+    >> Listening on 0.0.0.0:4833, CTRL+C to stop
+
+## Features
+
+* **For designers** and site builders:
+  * Be in full control of markup, and write in whatever template language you're comfortable with.
+  * Build custom page types that will the custom fields you need with the template you define.
+
+* **For site owners:**
+  * Use a CMS with an interface you will love, rather than put up with.
+
+* **For developers:**
+  * Easy-to-extend with a simple extension system.
+  * Built on top of [Sinatra](http://sinatrarb.com), a tried and tested microframework.
+
+[Source code on GitHub](http://github.com/buildwithaura/aura "Source code")