outpost-cms 0.0.3

data/lib/outpost/controller/actions.rb

@@ -0,0 +1,72 @@
+##
+# Outpost::Controller::Actions
+#
+# This provides basic CRUD actions for you to include into any
+# controller that you want to behave like a resource management
+# area.
+module Outpost
+  module Controller
+    module Actions
+      def index
+        respond_with :outpost, @records
+      end
+
+      def new
+        breadcrumb "New"
+        @record = model.new
+        respond_with :outpost, @record
+      end
+
+      def show
+        redirect_to @record.admin_edit_path
+      end
+
+      def edit
+        breadcrumb "Edit", nil, @record.to_title
+        respond_with :outpost, @record
+      end
+
+      def create
+        @record = model.new(form_params)
+        
+        if @record.save
+          notice "Saved #{@record.simple_title}"
+          respond_with :outpost, @record, location: requested_location
+        else
+          breadcrumb "New"
+          render :new
+        end
+      end
+
+      def update
+        if @record.update_attributes(form_params)
+          notice "Saved #{@record.simple_title}"
+          respond_with :outpost, @record, location: requested_location
+        else
+          breadcrumb "Edit", nil, @record.to_title
+          render :edit
+        end
+      end
+
+      def destroy
+        @record.destroy
+        notice "Deleted #{@record.simple_title}"
+        respond_with :outpost, @record
+      end
+      
+      private
+      
+      def form_params
+        params[model.singular_route_key]
+      end
+
+      def requested_location
+        case params[:commit_action]
+        when "edit" then @record.admin_edit_path
+        when "new"  then model.admin_new_path
+        else model.admin_index_path
+        end
+      end
+    end # Actions
+  end # Controller
+end # Outpost

data/lib/outpost/controller/authentication.rb

@@ -0,0 +1,34 @@
+module Outpost
+  module Controller
+    module Authentication
+      extend ActiveSupport::Concern
+
+      included do
+        before_filter :require_login
+        helper_method :current_user
+      end
+
+      # Public: The currently logged-in user.
+      #
+      # Returns Outpost.user_class instance.
+      def current_user
+        begin
+          @current_user ||= Outpost.user_class.where(can_login: true).find(session[:user_id])
+        rescue ActiveRecord::RecordNotFound
+          session[:user_id]   = nil
+          @current_user       = nil
+        end
+      end
+
+      # Private: Callback to require login.
+      #
+      # Returns nothing.
+      def require_login
+        if !current_user
+          session[:return_to] = request.fullpath
+          redirect_to outpost_login_path and return false
+        end
+      end
+    end # Authentication
+  end # Controller
+end # Outpost

data/lib/outpost/controller/authorization.rb

@@ -0,0 +1,28 @@
+##
+# Authorization
+#
+# Basic authorization methods for controllers
+module Outpost
+  module Controller
+    module Authorization
+      # Make sure the user can authorize the current resource
+      def authorize(resource)
+        if !current_user.can_manage?(resource)
+          handle_unauthorized(resource)
+        end
+      end
+
+      # Use this for before_filter. Should be overridden for custom behavor.
+      def authorize_resource
+        authorize(self.class.model)
+      end
+
+      # What to do when a user doesn't have proper permissions
+      def handle_unauthorized(resource)
+        redirect_to outpost_root_path, 
+          alert: "You don't have permission to manage #{resource.to_title.pluralize}"
+        return false
+      end
+    end # Authorization
+  end # Controller
+end # Outpost

data/lib/outpost/controller/callbacks.rb

@@ -0,0 +1,14 @@
+module Outpost
+  module Controller
+    module Callbacks
+      def get_record
+        @record = model.find(params[:id])
+      end
+
+      def get_records
+        @records = model.order("#{model.table_name}.#{order} #{sort_mode}")
+          .page(params[:page]).per(self.list.per_page)
+      end
+    end # Callbacks
+  end # Controller
+end # Outpost

data/lib/outpost/controller/custom_errors.rb

