smithycms 0.0.1

data/app/controllers/smithy/page_contents_controller.rb

@@ -0,0 +1,90 @@
+require_dependency "smithy/base_controller"
+
+module Smithy
+  class PageContentsController < BaseController
+    before_filter :load_page
+    before_filter :load_page_content, :only => [ :edit, :update, :destroy, :preview ]
+    before_filter :build_content_block, :only => [ :edit, :update ]
+    before_filter :load_content_blocks, :only => [ :new, :create ]
+    respond_to :html, :json
+
+    def new
+      @page_content = Smithy::PageContent.new(params[:page_content])
+      @page_content.label = [@page.title, @page_content.container.titleize].join(' - ') unless @page_content.label?
+    end
+
+    def create
+      @page_content = Smithy::PageContent.new
+      # we have to ensure that the content_block_type gets added before the content_block_attributes
+      # see PageContent#content_block_attributes=
+      @page_content.content_block_type = params[:page_content][:content_block_type]
+      @page_content.attributes = params[:page_content]
+      @page_content.page = @page
+      @page_content.save
+      respond_with @page_content do |format|
+        format.html { @page_content.persisted? ? redirect_to(edit_page_content_path(@page.id, @page_content)) : render(:action => 'new') }
+      end
+    end
+
+    def edit
+      respond_with @page_content
+    end
+
+    def update
+      @page_content = Smithy::PageContent.find(params[:id])
+      @saved = @page_content.update_attributes(params[:page_content])
+      flash.notice = "Your content was saved" if @saved
+      respond_with @page_content do |format|
+        format.html { @saved ? redirect_to(edit_page_path(@page.id)) : render(:action => "edit") }
+      end
+    end
+
+    def destroy
+      @page_content.destroy
+      respond_with @page_content do |format|
+        format.html { redirect_to edit_page_path(@page.id), :notice => "Your content was deleted from the page" }
+      end
+    end
+
+    def preview
+      respond_with @page_content do |format|
+        format.html { render :text => @page_content.render, :layout => 'smithy/modal' }
+      end
+    end
+
+    def order
+      params[:order].each_with_index do |page_content_id, index|
+        page_content = @page.contents.find(page_content_id)
+        page_content.update_attribute(:position, index)
+      end
+      if request.xhr?
+        render :nothing => true, :status => 200
+      else
+        redirect_to edit_page_path(@page.id)
+      end
+    end
+
+    private
+      def build_content_block
+        unless @page_content.content_block.present?
+          klass = "Smithy::#{@page_content.content_block_type.classify}".safe_constantize || @page_content.content_block_type.classify.safe_constantize
+          if klass
+            @page_content.content_block = klass.new
+          end
+        end
+      end
+
+      def load_content_blocks
+        @content_blocks = Smithy::ContentBlock.all
+      end
+
+      def load_page
+        @page = Smithy::Page.find(params[:page_id])
+      end
+
+      def load_page_content
+        @page_content = Smithy::PageContent.find(params[:id])
+      end
+
+  end
+end

data/app/controllers/smithy/pages_controller.rb

