amalgam 2.1.1

data/config/routes.rb

@@ -0,0 +1,48 @@
+Amalgam::Engine.routes.draw do
+
+  if Amalgam.authorities.present?
+    instance_eval <<-METHODS, __FILE__, __LINE__ + 1
+      match "/:resource/signin" => "sessions#new", :via => :get, :as => 'signin'
+      delete "/:resource/signout" => "sessions#destroy", :as => 'signout'
+      match "/:resource/signup" => "registrations#new", :via => :get, :as => 'signup'
+      match "/:resource/edit" => "registrations#edit", :via => :get, :as => 'edit_info'
+    METHODS
+
+    Amalgam.authorities.each do |auth_name, type|
+      instance_eval <<-METHODS, __FILE__, __LINE__ + 1
+        post "/#{auth_name.to_s}/signin" => "sessions#create"
+        post "/#{auth_name.to_s}/signup" => "registrations#create"
+        put "/#{auth_name.to_s}/edit_info" => "registrations#update"
+      METHODS
+    end
+  end
+
+	namespace :admin do
+    resources :groups
+    root :to => 'pages#index'
+    post 'editor/upload_image' => 'editor#upload_image'
+    put 'editor' => 'editor#update' , :as => 'editor'
+	end
+
+  def match(path, *rest)
+    path[:menu_item] ||= false if path.is_a? Hash
+    default_actions = [:new,:index]
+    if parent_resource
+      Amalgam.admin_menus[@scope[:controller]] ||= parent_resource.actions & default_actions
+      Amalgam.admin_menus[@scope[:controller]] << (rest.first[:as] || path) if rest.present? && rest.first.delete(:menu_item)
+    else
+      if path.is_a?(Hash) && path.delete(:menu_item)
+        name = path[:as] ? path[:as] : path.keys.first.split('/').last
+        if name.present?
+          Amalgam.admin_menus[name] = []
+          Amalgam.admin_menus[name] << {:controller => path.first[1].split("#").first}
+        end
+      end
+    end
+    super(path,*rest)
+  end
+
+  namespace :admin do
+    instance_eval &Amalgam.routes
+  end
+end

data/lib/amalgam.rb

@@ -0,0 +1,91 @@
+require "amalgam/engine"
+
+module Amalgam
+  def self.setup
+    require_all!
+    yield self
+    if !Rails.application.config.consider_all_requests_local
+      load_templates
+    end
+  end
+
+  mattr_accessor :admin_menus
+  @@admin_menus = {}
+
+  mattr_accessor :type_whitelist
+  @@type_whitelist = []
+
+  mattr_accessor :controllers
+  @@controllers = []
+
+  mattr_accessor :authority_keys
+  @@authority_keys = [:username]
+
+  mattr_accessor :authorities
+  @@authorities = {}
+
+  mattr_accessor :authority_urls
+  @@authority_urls = {}
+
+  mattr_accessor :attachment_class_name
+  @@attachment_class_name = 'Attachment'
+
+  #params or subdomain or nil
+  mattr_accessor :i18n
+  @@i18n = nil
+
+  mattr_accessor :models_with_templates
+  @@models_with_templates = []
+
+  mattr_reader :routes
+  @@routes = Proc.new do
+    resources :pages, :except => [:show]
+  end
+
+  def self.load_templates
+    models_with_templates.each do |model|
+      Amalgam::TemplateFinder::Rule.load(Rails.root,model.to_s)
+    end
+  end
+
+  def self.admin_routes(&block)
+    @@routes = Proc.new(&block)
+  end
+
+  def self.authority_model(model,options = {})
+    if options[:as].present?
+      @@authorities[model] = options[:as]
+    else
+      @@authorities[model] = :default
+    end
+    if options[:redirect_url].present?
+      @@authority_urls[model] = options[:redirect_url]
+    else
+      @@authority_urls[model] = nil
+    end
+    Amalgam::Authorities::Controllers::Helpers.amalgam_define_helpers(model.to_s,options)
+  end
+
+  protected
+  def self.require_all!
+    require 'page_routes'
+    require 'amalgam/validators/slug'
+    require 'amalgam/content_persistence'
+    require 'amalgam/models/hierarchical'
+    require 'amalgam/models/attachable'
+    require 'amalgam/models/templatable'
+    require 'amalgam/models/group'
+    require 'amalgam/models/base_group'
+    require 'amalgam/models/groupable'
+    require 'amalgam/models/page'
+    require 'amalgam/template_finder'
+    require 'amalgam/editable'
+    require 'amalgam/authorities/controllers/helpers'
+    require 'amalgam/authorities/model'
+    require 'amalgam/authorities/models/active_record'
+    require 'amalgam/globalize/helpers'
+    require 'amalgam/globalize'
+    require 'amalgam/tree/exportable'
+    require 'amalgam/tree/importable'
+  end
+end

data/lib/amalgam/authorities/controllers/helpers.rb