@@ -0,0 +1,41 @@
+module Outpost
+  module Controller
+    module CustomErrors
+      extend ActiveSupport::Concern
+      
+      NOT_FOUND_ERROR_CLASSES = [
+        ActionController::RoutingError, 
+        ActionController::UnknownController,
+        AbstractController::ActionNotFound, 
+        ActiveRecord::RecordNotFound
+      ]
+
+      if defined?(ActionController::UnknownFormat)
+        NOT_FOUND_ERROR_CLASSES << ActionController::UnknownFormat
+      end
+
+      included do
+        rescue_from StandardError, with: ->(e) { render_error(500, e) and return false }
+        rescue_from *NOT_FOUND_ERROR_CLASSES, with: ->(e) { render_error(404, e) and return false }
+      end
+      
+      #----------------------
+      
+      def render_error(status, e=StandardError)
+        response.status = status
+
+        if Rails.application.config.consider_all_requests_local
+          raise e
+        else
+          respond_to do |format|
+            format.html { render template: "/errors/error_#{status}", layout: "application", status: status, locals: { error: e } }
+            format.xml { render xml: { error: response.message, code: status }, status: status }
+            format.json { render json: { error: response.message, code: status }, status: status }
+            format.text { render text: "#{status} - #{response.message}", status: status}
+            format.any { head status }
+          end
+        end
+      end
+    end # CustomErrors
+  end
+end

data/lib/outpost/controller/filtering.rb

