yodel 0.0.1

data/lib/yodel/models/core/record/section.rb

@@ -0,0 +1,21 @@
+class Section < Array
+  attr_reader :name
+  
+  def initialize(name)
+    @name = name
+    super()
+  end
+  
+  def display?
+    any? {|field| display_field?(field)}
+  end
+  
+  def displayed_fields
+    select {|field| display_field?(field)}
+  end
+  
+  private
+    def display_field?(field)
+      field.display? && field.default_input_type.present? && field.default_input_type != :embedded
+    end
+end

data/lib/yodel/models/core/record/site_record.rb

@@ -0,0 +1,31 @@
+require './record/mongo_record'
+require './model/site_model'
+
+class SiteRecord < MongoRecord
+  extend SiteModel
+  attr_reader :site
+  
+  def initialize(site, values={}, new_record=true)
+    @site = site
+    super(values, new_record)
+  end
+  
+  def site_id;  @values['_site_id']; end
+
+  def default_values
+    super.merge({'_site_id' => site.id})
+  end
+  
+  def inspect_hash
+    {site_id: site_id}.merge(super)
+  end
+  
+  def perform_reload(params)
+    document = load_mongo_document(_id: params[:id])
+    initialize(params[:site], document)
+  end
+  
+  def prepare_reload_params
+    super.tap {|vals| vals[:site] = site}
+  end
+end

data/lib/yodel/models/core/site/migration.rb

@@ -0,0 +1,52 @@
+class Migration
+  def self.run_migrations(site)
+    Yodel.config.logger.info "Migrating #{site.name}"
+    
+    each_migration_for(site) do |migration, file|
+      unless migration.nil?
+        next if site.migrations.include?(migration.name)
+        migration.up(site)
+      
+        # newly created models are incomplete; reload the site
+        # to force complete versions to be generated for use
+        site.migrations << migration.name
+        site.save
+        site.reload
+      
+        Yodel.config.logger.info "Migrated #{migration.name}"
+      else
+        raise MissingMigration.new(file)
+      end
+    end
+    
+    Yodel.config.logger.info "Migrations for #{site.name} complete"
+  end
+  
+  # As migration files are require'd this method will be triggered so
+  # we have a reference to the 'current' migration class being run
+  def self.inherited(child)
+    @migration = child
+  end
+  
+  
+  private
+    def self.each_migration_for(site, &block)
+      each_migration(File.join(site.migrations_directory, Yodel::YODEL_MIGRATIONS_DIRECTORY_NAME), &block)
+      each_migration(File.join(site.migrations_directory, Yodel::EXTENSION_MIGRATIONS_DIRECTORY_NAME), &block)
+      each_migration(File.join(site.migrations_directory, Yodel::SITE_MIGRATIONS_DIRECTORY_NAME), &block)
+    end
+    
+    # Iterate over every migration and yield the migration class
+    # to the supplied block. Incorrect migration files may result
+    # in nil being yielded. The caller can respond appropriately.
+    # The current file (a string path) is also provided.
+    def self.each_migration(directory)
+      return unless File.directory?(directory)
+      Dir[File.join(directory, '**/*.rb')].sort.each do |file|
+        @migration = nil
+        load file
+        yield @migration, file
+        Object.send(:remove_const, @migration.name.to_sym) if @migration
+      end
+    end
+end

data/lib/yodel/models/core/site/remote.rb

@@ -0,0 +1,61 @@
+class Remote < MongoRecord
+  collection :remotes
+  field :name, :string, validations: {required: {}}
+  field :url, :string, validations: {required: {}}
+  field :username, :string, validations: {required: {}}
+  field :password, :password, validations: {required: {}}
+  many  :sites, store: false
+  
+  def site_list
+    perform_request('/sites.json', :get)
+  end
+  
+  def create_site
+    perform_request('/sites.json', :post)
+  end
+  
+  before_save :hash_password
+  def hash_password
+    return unless password_changed? && password?
+    self.password = Password.hashed_password(nil, password)
+  end
+  
+  def host
+    URI.parse(url).host
+  end
+  
+  def git_url(remote_id)
+    git_url = URI.parse(url).merge("/git/#{remote_id}")
+    git_url.user = CGI.escape(username)
+    git_url.password = password
+    git_url.to_s
+  end
+  
+  private
+    def perform_request(request_path, method)
+      case method
+      when :get
+        klass = Net::HTTP::Get
+      when :post
+        klass = Net::HTTP::Post
+      else
+        raise "Unknown remote request type"
+      end
+      uri = URI.parse(url)
+      
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        request = klass.new(uri.merge(request_path).path, {'Content-Type' => 'application/json'})
+        request.basic_auth username, password
+        response = http.request(request, '')
+        if response.is_a?(Net::HTTPNotFound)
+          {'success' => false, 'reason' => 'Path or domain not found'}
+        elsif response.code == 302
+          {'success' => false, 'reason'=> 'Redirection not supported'}
+        else
+          JSON.parse(response.body)
+        end
+      end
+    rescue Errno::ECONNREFUSED, Errno::EHOSTDOWN, Errno::EHOSTUNREACH, Errno::ECONNRESET
+      {'success' => false, 'reason' => 'Remote host could not be contacted'}
+    end
+end

