smithycms 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012-2013 Tim Glen
+
+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,142 @@
+# Smithy CMS
+
+[![Code Climate](https://codeclimate.com/github/sterrym/smithy.png)](https://codeclimate.com/github/sterrym/smithy)
+
+## Templates & Includes
+These are the building blocks of a page. All the markup is written using the Liquid templating engine. This allows anyone to be able to write templates without the dangers of exposing the whole stack to the template editor.
+
+## Pages
+On top of its own innate elements (title, permalink, etc), each page belongs to a template and through the template, has a set of available content containers. To each container, pieces of content can be added and organized via various "Content Blocks".
+
+## Content Blocks
+A "Content Block" is simply an ActiveRecord model with a Smithy inclusion (<code>include Smithy::ContentBlocks::Model</code>), a <code>_form_fields</code> partial (preferably utilizing formtastic) and it's own set of templates, managed within Smithy.
+
+## Getting Started
+To get started, add this to your Gemfile
+
+```ruby
+gem 'smithy', :github => 'sterrym/smithy'
+```
+
+If you need basic authentication and don't want to integrate with existing auth in your system, add this to your Gemfile too:
+gem 'smithy-auth', :github => 'sterrym/smithy-auth'
+
+Installing the CMS is simple, you can just
+
+```shell
+bundle install
+rake smithy:install:migrations
+rake smithy_auth:install:migrations # (if you are using smithy-auth)
+rake db:migrate
+```
+
+To your routes file, you need to mount Smithy - typically, this would be done at the root
+
+```ruby
+mount Smithy::Engine => "/"
+```
+
+Now start up your server and go to http://localhost:nnnn/smithy
+
+## Integrating with third-party authentication
+
+Add this to your routes file (below the `mount Smithy::Engine` line). It will redirect smithy/login|logout (the built-in paths) to your existing authentication paths.
+
+```ruby
+scope "/smithy" do
+  match "/login" => redirect("/your/login/path"), :as => :login
+  match '/logout' => redirect("/"), :as => :logout
+end
+```
+
+Add the following to your application controller:
+
+```ruby
+def smithy_current_user
+  current_user # use whichever method name you have implemented to return the current_user
+end
+helper_method :smithy_current_user
+```
+
+If you wish for all of your users to have access to smithy, simply add this method to your user model:
+
+```ruby
+def smithy_admin?
+  true
+end
+```
+
+Alternatively, you can add a boolean field (via migration) named `smithy_admin` to your users table and manage the field with with your existing user management.
+
+Restart your local server and you should be good to go.
+
+### Templates
+
+Create your first Template, naming it whatever you want ("Home" or "Default" or something equally original). In the content, add `{{ page.container.main_content }}`. In the background, this will auto-create a container that will be used by any page using your template. You can name your container whatever you would like: `{{ page.container.foo }}` works as well. After you have created new page containers, they will automatically show up on the Page edit screen and allow you to add content to the container.
+
+If you want, you can create Includes. For instance, if you create an Include named "header", you can utilize it in your Template via `{% include 'header' %}`.
+
+Note, you can also create stylesheet and javascript files, included in your templates via smithy_stylesheet_link_tag and smithy_javascript_include_tag. javascript_include_tag calls out directly to ActionView so you can also access files from your host application directly. Eg. `{% smithy_javascript_include_tag 'my_special_javascript' %}`
+
+### Pages
+
+Follow the "Manage Content" link in the header and create your first page. Add a Title ("Home" for instance), select your Template and save the page. The page will save and you will be on the Edit screen for your new page. You can see that your "Main Content" container is now available.
+
+### Content Blocks
+
+Smithy comes with some useful Content Blocks already created, though you may need to add them to your system: Content, Image, PageList. After adding a Content Block, you must also create at least one template for it before you can use it on a page. Once you have added a template, you can utilize that Content Block in any available Page container.
+
+### Adding Custom Content Blocks
+
+While Smithy has some default Content Blocks, you will often want to add your own structured content, allowing you to manage templates for more structured content. To add a custom Content Block, do the following:
+
+1. create a new table & model or use an existing one from your app. This can be a single, stand-alone model or a model with associations, Smithy doesn't really care.
+2. Add `include Smithy::ContentBlocks::Model` to the top of your model. This gives some extra functionality for Smithy.
+2. Add a views/mymodel/_form_fields.html.erb to your app, replacing "mymodel" with your new model name. This is identical to adding your own view/partial for the model. An "f" variable is passed to the partial, which represents a formtastic form. While formtastic is outside the scope of this document (look it up!), you can also just create your form however you want though it will be way simpler to just use formtastic syntax!
+3. Smithy will automatically look for your _form_fields.html.erb partial to manage the Content Block when adding Page Content to a page.
+4. Register your Content Block by entering the Smithy admin, clicking on Content Blocks and adding a new Content Block with your new model name, creating a template for your new Content Block at the same time.
+
+Your _form_fields.html.erb file could look something like this:
+
+```ruby
+<%= f.inputs "Client Story" do %>
+  <%= f.input :client_name %>
+  <%= f.input :project_name %>
+  <%= f.input :content, :as => :text, :input_html => { :class => "span12" } %>
+<% end %>
+```
+
+If you want to customize which columns are available to your liquid template, you can add a #to_liquid method to your model. Eg.:
+
+```ruby
+def to_liquid
+  {
+    'id' => self.id,
+    'client_name' => self.client_name,
+    'project_name' => self.project_name,
+    'content' => self.content,
+    'story_images' => self.images.map(&:to_liquid),
+    'formatted_content' => self.formatted_content
+  }
+end
+```
+Using the above #to_liquid method, your template could look like this:
+
+```html
+<article class="client_story" id="client_story-{{ id }}">
+  <div class="content">
+    <h3>{{ client_name }}</h3>
+    {% unless project_name == blank %}<h4>{{ project_name }}</h4>{% endunless %}
+    {{ formatted_content }}
+  </div>
+  <div class="images">
+    <div class="cycle-slideshow">
+      {% for story_image in story_images %}
+      <img src="{{ story_image.thumbnail.url }}" alt="">
+      {% endfor %}
+    </div>
+  </div>
+</article>
+```
+
+If you want to be able to represent your ContentBlock uniquely in different contexts, you can simply create more templates and choose which template to use in each context.

data/Rakefile

@@ -0,0 +1,27 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Smithy'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+

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

@@ -0,0 +1,13 @@
+//= require jquery
+//= require jquery_ujs
+//= require 'smithy/jquery-ui.min'
+//= require jquery-fileupload/basic
+//= require jquery-fileupload/vendor/tmpl
+//= require bootstrap
+//= require ace/ace
+//= require ace/mode-css.js
+//= require ace/mode-html.js
+//= require ace/mode-javascript.js
+//= require ace/mode-liquid.js
+//= require ace/mode-markdown.js
+//= require_tree .

data/app/assets/javascripts/smithy/assets.js.coffee

@@ -0,0 +1,35 @@
+# Place all the behaviors and hooks related to the matching controller here.
+# All this logic will automatically be available in application.js.
+# You can use CoffeeScript in this file: http://jashkenas.github.com/coffee-script/
+jQuery ->
+  $('#fileupload').fileupload
+    add: (e, data) ->
+      types = /(\.|\/)(gif|jpe?g|png|pdf)$/i
+      file = data.files[0]
+      if types.test(file.type) || types.test(file.name)
+        data.context = $(tmpl("template-upload", file))
+        $('#fileupload').append(data.context)
+        data.submit()
+      else
+        alert("#{file.name} is not a gif, jpeg, png or pdf file")
+
+    progress: (e, data) ->
+      if data.context
+        progress = parseInt(data.loaded / data.total * 100, 10)
+        data.context.find('.bar').css('width', progress + '%')
+
+    done: (e, data) ->
+      file = data.files[0]
+      domain = $('#fileupload').attr('action')
+      path = $('#fileupload input[name=key]').val().replace('${filename}', file.name)
+      to = $('#fileupload').data('post') + ".js"
+      content = {}
+      content[$('#fileupload').data('as')] = domain + path
+      $.post(to, content)
+
+      data.context.remove() if data.context # remove progress bar
+
+    fail: (e, data) ->
+      alert("#{data.files[0].name} failed to upload.")
+      console.log("Upload failed:")
+      console.log(data)

data/app/assets/javascripts/smithy/guides.js

@@ -0,0 +1,23 @@
+$('[data-toggle="remote-load"]').click(function(e) {
+  e.preventDefault();
+  var activator = this;
+  var remote = $(this).attr("href");
+  var target = $(this).attr("data-target");
+  if ($(target).filter(":empty").length > 0) {
+    $(target).hide();
+    $.ajax($(this).attr("href"), {
+      success: function(data) {
+        $(target).append($('<div data-type="remote-load"></div>').append(data));
+        $('[data-dismiss="remote-load"]', $(target)).on('click', function(e) {
+          e.preventDefault();
+          $(activator).click();
+        });
+        $(target).slideDown('slow');
+      }
+    });
+  } else if ($(target).filter(":hidden").length > 0) {
+    $(target).slideDown('slow');
+  } else if ($(target).filter(":visible").length > 0) {
+    $(target).slideUp('slow');
+  }
+});