@@ -0,0 +1,22 @@
+module Outpost
+  module Controller
+    module Filtering
+      private
+
+      def filter_records
+        if params[:filter].is_a? Hash
+          params[:filter].each do |attribute, value|
+            next if value.blank?
+            scope = "filtered_by_#{attribute}"
+
+            if @records.klass.respond_to? scope
+              @records = @records.send(scope, value)
+            else
+              @records = @records.where(attribute => value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/outpost/controller/helpers.rb

@@ -0,0 +1,52 @@
+## 
+# Outpost::Controller::Helpers
+module Outpost
+  module Controller
+    module Helpers
+      extend ActiveSupport::Concern
+      include Outpost::Controller::Ordering
+      
+      included do
+        helper_method :sort_mode, :order
+      end
+
+      # Public: The order that the records are currently sorted by.
+      # This gets passed directly to ActiveRecord, so it should be
+      # a valid database order.
+      #
+      # Returns String of the order.
+      def order
+        @order ||= set_order
+      end
+
+      # Public: The sort mode that the records are currently sorted by.
+      # This gets passed directory to ActiveRecord, so it should be
+      # a valid database sort mode.
+      #
+      # Examples
+      #
+      #   sort_mode
+      #   # => "asc"
+      #
+      # Returns String of the sort mode.
+      def sort_mode
+        @sort_mode ||= set_sort_mode
+      end
+
+      # Public: Set the flash[:notice] message, only for HTML requests.
+      #
+      # message - (String) The message to add to the flash.
+      #
+      # Examples
+      #
+      #   notice("Success")
+      #   flash[:notice]
+      #   # => "Success"
+      #
+      # Returns nothing.
+      def notice(message)
+        flash[:notice] = message if request.format.html?
+      end
+    end # Helpers
+  end # Controller
+end # Outpost

data/lib/outpost/controller/ordering.rb

@@ -0,0 +1,46 @@
+module Outpost
+  module Controller
+    module Ordering
+      private
+      
+      # Set which attribute is doing the sorting
+      #
+      # If params[:order] is present, then set the
+      # preference to that and return it.
+      #
+      # If not present, but preferred order is,
+      # then use the preferred order.
+      #
+      # Otherwise use the list order.
+      def set_order
+        key = "#{model.content_key}_order"
+        preferred_order = preference(key)
+
+        @order = if params[:order].present?
+          set_preference(key, params[:order])
+        elsif preferred_order.present?
+          preferred_order
+        else
+          list.default_order
+        end
+      end
+
+      # Set the sort mode
+      #
+      # It will either be the requested sort mode, or if not available, 
+      # then the table's default sort mode.
+      def set_sort_mode
+        key = "#{model.content_key}_sort_mode"
+        preferred_sort_mode = preference(key)
+
+        @sort_mode = if %w{ asc desc }.include?(params[:sort_mode])
+          set_preference(key, params[:sort_mode])
+        elsif preferred_sort_mode.present?
+          preferred_sort_mode
+        else
+          list.default_sort_mode
+        end
+      end
+    end
+  end
+end

data/lib/outpost/controller/preferences.rb

@@ -0,0 +1,71 @@
+module Outpost
+  module Controller
+    module Preferences
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :preference
+      end
+
+      # Public: Getter for preference.
+      # Preferences are stored in the browser's session on a per-resource
+      # basis.
+      #
+      # key - (String) The key for the preference.
+      #
+      # Examples
+      #
+      #   preference("posts_order")
+      #   # => "updated_at"
+      #
+      # Returns String of the requested preference.
+      def preference(key)
+        session["preference_#{key}"]
+      end
+      
+      # Public: Writer for preference.
+      #
+      # key   - (String) The key to write to.
+      # value - (String) The value of the preference.
+      #
+      # Examples
+      #
+      #   set_preference("posts_order", "updated_at")
+      #   preference("posts_order")
+      #   # => "updated_at"
+      #
+      # Returns nothing. 
+      def set_preference(key, value)
+        session["preference_#{key}"] = value
+      end
+
+      # Public: Unset a preference.
+      #
+      # key - (String) The key to delete from preferences.
+      #
+      # Examples
+      #
+      #   unset_preference("posts_order")
+      #   preference("posts_order")
+      #   # => nil
+      #
+      # Returns nothing.
+      def unset_preference(key)
+        set_preference(key, nil)
+      end
+
+
+      private
+      
+      def remove_preferences
+        Outpost.config.preferences.each do |preference|
+          key = "#{model.content_key}_#{preference}"
+
+          if params[preference] == "" && preference(key).present?
+            unset_preference(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/outpost/controller.rb

@@ -0,0 +1,123 @@
+  ##
+# Outpost::Controller
+module Outpost
+  module Controller
+    extend ActiveSupport::Autoload
+    extend ActiveSupport::Concern
+
+    autoload :Actions
+    autoload :Callbacks
+    autoload :Helpers
+    autoload :Ordering
+    autoload :Filtering
+    autoload :Preferences
+    autoload :Authentication
+    autoload :Authorization
+    autoload :CustomErrors
+    
+    included do
+      helper_method :list, :model, :fields
+    end
+
+
+    # Public: Proxy to the controller's model.
+    def model
+      self.class.model
+    end
+
+    # Public: Proxy to the controller's list.
+    def list
+      self.class.list
+    end
+
+    # Public: Proxy to the controller's fields.
+    def fields
+      self.class.fields
+    end
+
+    module ClassMethods
+      attr_accessor :model
+      attr_writer :fields
+
+      # Public: The fields for a form.
+      #
+      # If no fields have been defined, then the default fields will be used.
+      # Using the default fields will also set the permitted params to those
+      # fields.
+      #
+      # Returns Array of fields.
+      def fields
+        @fields ||= begin
+          default_fields
+        end
+      end
+
+      # Public: The list for this controller.
+      #
+      # If no list has been defined yet, this method will
+      # also define the list with the class's default columns.
+      #
+      # Returns the list.
+      def list
+        @list ||= define_list do |l|
+          l.default_columns.each do |attribute|
+            l.column attribute
+          end
+        end
+      end
+
+      # Public: Define the list for this controller.
+      #
+      # block - A block to define the list. See List::Base for more.
+      #
+      # Examples
+      #
+      #   define_list do |l|
+      #     l.per_page = 50
+      #     l.column :name
+      #   end
+      #
+      # Returns nothing.
+      def define_list(&block)
+        @list = List::Base.new(model, &block)
+      end
+
+      # Public: Declare a controller as being a controller for Outpost.
+      #
+      # model - (constant) The model for this controller.
+      #
+      # Examples
+      #
+      #   class Admin::NewsStoriesController < Admin::ResourceController
+      #     outpost_controller model: NewsStory
+      #   end
+      #
+      def outpost_controller(attributes={})
+        @model = attributes[:model] || find_model
+
+        include Outpost::Controller::Helpers
+        include Outpost::Controller::Callbacks
+        include Outpost::Controller::Actions
+        include Outpost::Controller::Ordering
+        include Outpost::Controller::Filtering
+        include Outpost::Controller::Preferences
+
+        before_filter :get_record, only: [:show, :edit, :update, :destroy]
+        before_filter :get_records, only: [:index]
+        before_filter :authorize_resource
+        before_filter :filter_records, only: [:index]
+      end
+
+
+      private
+
+      def default_fields
+        model.column_names - Outpost.config.excluded_form_fields
+      end
+
+      def find_model
+        self.name.demodulize.underscore.split("_")[0...-1].join("_").classify.constantize
+      end
+    end # ClassMethods
+  end # Controller
+end # Outpost

data/lib/outpost/engine.rb

@@ -0,0 +1,10 @@
+module Outpost
+  class Engine < ::Rails::Engine
+    config.generators do |g|
+      g.test_framework :rspec, fixture: false
+      g.fixture_replacement :factory_girl, dir: "spec/factories"
+      g.assets false
+      g.helper false
+    end
+  end
+end

data/lib/outpost/helpers/naming.rb

@@ -0,0 +1,22 @@
+##
+# Naming
+#
+# Some naming helpers.
+#
+# Example:
+#
+#   Outpost::Helpers::Naming.to_class("outpost/news_stories")
+module Outpost
+  module Helpers
+    module Naming
+      extend self
+      
+      # These helpers expect a controller param, 
+      # such as 'outpost/news_stories'
+      # "outpost/news_stories" => NewsStory
+      def to_class(controller)
+        controller.singularize.camelize.demodulize.constantize
+      end
+    end # Naming
+  end # Helpers
+end # Outpost

data/lib/outpost/helpers.rb

@@ -0,0 +1,6 @@
+module Outpost
+  module Helpers
+    extend ActiveSupport::Autoload
+    autoload :Naming
+  end
+end

data/lib/outpost/hook.rb

@@ -0,0 +1,35 @@
+##
+# Outpost::Hook
+#
+# Hook into Newsroom.js
+module Outpost
+  class Hook
+    attr_accessor :data, :path
+    
+    def initialize(options={})
+      @path = options[:path]
+      @data = options[:data] || { touch: true }
+    end
+    
+    # Publish the message
+    def publish
+      response = connection.post do |request|
+        request.url @path
+        request.params = @data
+      end
+      
+      response
+    end
+        
+    private
+    
+    def connection
+      @connection ||= begin
+        Faraday.new(url: Rails.application.config.node.server) do |conn|
+          conn.response :json
+          conn.adapter Faraday.default_adapter
+        end
+      end
+    end
+  end # Hook
+end # Outpost

data/lib/outpost/list/base.rb

@@ -0,0 +1,78 @@
+module Outpost
+  module List
+    class Base
+      def initialize(model, &block)
+        @model   = model
+        @columns = ActiveSupport::HashWithIndifferentAccess.new
+        @filters = ActiveSupport::HashWithIndifferentAccess.new
+        @fields  = []
+
+        yield self if block_given?
+
+        @default_order     ||= List::DEFAULT_ORDER
+        @default_sort_mode ||= List::DEFAULT_SORT_MODE
+        @per_page          ||= List::DEFAULT_PER_PAGE
+      end
+
+      attr_accessor :default_order, :default_sort_mode
+      attr_reader :columns, :fields, :filters, :per_page, :model
+      
+      # Public: Set the per_page for pagination.
+      #
+      # val - (Integer) The value to send to pagination. Also accepts :all,
+      #       which passes `nil` to pagination and therefore will not 
+      #       paginate.
+      #
+      # Returns nothing.
+      def per_page=(val)
+        @per_page = val.to_i
+      end
+
+      # Public: Add a column to the list.
+      #
+      # attribute - (String) The attribute that this column represents.
+      # options   - (Hash) A hash of options. Gets passed directly to 
+      #             List::Column (default: {}).
+      #             * header  - (String) The title of the column, displayed in 
+      #                         the table header 
+      #                         (default: self.attribute.titleize).
+      #             * display - (Symbol or Proc) How to display this attribute.
+      #                         * If symbol, should be the name of a method in 
+      #                           AdminListHelper
+      #                         * If Proc, gets run as an instance of the class.
+      #                         * See AdminListHelper for more info.
+      #
+      # Examples
+      #
+      #   define_list do
+      #     column :name, header: "Full Name", display: :display_full_name
+      #     column :user, header: "Associated User", display: proc { self.user.name }
+      #   end
+      #
+      # Returns nothing.
+      def column(attribute, options={})
+        column = Column.new(attribute, self, options)
+        @columns[attribute] = column
+      end
+      
+      # Public: Define a filter for the list.
+      #
+      # attribute - (String) The attribute on which to filter.
+      # options   - (Hash) A hash of options that gets passed into Filter.new
+      #             (default: {}).
+      #
+      # Returns nothing.
+      def filter(attribute, options={})
+        filter = Filter.new(attribute, self, options)
+        @filters[attribute] = filter
+      end
+
+      # Private: Default columns for this list
+      #
+      # Returns Array of default columns.
+      def default_columns
+        @model.column_names - Outpost.config.excluded_list_columns
+      end
+    end
+  end
+end

data/lib/outpost/list/column.rb

@@ -0,0 +1,24 @@
+module Outpost
+  module List
+    class Column
+      attr_accessor :attribute, :display, :position, :list, :quick_edit, 
+        :sortable, :default_sort_mode, :_display_helper, :header
+
+      alias_method :quick_edit?, :quick_edit
+      alias_method :sortable?, :sortable
+      
+      def initialize(attribute, list, attributes={})
+        @attribute = attribute.to_s
+        @list      = list
+        @position  = @list.columns.size
+
+        @header     = attributes[:header] || @attribute.titleize
+        @display    = attributes[:display]
+        @quick_edit = !!attributes[:quick_edit]
+        @sortable   = !!attributes[:sortable]
+
+        @default_sort_mode = attributes[:default_sort_mode] || List::DEFAULT_SORT_MODE
+      end
+    end
+  end
+end