aura 0.0.1.pre10

data/lib/aura/slugs.rb

@@ -0,0 +1,87 @@
+class Aura
+  module Slugs
+    extend self
+
+    # @group Module functions
+
+    # Finds a record from a path.
+    #
+    # Please use {Aura.find}.
+    #
+    def find(path)
+      item = find_by_model_id(path)
+      return item  unless item.nil?
+
+      path = path.split('/').reject { |s| s.empty? }
+      item = nil
+
+      path.each do |slug|
+        item = find_single(slug, item)
+        return nil  if item.nil?
+      end
+
+      item
+    end
+
+    # Finds a record from a model id path in the format */model_name/id*.
+    #
+    # You do not need to call this as this is already done by
+    # {Aura.find}.
+    #
+    # @example
+    #
+    #   page = Aura.slugs.find_by_model_id('/page/2')
+    #   assert page == Page[2]
+    #
+    def find_by_model_id(path)
+      model_name, id = path.squeeze('/').split('/').compact
+      return nil  if id.nil?
+
+      # Make sure it's numeric
+      id = id.to_i
+      return nil  if id == 0
+
+      model = Aura.models.all.detect { |m| m.class_name == model_name }
+      return nil  if model.nil?
+
+      model[id]
+    end
+
+    # Ensures that a given model is going to be searched by
+    # {Aura.find}.
+    #
+    # This is automatically called by {AuraSluggable}.
+    #
+    # @example
+    #
+    #   # Loading the sluggable plugin does {#register} automatically.
+    #   class MyModel < Aura::Model
+    #     plugin :aura_sluggable
+    #   end
+    #
+    #   item = MyModel.new :slug => 'hello'
+    #   item.save
+    #
+    #   # Now you may search for it.
+    #   assert item == Aura.find('/hello')
+    #
+    def register(model)
+      @models ||= []
+      @models << model  unless @models.include? model
+    end
+
+  protected
+    def find_single(slug, parent=nil)
+      models.each do |model|
+        item = model.get_by_slug(slug, parent)
+        return item  unless item.nil?
+      end
+      nil
+    end
+
+    def models
+      @models ||= []
+    end
+  end
+end
+

data/lib/aura/subtype.rb

@@ -0,0 +1,48 @@
+require 'ostruct'
+
+# Class: Subtype (Aura)
+# A subtype.
+#
+# ## Description
+#    This is an OpenStruct. See {AuraSubtyped} for details.
+#
+# ## Allowed options
+#
+#  * `name`
+#  * `template`
+#  * `parentable`
+#  * `deletable`
+#  * `allowed_subtypes` - Array of symbols of subtypes permitted for its children
+#
+class Aura
+class Subtype < OpenStruct
+  def parentable
+    r = @table[:parentable]; r.nil? ? true : r
+  end
+
+  alias parentable? parentable
+
+  def deletable
+    r = @table[:deletable]; r.nil? ? true : r
+  end
+
+  alias deletable? deletable
+
+  def to_s
+    name
+  end
+
+  def name
+    @table[:name].to_s
+  end
+
+  def template
+    @table[:template] || 'show'
+  end
+
+  def _id
+    # Alias for #id for 1.8.6 compatibility
+    @table[:id]
+  end
+end
+end

data/lib/aura/tasks.rb

@@ -0,0 +1,24 @@
+# Module: Tasks (Aura)
+# Rake tasks loader.
+#
+# #### Loading Rake tasks
+# Put {Aura::Tasks.load!} in your project's `Rakefile`.
+#
+#     # [Rakefile (ruby)]
+#     require 'aura'
+#     Aura::Tasks.load!
+#
+class Aura
+  module Tasks
+    # Class method: load! (Aura::Tasks)
+    # Loads rake tasks.
+    #
+    # ## Description
+    #    Put this in your app's Rakefile. See {Aura::Tasks} for an example.
+    #
+    def self.load!
+      require File.expand_path('../tasks/common.rb', __FILE__)
+      load    File.expand_path('../tasks/db.rake', __FILE__)
+    end
+  end
+end

data/lib/aura/tasks/common.rb

@@ -0,0 +1,17 @@
+class RakeStatus
+  def self.heading(what, status)
+    if what == :run
+      color = 30
+      puts "\033[1;#{color}m$ %s \033[0m" % [status]
+      return
+    end
+    puts "* %s" % [status]
+  end
+
+  def self.print(what, status)
+    color = 32
+    color = 31  if what == :error
+    what = ""  if what == :info
+    puts "\033[1;#{color}m  %-14s\033[0m %s" % [what, status]
+  end
+end

