smithycms 0.0.1

data/lib/smithy/dependencies.rb

@@ -0,0 +1,19 @@
+require 'rack/cache'
+
+require 'awesome_nested_set'
+require 'bootstrap-sass'
+require 'awesome_nested_set'
+require 'dragonfly'
+require 'fog'
+require 'font-awesome-sass-rails'
+require 'formtastic'
+require 'formtastic-bootstrap'
+require 'friendly_id'
+require 'httparty'
+require 'kaminari'
+require 'jquery-fileupload-rails'
+require 'jquery/rails'
+require 'liquid'
+require 'sass-rails'
+require 'slodown'
+

data/lib/smithy/dragonfly/asset_helper.rb

@@ -0,0 +1,67 @@
+module Smithy
+  module Dragonfly
+    module AssetHelper
+
+      extend ActiveSupport::Concern
+      included do
+        before_save :set_content_types
+      end
+
+      module ClassMethods
+        def content_types
+          {
+            :image      => ['image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/x-png', 'image/jpg', 'image/x-icon'],
+            :media      => [/^video/, 'application/x-shockwave-flash', 'application/x-flash-video', 'application/x-swf', /^audio/, 'application/ogg', 'application/x-mp3'],
+            :pdf        => ['application/pdf', 'application/x-pdf'],
+            :stylesheet => ['text/css'],
+            :javascript => ['text/javascript', 'text/js', 'application/x-javascript', 'application/javascript', 'text/x-component'],
+            :font       => ['application/x-font-ttf', 'application/vnd.ms-fontobject', 'image/svg+xml', 'application/x-woff']
+          }
+        end
+
+        def dragonfly_datastore
+          if ENV['AWS_ACCESS_KEY_ID'].present? && ENV['AWS_SECRET_ACCESS_KEY'].present? && ENV['AWS_S3_BUCKET'].present?
+            datastore = ::Dragonfly::DataStorage::S3DataStore.new
+            datastore.configure do |c|
+              c.bucket_name = ENV['AWS_S3_BUCKET']
+              c.access_key_id = ENV['AWS_ACCESS_KEY_ID']
+              c.secret_access_key = ENV['AWS_SECRET_ACCESS_KEY']
+              # c.region = 'eu-west-1'                        # defaults to 'us-east-1'
+              # c.storage_headers = {'some' => 'thing'}       # defaults to {'x-amz-acl' => 'public-read'}
+              # c.url_scheme = 'https'                        # defaults to 'http'
+              # c.url_host = 'some.custom.host'               # defaults to "<bucket_name>.s3.amazonaws.com"
+            end
+          else
+            datastore = ::Dragonfly::DataStorage::FileDataStore.new
+          end
+          datastore
+        end
+
+        def dragonfly_remote_datastore
+          ::Smithy::Dragonfly::DataStorage::RemoteDataStore.new
+        end
+
+      end
+
+      def set_content_types
+        # empty by default - override in your own models if you need to use it
+      end
+
+      def set_content_type(file, content_type_column)
+        return unless file.present?
+        value = :other
+        content_type = file.mime_type
+        self.class.content_types.each_pair do |type, rules|
+          rules.each do |rule|
+            case rule
+            when String then value = type if content_type == rule
+            when Regexp then value = type if (content_type =~ rule) == 0
+            end
+          end
+        end
+        self[content_type_column] = value.to_s
+      end
+
+    end
+  end
+end

data/lib/smithy/dragonfly/remote_data_store.rb

@@ -0,0 +1,33 @@
+require 'httparty'
+module Smithy
+  module Dragonfly
+    module DataStorage
+      class RemoteDataStore
+        include ::Dragonfly::Configurable
+
+        def store(temp_object, opts={})
+          # raise "Sorry friend, this datastore is read-only."
+        end
+
+        def retrieve(uid)
+          response = HTTParty.get uid, :timeout => 3
+          unless response.ok?
+            #raise Forbidden if response.code == 403
+            raise DataNotFound
+          end
+
+          content = response.body
+          extra_data = {}
+          [
+            content,            # either a File, String or Tempfile
+            extra_data          # Hash with optional keys :meta, :name, :format
+          ]
+        end
+
+        def destroy(uid)
+          raise "Sorry friend, this datastore is read-only."
+        end
+      end
+    end
+  end
+end

data/lib/smithy/dragonfly.rb