@@ -0,0 +1,110 @@
+require_dependency "smithy/base_controller"
+
+module Smithy
+  class PagesController < BaseController
+    skip_before_filter :authenticate_smithy_admin, :only => [ :show ]
+    include Smithy::Liquid::Rendering
+    before_filter :load_page_from_path, :only => [ :show ]
+    before_filter :initialize_page, :only => [ :new, :create ]
+    before_filter :load_page, :only => [ :edit, :update, :destroy ]
+    before_filter :load_parent, :except => [ :index, :show, :order ]
+    before_filter :load_root, :only => [ :index ]
+    respond_to :html, :json
+
+    def index
+      respond_with @root
+    end
+
+    def show
+      render_page and return if smithy_current_user # no caching if you're editing
+      # adding :public param allow Rack::Cache to cache the result
+      @page.cache_length == 0 ? expires_now : expires_in(@page.cache_length.to_i.seconds, :public => true)
+      render_page if stale?(:etag => @page, :last_modified => @page.updated_at.utc, :public => true)
+    end
+
+    def new
+      respond_with @page
+    end
+
+    def create
+      @page.save
+      flash.notice = "Your page was created #{@page.published? ? 'and published' : 'as a draft'}" if @page.persisted?
+      respond_with @page do |format|
+        format.html { @page.persisted? ? redirect_to(edit_page_path(@page.id)) : render(:action => 'new') }
+      end
+    end
+
+    def edit
+      respond_with @page
+    end
+
+    def update
+      flash.notice = "Your page was saved #{@page.published? ? 'and published' : 'as a draft'}" if @page.update_attributes(params[:page])
+      respond_with @page do |format|
+        format.html { redirect_to edit_page_path(@page.id) }
+      end
+    end
+
+    def destroy
+      @page.destroy
+      respond_with @page.parent ? @page.parent : @page
+    end
+
+    def order
+      first = Smithy::Page.find(params[:order].shift)
+      @parent = first.parent
+      if @parent && @parent.children.count > 1 # Only need to order if there are multiple children.
+        left = first.id
+        params[:order].each do |page_id|
+          page = Smithy::Page.find(page_id)
+          page.move_to_right_of(left)
+          left = page.id
+        end
+      end
+      render :nothing => true, :status => 200 and return if request.xhr?
+      redirect_to pages_path
+    end
+
+    private
+      def initialize_page
+        @page = Page.new(params[:page])
+        set_publish
+      end
+
+      def load_page
+        @page = Page.find(params[:id])
+        @root = @page if Page.root == @page
+        set_publish
+      end
+
+      def load_page_from_path
+        @page = Page.find(page_path)
+        redirect_to @page.external_link and return false if @page.external_link?
+      end
+
+      def load_parent
+        @parent = @page.parent
+      end
+
+      def load_root
+        @root = Page.root
+      end
+
+      def page_path
+        params[:path] = '' if params[:id].nil? && params[:path].nil? # sets the root path when nothing else is passed
+        params[:path].nil? ? params[:id] : "/#{params[:path]}"
+      end
+
+      def render_page
+        respond_with @page do |format|
+          format.html { render_smithy_page }
+        end
+      end
+
+      def set_publish
+        @page.publish = true if params[:publish].present?
+        @page.publish = false if params[:draft].present?
+      end
+
+  end
+end

data/app/controllers/smithy/settings_controller.rb

@@ -0,0 +1,46 @@
+require_dependency "smithy/base_controller"
+
+module Smithy
+  class SettingsController < BaseController
+    respond_to :html, :json
+
+    def index
+      @settings = Setting.all
+      respond_with @settings
+    end
+
+    def show
+      @setting = Setting.find(params[:id])
+      respond_with @setting
+    end
+
+    def new
+      @setting = Setting.new(params[:setting])
+      respond_with @setting
+    end
+
+    def create
+      @setting = Setting.new(params[:setting])
+      @setting.save
+      flash.notice = "Your setting was created" if @setting.persisted?
+      respond_with @setting
+    end
+
+    def edit
+      @setting = Setting.find(params[:id])
+      respond_with @setting
+    end
+
+    def update
+      @setting = Setting.find(params[:id])
+      flash.notice = "Your setting was saved" if @setting.update_attributes(params[:setting])
+      respond_with @setting
+    end
+
+    def destroy
+      @setting = Setting.find(params[:id])
+      @setting.destroy
+      respond_with @setting
+    end
+  end
+end

data/app/controllers/smithy/sitemap_controller.rb

@@ -0,0 +1,13 @@
+require_dependency "smithy/base_controller"
+
+module Smithy
+  class SitemapController < BaseController
+    respond_to :xml
+    skip_before_filter :authenticate_smithy_admin
+
+    def show
+      @pages = Smithy::Page.root.self_and_descendants
+      respond_with @pages
+    end
+  end
+end

data/app/controllers/smithy/templates_controller.rb