data/lib/aura/tasks/db.rake

@@ -0,0 +1,54 @@
+namespace :db do
+  desc "Clears the database (no undo!)"
+  task :flush do
+    require ENV['APP_FILE']
+    RakeStatus.heading :info, "Clearing the database..."
+    Main.flush! { |*a| RakeStatus.print(*a) }
+    Main.restart!
+  end
+
+  desc "Load sample values."
+  task :sample do
+    require ENV['APP_FILE']
+    RakeStatus.heading :info, "Loading sample values..."
+    Main.seed!(:sample) { |*a| RakeStatus.print(*a) }
+    Main.restart!
+  end
+
+  desc "Dumps seed."
+  task :dump do
+    require ENV['APP_FILE']
+
+    RakeStatus.heading :info, "Working..."
+    output = Aura.db_dump_yaml
+
+    RakeStatus.heading :info, "Writing to config/seed.yml..."
+    File.open("config/seed.yml", 'w') { |f| f.write output }
+
+    puts ""
+    puts "Done."
+    puts ""
+    puts "The next time your app starts with a blank database, it will"
+    puts "load the data you have now. You can also load it manually"
+    puts "with rake db:load."
+    puts ""
+    puts "To disable this, remove the config/seed.yml file."
+    puts ""
+  end
+
+  desc "Loads seed."
+  task :load do
+    require ENV['APP_FILE']
+    RakeStatus.heading :info, "Clearing the database..."
+    Main.flush! { |*a| RakeStatus.print(*a) }
+    RakeStatus.heading :info, "Loading data from config/seed.yml..."
+    seed_file = Main.approot('config/seed.yml')
+    Aura.db_restore YAML::load_file(seed_file)
+    Main.restart!
+  end
+end
+
+task :default do
+  exec 'rake -s -T'
+end
+

data/lib/aura/utils.rb

@@ -0,0 +1,81 @@
+# Module: Utils (Aura)
+# Miscellaneous utilities.
+#
+class Aura
+  module Utils
+    extend self
+
+    # Method: query_string (Aura::Utils)
+    # Converts a hash into a query string.
+    #
+    # ## Usage
+    #     query_string(hash)
+    #
+    # ## Example
+    #     query_string(:q => "peanuts", :page => 2)
+    #     #=> q=peanuts&page=2
+    #
+    #     query_string(:fruits => %w[apple banana])
+    #     #=> q[]=apple&q[]=banana
+    #
+    def query_string(hash)
+      hash.inject([]) { |arr, (key, value)|
+        if value.is_a?(Array)
+          value.each do |e|
+            arr << key_value("#{key}[]", e)
+          end
+          arr
+        elsif value.is_a?(Hash)
+          value.each do |namespace, deeper|
+            arr << key_value("#{key}[#{namespace}]", deeper)
+          end
+          arr
+        else
+          arr << key_value(key, value)
+        end
+      }.join('&')
+    end
+
+    # Method: key_value (Aura::Utils)
+    # Converts two strings into a key value pair.
+    #
+    # ## Example
+    #     key_value('q', 'peanuts')
+    #     #=> q=peanuts
+    #
+    def key_value(k, v)
+      require 'cgi'
+      '%s=%s' % [CGI.escape(k.to_s), URI.escape(v.to_s)]
+    end
+
+    # Method: underscorize (Aura::Utils)
+    # Underscorizes a class's name.
+    #
+    # ## Example
+    #     underscorize(Sequel::Plugins::AuraSluggable)
+    #     #=> 'aura_sluggable'
+    #
+    def underscorize(klass)
+      klass.to_s.split('::').last.scan(/[A-Z][a-z0-9]*/).map { |s| s.downcase }.join('_')
+    end
+
+    # Method: in_dir? (Aura::Utils)
+    # Usage:  Utils.in_dir?(file, dir)
+    #
+    # Checks if a given `file` is inside `dir`.
+    #
+    def in_dir?(file, dir)
+      return false  unless File.exists?(file)
+      return false  unless File.directory?(dir)
+
+      node = File.dirname(file)
+
+      while true
+        parent = File.join(node, '..')
+        return false  if File.identical?(parent, node)
+        return true   if File.identical?(node, dir)
+        node = parent
+      end
+    end
+  end
+end