@@ -0,0 +1,115 @@
+module Amalgam
+  module Authorities
+    module Controllers
+      module Helpers
+        extend ActiveSupport::Concern
+
+        included do
+          helper_method :resource_name
+          helper_method :can_edit?
+        end
+
+        def self.amalgam_define_helpers(mapping,options = {}) #:nodoc:
+
+          as = options[:as].to_s if options[:as]
+
+          class_eval <<-METHODS, __FILE__, __LINE__ + 1
+            def authenticate_#{mapping}!
+              if !current_#{mapping}
+                store_location
+                redirect_to #{mapping}_signin_url, :alert => I18n.t('amalgam.sessions.fail.need_to_be_#{mapping}')
+              end
+            end
+
+            def #{mapping}_signed_in?
+              !!current_#{mapping}
+            end
+
+            def current_#{mapping}
+              @current_#{mapping} ||= #{mapping.classify.constantize}.find(session[:#{mapping}_id]) if session[:#{mapping}_id]
+            end
+
+          METHODS
+
+          if options[:as] && options[:as].to_s != mapping
+            class_eval <<-METHODS, __FILE__, __LINE__ + 1
+              def authenticate_#{as}!
+                if !current_#{as}
+                  store_location
+                  redirect_to #{mapping}_signin_url, :alert => I18n.t('amalgam.sessions.fail.need_to_be_#{as}')
+                end
+              end
+
+              def current_#{as}
+                current_#{mapping}
+              end
+
+              def #{as}_signed_in?
+                !!current_#{as}
+              end
+            METHODS
+          end
+
+          ActiveSupport.on_load(:action_controller) do
+            helper_method "current_#{mapping}", "#{mapping}_signed_in?"
+            helper_method "current_#{as}", "#{as}_signed_in?" if options[:as] && options[:as].to_s != mapping
+          end
+        end
+
+        protected
+
+        def after_sign_in_path_for(resource)
+
+        end
+
+        def after_sign_out_path_for(resource)
+        end
+
+        def sign_out_and_redirect_to(resource)
+        end
+
+        def after_sign_up_path_for(resource)
+          main_app.root_path
+        end
+
+        def after_update_path_for(resource)
+          amalgam.admin_root_path
+        end
+
+        def redirect_back_or_default(default)
+          if default || session[:return_to]
+            redirect_to( session[:return_to] || default )
+          else
+            redirect_to root_url
+          end
+          session[:return_to] = nil
+        end
+
+        def store_location
+          session[:return_to] = request.fullpath
+        end
+
+        def build_resource(params, classify = true)
+          Amalgam.authorities.each do |auth_name,type|
+            if params[auth_name]
+              self.resource_name = auth_name
+              return auth_name.to_s.classify.constantize.new if classify
+            end
+          end
+        end
+
+        def resource_name
+          @resource_name
+        end
+
+        def resource_name=(name)
+          @resource_name = name
+        end
+
+        def can_edit?
+          admin_signed_in?
+        end
+      end
+    end
+  end
+end

data/lib/amalgam/authorities/model.rb

@@ -0,0 +1,41 @@
+module Amalgam
+  module Authorities
+    module Model
+      module ClassMethods
+        # Locate an model given its unique login key.
+        #
+        # @abstract
+        # @param [String] key The unique login key.
+        # @return [Model] An instance of the user model class.
+        def locate(key)
+          raise NotImplementedError
+        end
+
+        # Authenticate a user with the given key and password.
+        #
+        # @param [String] key The unique login key provided for a given user.
+        # @param [String] password The presumed password for the user.
+        # @return [Model] An instance of the user model class.
+        def authenticate(conditions, password)
+          instance = locate(conditions)
+          return false unless instance
+          instance.authenticate(password)
+        end
+      end
+
+      # Returns self if the provided password is correct, false
+      # otherwise.
+      #
+      # @abstract
+      # @param [String] password The password to check.
+      # @return [self or false] Self if authenticated, false if not.
+      def authenticate(password)
+        raise NotImplementedError
+      end
+
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+      end
+    end
+  end
+end

data/lib/amalgam/authorities/models/active_record.rb

@@ -0,0 +1,49 @@
+require 'active_record'
+
+module Amalgam
+  module Authorities
+    module Models
+      class ActiveRecord < ::ActiveRecord::Base
+        include Amalgam::Authorities::Model
+
+        attr_accessible :password, :password_confirmation, :current_password
+        attr_accessor :login, :current_password
+        self.abstract_class = true
+        has_secure_password
+
+        validates_presence_of :current_password, :if => Proc.new {|user| user.require_current_password?}
+        validate :check_password, :check_current_password
+
+        def admin?
+          Amalgam.authorities[self.class.model_name.underscore.to_sym] == :admin
+        end
+
+        def self.locate(content)
+          query = []
+          Amalgam.authority_keys.each do |key|
+            query << "#{key.to_s} = :value"
+          end
+          where([query.join(" OR "),{:value => content}]).first
+        end
+
+        protected
+
+        def require_current_password?
+          !new_record? and (email_changed? or username_changed?)
+        end
+
+        def check_password
+          if self.password.present?
+            errors.add(:password_confirmation, I18n.t('amalgam.registrations.fail.password_confirmation_not_match')) unless self.password == self.password_confirmation
+          end
+        end
+
+        def check_current_password
+          if require_current_password?
+            errors.add(:current_password, I18n.t('amalgam.registrations.fail.current_password_not_match')) unless self.authenticate(self.current_password)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amalgam/content_persistence.rb

