outpost-cms 0.0.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Bryan Ricker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,295 @@
+# Outpost
+[![Build Status](https://travis-ci.org/SCPR/outpost.png)](https://travis-ci.org/SCPR/outpost)
+
+A Rails Engine for quickly standing up a CMS for a Newsroom.
+
+## Dependencies
+* `rails >= 3.2`
+* `ruby >= 1.9.3`
+
+See `.travis.yml` to see which Ruby versions are officially supported.
+
+## Installation
+Add `gem 'outpost-cms'` to your Gemfile. The module you interact with is just
+`Outpost`.
+
+**A note about the gem/repository/module name discrepancy**  
+There is [another gem](http://rubygems.org/gems/outpost) called "Outpost"
+which occupies the same namespace as this gem. However, the other Outpost
+is meant for service monitoring, and I can't imagine a scenario where
+these two gems would be used together in the same application. Therefore,
+I'm keeping the module name, and just renaming the gem to `outpost-cms`
+so we can both exist on RubyGems.
+
+
+This gem also has some hard dependencies that aren't in the gemspec.
+My goal is to reduce these dependencies as much as possible, but as this was 
+extracted from the KPCC application, these are fairly strict at this point.
+
+* `simple_form` - for Rails 3.2, use `~> 2.1.0`.
+For Rails 4.0, you'll need to use `~> 3.0.0.beta1`
+* `kaminari` - You need to use the 
+[kaminari master branch](https://github.com/amatsuda/kaminari).
+* `eco`
+* `sass-rails`
+* `bootstrap-sass`
+* `coffee-rails`
+
+## Usage
+### Authentication
+Much like Devise, Outpost provides a basic `SessionsController` and 
+corresponding views. To use these, just add them to your routes:
+
+```ruby
+namespace :outpost do
+  resources :sessions, only: [:create, :destroy]
+  get 'login'  => "sessions#new", as: :login
+  get 'logout' => "sessions#destroy", as: :logout
+end
+```
+
+Outpost also provides the `Outpost::Model::Authentication` module,
+which you should include into your User model to work with the provided
+`SessionsController`:
+
+```ruby
+class User < ActiveRecord::Base
+  include Outpost::Model::Authentication
+end
+```
+
+Your User class should have at least the following methods:
+* `password_digest` (string)
+* `last_login` (datetime)
+* `can_login` (boolean)
+* `is_superuser` (boolean)
+* `name` (string)
+
+
+#### Configuration
+
+You can set a different User class, or the attribute which the user 
+should use to login:
+
+```
+Outpost::Config.configure do |config|
+  config.user_class                   = "AdminUser"
+  config.authentication_attribute     = :username
+end
+```
+
+
+##### Routes
+
+Note that this gem doesn't provide any routes for you. It is expected that you'll want to use the path globbing to render Outpost-style 404's inside of Outpost (rather than your application's 404 page), so it gets too messy and complicated to try to combine your routes with path globbing.
+
+You'll want to put this at the bottom of you `outpost` namespace in your routes:
+
+```ruby
+root to: 'home#dashboard'
+
+resources :sessions, only: [:create, :destroy]
+get 'login'  => "sessions#new", as: :login
+get 'logout' => "sessions#destroy", as: :logout
+
+get "*path" => 'errors#not_found'
+```
+
+
+### Authorization
+Outpost comes with a built-in `Permission` model, whose only attribute is
+a String `resource`, which stores a class name which you want to be
+authorized throughout the application. Run this migration to set it up:
+
+
+```ruby
+create_table :permissions do |t|
+  t.string :resource
+  t.timestamps
+end
+
+create_table :user_permissions do |t|
+  t.integer :user_id
+  t.integer :permission_id
+  t.timestamps
+end
+
+add_index :permissions, :resource
+add_index :user_permissions, :user_id
+add_index :user_permissions, :permission_id
+```
+
+You can include `Outpost::Model::Authorization` into your User model
+to provide the Permission association, and also add the `can_manage?` 
+method:
+
+```ruby
+if !current_user.can_manage?(Post)
+  redirect_to outpost_root_path, alert: "Not Authorized"
+end
+```
+
+Authorization is "All-or-None"... in other words, a user can either 
+manage a resource or not - A user with permission for a particular model
+is able to Create, Read, Update, and Delete any of those objects.
+
+Outpost controllers will automatically authorize their resource. Within
+views, you can use one of the provided helpers to guard a block of text
+or a link:
+
+```erb
+<%= guard Post do %>
+  Only users who are authorized for Posts will see this.
+<% end %>
+
+<%= guarded_link_to Post, "Linked if authorized, plaintext if not", posts_path %>
+```
+
+
+### User Preferences
+Preferences are stored in the session, and on a per-resource basis.
+Outpost provides built-in hooks in the controller and views for 
+Order (attribute) and Sort Mode ("asc", "desc"). In order to manage other 
+preferences, you'll want to make use of a handful of methods that get
+mixed-in to your Outpost controllers:
+
+* `preference` - Access a preference's value.
+* `set_preference` - Set a preference's value.
+* `unset_preference` - Unset a preference's value.
+
+The key for a preference needs to follow the convention:
+
+```ruby
+"#{model.content_key}_#{preference}"
+```
+
+For example:
+
+```ruby
+set_preference("blog_entries_color", "ff0000")
+```
+
+You also need to add the parameter that the preference is using to 
+`config.preferences`:
+
+```ruby
+Outpost::Config.configure do |config|
+  # ...
+  config.preferences += [:color]
+end
+```
+
+A resource-based preference is automatically cleared if its param is an empty string (not `nil`). For example:
+
+```ruby
+# GET /outpost/posts?color=ff0000
+set_preference('posts_color', params[:color])
+preference('posts_color') # => ff0000
+
+# GET /outpost/posts?color=
+preference('posts_color') # => nil
+```
+
+If you have a preference for a non-resourceful page, you need to manage its
+cleanup manually.
+
+
+
+## Javascripts
+
+Outpost comes with a bunch of useful scripts built-in. Some of them are automatically used, and some are provided as "opt-in" functionality.
+
+
+### Field Counter
+
+![Field Counter](http://i.imgur.com/MUPrplL.png)
+
+This will add a counter above any field which will show the number of characters entered into that field, the target length, and the +/- fuzziness, as well as a color indicating where in that range they are.
+
+#### Use
+
+Add the class `field-counter` to a div wrapping the input field, and two data-attributes containing integers:
+
+* `data-target` - The target length (default: 145)
+* `data-fuzziness` - The fuzziness allowed (default: 20)
+
+If you're using `simple_form`, it might look like this:
+
+```ruby
+f.input :title, wrapper_html; { class: "field-counter", data: { target: 50, fuzziness: 10} }
+```
+
+
+### Preview
+
+![Preview](http://i.imgur.com/OZhlIOd.png)
+
+The Javascript for Preview is what handles sending the form data to the server, but you'll need to handle the server-side stuff yourself. The "Preview" button will show up once you've added a `preview` action to that controller. 
+
+#### Use
+
+The `preview` action needs to do a few things:
+
+* Find the object from the passed-in `obj_key` (You can use `Outpost::obj_by_key`). You'll also need to handle what happens if the record hasn't been saved yet.
+* Merge in the changed attributes.
+* Render the proper template/layout, or any validation errors (using `render_preview_validation_errors`).
+* Make sure you don't save anything. For this, I recommend doing any object updating inside of a database transaction, because assigning associations to a persisted object will save the object. Outpost provides a controller method, `with_rollback`, which will perform the block inside of a database transaction and force an `ActiveRecord::Rollback` at the end.
+
+Here is a full example of what your `preview` action could look like:
+
+```ruby
+def preview
+  @post = ContentBase.obj_by_key(params[:obj_key]) || Post.new
+  
+  with_rollback @post do
+    @post.assign_attributes(form_params)
+
+    if @post.valid?
+      render "/posts/_post", layout: "application", locals: { post: @post }
+    else
+      render_preview_validation_errors(@post)
+    end
+  end
+end
+```
+
+You'll also need to add two routes for the preview action:
+
+```ruby
+resources :posts do
+  put "preview", on: :member
+  post "preview", on: :collection
+end
+```
+
+You need both `post` and `put` to allow the preview to happen from either the New or Edit pages. If you're using Rails 4, use `patch` instead of `put`. In fact, if you're using Rails 4 (or the `routing_concerns` gem), then you can use Routing Concerns:
+
+```ruby
+concern :previewable do
+  patch "preview", on: :member
+  post "preview", on: :collection
+end
+
+resources :posts, concerns: [:previewable]
+resources :reporters, concerns: [:previewable]
+resources :stories, concerns: [:previewable]
+```
+
+
+#### More documentation to come.
+
+## Todo
+A ton of stuff. Here is a sampler:
+
+* Generators for resources (models, controllers).
+* Add record versioning (needs to be extracted from the SCPRv4 app).
+* Documentation... oh man, the documentation...
+
+## Contributing
+Pull Requests are encouraged! This engine was built specifically for KPCC, 
+so its flexibility is limited... if you have improvements to make, please 
+make them.
+
+Fork it, make your changes, and send me a pull request.
+
+Run tests with `bundle exec rake test`

data/Rakefile

@@ -0,0 +1,26 @@
+#!/usr/bin/env rake
+RAKED = true
+
+require 'bundler/setup'
+#require 'rdoc/task'
+require 'rspec/core/rake_task'
+require 'combustion'
+
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'Outpost'
+#   rdoc.markup   = 'tomdoc'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.md')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+#   rdoc.rdoc_files.include('app/helpers/**/*.rb')
+#   rdoc.rdoc_files.include('app/models/**/*.rb')
+# end
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each { |f| load f }
+
+Bundler.require :default, :test
+Combustion.initialize! :active_record, :action_controller
+Combustion::Application.load_tasks
+
+RSpec::Core::RakeTask.new(:test)

data/app/assets/javascripts/outpost/application.js

@@ -0,0 +1 @@
+//= require outpost

data/app/assets/javascripts/outpost/auto_slug_field.js.coffee

@@ -0,0 +1,53 @@
+# Find slug fields and load them up
+$ ->
+    for field in $("form input[name*='[slug]']")
+        new outpost.AutoSlugField(field: field)
+
+##
+# AutoSlugField
+#
+# Takes a field and turns it into a slug on-the-fly
+#
+class outpost.AutoSlugField
+    DefaultOptions:
+        titleClass: ".sluggable"
+        maxLength:  50
+    
+    constructor: (options={}) ->
+        @options = _.defaults options, @DefaultOptions
+
+        # Find the sluggable title field - if it doesn't 
+        # exist then we can't auto-generate a slug
+        @titleField = $(@options.titleClass)[0]
+
+        if @titleField
+            @slugField  = $ @options.field
+            @maxLength  = @options.maxLength
+            @button     = $ JST['outpost/templates/slug_generate_button']()
+
+            # If we found a matching field, 
+            # render the generate button and add it after the slug field
+            @slugField.after(@button)
+            @button.on
+                click: (event) =>
+                    @updateSlug($(@titleField).val())
+                    event.preventDefault()
+                    false
+
+        true
+
+    #------------------
+    
+    updateSlug: (value) ->
+        @slugField.val @slugify(value)
+    
+    #------------------
+    
+    slugify: (str) ->
+        str.toLowerCase()
+           .replace(/\s+/g, "-")     # Spaces -> `-`
+           .replace(/-{2,}/g, '-')   # Fix accidental double-hyphens
+           .replace(/[^\w\-]+/g, '') # Remove non-word characters/hyphen
+           .replace(/^-+/, '')       # Trim hyphens from beginning
+           .substring(0, @maxLength) # Just the first 50 characters
+           .replace(/-+$/, '')       # Trim hyphens from end

data/app/assets/javascripts/outpost/base.js.coffee

@@ -0,0 +1 @@
+window.outpost ?= {}

data/app/assets/javascripts/outpost/date_time_input.js.coffee

@@ -0,0 +1,108 @@
+# Find the inputs and load them.
+$ ->
+    outpost.DateTimeInput.buildDateTimeInputs($("form"))
+    outpost.DateTimeInput.buildDateInputs($("form"))
+
+##
+# DateTimeInput
+# 
+# Turns simple textfields (for datetime attributes) into
+# awesome timetime picker things.
+#
+# Does both Date and Time inputs (separately)
+#
+class outpost.DateTimeInput
+    @buildDateTimeInputs: (els) ->
+        for wrapper in $("div.datetime", els)
+            new outpost.DateTimeInput(wrapper: wrapper)
+        
+    @buildDateInputs: (els) ->
+        for wrapper in $("div.date", els)
+            new outpost.DateTimeInput(wrapper: wrapper, time: false, field: "input.date")
+        
+    #-----------------------
+    
+    DefaultOptions:
+        time:          true
+        dateTemplate:  JST["outpost/templates/date_field"]
+        timeTemplate:  JST["outpost/templates/time_field"]
+        timestampEls:  ".timestamp-el"
+        populateIcons: "span.populate"
+        controls:      "div.controls"
+        field:         "input.datetime"
+        dateFormat:    "YYYY-MM-DD"
+        timeFormat:    "HH:mm"
+        dbFormat:      "YYYY-MM-DD HH:mm:ss"
+
+    constructor: (options={}) ->
+        @options = _.defaults options, @DefaultOptions
+        @time    = @options.time
+
+        # Elements
+        @wrapper       = $ @options.wrapper
+        @controls      = $ @options.controls, @wrapper
+        @field         = $ @options.field, @wrapper
+
+        # Attributes
+        @id     = @field.attr("id")
+        @dateId = "#{@id}_date"
+        @timeId = "#{@id}_time"
+        
+        # Hide the field since we don't want anybody editing it directly
+        @field.hide()
+    
+        # Render the templates
+        # Prepend time first so it's second
+        @controls.prepend(@options.timeTemplate(time_id: @timeId, time_format: @options.timeFormat)) if @time
+        @controls.prepend(@options.dateTemplate(date_id: @dateId, date_format: @options.dateFormat))
+
+        # Register the newly-created elements
+        @timestampEls   = $ @options.timestampEls, @wrapper
+        @dateEl         = $ "##{@dateId}"
+        @timeEl         = $ "##{@timeId}"
+        @populateIcons  = $ @options.populateIcons, @wrapper
+
+        # Fill in the new fields with the correct date/time
+        # Only if the field has a value (i.e. we're editing the object)
+        if @field.val()
+            @dateEl.val @getDate(@options.dateFormat)
+            @timeEl.val @getDate(@options.timeFormat) if @time
+            
+        # Make the dateEl a datepicker
+        @dateEl.datepicker(autoclose: true, format: @options.dateFormat.toLowerCase())
+    
+        # Fill in hidden text field when visible field is changed
+        @timestampEls.on
+            change: (event) => (@field.trigger "update")
+
+        @field.on
+            update: => (@setDate(@dateEl.val(), @timeEl.val() if @time))
+            
+        # Fill in visible fields with right now time,
+        # and trigger the "update" event on field hidden field
+        @populateIcons.on
+            click: (event) =>
+                @populateDate(@dateEl, @options.dateFormat)
+                @populateDate(@timeEl, @options.timeFormat) if @time
+                @field.trigger "update"
+       
+    # Populate a visible field with a date human-readable date string
+    populateDate: (el, format) ->
+        date = moment().format(format)
+        el.val(date)
+
+    # Get timestamp from hidden field
+    getDate: (format) ->
+        date = Date.parse(@field.val())
+        moment(date).format(format) if date
+    
+    # Set value of hidden field to a real date
+    setDate: (date, time="") ->
+        date = moment(Date.parse("#{date} #{time}"))
+        console.log "date set to", date
+        
+        if date
+            formatted = date.format(@options.dbFormat) 
+            @field.val(formatted)
+        else
+            @field.val("")

data/app/assets/javascripts/outpost/field_counter.js.coffee

@@ -0,0 +1,93 @@
+
+$ ->
+    # Initialize a FieldCounter for any field that asks for it.
+    for field in $("form .field-counter")
+        el        = $(field)
+        target    = el.attr("data-target")
+        fuzziness = el.attr("data-fuzziness")
+        new outpost.FieldCounter(el, target: target, fuzziness: fuzziness)
+
+##   
+# FieldCounter
+# To turn a field into a field counter, add three attributes:
+#
+#   class="field-counter"
+#   data-target="50"        # Perfect length
+#   data-fuzziness="10"     # Lee-way in either direction (inclusive)
+#
+# Anything spanning the range of 
+#
+#   `(target - fuzziness) through (target + fuzziness)`
+#
+# (inclusive) will be considered "in-range". Everything else is
+# "out of range". By default, this class will use the Twitter Bootstrap
+# notification classes, but that can be overridden.
+#
+class outpost.FieldCounter
+    DefaultOptions:
+        target:          145                      # Perfect length
+        fuzziness:       20                       # Lee-way (in either direction, inclusive)
+        inRangeClass:    "alert alert-success"
+        outOfRangeClass: "alert alert-warning"
+        counterClass:    "counter-notify"
+        counterWrapper:  ".controls"             # The element to which the counter will be prepended
+        counterStyle:    "padding: 3px; margin: 0 0 2px 0;"
+        
+    constructor: (@el, options={}) ->
+        @options = _.defaults options, @DefaultOptions
+
+        # Setup elements
+        @field   = $("input, textarea", @el)
+        @counterEl = $("<div />", class: @options.counterClass, style: @options.counterStyle)
+        $(@options.counterWrapper, @el).prepend @counterEl
+        
+        # Setup attributes
+        @count     = 0
+        @target    = parseInt(@options.target)
+        @fuzziness = parseInt(@options.fuzziness)
+        @rangeLow  = @target - @fuzziness
+        @rangeHigh = @target + @fuzziness
+        
+        @inRangeClass    = @options.inRangeClass
+        @outOfRangeClass = @options.outOfRangeClass
+        
+        # Register listeners
+        @field.on
+            keyup: (event) =>
+                @updateCount($(event.target).val().length)
+        
+        @el.on
+            updateCounter: (event, count) =>
+                @updateText(count)
+                @updateColor(count)
+
+        # Set the count on initialize
+        @updateCount(@field.val().length)
+                
+    #--------------
+
+    inRange: ->
+        @rangeLow <= @count and @count <= @rangeHigh
+                    
+    #--------------
+    
+    updateCount: (length) ->
+        @count = length
+        @el.trigger "updateCounter", @count
+    
+    #--------------
+    
+    updateText: (count) ->
+        @counterEl.html("<strong>Optimal Length:</strong> #{count} of #{@target} (+/- #{@fuzziness})")
+
+    #--------------
+    
+    updateColor: (count) ->
+        if @inRange()
+            @counterEl.removeClass(@outOfRangeClass)
+            @counterEl.addClass(@inRangeClass)
+        else
+            @counterEl.removeClass(@inRangeClass)
+            @counterEl.addClass(@outOfRangeClass)
+        
+        

data/app/assets/javascripts/outpost/field_manager.js.coffee

@@ -0,0 +1,37 @@
+##
+# FieldManager
+#
+# A simple class that listens for certain events
+# and does things to forms
+#
+class outpost.FieldManager
+    constructor: ->
+        
+        $("fieldset.form-block legend").on
+            click: (event) ->
+                target = $(@)
+                target.siblings(".fields").toggle()
+                target.siblings(".notification").toggle()
+
+        # Add fields
+        $(".js-add-fields").on
+            click: (event) ->
+                event.preventDefault()
+
+                target = $(@)
+                time   = new Date().getTime()
+                regexp = new RegExp(target.data('id'), 'g')
+                fields = $(target.data('fields').trim().replace(regexp, time))
+                
+                if buildTarget = target.data('build-target')
+                    $(buildTarget).append fields
+                else
+                    target.before(fields)
+                    
+                # Build any special fields.
+                # TODO: Can we accomplish this with triggers?
+                outpost.DateTimeInput.buildDateTimeInputs(fields)
+                outpost.DateTimeInput.buildDateInputs(fields)
+                $("select", fields).select2
+                    placeholder: " "
+                    allowClear: true