@@ -0,0 +1,30 @@
+require 'smithy/dragonfly/asset_helper'
+require 'smithy/dragonfly/remote_data_store'
+module Smithy
+  module Dragonfly
+
+    def self.resize_url(source, resize_string)
+      file = nil
+
+      if source.is_a?(String)
+        source.strip!
+        if source =~ /^http/
+          file = self.app.fetch_url(source)
+        else
+          file = self.app.fetch_file(File.join('public', source))
+        end
+      elsif source.respond_to?(:url) # dragonfly uploader
+        file = source
+      else
+        Smithy.log :error, "Unable to resize on the fly: #{source.inspect}"
+        return
+      end
+      file.process(:thumb, resize_string).url
+    end
+
+    def self.app
+      ::Dragonfly[:files]
+    end
+
+  end
+end

data/lib/smithy/engine.rb

@@ -0,0 +1,48 @@
+module Smithy
+  class Engine < ::Rails::Engine
+    isolate_namespace Smithy
+
+    class << self
+      attr_accessor :root
+      def root
+        @root ||= Pathname.new(File.expand_path('../../', File.dirname(__FILE__)))
+      end
+    end
+
+    config.autoload_paths += %W(#{config.root}/lib)
+
+    config.to_prepare do
+      # include the Smithy helpers in the host application
+      ::ApplicationController.send :helper, Smithy::Engine.helpers
+    end
+
+    config.generators do |g|
+      g.test_framework :rspec, :fixture => false, :view_specs => false
+      g.integration_tool :rspec
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+
+    config.after_initialize do
+      # We need to reload the routes here due to how Smithy sets them up.
+      # The different facets of Smithy (auth) append/prepend routes to Smithy
+      # *after* the main engine has been loaded.
+      #
+      # So we wait until after initialization is complete to do one final reload.
+      # This then makes the appended/prepended routes available to the application.
+      Rails.application.routes_reloader.reload!
+      # we need to require all our model files so that ContentBlocks
+      # are registered with the engine
+      Dir[Smithy::Engine.root.join('app', 'models', 'smithy', '*.rb')].each do |file|
+        require_dependency file if ActiveRecord::Base.connection.table_exists?(file.pluralize)
+      end
+    end
+
+    # TODO: Abstract out the configuration
+    # initializer "smithy.config", :before => :load_config_initializers do |app|
+    #   Smithy::Config = app.config.smithy.preferences
+    # end
+
+  end
+end

data/lib/smithy/formatter.rb

@@ -0,0 +1,46 @@
+module Smithy
+  class Formatter < ::Slodown::Formatter
+
+    def render
+      self.complete.to_s
+    end
+
+    private
+      def kramdown_options
+        { coderay_css: 'style' }
+      end
+
+      def sanitize_config
+        {
+          elements: %w(
+            p br a span sub sup strong em div hr abbr
+            ul ol li
+            blockquote pre code
+            h1 h2 h3 h4 h5 h6
+            img object param del
+          ),
+          attributes: {
+            :all     => ['class', 'style', 'title', 'id'],
+            'a'      => ['href', 'rel', 'name', 'target'],
+            'li'     => ['id'],
+            'sup'    => ['id'],
+            'img'    => ['src', 'title', 'alt', 'width', 'height'],
+            'object' => ['width', 'height'],
+            'param'  => ['name', 'value'],
+            'embed'  => ['allowscriptaccess', 'width', 'height', 'src'],
+            'iframe' => ['width', 'height', 'src']
+          },
+          protocols: {
+            'a' => { 'href' => ['ftp', 'http', 'https', 'mailto', '#fn', '#fnref', :relative] },
+            'img' => {'src'  => ['http', 'https', :relative]},
+            'iframe' => {'src'  => ['http', 'https']},
+            'embed' => {'src'  => ['http', 'https']},
+            'object' => {'src'  => ['http', 'https']},
+            'li' => {'id' => ['fn']},
+            'sup' => {'id' => ['fnref']}
+          },
+          transformers: ::Slodown::EmbedTransformer
+        }
+      end
+  end
+end

data/lib/smithy/liquid/database.rb

@@ -0,0 +1,12 @@
+module Smithy
+  module Liquid
+    class Database
+      def read_template_file(template_path, context)
+        _include = Smithy::Template.partials.where(:name => template_path).first
+        raise ActiveRecord::RecordNotFound, "No such template '#{template_path}'" unless _include.present?
+
+        _include.content
+      end
+    end
+  end
+end

data/lib/smithy/liquid/drops/base.rb

@@ -0,0 +1,16 @@
+module Smithy
+  module Liquid
+    module Drops
+      class Base < ::Liquid::Drop
+        attr_reader :_source
+        def initialize(source)
+          @_source = source
+        end
+
+        def id
+          (@_source.respond_to?(:id) ? @_source.id : nil) || 'new'
+        end
+      end
+    end
+  end
+end

data/lib/smithy/liquid/drops/page.rb

@@ -0,0 +1,78 @@
+module Smithy
+  module Liquid
+    module Drops
+      class Page < Base
+        delegate :title, :depth, :permalink, :root, :site, :to => '_source'
+
+        def breadcrumbs
+          self._source.ancestors.where(["id != ?", root]).map(&:to_liquid)
+        end
+
+        def browser_title
+          self._source.browser_title.present? ? self._source.browser_title : self.generated_browser_title
+        end
+
+        def children
+          self._source.children.map(&:to_liquid)
+        end
+
+        def container
+          self.rendered_containers
+        end
+
+        def meta_description
+          self._source.description
+        end
+
+        def meta_keywords
+          self._source.keywords
+        end
+
+        def parent
+          self._source.parent.to_liquid
+        end
+
+        def path
+          self._source.url
+        end
+
+        def published?
+          self._source.published?
+        end
+
+        def show_in_navigation?
+          self._source.show_in_navigation?
+        end
+
+        def root?
+          self._source.root?
+        end
+
+        def leaf?
+          self._source.leaf?
+        end
+
+        def child?
+          self._source.child?
+        end
+
+        protected
+          def generated_browser_title
+            @generated_browser_title ||= generated_browser_titles.join(' | ')
+          end
+
+          def rendered_containers
+            Hash[ *_source.containers.map(&:name).map{|cn| [cn, _source.render_container(cn) ] }.flatten ]
+          end
+
+        private
+          def generated_browser_titles
+            titles = _source.self_and_ancestors.map(&:title)
+            titles.shift unless _source.root? # keep all except the first element unless root
+            titles << site.title if site.title.present?
+            titles
+          end
+      end
+    end
+  end
+end

data/lib/smithy/liquid/filters/asset_tag.rb

@@ -0,0 +1,33 @@
+module Smithy
+  module Liquid
+    module Filters
+      module AssetTag
+        def image_tag(input, *args)
+          image_options = inline_options(args_to_options(args))
+          "<img src=\"#{input}\" #{image_options}>"
+        end
+
+        protected
+          # Convert an array of properties ('key:value') into a hash
+          # Ex: ['width:50', 'height:100'] => { :width => '50', :height => '100' }
+          def args_to_options(*args)
+            options = {}
+            args.flatten.each do |a|
+              if (a =~ /^(.*):(.*)$/)
+                options[$1.to_sym] = $2
+              end
+            end
+            options
+          end
+
+          # Write options (Hash) into a string according to the following pattern:
+          # <key1>="<value1>", <key2>="<value2", ...etc
+          def inline_options(options = {})
+            return '' if options.empty?
+            (options.stringify_keys.sort.to_a.collect { |a, b| "#{a}=\"#{b}\"" }).join(' ') << ' '
+          end
+      end
+      ::Liquid::Template.register_filter(AssetTag)
+    end
+  end
+end

data/lib/smithy/liquid/filters/resize.rb

@@ -0,0 +1,12 @@
+module Smithy
+  module Liquid
+    module Filters
+      module Resize
+        def resize(input, resize_string)
+          Locomotive::Dragonfly.resize_url(input, resize_string)
+        end
+      end
+      ::Liquid::Template.register_filter(Resize)
+    end
+  end
+end

data/lib/smithy/liquid/rendering.rb

@@ -0,0 +1,50 @@
+module Smithy
+  module Liquid
+    module Rendering
+
+      private
+
+      def render_smithy_page
+        if smithy_current_user
+          output = @page.template.liquid_template.render(liquid_context)
+        else
+          output = Rails.cache.fetch("#{@page.cache_key}-render_smithy_page") do
+            @page.template.liquid_template.render(liquid_context)
+          end
+        end
+        render :text => output, :layout => false
+      end
+
+      def render_as_smithy_page(template_name)
+        output = Smithy::Template.templates.find_by_name(template_name).liquid_template.render(liquid_context)
+        render :text => output, :layout => false
+      end
+
+      def liquid_context
+        ::Liquid::Context.new({}, smithy_default_assigns, smithy_default_registers, false)
+      end
+
+      def smithy_default_assigns
+        {
+          'page'              => @page,
+          'current_page'      => self.params[:path],
+          'params'            => self.params,
+          'path'              => request.path,
+          'fullpath'          => request.fullpath,
+          'url'               => request.url,
+          'now'               => Time.now.utc,
+          'today'             => Date.today,
+          'site'              => @page.site
+        }
+      end
+
+      def smithy_default_registers
+        {
+          :controller => self,
+          :page => @page,
+          :site => @page.site
+        }
+      end
+    end
+  end
+end

data/lib/smithy/liquid/tags/asset.rb

@@ -0,0 +1,54 @@
+module Smithy
+  module Liquid
+    module Tags
+      module Asset
+        class AssetImageTag < ::Liquid::Tag
+          Syntax = /(#{::Liquid::Expression}+)?/
+          def initialize(tag_name, markup, tokens)
+            if markup =~ Syntax
+              @asset_id = $1.gsub('\'', '').strip
+              if @asset = ::Smithy::Asset.find_by_id(@asset_id)
+                @url = @asset.file.url
+                @alt = @asset.name
+              else
+                @url = @asset_id
+                @alt = ''
+              end
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in '#{@tag_name}' - Valid syntax: image_tag <asset_id|path>")
+            end
+            super
+          end
+
+          def render(context)
+            controller  = context.registers[:controller]
+            controller.view_context.send(:image_tag, @url, :alt => @alt)
+          end
+        end
+        class AssetFilePath < ::Liquid::Tag
+          Syntax = /(#{::Liquid::Expression}+)?/
+          def initialize(tag_name, markup, tokens)
+            if markup =~ Syntax
+              @asset_id = $1.gsub('\'', '')
+              if @asset = ::Smithy::Asset.find_by_id(@asset_id)
+                @url = @asset.file.url
+              else
+                @url = @asset_id
+              end
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in '#{@tag_name}' - Valid syntax: file_path <asset_id|path>")
+            end
+            super
+          end
+
+          def render(context)
+            @url
+          end
+        end
+      end
+      ::Liquid::Template.register_tag('asset_image_tag', Asset::AssetImageTag)
+      ::Liquid::Template.register_tag('asset_image_path', Asset::AssetFilePath)
+      ::Liquid::Template.register_tag('asset_file_path', Asset::AssetFilePath)
+    end
+  end
+end

data/lib/smithy/liquid/tags/csrf.rb

@@ -0,0 +1,30 @@
+module Smithy
+  module Liquid
+    module Tags
+      module Csrf
+
+        class Param < ::Liquid::Tag
+          def render(context)
+            controller  = context.registers[:controller]
+            name        = controller.send(:request_forgery_protection_token).to_s
+            value       = controller.send(:form_authenticity_token)
+            %(<input type="hidden" name="#{name}" value="#{value}">)
+          end
+        end
+
+        class Meta < ::Liquid::Tag
+          def render(context)
+            controller  = context.registers[:controller]
+            name        = controller.send(:request_forgery_protection_token).to_s
+            value       = controller.send(:form_authenticity_token)
+            %{<meta name="csrf-param" content="#{name}">\n} +
+            %{<meta name="csrf-token" content="#{value}">}
+          end
+        end
+      end
+      ::Liquid::Template.register_tag('csrf_param', Csrf::Param)
+      ::Liquid::Template.register_tag('csrf_meta_tag', Csrf::Meta)
+      ::Liquid::Template.register_tag('csrf_meta_tags', Csrf::Meta)
+    end
+  end
+end

data/lib/smithy/liquid/tags/html.rb

@@ -0,0 +1,61 @@
+
+module Smithy
+  module Liquid
+    module Tags
+      module Html
+        class Base < ::Liquid::Tag
+          Syntax = /(#{::Liquid::Expression}+)?/
+          def initialize(tag_name, markup, tokens)
+            if markup =~ Syntax
+              @tag = $1.gsub('\'', '')
+            else
+              raise ::Liquid::SyntaxError.new("Syntax Error in '#{tag_name}' - Valid syntax: #{tag_name} <path_to/your_file>")
+            end
+            super
+          end
+
+          def tag
+            @tag
+          end
+
+          def tag_with_ext(ext)
+            tag.match(/\.#{ext}$/) ? tag : "#{tag}.#{ext}"
+          end
+
+          def render(context)
+            raise Error.new("please override Smithy::Liquid::Tag::Html::Base#render")
+          end
+        end
+
+        class StylesheetLinkTag < Base
+          def render(context)
+            controller = context.registers[:controller]
+            controller.view_context.send(:stylesheet_link_tag, tag)
+          end
+        end
+        class JavascriptIncludeTag < Base
+          def render(context)
+            controller = context.registers[:controller]
+            controller.view_context.send(:javascript_include_tag, tag)
+          end
+        end
+        class SmithyJavascriptIncludeTag < Base
+          def render(context)
+            controller = context.registers[:controller]
+            controller.view_context.send(:javascript_include_tag, "/templates/javascripts/#{tag_with_ext('js')}")
+          end
+        end
+        class SmithyStylesheetLinkTag < Base
+          def render(context)
+            controller = context.registers[:controller]
+            controller.view_context.send(:stylesheet_link_tag, "/templates/stylesheets/#{tag_with_ext('css')}")
+          end
+        end
+      end
+      ::Liquid::Template.register_tag('stylesheet_link_tag', Html::StylesheetLinkTag)
+      ::Liquid::Template.register_tag('javascript_include_tag', Html::JavascriptIncludeTag)
+      ::Liquid::Template.register_tag('smithy_javascript_include_tag', Html::SmithyJavascriptIncludeTag)
+      ::Liquid::Template.register_tag('smithy_stylesheet_link_tag', Html::SmithyStylesheetLinkTag)
+    end
+  end
+end

data/lib/smithy/liquid/tags/nav.rb

@@ -0,0 +1,76 @@
+module Smithy
+  module Liquid
+    module Tags
+      class Nav < ::Liquid::Tag
+        Syntax = /(#{::Liquid::Expression}+)?/
+
+        # {% nav site|page, id: 'main-nav', depth: 1, class: 'nav', active_class: 'on' }
+        def initialize(tag_name, markup, tokens)
+          @options = { :id => 'nav', :depth => 1, :class => '', :active_class => 'on' }
+          if markup =~ Syntax
+            @source = ($1 || 'site').gsub(/"|'/, '')
+            markup.scan(::Liquid::TagAttributes) do |key, value|
+              @options[key.to_sym] = value.gsub(/"|'/, '')
+            end
+            @options[:depth] = @options[:depth].to_i
+            @options[:depth] = 100 if @options[:depth] == 0
+            @options[:wrapper] == "false" ? false : true
+          else
+            raise ::Liquid::SyntaxError.new("Syntax Error in 'nav' - Valid syntax: nav <site|page|section> <options>")
+          end
+          super
+        end
+
+        def parse(tokens)
+          @tokens = tokens
+        end
+
+        def render(context)
+          @site = context.registers[:site]
+          @page = context.registers[:page]
+          @controller = context.registers[:controller]
+          render_wrapper(render_list_items(root_node, 1), @options[:id])
+        end
+
+        def render_children(parent, depth)
+          list_items = render_list_items(parent, depth)
+          return unless list_items.present?
+          render_wrapper(list_items)
+        end
+
+        def render_list_item(item, depth)
+          item_id = "#{@options[:id]}-#{item.permalink}"
+          href = item.url
+          label = item.title
+          css_class = " class=\"#{@options[:active_class]}\"" if (@page && @page.id == item.id) || (@controller && [item.path, item.external_link].include?(@controller.request.path))
+          %Q{#{"  " * depth}<li id="#{item_id}"#{css_class}><a href="#{href}" id="#{item_id}-link">#{label}</a>#{render_children(item, depth.succ)}</li>}
+        end
+
+        def render_list_items(parent, depth)
+          return if depth > @options[:depth] || parent.leaf?
+          parent.children.included_in_navigation.inject([]) do |items, item|
+            items << render_list_item(item, depth)
+          end.join("\n")
+        end
+
+        def render_wrapper(list_items, id = nil)
+          list_id = id.present? ? " id=\"#{id}\"" : ''
+          %Q{<ul#{list_id}>\n#{list_items}\n</ul>}
+        end
+
+        def root_node
+          case @source
+          when 'site'
+            Smithy::Page.root
+          when 'page'
+            @page
+          when 'section'
+            @page == Smithy::Page.root ? @page : @page.self_and_ancestors.second
+          end
+        end
+
+      end
+      ::Liquid::Template.register_tag('nav', Nav)
+    end
+  end
+end