@@ -0,0 +1,79 @@
+require_dependency "smithy/base_controller"
+
+module Smithy
+  class TemplatesController < BaseController
+    skip_before_filter :authenticate_smithy_admin, :only => [ :javascript, :stylesheet ]
+    before_filter :load_templates
+    respond_to :html, :json
+
+    def index
+      respond_with @templates
+    end
+
+    def new
+      @template = Template.new(params[:template])
+      respond_with @template
+    end
+
+    def create
+      @template = Template.new(params[:template])
+      @template.save
+      flash.notice = "Your template was created" if @template.persisted?
+      respond_with @template do |format|
+        format.html { redirect_to [:edit, @template] }
+      end
+    end
+
+    def edit
+      @template = Template.find(params[:id])
+      @template_editor_type = case @template.template_type
+      when 'javascript'
+        'javascript'
+      when 'stylesheet'
+        'css'
+      else
+        'liquid'
+      end
+      respond_with @template
+    end
+
+    def update
+      @template = Template.find(params[:id])
+      flash.notice = "Your template was saved" if @template.update_attributes(params[:template])
+      respond_with @template do |format|
+        format.html { redirect_to [:edit, @template] }
+      end
+    end
+
+    def destroy
+      @template = Template.find(params[:id])
+      @template.destroy
+      respond_with @template
+    end
+
+    def javascript
+      @javascript = Template.javascripts.find_by_name(params[:javascript].sub(/\.js$/, ''))
+      render_asset_template(@javascript, params[:javascript], 'text/javascript')
+    end
+
+    def stylesheet
+      @stylesheet = Template.stylesheets.find_by_name(params[:stylesheet].sub(/\.css$/, ''))
+      render_asset_template(@stylesheet, params[:stylesheet], 'text/css')
+    end
+
+    private
+      def load_templates
+        @templates = Template.templates
+        @includes = Template.partials
+        @javascripts = Template.javascripts
+        @stylesheets = Template.stylesheets
+      end
+
+      def render_asset_template(template, template_name, content_type)
+        raise ActiveRecord::RecordNotFound, "No such stylesheet '#{template_name}'" unless template.present?
+        expires_in(2592000.seconds, :public => true) # cache for 30 days
+        headers['X-Content-Digest'] = Digest::SHA1.hexdigest(template.content) # digest of the content for cache control when the template changes
+        render :text => template.content, :content_type => content_type
+      end
+  end
+end

data/app/helpers/smithy/application_helper.rb

@@ -0,0 +1,36 @@
+module Smithy
+  module ApplicationHelper
+    def link_to_add_fields(name, association, form_builder)
+      html = content_tag(:div, :id => "#{association}_fields_blueprint", :style => "display:none;") do
+        form_builder.semantic_fields_for(association, model_object(form_builder, association), :child_index => "new_#{association}") do |builder|
+          form_builder.template.concat(raw render("#{form_builder.object.class.to_s.tableize}/#{association.to_s.singularize}_fields", :f => builder))
+        end
+      end
+      form_builder.template.concat(html)
+      form_builder.template.link_to(name, "javascript:void(0)", :class => "add_nested_fields", "data-association" => association)
+    end
+
+    def link_to_remove_fields(name, form_builder)
+      form_builder.hidden_field(:_destroy) + @template.link_to(name, "javascript:void(0)", :class => "remove_nested_fields")
+    end
+
+    def render_markdown_input(fieldname, editor_name, form_builder)
+      content_for(:javascript) do
+        javascript_tag do
+          raw("var editor = ace_edit('#{form_builder.object.id || 'new'}', 'markdown', '#{editor_name}');\n") +
+          raw("editor.renderer.setShowGutter(false);")
+        end
+      end
+      hint = "Use markdown syntax for formatting. You can also use HTML directly. <a href=\"#{guide_path('markdown')}\" data-toggle=\"remote-load\" data-target=\"#content-guide\">See our markdown syntax reference</a>".html_safe
+      form_builder.input(fieldname, :as => :text, :input_html => { :class => "span12", :id => "#{editor_name}-#{form_builder.object.id || 'new'}" }, :hint => hint) +
+      content_tag(:div, nil, :id => "#{editor_name}_editor-#{form_builder.object.id || 'new'}", :class => "#{editor_name}_editor ace_editor") +
+      content_tag(:div, nil, :id => 'content-guide')
+    end
+
+    private
+      def model_object(form_builder, association)
+        model_object = form_builder.object.class.reflect_on_association(association).klass.new
+      end
+
+  end
+end

data/app/helpers/smithy/assets_helper.rb

@@ -0,0 +1,9 @@
+module Smithy
+  module AssetsHelper
+    def asset_image_tag(asset_id)
+      asset = Smithy::Asset.find_by_id(asset_id)
+      return unless asset
+      image_tag(asset.file.url(:host => "#{request.protocol}#{request.host_with_port}"), :alt => asset.name)
+    end
+  end
+end

data/app/helpers/smithy/pages_helper.rb