data/lib/yodel/models/core/site/site.rb

@@ -0,0 +1,202 @@
+class Site < MongoRecord
+  attr_reader :cached_records, :cached_models
+  
+  collection :sites
+  field :name, :string
+  field :created_at, :time
+  field :root_directory, :string
+  field :remote_id, :string
+  field :model_plural_names, :hash
+  field :model_types, :hash
+  field :extensions, :array
+  field :migrations, :array
+  field :options, :hash
+  field :domains, :array
+  one   :remote
+  
+  def initialize(values={}, new_record=true)
+    super
+    @cached_records = {}
+    @cached_models  = {}
+    
+    # static models
+    @models = Model.scoped_for(self)
+    @cached_models['Model']   = @cached_models['models']    = @models
+    @cached_models['Trigger'] = @cached_models['triggers']  = Trigger.scoped_for(self)
+    @cached_models['Task']    = @cached_models['tasks']     = Task.scoped_for(self)
+  end
+  
+  
+  # ----------------------------------------
+  # Accessors
+  # ----------------------------------------
+  # TODO: a better interface is site.options.name.option; site.options.pages.permalink_character
+  def option(path)
+    component, option = path.split('.')
+    options[component].try(:fetch, option, nil).try(:fetch, 'value', nil)
+  end
+  
+  def log
+    @log ||= Log.new(self)
+  end
+  
+  def public_directory
+    @public_dir ||= File.join(root_directory, Yodel::PUBLIC_DIRECTORY_NAME)
+  end
+  
+  def public_directories
+    @public_dirs ||= Yodel.config.public_directories + [public_directory]
+  end
+  
+  def layouts_directory
+    @layouts_dir ||= File.join(root_directory, Yodel::LAYOUTS_DIRECTORY_NAME)
+  end
+  
+  def layout_directories
+    @layout_dirs ||= Yodel.config.layout_directories + [layouts_directory]
+  end
+  
+  def partials_directory
+    @partials_dir ||= File.join(root_directory, Yodel::PARTIALS_DIRECTORY_NAME)
+  end
+  
+  def migrations_directory
+    @migrations_dir ||= File.join(root_directory, Yodel::MIGRATIONS_DIRECTORY_NAME)
+  end
+  
+  def attachments_directory
+    @attachments_dir ||= File.join(root_directory, Yodel::ATTACHMENTS_DIRECTORY_NAME)
+  end
+  
+  def site_yaml_path
+    File.join(root_directory, Yodel::SITE_YML_FILE_NAME)
+  end
+  
+  def local_domain
+    domains.find {|domain| domain.end_with?('.yodel')}
+  end
+  
+  def remote_domains
+    domains.select do |domain|
+      !domain.end_with?('.yodel') &&
+      !domain.end_with?('.local') &&
+      !domain.end_with?('.localhost') &&
+      !domain.start_with?('192.168.') &&
+      !domain.start_with?('10.') &&
+      !domain.start_with?('127.') &&
+      (!domain.start_with?('172.') || !(16..31).include?(domain.split('.')[1].to_i)) &&
+      domain != '0.0.0.0' &&
+      domain != '255.255.255.255' &&
+      domain != 'localhost' &&
+      domain != 'broadcasthost'
+    end
+  end
+  
+  def latest_revision
+    Dir.chdir(root_directory) do
+      `git log -n1 --pretty=format:"%H"`
+    end
+  end
+  
+  def latest_revision_date
+    Dir.chdir(root_directory) do
+      `git log -n1 --pretty=format:"%ai"`
+    end
+  end
+  
+  
+  # ----------------------------------------
+  # Life cycle
+  # ----------------------------------------
+  before_destroy :destroy_records
+  def destroy_records
+    Trigger.collection.remove(_site_id: id)
+    LogEntry.collection.remove(_site_id: id)
+    Record.collection.remove(_site_id: id)
+    Model.collection.remove(_site_id: id)
+    Task.collection.remove(_site_id: id)
+  end
+  
+  after_destroy :destroy_directories
+  def destroy_directories
+    # root directory
+    FileUtils.remove_entry_secure(root_directory) if File.directory?(root_directory)
+    
+    # domain symlinks in production
+    if Yodel.env.production?
+      domains.each do |domain|
+        path = File.join(Yodel.config.public_directory, domain)
+        FileUtils.remove_file(path, true) if File.symlink?(path)
+      end
+    end
+  end
+  
+  after_save :update_site_yml
+  def update_site_yml
+    return unless Yodel.env.development?
+    File.open(site_yaml_path, 'w') do |file|
+      file.write(YAML.dump({
+        name: name.to_s,
+        extensions: extensions.to_a,
+        domains: remote_domains.to_a,
+        options: options.to_hash
+      }))
+    end
+  end
+  
+  def reload_from_site_yaml
+    update(YAML.load_file(site_yaml_path))
+  end
+  
+  def self.load_from_site_yaml(path)
+    Site.new(YAML.load_file(path)).tap do |site|
+      site.root_directory = File.dirname(path)
+    end
+  end
+  
+  
+  # ----------------------------------------
+  # Model Lookups
+  # ----------------------------------------
+  # Method missing is utilised to allows lookups of models by their plural name
+  # directly on a site object. site.models is equivalent to site.model('Model')
+  def method_missing(name, *args, &block)
+    # attempt to find the model in the cached_models hash
+    key = name.to_s
+    model = @cached_models[key]
+    return model unless model.nil?
+    
+    # otherwise perform a lookup
+    model = model_by_plural_name(key)
+    return super if model.nil?
+    model
+  end
+  
+  # Retrieve a model by its plural name ('models' as opposed to 'Model'). In general
+  # use the method missing functionality of site since it checks the cached_models
+  # hash before performing a lookup, whereas this method will always do a lookup.
+  def model_by_plural_name(name)
+    # ensure the site has a reference to a model by this name. get is required here
+    # instead calling 'model_types' explicitly as that relies on method_missing
+    # which in turn sometimes calls this method (creating infinite recursion)
+    model_id = get('model_types')[name]
+    return nil if model_id.nil?
+    
+    # perform a lookup; nil will be returned if the model doesn't exist
+    model = @models.find(model_id)
+    @cached_models[name] = model
+    @cached_models[model.name] = model
+    @cached_records[model.id] = model
+  end
+  
+  # Retrieve a model by its full name ('Model' as opposed to 'models')
+  def model(name)
+    # get is required here instead calling 'model_types' explicitly as that relies
+    # on method_missing which in turn sometimes calls this method (creating
+    # infinite recursion)
+    return nil if name.nil?
+    model = @cached_models[name]
+    return model unless model.nil?
+    model_by_plural_name(get('model_plural_names')[name])
+  end
+end

