spontaneous 0.2.0.beta1 → 0.2.0.beta2

data/lib/spontaneous/capistrano/deploy.rb

@@ -3,7 +3,7 @@ Capistrano::Configuration.instance(:must_exist).load do
   set :normalize_asset_timestamps, false
 
   set :bundle_cmd,              "bundle"
-  set :bundle_flags,            "--deployment --quiet --binstubs --shebang ruby-local-exec"
+  set :bundle_flags,            "--deployment --quiet --binstubs"
 
   # Remove tmp/pids from list of shared dirs that get symlinked into the release
   set :shared_children,   %w(public/system log)
@@ -19,7 +19,7 @@ Capistrano::Configuration.instance(:must_exist).load do
     end
 
     task :symlink_application do
-      run "cd #{release_path} && ln -s `bundle show spontaneous`/application public/.spontaneous"
+      run "cd #{release_path} && ln -s `#{fetch(:bundle_cmd, 'bundle')} show spontaneous`/application public/.spontaneous"
     end
 
     # Capistrano automatically creates a tmp directory - I don't like that

data/lib/spontaneous/capistrano/sync.rb

@@ -53,7 +53,7 @@ Capistrano::Configuration.instance(:must_exist).load do
         dumper.dump(dump_file)
         remote_dump_file = File.join(deploy_to, dumpfilename)
         top.upload(dump_file, remote_dump_file)