data/lib/aura/version.rb

@@ -0,0 +1,25 @@
+class Aura
+  # Class method: version (Aura)
+  # Returns the current version.
+  #
+  # ## Example
+  #    Aura.version  #=> "0.5.2"
+  #
+  def self.version
+    "0.0.1.pre10"
+  end
+  
+  # Class method: prerelease? (Aura)
+  # Checks if the Aura version is a prerelease.
+  #
+  # ## Example
+  #    Aura.version      #=> "0.5.2"
+  #    Aura.prerelease?  #=> false
+  #
+  #    Aura.version      #=> "0.6.0.pre4"
+  #    Aura.prerelease?  #=> true
+  #
+  def self.prerelease?
+    version.count('.') > 2
+  end
+end

data/lib/core/hasharray.rb

@@ -0,0 +1,65 @@
+# Class: HashArray
+# A stopgap solution to Ruby 1.8's lack of ordered hashes.
+#
+# A HashArray, for all intents and purposes, acts like an array. However, the
+# common stuff are overloaded to work with hashes.
+#
+# ## Basic usage
+#
+# #### Creating
+# You can create a HashArray by passing it an array.
+#
+#     dict = HashArray.new([
+#       { :good_morning => "Bonjour" },
+#       { :goodbye      => "Au revoir" },
+#       { :good_evening => "Bon nuit" }
+#     ])
+#
+# #### Converting
+# You may also use it like so:
+#
+#     letters = [ { :a => "Aye"}, { :b => "Bee" } ].to_hash_array
+#
+# #### Iterating
+# Now you can use the typical enumerator functions:
+#
+#     dict.each do |(key, value)|
+#       puts "#{key} is #{value}"
+#     end
+#
+#     #=> :good_morning is "Bonjour"
+#     #   :goodbye is "Au revoir"
+#     #   :good_evening is "Bon nuit"
+#
+class HashArray < Array
+  # Works like Hash#each.
+  #
+  # By extension, methods that rely on #each (like #inject) will work
+  # as intended.
+  #
+  def each(&block)
+    super { |hash| yield hash.to_a.flatten }
+  end
+
+  # Works like Hash#map.
+  def map(&block)
+    super { |hash| yield hash.to_a.flatten }
+  end
+
+  # Works like Hash#values.
+  def values
+    inject([]) { |a, (k, v)| a << v; a }
+  end
+
+  # Returns everything as a hash.
+  def to_hash
+    inject({}) { |hash, (k, v)| hash[k] = v; hash }
+  end
+end
+
+class Array
+  # Transforms a given array of hashes into a HashArray.
+  def to_hash_array
+    HashArray.new self
+  end
+end

data/lib/core/object_ext.rb

@@ -0,0 +1,9 @@
+class Object
+  def try(meth, *a)
+    send(meth, *a)  if respond_to?(meth)
+  end
+
+  def tap
+    yield self; self
+  end
+end

data/lib/sequel/plugins/aura_custom.rb

@@ -0,0 +1,16 @@
+module Sequel
+module Plugins
+module AuraCustom
+  module InstanceMethods
+    def custom
+      @values[:custom]
+    end
+
+    def custom=(hash)
+      @values[:custom] ||= Hash.new
+      @values[:custom] = @values[:custom].merge(hash)
+    end
+  end
+end
+end
+end

data/lib/sequel/plugins/aura_editable.rb

@@ -0,0 +1,39 @@
+# Sequel plugin: AuraEditable
+# For things that you can edit in the admin panel.
+#
+# ## Description
+#    Use this plugin in you want your model editable.
+#
+# #### How to use
+# Use `plugin :aura_editable`.
+#
+#     class Book < Sequel::Model
+#       plugin :aura_editable
+#     end
+#
+module Sequel
+  module Plugins
+    module AuraEditable
+      module InstanceMethods
+        def editable?
+          true
+        end
+      end
+
+      module ClassMethods
+        def editable?
+          true
+        end
+
+        def form(type=:edit, &block)
+          @forms ||= Hash.new
+          return @forms[type]  unless block_given?
+
+          @forms[type] = ::Terra::Form.new
+          @forms[type].root_name 'editor'
+          @forms[type].configure &block
+        end
+      end
+    end
+  end
+end