@@ -0,0 +1,40 @@
+module Amalgam
+	class ContentPersistence
+
+	  def self.save(content)
+	    records = prepare_records(content)
+	    records.each do |key,record|
+	      instance = record[:class].constantize.find(record[:id])
+	      # merge only changed field of model
+	      attrs = instance.attributes.slice(*record[:attributes].keys).deep_merge(record[:attributes])
+	      instance.update_attributes(attrs)
+	    end
+	  end
+
+	  def self.sanitize_content_key(key)
+	    if r = %r{\A(?<type>[a-z_]+)/(?<id>[0-9a-z]+)\.(?<field>[0-9a-z_]+(\.[0-9a-z_]+)*)\z}.match(key.chomp.downcase)
+	      cls = r[:type].classify
+	      raise %{Illegal type "#{cls}"} unless Amalgam.type_whitelist.include?(cls)
+	      [cls,r[:id],r[:field]]
+	    else
+	      raise %{Illegal content key "#{key}"}
+	    end
+	  end
+
+	  def self.prepare_records(content)
+	    records = {}
+	    content.each do |content_key,content_value|
+	      klass,id,field = sanitize_content_key(content_key)
+	      record = records["#{klass}/#{id}"] ||= {
+	        :class => klass,
+	        :id => id,
+	        :attributes => {}
+	      }
+	      # convert form 'field.sub1.sub2 = value' to '{field:{sub1:{sub2:value}}'
+	      attribute = (field.split('.') << content_value['value']).reverse.reduce{|value,key| {key => value} }
+	      record[:attributes].deep_merge!(attribute)
+	    end
+	    records
+	  end
+	end
+end

data/lib/amalgam/editable.rb

@@ -0,0 +1,20 @@
+module Amalgam
+	module Editable
+
+    def self.included(base)
+      base.layout :layout_with_mercury
+    end
+
+    protected
+
+    def content_layout
+      nil
+    end
+
+    private
+
+    def layout_with_mercury
+      !params[:mercury_frame] && can_edit? && !request.xhr? ? 'amalgam/admin/editor' : content_layout
+    end
+	end
+end

data/lib/amalgam/engine.rb

@@ -0,0 +1,46 @@
+module Amalgam
+  class Engine < ::Rails::Engine
+    isolate_namespace Amalgam
+
+    initializer :assets do |config|
+      Rails.application.config.assets.precompile += %w( amalgam/admin.js amalgam/admin.css amalgam/editor.css amalgam/editor.js )
+    end
+
+    initializer "amalgam.params.filter" do |app|
+      app.config.filter_parameters += [:password, :password_confirmation, :current_password]
+    end
+
+    #https://gist.github.com/1464315
+    initializer "error_view" do |config|
+      ActionView::Base.field_error_proc = Proc.new do |html_tag, instance|
+       html = %(<div class="field_with_errors">#{html_tag}</div>).html_safe
+       # add nokogiri gem to Gemfile
+       elements = Nokogiri::HTML::DocumentFragment.parse(html_tag).css "label, input"
+       elements.each do |e|
+         if e.node_name.eql? 'label'
+           html = %(<div class="error">#{e}</div>).html_safe
+         elsif e.node_name.eql? 'input'
+           if instance.error_message.kind_of?(Array)
+             html = %(<div class="error">#{html_tag}<span class="help-inline">&nbsp;#{instance.error_message.join(',')}</span></div>).html_safe
+           else
+             html = %(<div class="error">#{html_tag}<span class="help-inline">&nbsp;#{instance.error_message}</span></div>).html_safe
+           end
+         end
+       end
+       html
+      end
+    end
+
+    #http://stackoverflow.com/questions/8797690/rails-3-1-better-way-to-expose-an-engines-helper-within-the-client-app
+    initializer 'Amalgam.action_controller' do |app|
+      ActiveSupport.on_load :action_controller do
+        helper Amalgam::Admin::LayoutHelper
+        helper Amalgam::Editor::EditorHelper
+        helper Amalgam::Editor::PropertiesBuilderHelper
+        helper Amalgam::AttachmentsHelper
+        helper Amalgam::PagesHelper
+        helper Amalgam::UrlHelper if Amalgam.i18n
+      end
+    end
+  end
+end