data/lib/yodel/models/core/validations/email_address_validation.rb

@@ -0,0 +1,24 @@
+class EmailAddressValidation < Validation
+  def self.validate(params, field, name, value, record, errors)
+    begin
+      # modified: http://my.rails-royce.org/2010/07/21/email-validation-in-ruby-on-rails-without-regexp/
+      address = Mail::Address.new(value)
+    
+      # ensure there is a domain and the full parsed address is equivalent to the value
+      if address.domain.present? && address.address == value
+        # ensure the domain component is made up of more than just a TLD
+        domain_tree = address.send(:tree).domain
+        if domain_tree.dot_atom_text.elements.size > 1
+          return true
+        end
+      end
+    rescue
+    end
+    
+    errors[field.name] << new(name)
+  end
+
+  def describe
+    "must be a valid email address"
+  end
+end

data/lib/yodel/models/core/validations/embedded_records_validation.rb

@@ -0,0 +1,31 @@
+class EmbeddedRecordsValidation < Validation
+  def initialize(params, errors)
+    super(params)
+    @errors = errors
+  end
+  
+  def self.validate(field, records, record, errors)
+    # embedded record validations
+    records = [records] unless records.respond_to?(:to_a)
+    embedded_errors = Errors.new
+    records.to_a.each_with_index do |embedded_record, index|
+      embedded_errors[index] = embedded_record.valid? ? nil : embedded_record.errors
+    end
+    
+    # field set validations
+    field.fields.each do |name, embedded_field|
+      next unless embedded_field.set_validations
+      set_value = records.to_a.collect {|embedded| embedded.get(name)}.uniq
+      embedded_field.set_validations.each do |type, params|
+        Validation.validate(type, params, embedded_field, name, set_value, record, embedded_errors)
+      end
+    end
+    
+    errors[field.name] = embedded_errors unless embedded_errors.empty?
+  end
+
+  def describe
+    # FIXME: don't just call inspect here, format correctly using describe calls
+    "has these errors: #{@errors.inspect}}"
+  end
+end

data/lib/yodel/models/core/validations/errors.rb

@@ -0,0 +1,51 @@
+class Errors
+  def initialize
+    @errors = {}
+  end
+  
+  def inspect
+    @errors.inspect
+  end
+  
+  def [](name)
+    @errors[name] ||= []
+    @errors[name]
+  end
+  
+  def []=(name, value)
+    return if value.nil?
+    @errors[name] = value
+  end
+  
+  def key?(name)
+    @errors.key?(name)
+  end
+  
+  def empty?
+    @errors.empty?
+  end
+  
+  def clear
+    @errors.clear
+    @summary = nil
+  end
+  
+  # errors on a collection
+  def <<(error)
+    self['_'] << error
+  end
+  
+  def summarise
+    @summary ||= @errors.each_with_object({}) do |(field, errors), hash|
+      if errors.respond_to?(:summarise)
+        hash[field.to_s] = errors.summarise.values.to_sentence
+      else
+        hash[field.to_s] = "#{field.to_s.humanize} #{errors.collect(&:describe).to_sentence}"
+      end
+    end
+  end
+  
+  def to_json(*a)
+    summarise.to_json(*a)
+  end
+end