ordinary_cms 0.0.1 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c81e01a5f85d2dc8c54bcc4da7ae209ef9a23288
-  data.tar.gz: b955bdeac74f448b6242f2ce242ed962700d3585
+  metadata.gz: ce29f59c5459ab8098f81cd11b4319f6ecdd2943
+  data.tar.gz: ceed02fa468b550b64cb5c7469635f38e4fd8aff
 SHA512:
-  metadata.gz: dc56c185582ff11c374fb68c882f5901560e84d964007efa344f51ae7726ec4ac20ed6f90860f810e7bd120eef7f5c9d435528a87b3dc3fad5b31cc2e30e47aa
-  data.tar.gz: dd60cf4e7d902d719504ffe9e0f794cd0aa8a9ab78aecb41dcbf4d5cca20bd77ac907dbb9a085ccc6c7a50562e513a2c3459d1f05c46988aadde287af1358250
+  metadata.gz: 4bf730a0e35eda6a122378ff749f7f7be9fb1532bbec1b08b158279e7539654fd39851bc8c7de03c0599ca37d1b50a7dc324bffb3662d5271201ee2f9bffa3d3
+  data.tar.gz: 7df40e85119d1beaefd36b9be369e3c0b47d47eb3a8a9c4918e9fbd00ba91abe16887edf9ef30ff149533aa661c690e6effa83178f38a84f1faf0d025a582134

data/app/admin/ordinary_cms/page.rb

@@ -0,0 +1,44 @@
+ActiveAdmin.register OrdinaryCms::Page do
+
+  permit_params :name, seo_attributes: [ :id, :title, :description, :keywords ],
+                sections_attributes: [:id, :name, :text, :_destroy]
+
+  member_action :set_as_root, method: :patch do
+    OrdinaryCms::Page.find(params[:id]).set_as_root!
+    redirect_to :back
+  end
+
+
+  index do
+    selectable_column
+    column :name
+    column do |page|
+        link_to t('edit_content'),
+                "/editor#{ordinary_cms.page_path(page)}"
+    end
+    column do |page|
+      link_to t(:set_as_root), set_as_root_admin_ordinary_cms_page_path(page), {method: :patch} unless page.root?
+    end
+    default_actions
+  end
+
+  form do |f|
+    f.inputs do
+      f.input :name
+      f.has_many :sections, allow_destroy: true do |section|
+        section.input :name
+        section.input :alias
+        section.input :content, as: :text
+      end
+    end
+
+    f.inputs name: 'Seo', for: [:seo, f.object.seo] do |s|
+      s.input :title
+      s.input :description
+      s.input :keywords
+    end
+
+    f.actions
+  end
+
+end

data/app/assets/javascripts/mercury.js