@@ -0,0 +1,12 @@
+module Smithy
+  module PagesHelper
+    def tree_for_select
+      tree_for_select = []
+      Smithy::Page.each_with_level(Smithy::Page.root.self_and_descendants) do |page, level|
+        prepend = level == 0 ? '' : "#{'-' * level} "
+        tree_for_select << [ "#{prepend}#{page.title}", page.id]
+      end if Smithy::Page.root.present?
+      tree_for_select
+    end
+  end
+end

data/app/helpers/smithy/settings_helper.rb

@@ -0,0 +1,4 @@
+module Smithy
+  module SettingsHelper
+  end
+end

data/app/helpers/smithy/templates_helper.rb

@@ -0,0 +1,4 @@
+module Smithy
+  module TemplatesHelper
+  end
+end

data/app/helpers/smithy/upload_helper.rb

@@ -0,0 +1,110 @@
+module Smithy
+  module UploadHelper
+    def uploader_form(object, options = {}, &block)
+      # s3_uploader = S3Uploader.new(options)
+      # uploader = s3_uploader.s3_available? ? s3_uploader : FileUploader.new(options)
+      uploader = S3Uploader.new(options)
+      form_tag(uploader.url, uploader.form_options) do
+        uploader.fields.map do |name, value|
+          hidden_field_tag(name, value)
+        end.join.html_safe + capture(&block)
+      end
+    end
+
+    class Base
+      def form_options
+        {
+          id: @options[:id],
+          method: "post",
+          authenticity_token: false,
+          multipart: true,
+          data: {
+            post: @options[:post],
+            as: @options[:as]
+          }
+        }
+      end
+    end
+
+    class FileUploader < Base
+      def initialize(options)
+        @options = options.reverse_merge( id: "fileupload" )
+      end
+
+      def fields
+        { :key => key }
+      end
+
+      def key
+        @key ||= "uploads/assets/${filename}"
+      end
+
+      def url
+        @options[:post]
+      end
+    end
+
+    class S3Uploader < Base
+      def initialize(options)
+        @options = options.reverse_merge(
+          id: "fileupload",
+          aws_access_key_id: ENV["AWS_ACCESS_KEY_ID"],
+          aws_secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"],
+          bucket: ENV["AWS_S3_BUCKET"],
+          acl: "public-read",
+          expiration: 10.hours.from_now,
+          max_file_size: 500.megabytes,
+          as: "file"
+        )
+      end
+
+      def fields
+        {
+          :key => key,
+          :acl => @options[:acl],
+          :policy => policy,
+          :signature => signature,
+          "AWSAccessKeyId" => @options[:aws_access_key_id],
+        }
+      end
+
+      def key
+        @key ||= "uploads/assets/#{SecureRandom.hex}/${filename}"
+      end
+
+      def url
+        "https://#{@options[:bucket]}.s3.amazonaws.com/"
+      end
+
+      def policy
+        Base64.encode64(policy_data.to_json).gsub("\n", "")
+      end
+
+      def policy_data
+        {
+          expiration: @options[:expiration].utc.iso8601,
+          conditions: [
+            ["starts-with", "$utf8", ""],
+            ["starts-with", "$key", ""],
+            ["content-length-range", 0, @options[:max_file_size]],
+            {bucket: @options[:bucket]},
+            {acl: @options[:acl]}
+          ]
+        }
+      end
+
+      def signature
+        Base64.encode64(
+          OpenSSL::HMAC.digest(
+            OpenSSL::Digest::Digest.new('sha1'),
+            @options[:aws_secret_access_key], policy
+          )
+        ).gsub("\n", "")
+      end
+
+      def s3_available?
+        @options[:aws_access_key_id].present? && @options[:aws_secret_access_key].present? && @options[:bucket].present?
+      end
+    end
+  end
+end

data/app/models/smithy/asset.rb