-        run %(cd #{current_path} && bundle exec rake db:load dumpfile=#{remote_dump_file} )
+        run %(cd #{current_path} && #{fetch(:bundle_cmd, 'bundle')} exec rake db:load dumpfile=#{remote_dump_file} )
       end
     end
 

data/lib/spontaneous/cli/init.rb

@@ -16,6 +16,7 @@ module Spontaneous::Cli
     method_option :user, :type => :string, :default => nil, :aliases => "-u", :desc => "Database admin user"
     method_option :password, :type => :string, :default => "", :aliases => "-p", :desc => "Database admin password"
     method_option :account, :type => :hash, :default => {}, :aliases => "-a", :desc => "Details of the root login"
+    method_option :create_user, :type => :boolean, :default => true, :desc => "Enable creation of a root user"
 
     def init
       prepare :init
@@ -35,7 +36,7 @@ module Spontaneous::Cli
       boot!
 
       # Add a root user if this is a new site
-      insert_root_user if ::Spontaneous::Permissions::User.count == 0
+      insert_root_user if (options.create_user && ::Spontaneous::Permissions::User.count == 0)
 
     end
 
@@ -74,6 +75,7 @@ module Spontaneous::Cli
           say "  >> Done"
         rescue => e
           say " >>> Error running migrations on database `#{site_config[:database]}`:\n   > #{e}", :red
+          raise e
         end
       end
     end
@@ -99,18 +101,11 @@ module Spontaneous::Cli
 
     def create_database(connection, config)
       commands = case connection.database_type
-                when :postgres
-                  [
-                    [%(CREATE ROLE "#{config[:user]}" LOGIN PASSWORD '#{config[:password]}'), false],
-                    [%(CREATE DATABASE "#{config[:database]}" WITH TEMPLATE=template0 ENCODING='UTF8' LC_COLLATE='C.UTF-8' LC_CTYPE='C.UTF-8' OWNER="#{config[:user]}"), true]
-                  ]
-                when :mysql
-                  host = config[:host].blank? ? "" : "@#{config[:host]}"
-                  [
-                    ["CREATE DATABASE `#{config[:database]}` CHARACTER SET UTF8", true],
-                    ["GRANT ALL ON `#{config[:database]}`.* TO `#{config[:user]}`#{host} IDENTIFIED BY '#{config[:password]}'", false]
-                  ]
-                end
+                 when :postgres
+                   create_postgres_database_commands(config)
+                 when :mysql
+                   create_mysql_database_commands(config)
+                 end
       commands.each do |command, raise_error|
         begin
           connection.run(command)
@@ -119,5 +114,33 @@ module Spontaneous::Cli
         end
       end
     end
+
+    def create_mysql_database_commands(config)
+      host = config[:host].blank? ? "" : "@#{config[:host]}"
+      cmds = [ ["CREATE DATABASE `#{config[:database]}` CHARACTER SET UTF8", true] ]
+      unless config[:user] == "root"
+        cmds << ["GRANT ALL ON `#{config[:database]}`.* TO `#{config[:user]}`#{host} IDENTIFIED BY '#{config[:password]}'", false]
+      end
+      cmds
+    end
+
+    # On some machines the db creation fails due to incompabilities between the UTF8 encoding
+    # and the configured locale.
+    # You can force a locale for the db by adding LC_COLLATE & LC_CTYPE params
+    # to the CREATE command:
+    #
+    #   LC_COLLATE='C.UTF-8' LC_CTYPE='C.UTF-8'
+    #
+    # but I don't know a good/the best way to determine the most appropriate UTF-8 locale
+    # C.UTF-8 doesn't exist on OS X.
+    def create_postgres_database_commands(config)
+      create_cmd = %(CREATE DATABASE "#{config[:database]}" WITH TEMPLATE=template0 ENCODING='UTF8')
+      cmds = []
+      unless config[:user].blank?
+        create_cmd << %( OWNER="#{config[:user]}")
+        cmds << [%(CREATE ROLE "#{config[:user]}" LOGIN PASSWORD '#{config[:password]}'), false]
+      end
+      cmds << [create_cmd, true]
+    end
   end # Init
 end # Spontaneous::Cli

data/lib/spontaneous/cli/server.rb

@@ -68,7 +68,6 @@ module Spontaneous
         prepare! :server, mode
         Spontaneous::Server.run!(options)
       end
-
     end
   end
 end

data/lib/spontaneous/cli/site.rb

@@ -129,7 +129,8 @@ module Spontaneous
           Spontaneous::Site.publish_all
         end
         # Rescue all errors to feed back to the UI
-      rescue ::Exception => e
+      rescue => e
+        $stderr.puts(e.message)
         send_error_notification(e)
       end
 

data/lib/spontaneous/cli.rb

@@ -33,7 +33,7 @@ module Spontaneous
         if choice and choice <= actions.length and choice > 0
           action = actions[choice - 1]
           begin
-            Spontaneous::Schema.apply(action)
+            Spontaneous.schema.apply(action)
           rescue Spontaneous::SchemaModificationError => error
             fix_schema(error)
           end
@@ -97,11 +97,13 @@ module Spontaneous
 
     class Root < ::Thor
       register Spontaneous::Cli::Console,  "console",  "console",           "Gives you console access to the current site"
+      register Spontaneous::Cli::Console,  "c",  "c",           "Gives you console access to the current site"
       register Spontaneous::Cli::User,     "user",     "user [ACTION]",     "Administer site users"
       register Spontaneous::Cli::Generate, "generate", "generate [OBJECT]", "Generates things"
       register Spontaneous::Cli::Site,     "site",     "site [ACTION]",     "Run site-wide actions"
       register Spontaneous::Cli::Init,     "init",     "init",              "Creates databases and initialises a new Spontaneous site"
       register Spontaneous::Cli::Server,   "server",   "server [ACTION]",   "Launch development server(s)"
+      register Spontaneous::Cli::Server,   "s",   "s [ACTION]",   "Launch development server(s)"
       register Spontaneous::Cli::Media,    "media",    "media [ACTION]",    "Manage site media"
       register Spontaneous::Cli::Sync,     "sync",     "sync [DIRECTION]",  "Sync database and media to and from the production server"
       register Spontaneous::Cli::Migrate,  "migrate",  "migrate",           "Runs Spontaneous migrations"

data/lib/spontaneous/collections/entry_set.rb

@@ -12,17 +12,9 @@ module Spontaneous::Collections
       @store = Hash.new { |hash, key| hash[key] = [] }
       (piece_store || []).each do |data|
         id = data[0]
-        entry = \
-          if data.length == 2
-            page = @owner._pieces.detect { |piece| piece.id == id }
-            if page
-              Spontaneous::PagePiece.new(@owner, page, data[1])
-            else
-              nil
-            end
-          else
-            @owner._pieces.detect { |piece| piece.id == id }
-          end
+        entry = if (content = @owner._pieces.detect { |piece| piece.id == id })
+          content.page? ? Spontaneous::PagePiece.new(@owner, content, data[1]) : content
+        end
         # if the piece/page has been deleted or is invisible
         # then we just want to silently skip it
         if entry
@@ -118,7 +110,7 @@ module Spontaneous::Collections
     end
 
     def ==(set)
-      super or entries == set
+      super || (entries == set)
     end
 
     protected

data/lib/spontaneous/collections/hash_with_fallback.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+
+
+module Spontaneous::Collections
+  class HashWithFallback < Hash
+    def initialize(fallback, use_fallback_proc, obj = nil, &block)
+      use_fallback_proc ||= proc { |val| val.nil? }
+      @fallback, @use_fallback_proc = fallback, use_fallback_proc
+      super(obj, &block)
+    end
+
+    def [](key)
+      val = super
+      if @use_fallback_proc[val]
+         val = @fallback[key]
+      end
+      val
+    end
+  end
+end

data/lib/spontaneous/collections/prototype_set.rb

@@ -32,8 +32,8 @@ module Spontaneous::Collections
       local_order << key unless order.include?(key)
     end
 
-    def key?(key)
-      keys.include?(key.to_sym)
+    def key?(key, inherited = true)
+      keys(inherited).include?(key.to_sym)
     end
 
     alias_method :has_key?, :key?
@@ -86,8 +86,8 @@ module Spontaneous::Collections
       end
     end
 
-    def keys
-      order.map { |name| name }
+    def keys(inherited = true)
+      order(inherited).map { |name| name }
     end
 
     def values
@@ -120,8 +120,9 @@ module Spontaneous::Collections
     end
 
 
-    def order
+    def order(inherited = true)
       return @custom_order if @custom_order
+      return local_order unless inherited
       superset? ? (superset.order + local_order) : local_order
     end
 

data/lib/spontaneous/crypt.rb

@@ -22,7 +22,7 @@ module Spontaneous
         Version.subclasses.sort { |v1, v2| v1.version <=> v2.version }
       end
 
-      def hash(password)
+      def hash_password(password)
         current.create(password)
       end
 
@@ -71,7 +71,7 @@ module Spontaneous
       alias_method :needs_upgrade?, :outdated?
 
       def upgrade
-        Spontaneous::Crypt.hash(@password)
+        Spontaneous::Crypt.hash_password(@password)
       end
 
       def salt

data/lib/spontaneous/data_mapper/content_model/associations.rb

@@ -58,28 +58,20 @@ module Spontaneous
           end
         end
 
-        def has_many(name, opts = {})
-          opts[:association] = :one_to_many
-          opts[:model] ||= self
-          opts[:mapper_method]  = "#{name}_mapper"
+        def has_many_content(name, opts = {})
+          opts[:association]    = :one_to_many
           opts[:dataset_method] = "#{name}_dataset"
           opts[:add_method]     = "add_#{name.to_s.singularize}"
-          opts[:module]       ||= association_method_module
+          mod = opts[:module] ||= association_method_module
 
-          where = opts[:model].respond_to?(:where!) ? :where! : :where
-
-          define_association_method(opts, opts[:mapper_method]) {
-            opts[:model] == model ? self.mapper : opts[:model]
-          }
-          define_association_method(opts, opts[:dataset_method]) {
-            m = send(opts[:mapper_method])
-            c = m.respond_to?(:qualify_column) ? m.send(:qualify_column, opts[:key]) : opts[:key]
-            m.send(where, [[c, id]])
+          define_association_method(mod, opts[:dataset_method]) {
+            m = mapper
+            m.where!([[m.qualify_column(opts[:key]), id]])
           }
-          define_association_method(opts, name) { |options = {}|
-            cached_has_many_association(name, options)
+          define_association_method(mod, name) { |options = {}|
+            load_cached_association(name, options)
           }
-          define_association_method(opts, opts[:add_method]) { |member|
+          define_association_method(mod, opts[:add_method]) { |member|
             member.send("#{opts[:key]}=", self.id)
             member.save
           }
@@ -87,35 +79,20 @@ module Spontaneous
           associations[name] = opts
         end
 
-        def define_association_method(opts, name, &block)
-          opts[:module].module_eval{ define_method(name, &block) }
-        end
-
-        alias_method :one_to_many, :has_many
-
-        def belongs_to(name, opts = {})
-          opts[:association] = :many_to_one
-          opts[:model] ||= self
-          opts[:mapper_method]  = "#{name}_mapper"
+        def belongs_to_content(name, opts = {})
+          opts[:association]    = :many_to_one
           opts[:dataset_method] = "#{name}_dataset"
           opts[:add_method]     = "#{name}="
-          opts[:module]       ||= association_method_module
-
-          where = opts[:model].respond_to?(:where!) ? :where! : :where
+          mod = opts[:module] ||= association_method_module
 
-          define_association_method(opts, opts[:mapper_method]) {
-            opts[:model] == model ? self.mapper : opts[:model]
-          }
-          define_association_method(opts, opts[:dataset_method]) {
-            m = send(opts[:mapper_method])
-            id = send(opts[:key])
-            c = m.respond_to?(:qualify_column) ? m.send(:qualify_column, :id) : :id
-            m.send(where, [[c, id]])
+          define_association_method(mod, opts[:dataset_method]) {
+            m  = mapper
+            m.where!([[m.qualify_column(:id), send(opts[:key])]])
           }
-          define_association_method(opts, name) { |options = {}|
-            cached_belongs_to_association(name, options)
+          define_association_method(mod, name) { |options = {}|
+            load_cached_association(name, options)
           }
-          define_association_method(opts, opts[:add_method]) { |owner|
+          define_association_method(mod, opts[:add_method]) { |owner|
             set_association_cache(name, owner)
             send("#{opts[:key]}=", owner.id) if owner
           }
@@ -123,7 +100,84 @@ module Spontaneous
           associations[name] = opts
         end
 
-        alias_method :many_to_one, :belongs_to
+        alias_method :many_to_one_content, :belongs_to_content
+
+        def define_association_method(mod, name, &block)
+          mod.module_eval{ define_method(name, &block) }
+        end
+
+        alias_method :one_to_many_content, :has_many_content
+
+        def one_to_many(name, opts={}, &block)
+          define_plural_proxy_association(:one_to_many, name, opts, &block)
+        end
+
+        alias_method :has_many, :one_to_many
+
+        def many_to_one(name, opts = {}, &block)
+          association = define_singular_proxy_association(:many_to_one, name, opts, &block)
+          # We need to feed back changes to the association key to the owning
+          # content model. It doesn't matter if the proxy class never recieves
+          # the message because we don't care about its state at all
+          association[:keys].map { |key| "#{key}=" }.each do |method|
+            association_proxy_class.class_eval(<<-RB)
+              def #{method}(value)
+                __content__.send(:#{method}, value)
+              end
+            RB
+          end
+          association
+        end
+
+        alias_method :belongs_to, :many_to_one
+
+        def one_to_one(name, opts = {}, &block)
+          define_singular_proxy_association(:one_to_one, name, opts, &block)
+        end
+
+        alias_method :has_one, :one_to_one
+
+        def define_plural_proxy_association(type, name, opts, &block)
+          singular = name.to_s.singularize
+          plural   = name.to_s.pluralize
+          methods = [ name, "#{plural}_dataset", "add_#{singular}", "remove_#{singular}", "remove_all_#{plural}", ]
+          define_proxy_association(type, methods, name, opts, &block)
+        end
+
+        def define_singular_proxy_association(type, name, opts, &block)
+          methods = [ name, "#{name}=", "#{name}_dataset" ]
+          define_proxy_association(type, methods, name, opts, &block)
+        end
+
+        def define_proxy_association(association, proxy_methods, name, opts = {}, &block)
+          assoc = association_proxy_class.send(association, name, opts, &block)
+          proxy_methods.each do |method_name|
+            association_method_module.module_eval(<<-RB, __FILE__, __LINE__)
+              def #{method_name}(*args, &block)
+                association_proxy_instance.send(:#{method_name}, *args, &block)
+              end
+            RB
+           end
+          assoc
+        end
+
+        def association_proxy_class
+          @association_proxy_class ||= Class.new(association_proxy_superclass)
+        end
+
+        # If we have a superclass that is a content object then we want to
+        # inherit its associations. If not then we need to create a base
+        # class.
+        def association_proxy_superclass
+          if superclass.respond_to?(:association_proxy_class)
+            superclass.association_proxy_class
+          else
+            ::Sequel::Model(mapper.table.dataset).tap do |klass|
+              klass.send :plugin,      :association_dependencies
+              klass.send :attr_reader, :__content__
+            end
+          end
+        end
 
         module InstanceMethods
           def after_destroy
@@ -140,33 +194,19 @@ module Spontaneous
 
           private
 
-          def cached_belongs_to_association(name, options)
-            clear_association_cache(name) if options[:reload]
-            ac = associations_cache
-            unless ac.key?(name)
-              ac[name] = load_belongs_to_association(name)
+          def association_proxy_instance
+            @association_proxy_instance ||= self.class.association_proxy_class.call(attributes).tap do |instance|
+              instance.instance_variable_set(:@__content__, self)
             end
-            ac[name]
           end
 
-          def load_belongs_to_association(name)
-            assoc = model.associations[name]
-            id    = send(assoc[:key])
+          def load_many_to_one_association(assoc)
+            id = send(assoc[:key])
             return nil if id.nil?
-            self.send(assoc[:mapper_method])[id]
+            mapper[id]
           end
 
-          def cached_has_many_association(name, options)
-            clear_association_cache(name) if options[:reload]
-            ac = associations_cache
-            unless ac.key?(name)
-              ac[name] = load_has_many_association(name)
-            end
-            ac[name]
-          end
-
-          def load_has_many_association(name)
-            assoc = model.associations[name]
+          def load_one_to_many_association(assoc)
             members = self.send(assoc[:dataset_method]).all
             if (reciprocal = assoc[:reciprocal])
               members.each do |member|
@@ -176,6 +216,17 @@ module Spontaneous
             members
           end
 
+          def load_cached_association(name, options)
+            assoc = model.associations[name]
+            clear_association_cache(name) if options[:reload]
+            ac = associations_cache
+            unless ac.key?(name)
+              load_method = "load_#{assoc[:association]}_association"
+              ac[name] = send(load_method, assoc)
+            end
+            ac[name]
+          end
+
           def associations_cache
             @associations_cache ||= {}
           end
@@ -190,6 +241,7 @@ module Spontaneous
 
           def refresh
             associations_cache.clear
+            @association_proxy_instance = nil
             super
           end
         end

data/lib/spontaneous/data_mapper.rb

@@ -19,7 +19,7 @@ module Spontaneous
     class ScopingMapper
       extend Forwardable
 
-      attr_reader :schema
+      attr_reader :schema, :table
 
       def initialize(table, schema)
         @table, @schema = table, schema

data/lib/spontaneous/errors.rb

@@ -46,6 +46,12 @@ module Spontaneous
 
   class InvalidPrototypeDefinitionError < Error; end
 
+  class AnonymousRootException < Error
+    def initialize
+      super("Content roots must have a valid slug")
+    end
+  end
+
   class SchemaModificationError < Error
     extend Forwardable
 

data/lib/spontaneous/extensions/object_space.rb

@@ -7,6 +7,12 @@ module ObjectSpace
       ObjectSpace.each_object(Class)  { |o| klasses << o }
       klasses
     end
+
+    def modules
+      modules = []
+      ObjectSpace.each_object(Module)  { |o| modules << o }
+      modules
+    end
   end
 end unless ObjectSpace.respond_to?(:classes)
 

data/lib/spontaneous/facet.rb

@@ -10,6 +10,7 @@ module Spontaneous
       paths.add :templates, "templates"
       paths.add :config, "config"
       paths.add :public, "public"
+      paths.add :assets, "assets"
       paths.add :tasks, ["lib/tasks", "**/*.rake"]
       paths.add :migrations, ["db/migrations", "**/*.rake"]
       paths.add :plugins, ["plugins", "*"]