@@ -0,0 +1,461 @@
+/*!
+ * Mercury Editor is a CoffeeScript and jQuery based WYSIWYG editor.  Documentation and other useful information can be
+ * found at https://github.com/jejacks0n/mercury
+ *
+ * Minimum jQuery requirements are 1.7
+ *= require_self
+ *= require jquery
+ * You can include the Rails jQuery ujs script here to get some nicer behaviors in modals, panels and lightviews when
+ * using :remote => true within the contents rendered in them.
+ * require jquery_ujs
+ *
+ * Add any requires for the support libraries that integrate nicely with Mercury Editor.
+ * require mercury/support/history
+ *
+ * Require Mercury Editor itself.
+ *= require mercury/mercury
+ *
+ * Require any localizations you wish to support
+ * Example: es.locale, or fr.locale -- regional dialects are in each language file so never en_US for instance.
+ * Make sure you enable the localization feature in the configuration.
+ * require mercury/locales/swedish_chef.locale
+ *
+ * Add all requires for plugins that extend or change the behavior of Mercury Editor.
+ * require mercury/plugins/save_as_xml/plugin.js
+ *
+ * Require any files you want to use that either extend, or change the default Mercury behavior.
+ * require mercury_overrides
+ */
+
+
+
+window.Mercury = {
+
+    // # Mercury Configuration
+    config: {
+        // ## Toolbars
+        //
+        // This is where you can customize the toolbars by adding or removing buttons, or changing them and their
+        // behaviors.  Any top level object put here will create a new toolbar.  Buttons are simply nested inside the
+        // toolbars, along with button groups.
+        //
+        // Some toolbars are custom (the snippets toolbar for instance), and to denote that use _custom: true.  You can then
+        // build the toolbar yourself with it's own behavior.
+        //
+        // Buttons can be grouped, and a button group is simply a way to wrap buttons for styling -- they can also handle
+        // enabling or disabling all the buttons within it by using a context.  The table button group is a good example of
+        // this.
+        //
+        // It's important to note that each of the button names (keys), in each toolbar object must be unique, regardless of
+        // if it's in a button group, or nested, etc.  This is because styling is applied to them by name, and because their
+        // name is used in the event that's fired when you click on them.
+        //
+        // Button format: `[label, description, {type: action, type: action, etc}]`
+        //
+        // ### The available button types are:
+        //
+        // - toggle:    toggles on or off when clicked, otherwise behaves like a button
+        // - modal:     opens a modal window, expects the action to be one of:
+        //   1. a string url
+        //   2. a function that returns a string url
+        // - lightview: opens a lightview window (like modal, but different UI), expects the action to be one of:
+        //   1. a string url
+        //   2. a function that returns a string url
+        // - panel:     opens a panel dialog, expects the action to be one of:
+        //   1. a string url
+        //   2. a function that returns a string url
+        // - palette:   opens a palette window, expects the action to be one of:
+        //   1. a string url
+        //   2. a function that returns a string url
+        // - select:    opens a pulldown style window, expects the action to be one of:
+        //   1. a string url
+        //   2. a function that returns a string url
+        // - context:   calls a callback function, expects the action to be:
+        //   1. a function that returns a boolean to highlight the button
+        //   note: if a function isn't provided, the key will be passed to the contextHandler, in which case a default
+        //         context will be used (for more info read the Contexts section below)
+        // - mode:      toggle a given mode in the editor, expects the action to be:
+        //   1. a string, denoting the name of the mode
+        //   note: it's assumed that when a specific mode is turned on, all other modes will be turned off, which happens
+        //         automatically, thus putting the editor into a specific "state"
+        // - regions:   allows buttons to be enabled/disabled based on what region type has focus, expects:
+        //   1. an array of region types (eg. ['full', 'markdown'])
+        // - preload:   allows some dialog views to be loaded when the button is created instead of on first open, expects:
+        //   1. a boolean true / false
+        //   note: this is only used by panels, selects, and palettes
+        //
+        // Separators are any "button" that's not an array, and are expected to be a string.  You can use two different
+        // separator styles: line ('-'), and spacer (' ').
+        //
+        // ### Adding Contexts
+        //
+        // Contexts are used callback functions used for highlighting and disabling/enabling buttons and buttongroups.  When
+        // the cursor enters an element within an html region for instance we want to disable or highlight buttons based on
+        // the properties of the given node.  You can see examples of contexts in, and add your own to:
+        // `Mercury.Toolbar.Button.contexts` and `Mercury.Toolbar.ButtonGroup.contexts`
+        toolbars: {
+            primary: {
+                save:                  ['Save', 'Save this page'],
+                preview:               ['Preview', 'Preview this page', { toggle: true, mode: true }],
+                sep1:                  ' ',
+                undoredo:              {
+                    undo:                ['Undo', 'Undo your last action'],
+                    redo:                ['Redo', 'Redo your last action'],
+                    sep:                 ' '
+                },
+                insertLink:            ['Link', 'Insert Link', { modal: '/mercury/modals/link.html', regions: ['full', 'markdown'] }],
+                insertMedia:           ['Media', 'Insert Media (images and videos)', { modal: '/mercury/modals/media.html', regions: ['full', 'markdown'] }],
+                insertTable:           ['Table', 'Insert Table', { modal: '/mercury/modals/table.html', regions: ['full', 'markdown'] }],
+                insertCharacter:       ['Character', 'Special Characters', { modal: '/mercury/modals/character.html', regions: ['full', 'markdown'] }],
+                snippetPanel:          ['Snippet', 'Snippet Panel', { panel: '/mercury/panels/snippets.html' }],
+                sep2:                  ' ',
+                historyPanel:          ['History', 'Page Version History', { panel: '/mercury/panels/history.html' }],
+                sep3:                  ' ',
+                notesPanel:            ['Notes', 'Page Notes', { panel: '/mercury/panels/notes.html' }]
+            },
+
+            editable: {
+                _regions:              ['full', 'markdown'],
+                predefined:            {
+                    style:               ['Style', null, { select: '/mercury/selects/style.html', preload: true }],
+                    sep1:                ' ',
+                    formatblock:         ['Block Format', null, { select: '/mercury/selects/formatblock.html', preload: true }],
+                    sep2:                '-'
+                },
+                colors:                {
+                    backColor:           ['Background Color', null, { palette: '/mercury/palettes/backcolor.html', context: true, preload: true, regions: ['full'] }],
+                    sep1:                ' ',
+                    foreColor:           ['Text Color', null, { palette: '/mercury/palettes/forecolor.html', context: true, preload: true, regions: ['full'] }],
+                    sep2:                '-'
+                },
+                decoration:            {
+                    bold:                ['Bold', null, { context: true }],
+                    italic:              ['Italicize', null, { context: true }],
+                    overline:            ['Overline', null, { context: true, regions: ['full'] }],
+                    strikethrough:       ['Strikethrough', null, { context: true, regions: ['full'] }],
+                    underline:           ['Underline', null, { context: true, regions: ['full'] }],
+                    sep:                 '-'
+                },
+                script:                {
+                    subscript:           ['Subscript', null, { context: true }],
+                    superscript:         ['Superscript', null, { context: true }],
+                    sep: '-'
+                },
+                justify:               {
+                    justifyLeft:         ['Align Left', null, { context: true, regions: ['full'] }],
+                    justifyCenter:       ['Center', null, { context: true, regions: ['full'] }],
+                    justifyRight:        ['Align Right', null, { context: true, regions: ['full'] }],
+                    justifyFull:         ['Justify Full', null, { context: true, regions: ['full'] }],
+                    sep:                 '-'
+                },
+                list:                  {
+                    insertUnorderedList: ['Unordered List', null, { context: true }],
+                    insertOrderedList:   ['Numbered List', null, { context: true }],
+                    sep:                 '-'
+                },
+                indent:                {
+                    outdent:             ['Decrease Indentation'],
+                    indent:              ['Increase Indentation'],
+                    sep:                 '-'
+                },
+                table:                 {
+                    _context:            true,
+                    insertRowBefore:     ['Insert Table Row', 'Insert a table row before the cursor', { regions: ['full'] }],
+                    insertRowAfter:      ['Insert Table Row', 'Insert a table row after the cursor', { regions: ['full'] }],
+                    deleteRow:           ['Delete Table Row', 'Delete this table row', { regions: ['full'] }],
+                    insertColumnBefore:  ['Insert Table Column', 'Insert a table column before the cursor', { regions: ['full'] }],
+                    insertColumnAfter:   ['Insert Table Column', 'Insert a table column after the cursor', { regions: ['full'] }],
+                    deleteColumn:        ['Delete Table Column', 'Delete this table column', { regions: ['full'] }],
+                    sep1:                ' ',
+                    increaseColspan:     ['Increase Cell Columns', 'Increase the cells colspan'],
+                    decreaseColspan:     ['Decrease Cell Columns', 'Decrease the cells colspan and add a new cell'],
+                    increaseRowspan:     ['Increase Cell Rows', 'Increase the cells rowspan'],
+                    decreaseRowspan:     ['Decrease Cell Rows', 'Decrease the cells rowspan and add a new cell'],
+                    sep2:                '-'
+                },
+                rules:                 {
+                    horizontalRule:      ['Horizontal Rule', 'Insert a horizontal rule'],
+                    sep1:                '-'
+                },
+                formatting:            {
+                    removeFormatting:    ['Remove Formatting', 'Remove formatting for the selection', { regions: ['full'] }],
+                    sep2:                ' '
+                },
+                editors:               {
+                    htmlEditor:          ['Edit HTML', 'Edit the HTML content', { regions: ['full'] }]
+                }
+            },
+
+            snippets: {
+                _custom:               true,
+                actions:               {
+                    editSnippet:         ['Edit Snippet Settings'],
+                    sep1:                ' ',
+                    removeSnippet:       ['Remove Snippet']
+                }
+            }
+        },
+
+
+        // ## Region Options
+        //
+        // You can customize some aspects of how regions are found, identified, and saved.
+        //
+        // attribute: Mercury identifies editable regions by a data-mercury attribute.  This attribute has to be added in
+        // your HTML in advance, and is the only real code/naming exposed in the implementation of Mercury.  To allow this
+        // to be as configurable as possible, you can set the name of this attribute.  If you change this, you should adjust
+        // the injected styles as well.
+        //
+        // identifier: This is used as a unique identifier for any given region (and thus should be unique to the page).
+        // By default this is the id attribute but can be changed to a data attribute should you want to use something
+        // custom instead.
+        //
+        // dataAttributes: The dataAttributes is an array of data attributes that will be serialized and returned to the
+        // server upon saving.  These attributes, when applied to a Mercury region element, will be automatically serialized
+        // and submitted with the AJAX request sent when a page is saved.  These are expected to be HTML5 data attributes,
+        // and 'data-' will automatically be prepended to each item in this directive. (ex. ['scope', 'version'])
+        //
+        // determineType: This function is called after checking the data-type attribute for the correct field type. Use
+        // it if you want to dynamically set the type based on inspection of the region.
+        regions: {
+            attribute: 'data-mercury',
+            identifier: 'id',
+            dataAttributes: []
+            // determineType: function(region){},
+        },
+
+
+        // ## Snippet Options / Preview
+        //
+        // When a user drags a snippet onto the page they'll be prompted to enter options for the given snippet.  The server
+        // is expected to respond with a form.  Once the user submits this form, an Ajax request is sent to the server with
+        // the options provided; this preview request is expected to respond with the rendered markup for the snippet.
+        //
+        // method: The HTTP method used when submitting both the options and the preview.  We use POST by default because a
+        // snippet options form may contain large text inputs and we don't want that to be truncated when sent to the
+        // server.
+        //
+        // optionsUrl: The url that the options form will be loaded from.
+        //
+        // previewUrl: The url that the options will be submitted to, and will return the rendered snippet markup.
+        //
+        // **Note:** `:name` will be replaced with the snippet name in the urls (eg. /mercury/snippets/example/options.html)
+        snippets: {
+            method: 'POST',
+            optionsUrl: '/mercury/snippets/:name/options.html',
+            previewUrl: '/mercury/snippets/:name/preview.html'
+        },
+
+
+        // ## Image Uploading
+        //
+        // If you drag images from your desktop into regions that support it, it will be uploaded to the server and inserted
+        // into the region.  You can disable or enable this feature, the accepted mime-types, file size restrictions, and
+        // other things related to uploading.
+        //
+        // **Note:** Image uploading is only supported in some region types, and some browsers.
+        //
+        // enabled: You can set this to true, or false if you want to disable the feature entirely.
+        //
+        // allowedMimeTypes: You can restrict the types of files that can be uploaded by providing a list of allowed mime
+        // types.
+        //
+        // maxFileSize: You can restrict large files by setting the maxFileSize (in bytes).
+        //
+        // inputName: When uploading, a form is generated and submitted to the server via Ajax.  If your server would prefer
+        // a different name for how the image comes through, you can change the inputName.
+        //
+        // url: The url that the image upload will be submitted to.
+        //
+        // handler: You can use false to let Mercury handle it for you, or you can provide a handler function that can
+        // modify the response from the server.  This can be useful if your server doesn't respond the way Mercury expects.
+        // The handler function should take the response from the server and return an object that matches:
+        // `{image: {url: '[your provided url]'}`
+        uploading: {
+            enabled: true,
+            allowedMimeTypes: ['image/jpeg', 'image/gif', 'image/png'],
+            maxFileSize: 1235242880,
+            inputName: 'image[image]',
+            url: '/mercury/images',
+            handler: false
+        },
+
+
+        // ## Localization / I18n
+        //
+        // Include the .locale files you want to support when loading Mercury.  The files are always named by the language,
+        // and not the regional dialect (eg. en.locale.js) because the regional dialects are nested within the primary
+        // locale files.
+        //
+        // The client locale will be used first, and if no proper locale file is found for their language then the fallback
+        // preferredLocale configuration will be used.  If one isn't provided, and the client locale isn't included, the
+        // strings will remain untranslated.
+        //
+        // enabled: Set to false to disable, true to enable.
+        //
+        // preferredLocale: If a client doesn't support the locales you've included, this is used as a fallback.
+        localization: {
+            enabled: false,
+            preferredLocale: 'swedish_chef-BORK'
+        },
+
+
+        // ## Behaviors
+        //
+        // Behaviors are used to change the default behaviors of a given region type when a given button is clicked.  For
+        // example, you may prefer to add HR tags using an HR wrapped within a div with a classname (for styling).  You
+        // can add your own complex behaviors here and they'll be shared across all regions.
+        //
+        // If you want to add behaviors to specific region types, you can mix them into the actions property of any region
+        // type.
+        //
+        //     Mercury.Regions.Full.actions.htmlEditor = function() {}
+        //
+        // You can see how the behavior matches up directly with the button names.  It's also important to note that the
+        // callback functions are executed within the scope of the given region, so you have access to all it's methods.
+        behaviors: {
+            //foreColor: function(selection, options) { selection.wrap('<span style="color:' + options.value.toHex() + '">', true) },
+            htmlEditor: function() { Mercury.modal('/mercury/modals/htmleditor.html', { title: 'HTML Editor', fullHeight: true, handler: 'htmlEditor' }); }
+        },
+
+
+        // ## Global Behaviors
+        //
+        // Global behaviors are much like behaviors, but are more "global".  Things like save, exit, etc. can be included
+        // here.  They'll only be called once, and execute within the scope of whatever editor is instantiated (eg.
+        // PageEditor).
+        //
+        // An example of changing how saving works:
+        //
+        //     save: function() {
+        //       var data = top.JSON.stringify(this.serialize(), null, '  ');
+        //       var content = '<textarea style="width:500px;height:200px" wrap="off">' + data + '</textarea>';
+        //       Mercury.modal(null, {title: 'Saving', closeButton: true, content: content})
+        //     }
+        //
+        // This is a nice way to add functionality, when the behaviors aren't region specific.  These can be triggered by a
+        // button, or manually with `Mercury.trigger('action', {action: 'barrelRoll'})`
+        globalBehaviors: {
+            exit: function() { window.location.href = this.iframeSrc() },
+            barrelRoll: function() { $('body').css({webkitTransform: 'rotate(360deg)'}) }
+        },
+
+
+        // ## Ajax and CSRF Headers
+        //
+        // Some server frameworks require that you provide a specific header for Ajax requests.  The values for these CSRF
+        // tokens are typically stored in the rendered DOM.  By default, Mercury will look for the Rails specific meta tag,
+        // and provide the X-CSRF-Token header on Ajax requests, but you can modify this configuration if the system you're
+        // using doesn't follow the same standard.
+        csrfSelector: 'meta[name="csrf-token"]',
+        csrfHeader: 'X-CSRF-Token',
+
+
+        // ## Editor URLs
+        //
+        // When loading a given page, you may want to tweak this regex.  It's to allow the url to differ from the page
+        // you're editing, and the url at which you access it.
+        editorUrlRegEx: /([http|https]:\/\/.[^\/]*)\/editor\/?(.*)/i,
+
+
+        // ## Hijacking Links & Forms
+        //
+        // Mercury will hijack links and forms that don't have a target set, or the target is set to _self and will set it
+        // to _parent.  This is because the target must be set properly for Mercury to not get in the way of some
+        // functionality, like proper page loads on form submissions etc.  Mercury doesn't do this to links or forms that
+        // are within editable regions because it doesn't want to impact the html that's saved.  With that being explained,
+        // you can add classes to links or forms that you don't want this behavior added to.  Let's say you have links that
+        // open a lightbox style window, and you don't want the targets of these to be set to _parent.  You can add classes
+        // to this array, and they will be ignored when the hijacking is applied.
+        nonHijackableClasses: [],
+
+
+        // ## Pasting & Sanitizing
+        //
+        // When pasting content into Mercury it may sometimes contain HTML tags and attributes.  This markup is used to
+        // style the content and makes the pasted content look (and behave) the same as the original content.  This can be a
+        // desired feature or an annoyance, so you can enable various sanitizing methods to clean the content when it's
+        // pasted.
+        //
+        // sanitize: Can be any of the following:
+        // - false: no sanitizing is done, the content is pasted the exact same as it was copied by the user
+        // - 'whitelist': content is cleaned using the settings specified in the tag white list (described below)
+        // - 'text': all html is stripped before pasting, leaving only the raw text
+        //
+        // whitelist: The white list allows you to specify tags and attributes that are allowed when pasting content.  Each
+        // item in this object should contain the allowed tag, and an array of attributes that are allowed on that tag.  If
+        // the allowed attributes array is empty, all attributes will be removed.  If a tag is not present in this list, it
+        // will be removed, but without removing any of the text or tags inside it.
+        //
+        // **Note:** Content is *always* sanitized if looks like it's from MS Word or similar editors regardless of this
+        // configuration.
+        pasting: {
+            sanitize: 'whitelist',
+            whitelist: {
+                h1:     [],
+                h2:     [],
+                h3:     [],
+                h4:     [],
+                h5:     [],
+                h6:     [],
+                table:  [],
+                thead:  [],
+                tbody:  [],
+                tfoot:  [],
+                tr:     [],
+                th:     ['colspan', 'rowspan'],
+                td:     ['colspan', 'rowspan'],
+                div:    ['class'],
+                span:   ['class'],
+                ul:     [],
+                ol:     [],
+                li:     [],
+                b:      [],
+                strong: [],
+                i:      [],
+                em:     [],
+                u:      [],
+                strike: [],
+                br:     [],
+                p:      [],
+                hr:     [],
+                a:      ['href', 'target', 'title', 'name'],
+                img:    ['src', 'title', 'alt']
+            }
+        },
+
+
+        // ## Injected Styles
+        //
+        // Mercury tries to stay as much out of your code as possible, but because regions appear within your document we
+        // need to include a few styles to indicate regions, as well as the different states of them (eg. focused).  These
+        // styles are injected into your document, and as simple as they might be, you may want to change them.
+        injectedStyles: '' +
+            '[data-mercury]       { min-height: 10px; outline: 1px dotted #09F } ' +
+            '[data-mercury]:focus { outline: none; -webkit-box-shadow: 0 0 10px #09F, 0 0 1px #045; box-shadow: 0 0 10px #09F, 0 0 1px #045 }' +
+            '[data-mercury].focus { outline: none; -webkit-box-shadow: 0 0 10px #09F, 0 0 1px #045; box-shadow: 0 0 10px #09F, 0 0 1px #045 }' +
+            '[data-mercury]:after { content: "."; display: block; visibility: hidden; clear: both; height: 0; overflow: hidden; }' +
+            '[data-mercury] table { border: 1px dotted red; min-width: 6px; }' +
+            '[data-mercury] th    { border: 1px dotted red; min-width: 6px; }' +
+            '[data-mercury] td    { border: 1px dotted red; min-width: 6px; }' +
+            '[data-mercury] .mercury-textarea       { border: 0; box-sizing: border-box; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; resize: none; }' +
+            '[data-mercury] .mercury-textarea:focus { outline: none; -webkit-box-shadow: none; -moz-box-shadow: none; box-shadow: none; }'
+    },
+
+    // ## Silent Mode
+    //
+    // Turning silent mode on will disable asking about unsaved changes before leaving the page.
+    silent: false,
+
+    // ## Debug Mode
+    //
+    // Turning debug mode on will log events and other various things (using console.debug if available).
+    debug: false,
+
+    onload: function() {
+        Mercury.on('saved', function() {
+            window.location.href = window.location.href.replace(/\/editor\//i, '/');
+        });
+    }
+
+};

data/app/controllers/ordinary_cms/pages_controller.rb

@@ -0,0 +1,32 @@
+require_dependency "ordinary_cms/application_controller"
+
+module OrdinaryCms
+  class PagesController < ApplicationController
+    before_action :set_page, only: [:show, :update]
+    before_action ActiveAdmin.application.authentication_method, only: :update
+
+    def show
+      request.subdomain
+    end
+
+    def update
+      sections_keys = params[:content].keys - [:undefined]
+      sections_keys.each do |key|
+        section = @page.section(key)
+        section.update_attributes content: params[:content][key][:value] unless section.nil?
+      end
+      render text: ''
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_page
+        @page = Page.find(params[:id])
+      end
+
+      # Only allow a trusted parameter "white list" through.
+      def page_params
+        []
+      end
+  end
+end

data/app/controllers/ordinary_cms/root_controller.rb

@@ -0,0 +1,8 @@
+module OrdinaryCms
+  class RootController < ApplicationController
+    def show
+      @page = Page.find_by root: true
+      render 'ordinary_cms/pages/show'
+    end
+  end
+end

data/app/helpers/ordinary_cms/pages_helper.rb

@@ -0,0 +1,4 @@
+module OrdinaryCms
+  module PagesHelper
+  end
+end

data/app/models/ordinary_cms/page.rb

@@ -0,0 +1,20 @@
+module OrdinaryCms
+  class Page
+    include Mongoid::Document
+    include ActsAsPage
+
+    field :root, type: Boolean, default: false
+
+    embeds_many :sections, class_name: 'OrdinaryCms::Section'
+    accepts_nested_attributes_for :sections
+
+    def section(name)
+      sections.where(name: name).first
+    end
+
+    def set_as_root!
+      Page.where(root: true).update_all root: false
+      self.update_attributes! root: true
+    end
+  end
+end

data/app/models/ordinary_cms/section.rb

@@ -0,0 +1,29 @@
+module OrdinaryCms
+  class Section
+    include Mongoid::Document
+    include ActionView::Helpers::OutputSafetyHelper
+
+    field :name
+    field :alias
+    field :content
+
+    embedded_in :ordinary_cms_page
+
+    validates :name, uniqueness: true, presence: true
+
+    def self.[](key)
+      find_by name: key
+    end
+
+    def render(what=:content)
+      if what == :alias
+        ActionController::Base.helpers.content_tag(:span, 'data-mercury' => 'simple') {self.alias}
+      else
+        ActionController::Base.helpers.content_tag(
+            :div,
+            {class: 'section', id: self.name, 'data-mercury' => 'full'}) {raw self.content}
+      end
+
+    end
+  end
+end

data/app/views/ordinary_cms/pages/show.html.erb

@@ -0,0 +1,12 @@
+<p id="notice"><%= notice %></p>
+
+<p data-mercury="simple">
+  <strong>Name:</strong>
+  <%= @page.name %>
+</p>
+<strong>Text:</strong>
+<p data-mercury="full">
+  <%= @page.text %>
+</p>
+
+<%= @page.section('first').render %>

data/config/initializers/active_admin.rb

@@ -0,0 +1,5 @@
+require 'active_admin'
+ActiveAdmin.application.tap do |config|
+  config.load_paths << "#{OrdinaryCms::Engine.root}/app/admin"
+  config.load_paths <<  File.expand_path('app/admin', Rails.root)
+end

data/config/locales/en.yml

@@ -0,0 +1,19 @@
+en:
+  edit_content: Edit content
+  set_as_root: Set as Root
+  mongoid: &mongoid
+    models:
+      ordinary_cms/page:
+        one:   Page
+        other: Pages
+      ordinary_cms/section:
+        one:   Section
+        other: Sections
+
+    attributes:
+      ordinary_cms/page:
+        name: Name
+      ordinary_cms/section:
+        name: Name
+        alias: Alias
+        content: Content

data/config/locales/ru.yml

@@ -0,0 +1,24 @@
+ru:
+  edit_content: Редактировать стариницу
+  set_as_root: Установить главной
+
+  mongoid: &mongoid
+    models:
+      ordinary_cms/page:
+        one:   Страница
+        few:   Страницы
+        many:  Страниц
+        other: Страницы
+      ordinary_cms/section:
+        one:   Раздел
+        few:   Раздела
+        many:  Разделов
+        other: Разделы
+
+    attributes:
+      ordinary_cms/page:
+        name: Имя
+      ordinary_cms/section:
+        name: Имя
+        alias: Псевдоним
+        content: Контент

data/config/routes.rb

@@ -1,2 +1,6 @@
 OrdinaryCms::Engine.routes.draw do
+
+  resources :pages, only: [:show, :update]
+
+  root 'root#show'
 end

data/lib/generators/ordinary_cms/install/install_generator.rb

@@ -0,0 +1,22 @@
+require 'rails/generators'
+
+module OrdinaryCms
+  class InstallGenerator < Rails::Generators::Base
+    source_root OrdinaryCms::Engine.root
+    argument :name, type: :string, default: "AdminUser"
+
+    def generate_activeadmin
+      generate("active_admin:install", name) unless ARGV.include? "--skip-activeadmin"
+    end
+
+    def copy_mercury_config
+      copy_file 'app/assets/javascripts/mercury.js'
+    end
+
+    def add_routes
+      route %Q{mount Mercury::Engine => '/'}
+      route %Q{mount OrdinaryCms::Engine => '/'}
+    end
+
+  end
+end

data/lib/ordinary_cms/engine.rb

@@ -1,3 +1,7 @@
+require 'acts_as_page'
+require 'active_admin'
+require 'active_admin-mongoid'
+
 module OrdinaryCms
   class Engine < ::Rails::Engine
     isolate_namespace OrdinaryCms

data/lib/ordinary_cms/version.rb

@@ -1,3 +1,3 @@
 module OrdinaryCms
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,29 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: ordinary_cms
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
 platform: ruby
 authors:
 - max-konin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-08-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: haml-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sass-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid_acts_as_page
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.0.0.beta1
 description: Description of OrdinaryCms.
 email:
 - maxim21214@gmail.com
@@ -34,12 +90,24 @@ files:
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
+- app/admin/ordinary_cms/page.rb
+- app/assets/javascripts/mercury.js
 - app/assets/javascripts/ordinary_cms/application.js
 - app/assets/stylesheets/ordinary_cms/application.css
 - app/controllers/ordinary_cms/application_controller.rb
+- app/controllers/ordinary_cms/pages_controller.rb
+- app/controllers/ordinary_cms/root_controller.rb
 - app/helpers/ordinary_cms/application_helper.rb
+- app/helpers/ordinary_cms/pages_helper.rb
+- app/models/ordinary_cms/page.rb
+- app/models/ordinary_cms/section.rb
 - app/views/layouts/ordinary_cms/application.html.erb
+- app/views/ordinary_cms/pages/show.html.erb
+- config/initializers/active_admin.rb
+- config/locales/en.yml
+- config/locales/ru.yml
 - config/routes.rb
+- lib/generators/ordinary_cms/install/install_generator.rb
 - lib/ordinary_cms.rb
 - lib/ordinary_cms/engine.rb
 - lib/ordinary_cms/version.rb