@@ -0,0 +1,64 @@
+module Smithy
+  class Asset < ActiveRecord::Base
+    attr_accessible :name, :file, :file_name, :file_url, :retained_file, :uploaded_file_url
+
+    validates_presence_of :file, :name
+
+    has_many :images, :dependent => :destroy
+
+    file_accessor :file
+    include Smithy::Dragonfly::AssetHelper
+
+    before_validation :set_name
+    before_save :set_file_uid_manually
+
+    default_scope order(:name)
+
+    def file
+      # check for the jquery uploaded file first, just in case one got past the manual check. Also keeps backwards-compatibility
+      if self.uploaded_file_url?
+        dragonfly_attachments[:file].app.datastore = self.class.dragonfly_remote_datastore
+        self.file_url = URI.escape(self.uploaded_file_url)
+      elsif dragonfly_attachments[:file].to_value
+        dragonfly_attachments[:file].app.datastore = self.class.dragonfly_datastore
+      end
+      dragonfly_attachments[:file].to_value
+    end
+
+    def to_liquid
+      {
+        'id' => self.id,
+        'name' => self.name,
+        'content_type' => self.content_type,
+        'file' => self.file,
+        'file_name' => self.file_name,
+        'file_width' => self.file_width,
+        'file_height' => self.file_height,
+        'file_size' => self.file_size,
+        'url' => self.file.url
+      }
+    end
+
+    private
+      def set_content_types
+        set_content_type(self.file, :content_type)
+      end
+
+      # this allows dragonfly to take over management of the uploaded file. We are
+      # assuming that jquery-upload and dragonfly are using the same data storage...
+      def set_file_uid_manually
+        if self.uploaded_file_url? # this means it was uploaded via jquery-upload
+          self.file_uid = URI.parse(self.uploaded_file_url).path.sub(/^\//, '')
+          self.uploaded_file_url = nil
+        end
+      end
+
+      def set_name
+        if self.uploaded_file_url?
+          self.name = File.basename(self.uploaded_file_url, '.*').titleize unless self.name?
+        elsif self.file.present?
+          self.name = File.basename(self.file.name, '.*').titleize unless self.name?
+        end
+     end
+  end
+end

data/app/models/smithy/content.rb

@@ -0,0 +1,35 @@
+module Smithy
+  class Content < ActiveRecord::Base
+    include Smithy::ContentBlocks::Model
+
+    attr_accessible :content
+
+    validates_presence_of :content
+
+    before_save :render_markdown_content
+
+    class << self
+      def content_block_description
+        "Content is primarily used for adding text-based content to your pages"
+      end
+    end
+
+    def formatted_content
+      self.markdown_content
+    end
+
+    def to_liquid
+      {
+        'id' => self.id,
+        'content' => self.content,
+        'formatted_content' => self.formatted_content
+      }
+    end
+
+    private
+      def render_markdown_content
+        formatter = Smithy::Formatter.new(self.content)
+        self.markdown_content = formatter.render
+      end
+  end
+end

data/app/models/smithy/content_block.rb

@@ -0,0 +1,41 @@
+module Smithy
+  class ContentBlock < ActiveRecord::Base
+    attr_accessible :name, :templates_attributes
+
+    validates_presence_of :name
+
+    has_many :templates, :class_name => "ContentBlockTemplate"
+    has_many :page_contents
+
+    after_save :touch_page_contents
+
+    accepts_nested_attributes_for :templates, :reject_if => lambda {|a| a['name'].blank? || a['content'].blank? }, :allow_destroy => true
+
+    default_scope order(:name)
+
+    def description
+      klass.content_block_description if klass
+    end
+
+    def content_field_names
+      unless @content_field_names
+        if klass.new.respond_to?(:to_liquid)
+          @content_field_names = klass.new.to_liquid.keys
+        else
+          @content_field_names = klass.column_names.delete_if{|column_name| ["id", "created_at", "updated_at"].include?(column_name) }
+        end
+      end
+      @content_field_names
+    end
+
+    private
+      def klass
+        @klass ||= "#{self.name}".safe_constantize || "Smithy::#{self.name}".safe_constantize
+      end
+
+      def touch_page_contents
+        self.page_contents.each(&:touch)
+      end
+
+  end
+end

data/app/models/smithy/content_block_template.rb

@@ -0,0 +1,26 @@
+module Smithy
+  class ContentBlockTemplate < ActiveRecord::Base
+    attr_accessible :content, :name
+
+    belongs_to :content_block, :touch => true
+    has_many :page_contents
+
+    validates_presence_of :name
+    validates_uniqueness_of :name, :scope => :content_block_id
+    validates_presence_of :content
+
+    after_save :touch_page_contents
+
+    default_scope order(:name)
+
+    def liquid_template
+      @liquid_template ||= ::Liquid::Template.parse(self.content)
+    end
+
+    private
+      def touch_page_contents
+        self.page_contents.each(&:touch)
+      end
+
+  end
+end