spontaneous 0.2.0.alpha7 → 0.2.0.beta1

data/lib/spontaneous/concern.rb

@@ -0,0 +1,37 @@
+module Spontaneous
+  # Based on Concern but extended to allow running of
+  # a 'before_include' block before the module is included and before the
+  # 'included' block is run
+  module Concern
+    def self.extended(base)
+      base.instance_variable_set("@_dependencies", [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?("@_dependencies")
+        base.instance_variable_get("@_dependencies") << self
+        return false
+      else
+        return false if base < self
+        base.class_eval(&@_before_include_block) if instance_variable_defined?("@_before_include_block")
+        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+        super
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    def before_include(&block)
+      @_before_include_block = block
+    end
+  end
+end
+

data/lib/spontaneous/config.rb

@@ -105,9 +105,8 @@ module Spontaneous
       def_delegators :@settings, :key?
     end
 
-    @@defaults = {
-      #TODO: add in sensible default configuration (or do it in the generators)
-    }
+    DEFAULTS = {
+    }.freeze unless defined?(DEFAULTS)
 
     attr_reader :environment, :mode, :env, :base, :local, :defaults
 
@@ -117,7 +116,7 @@ module Spontaneous
       @local = Configuration.new
       @env = Configuration.new
       @base = Configuration.new
-      @defaults = Configuration.new(@@defaults)
+      @defaults = Configuration.new(DEFAULTS)
     end
 
     def load(config_root)

data/lib/spontaneous/crypt/version.rb

@@ -0,0 +1,130 @@
+require 'bcrypt'
+
+module Spontaneous::Crypt
+  class Version
+    FIELD_SEP   = ":".freeze
+
+    module ClassMethods
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(subclass)
+        subclasses << subclass
+        super
+      end
+
+      def version(*args)
+        return @version if args.empty?
+        @version = args.first
+      end
+
+      def serialize(hash)
+        Spontaneous::Crypt.serialize(version, hash)
+      end
+
+      def valid?(password, hash)
+        self.new(hash).valid?(password)
+      end
+    end
+
+    extend ClassMethods
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def valid?(password)
+      # Depends on implementation
+    end
+
+    def outdated?
+      Spontaneous::Crypt.outdated?(self.class)
+    end
+
+    def salt
+      # Depends on implementation
+    end
+
+    # A fast version for use during testing
+    class Fake < Version
+      version 0
+
+      def self.create(password)
+        serialize generate(password)
+      end
+
+      def self.generate(password)
+        Digest::SHA1.hexdigest(password)
+      end
+
+      def valid?(password)
+        @hash == self.class.generate(password)
+      end
+
+      def outdated?
+        false
+      end
+
+      def salt
+        ""
+      end
+    end
+    class SHALegacy < Version
+      version 201102
+
+      def self.create(hash, salt)
+        serialize [salt, BCrypt201301.generate(hash)].join(FIELD_SEP)
+      end
+
+      def self.sha(salt, password)
+        Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+      end
+
+      def initialize(blob)
+        @salt, hash = blob.split(FIELD_SEP)
+        @bcrypt = BCrypt201301.new(hash)
+      end
+
+      def valid?(password)
+        @bcrypt.valid?(sha(password))
+      end
+
+      def sha(password)
+        self.class.sha(@salt, password)
+      end
+
+      def salt
+        @salt
+      end
+    end
+
+    class BCrypt201301 < Version
+      version 201301
+
+      def self.cost
+        13
+      end
+
+      def self.create(password)
+        serialize generate(password)
+      end
+
+      def self.generate(password)
+        ::BCrypt::Password.create(password, :cost => cost)
+      end
+
+      def valid?(password)
+        self.password == password
+      end
+
+      def password
+        @password ||= ::BCrypt::Password.new(@hash)
+      end
+
+      def salt
+        password.salt
+      end
+    end
+  end
+end

data/lib/spontaneous/crypt.rb

@@ -0,0 +1,84 @@
+# encoding: UTF-8
+
+module Spontaneous
+  module Crypt
+    VERSION_SEP = "%".freeze
+
+    module ModuleMethods
+      def current
+        return version(@forced) if @forced
+        versions.last
+      end
+
+      def force_version(n)
+        @forced = n
+      end
+
+      def default_version
+        @forced = nil
+      end
+
+      def versions
+        Version.subclasses.sort { |v1, v2| v1.version <=> v2.version }
+      end
+
+      def hash(password)
+        current.create(password)
+      end
+
+      def version(version)
+        versions.detect { |v| v.version == version }
+      end
+
+      def valid?(password, blob)
+        new(password, blob).valid?
+      end
+
+      def serialize(version, hash)
+        [version, hash].join VERSION_SEP
+      end
+
+      def version_split(blob)
+        version, hash = blob.split(VERSION_SEP)
+        [version.to_i, hash]
+      end
+
+      def outdated?(version)
+        version.version < current.version
+      end
+
+      def new(password, blob)
+        version, hash = version_split(blob)
+        Validator.new(password, Crypt.version(version).new(hash))
+      end
+    end
+
+    extend ModuleMethods
+
+    class Validator
+      def initialize(password, version)
+        @password, @version = password, version
+      end
+
+      def valid?
+        @version.valid?(@password)
+      end
+
+      def outdated?
+        @version.outdated?
+      end
+
+      alias_method :needs_upgrade?, :outdated?
+
+      def upgrade
+        Spontaneous::Crypt.hash(@password)
+      end
+
+      def salt
+        @version.salt
+      end
+    end
+  end
+end
+
+require 'spontaneous/crypt/version'

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

@@ -0,0 +1,199 @@
+module Spontaneous
+  module DataMapper
+    module ContentModel
+      module Associations
+        def inherited(subclass)
+          subclass.instance_variable_set(:@associations, associations.dup)
+          subclass.instance_variable_set(:@association_dependencies, association_dependencies.dup)
+          super
+        end
+
+        # Provided for compatibility with Sequel models.
+        #
+        # In particular when constructing associations between
+        # a content model and a Sequel model, the Sequel
+        # association tries to automatically set the reciprocal
+        # value and uses Model.all_association_reflections to
+        # search for appropriate candidates.
+        #
+        # Returning an empty array here stops this crashing.
+        def all_association_reflections
+          []
+        end
+
+        def associations
+          @associations ||= {}
+        end
+
+        def association_method_module
+          @association_method_module ||= define_association_method_module
+        end
+
+        def define_association_method_module
+          m = Module.new
+          self.const_set(:AssociationMethods, m)
+          self.send :include, m
+          m
+        end
+
+        ASSOCIATION_MAPPING = {
+          :one_to_many=>:before,
+          :many_to_one=>:after,
+          :many_to_many=>:before,
+          :one_to_one=>:before
+        }
+
+        def association_dependencies
+          @association_dependencies ||= {
+            :before_delete=>[], :before_destroy=>[],
+            :after_delete=>[], :after_destroy=>[]
+          }
+        end
+
+        def add_association_dependency(opts)
+          if (action = opts[:dependent])
+            time = ASSOCIATION_MAPPING[opts[:association]]
+            hook = :"#{time}_#{action}"
+            association_dependencies[hook] << opts[:dataset_method]
+          end
+        end
+
+        def has_many(name, opts = {})
+          opts[:association] = :one_to_many
+          opts[:model] ||= self
+          opts[:mapper_method]  = "#{name}_mapper"
+          opts[:dataset_method] = "#{name}_dataset"
+          opts[:add_method]     = "add_#{name.to_s.singularize}"
+          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(opts, name) { |options = {}|
+            cached_has_many_association(name, options)
+          }
+          define_association_method(opts, opts[:add_method]) { |member|
+            member.send("#{opts[:key]}=", self.id)
+            member.save
+          }
+          add_association_dependency(opts)
+          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"
+          opts[:dataset_method] = "#{name}_dataset"
+          opts[:add_method]     = "#{name}="
+          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])
+            id = send(opts[:key])
+            c = m.respond_to?(:qualify_column) ? m.send(:qualify_column, :id) : :id
+            m.send(where, [[c, id]])
+          }
+          define_association_method(opts, name) { |options = {}|
+            cached_belongs_to_association(name, options)
+          }
+          define_association_method(opts, opts[:add_method]) { |owner|
+            set_association_cache(name, owner)
+            send("#{opts[:key]}=", owner.id) if owner
+          }
+          add_association_dependency(opts)
+          associations[name] = opts
+        end
+
+        alias_method :many_to_one, :belongs_to
+
+        module InstanceMethods
+          def after_destroy
+            super
+            model.association_dependencies[:after_delete].each{|m| send(m).delete}
+            model.association_dependencies[:after_destroy].each{|m| send(m).destroy}
+          end
+
+          def before_destroy
+            model.association_dependencies[:before_delete].each{|m| send(m).delete}
+            model.association_dependencies[:before_destroy].each{|m| send(m).destroy}
+            super
+          end
+
+          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)
+            end
+            ac[name]
+          end
+
+          def load_belongs_to_association(name)
+            assoc = model.associations[name]
+            id    = send(assoc[:key])
+            return nil if id.nil?
+            self.send(assoc[:mapper_method])[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]
+            members = self.send(assoc[:dataset_method]).all
+            if (reciprocal = assoc[:reciprocal])
+              members.each do |member|
+                member.send :set_association_cache, reciprocal, self
+              end
+            end
+            members
+          end
+
+          def associations_cache
+            @associations_cache ||= {}
+          end
+
+          def set_association_cache(name, value)
+            associations_cache[name] = value
+          end
+
+          def clear_association_cache(name)
+            associations_cache.delete(name)
+          end
+
+          def refresh
+            associations_cache.clear
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+module Spontaneous
+  module DataMapper
+    module ContentModel
+      module ColumnAccessors
+        def self.included(model)
+          m = Module.new
+          model.columns.each do |column|
+            m.module_eval "def #{column};     _get_column_value(:#{column})    ; end", __FILE__, __LINE__
+            m.module_eval "def #{column}=(v); _set_column_value(:#{column}, v) ; end", __FILE__, __LINE__
+          end
+          model.send :include, m
+        end
+
+
+        def changed_columns
+          @changed_columns ||= []
+        end
+
+        def _set_column_value(column, value)
+          attrs = @attributes
+          if new? || !attrs.key?(column) || value != attrs[column]
+            _change_column_value(column, value)
+          end
+        end
+
+        alias_method :[]=, :_set_column_value
+
+        def _change_column_value(column, value)
+          _mark_columns_as_modified(column)
+          @attributes[column] = value
+        end
+
+        def _mark_columns_as_modified(*columns)
+          cc = changed_columns
+          columns.each { |c| cc << c unless cc.include?(c) }
+        end
+
+        def _get_column_value(column)
+          @attributes[column]
+        end
+
+        alias_method :[], :_get_column_value
+
+        def modified_attributes
+          cc = changed_columns
+          return @attributes.reject { |col, val| col == :id } if cc.empty? && @modified
+          @attributes.reject { |col, val| !cc.include?(col) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Spontaneous
+  module DataMapper
+    module ContentModel
+      module InstanceHooks
+        # This only currently supports the after_save hooks as that's the
+        # only one that's used (by PagePieces to save their owner after
+        # a style change)
+        def after_save_hook(&block)
+          add_instance_hook(:after_save, &block)
+        end
+
+        def after_save
+          run_after_instance_hooks(:after_save)
+          super
+        end
+
+        private
+
+        def add_instance_hook(hook, &block)
+          instance_hooks(hook).push(block)
+        end
+
+        def instance_hooks(hook)
+          @instance_hooks ||= {}
+          @instance_hooks[hook] ||= []
+        end
+
+        def run_after_instance_hooks(hook)
+          instance_hooks(hook).each{|b| b.call}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Spontaneous::DataMapper
+  module ContentModel
+    module Serialization
+      def self.included(model)
+        # Don't want to pollute this shared module with the accessors
+        # (in case we are using this in multiple models)
+        m = Module.new
+        model.serialized_columns.each do |column|
+          m.module_eval (<<-RB), __FILE__, __LINE__
+            def #{column}
+              _deserialize_column(:#{column}) { super }
+            end
+            def #{column}=(value)
+              super(_serialize_column(:#{column}, value))
+            end
+          RB
+        end
+        model.send :include, m
+      end
+
+      def refresh
+        _deserialized_values.clear
+        super
+      end
+
+      private
+
+      def _deserialized_values
+        @_deserialized_values ||= {}
+      end
+
+      def _deserialize_column(column)
+        cache = _deserialized_values
+        unless cache.key?(column)
+          cache[column] = _deserialize_value(yield)
+        end
+        cache[column]
+      end
+
+      def _deserialize_value(value)
+        Yajl::Parser.new(:symbolize_keys => true).parse(value || "null")
+      end
+
+      def _serialize_column(column, value)
+        _deserialized_values[column] = value
+        _serialize_value(value)
+      end
+
+      def _serialize_value(value)
+        Yajl::Encoder.new.encode(value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Spontaneous
+  module DataMapper
+
+    def self.timestamp
+      ::Sequel.datetime_class.now
+    end
+
+    module ContentModel
+      module Timestamps
+        def before_create
+          set_create_timestamp
+          super
+        end
+
+        # I have disabled update timestamps because the logic is more complex
+        # than this. Modification timestamps are controlled by the modification
+        # logic, e.g. preventing parent pages from appearing as modified on the
+        # addition of a new child page.
+        #
+        # def before_update
+        #   # set_update_timestamp
+        #   super
+        # end
+
+        def set_create_timestamp(time=nil)
+          return unless self.respond_to?(:created_at)
+          time ||= Spontaneous::DataMapper.timestamp
+          self.send(:"created_at=", time) if send(:created_at).nil?
+          # set_update_timestamp(time)
+        end
+
+        # def set_update_timestamp(time=nil)
+        #   return unless self.respond_to?(:modified_at)
+        #   self.send(:modified_at=, time || Spontaneous::DataMapper.timestamp)
+        # end
+      end
+    end
+  end
+end