landable 1.7.0

data/app/controllers/landable/api/templates_controller.rb

@@ -0,0 +1,33 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class TemplatesController < ApiController
+      def index
+        respond_with Template.all
+      end
+
+      def create
+        template = Template.new(template_params)
+        template.save!
+        respond_with template, status: :created, location: template_url(template)
+      end
+
+      def show
+        respond_with Template.find(params[:id])
+      end
+
+      def update
+        template = Template.find(params[:id])
+        template.update_attributes! template_params
+        respond_with template
+      end
+
+      private
+
+      def template_params
+        params.require(:template).permit(:id, :name, :body, :description, :thumbnail_url, :slug, :is_layout)
+      end
+    end
+  end
+end

data/app/controllers/landable/api/themes_controller.rb

@@ -0,0 +1,57 @@
+require_dependency "landable/api_controller"
+
+module Landable
+  module Api
+    class ThemesController < ApiController
+      def index
+        respond_with Theme.all
+      end
+
+      def create
+        theme = Theme.new(theme_params)
+        theme.save!
+        respond_with theme, status: :created, location: theme_url(theme)
+      end
+
+      def show
+        respond_with Theme.find(params[:id])
+      end
+
+      def update
+        theme = Theme.find(params[:id])
+        theme.update_attributes! theme_params
+        respond_with theme
+      end
+
+      def preview
+        theme = Theme.new(theme_params)
+        page  = Page.example(theme: theme)
+
+        params[:theme][:asset_ids].try(:each) do |asset_id|
+          theme.attachments.add Asset.find(asset_id)
+        end
+
+        content = render_to_string(
+          text: RenderService.call(page),
+          layout: page.theme.file || false
+        )
+
+        respond_to do |format|
+          format.html do
+            render text: content, layout: false, content_type: 'text/html'
+          end
+
+          format.json do
+            render json: {theme: {preview: content}}
+          end
+        end
+      end
+
+      private
+
+      def theme_params
+        params.require(:theme).permit(:id, :name, :body, :description, :thumbnail_url)
+      end
+    end
+  end
+end

data/app/controllers/landable/api_controller.rb

@@ -0,0 +1,75 @@
+require_dependency "landable/application_controller"
+require_dependency "landable/api_responder"
+require_dependency "landable/author"
+
+module Landable
+  class ApiController < ApplicationController
+    # skip any of these that may have been inherited from ::ApplicationController
+    skip_before_filter :protect_from_forgery
+    skip_before_action :verify_authenticity_token
+
+    # tracking is not necessary for API calls
+    skip_around_action :track_with_landable!
+
+    before_filter :require_author!
+
+    respond_to :json
+    self.responder = Landable::ApiResponder
+
+    rescue_from ActiveRecord::RecordNotFound do |ex|
+      head 404
+    end
+
+    rescue_from ActiveRecord::RecordInvalid do |ex|
+      render json: { errors: ex.record.errors }, status: :unprocessable_entity
+    end
+
+    rescue_from ActionController::UnknownFormat do |ex|
+      head :not_acceptable
+    end
+
+    rescue_from ActiveRecord::StaleObjectError do |ex|
+      render json: { author: ex.record.updated_by_author }, status: 409
+    end
+
+    rescue_from PG::Error do |ex|
+      if ex.message =~ /invalid input syntax for uuid/
+        head :not_found
+      else
+        raise ex
+      end
+    end
+
+
+    # here's looking at you, http://developer.github.com/v3/media/
+    # mime type matching is still handled by rails - see lib/landable/mime_types.rb
+
+    API_MEDIA_REGEX = /^application\/vnd\.landable(\.v(?<version>[\w\-]+))?(\.(?<param>(?:[\w\-]+)))?(\+(?<format>[\w\-]+))?/
+
+    def api_media
+      @api_media ||= begin
+        accept = request.headers['Accept'].match(API_MEDIA_REGEX) || {}
+
+        {
+          version: Landable::VERSION::STRING,
+          format:  request.format.symbol,
+          param:   accept['param'].presence,
+        }
+      end
+    end
+
+    protected
+
+    def require_author!
+      head :unauthorized if current_author.nil?
+    end
+
+    def current_author
+      return @current_author if @current_author
+      authenticate_with_http_basic do |username, token|
+        @current_author = Author.authenticate!(username, token)
+      end
+    end
+
+  end
+end

data/app/controllers/landable/application_controller.rb

@@ -0,0 +1,4 @@
+module Landable
+  class ApplicationController < ::ApplicationController
+  end
+end

data/app/controllers/landable/public/pages_controller.rb

@@ -0,0 +1,25 @@
+require_dependency "landable/application_controller"
+
+module Landable
+  module Public
+    class PagesController < ApplicationController
+      respond_to :html
+
+      self.responder = Landable::PageRenderResponder
+
+      def show
+        respond_with current_snapshot
+      end
+
+      private
+
+      def current_page
+        @current_page ||= Page.by_path(request.path)
+      end
+
+      def current_snapshot
+        @current_snapshot ||= current_page.published_revision.try(:snapshot) or Page.missing
+      end
+    end
+  end
+end

data/app/controllers/landable/public/preview/page_revisions_controller.rb

@@ -0,0 +1,16 @@
+require_dependency "landable/application_controller"
+
+module Landable
+  module Public
+    module Preview
+      class PageRevisionsController < ApplicationController
+        respond_to :html
+
+        def show
+          revision = PageRevision.find params[:id]
+          respond_with revision.snapshot, responder: Landable::PageRenderResponder
+        end
+      end
+    end
+  end
+end

data/app/controllers/landable/public/preview/pages_controller.rb

@@ -0,0 +1,16 @@
+require_dependency "landable/application_controller"
+
+module Landable
+  module Public
+    module Preview
+      class PagesController < ApplicationController
+        respond_to :html
+
+        def show
+          page = Page.find params[:id]
+          respond_with page, responder: Landable::PageRenderResponder, preview: true
+        end
+      end
+    end
+  end
+end

data/app/controllers/landable/public/sitemap_controller.rb

@@ -0,0 +1,18 @@
+require_dependency "landable/application_controller"
+
+module Landable
+  module Public
+    class SitemapController < ApplicationController
+      def index
+        sitemap = Landable::Page.generate_sitemap(
+          host: Landable.configuration.sitemap_host || request.host,
+          protocol: Landable.configuration.sitemap_protocol,
+          exclude_categories: Landable.configuration.sitemap_exclude_categories,
+          sitemap_additional_paths: Landable.configuration.sitemap_additional_paths,
+        )
+
+        render xml: sitemap
+      end
+    end
+  end
+end

data/app/decorators/landable/null_page_decorator.rb

@@ -0,0 +1,26 @@
+module Landable
+  class NullPageDecorator < Landable::PageDecorator
+    def initialize
+    end
+
+    def title
+      # Obviously, this should instead be configured with Landable in some way,
+      # such that you can register the titles you want everywhere. Or, of course,
+      # a more reasonable way to bypass Landable entirely yet still use the
+      # `landable` helper. Just waiting to tease out what features we need.
+      content_tag('title', 'No current page; default title')
+    end
+
+    def meta_tags
+      ''
+    end
+
+    def path
+      ''
+    end
+
+    def body
+      ''
+    end
+  end
+end

data/app/decorators/landable/page_decorator.rb

@@ -0,0 +1,40 @@
+module Landable
+  class PageDecorator
+    include ActionView::Helpers::TagHelper
+
+    def initialize(page)
+      raise TypeError.new("Use Landable::NullPageDecorator") if page.nil?
+      @page = page
+    end
+
+    def title
+      content_tag('title', page.title) if page.title?
+    end
+
+    def path
+      page.path
+    end
+
+    def body
+      page.body.try(:html_safe)
+    end
+
+    def head_content
+      page.head_content.try(:html_safe)
+    end
+
+    def meta_tags
+      return unless tags = page.meta_tags
+      Rails.logger.info "Meta tags string: #{tags}" if tags.is_a? String
+      return if tags.empty? or !tags.is_a? Hash
+
+      tags.map { |name, value|
+        tag('meta', name: name, content: value) if value.present?
+      }.compact.join("\n").html_safe
+    end
+
+    private
+
+    attr_reader :page # Keeping it private until there's a compelling reason not to
+  end
+end

data/app/helpers/landable/application_helper.rb

@@ -0,0 +1,13 @@
+module Landable
+  module ApplicationHelper
+    def method_missing(method, *args, &block)
+      return main_app.send(method, *args) if method =~ /_(path|url)$/ && main_app.respond_to?(method)
+      super
+    end
+
+    def respond_to?(method)
+      return true if method =~ /_(path|url)$/ && main_app.respond_to?(method)
+      super
+    end
+  end
+end

data/app/helpers/landable/pages_helper.rb

@@ -0,0 +1,20 @@
+module Landable
+  module PagesHelper
+    def landable(page = current_page)
+      return Landable::NullPageDecorator.new if page.nil?
+      @landable ||= Landable::PageDecorator.new(page)
+    end
+
+    def current_page
+      if params[:controller] == "landable/public/preview/page_revisions"
+        current_page = PageRevision.find(params[:id])
+      elsif params[:controller] == "landable/public/preview/pages"
+        current_page = Page.find(params[:id])
+      else
+        current_page = Page.by_path(request.path)
+      end
+
+      @current_page ||= current_page
+    end
+  end
+end

data/app/models/concerns/landable/has_assets.rb

@@ -0,0 +1,74 @@
+# Pages, page revisions, and themes are all renderable. Rendering potentially
+# involves assets. Rather than having to query for each asset as it's
+# discovered, this concern allows retrieval of all asset names for a given
+# body (#asset_names), and commits the habtm relation on save (#save_assets!;
+# allows us to say "this asset belongs to 3 pages"). #assets is overridden to
+# ensure that the assets returned /always/ reflect assets present in the Liquid
+# template.
+
+require_dependency 'landable/liquid'
+
+module Landable
+  module HasAssets
+    extend ActiveSupport::Concern
+
+    included do
+      has_and_belongs_to_many :assets, class_name: 'Landable::Asset', join_table: assets_join_table_name
+
+      before_save :save_assets!
+
+      def asset_names
+        # sticking with what we know about liquid, rather than doing regex.
+        # (though regex may be faster, should we need that optimization later.)
+        @asset_names ||= begin
+          template = ::Liquid::Template.parse(body)
+          asset_names_for_node template.root
+        end
+      end
+
+      def assets
+        Landable::Asset.where(name: asset_names)
+      end
+
+      # {asset_name: asset}
+      def assets_as_hash
+        Hash[assets.map { |asset| [asset.name, asset] }]
+      end
+
+      # passthrough for body=; clears the asset_names cache in the process
+      def body= body_val
+        @asset_names = nil
+        self[:body] = body_val
+      end
+
+      # this looks weird; I swear it works
+      def save_assets!
+        self.assets = self.assets
+      end
+
+
+      private
+
+      def asset_names_for_node node, names = []
+        # set up a recursing function to search for asset tags
+        if node.is_a? Landable::Liquid::AssetTag
+          names << node.asset_name unless names.include? node.asset_name
+        end
+
+        if node.respond_to? :nodelist and node.nodelist
+          node.nodelist.each { |node| asset_names_for_node node, names }
+        end
+
+        names
+      end
+
+    end
+
+    module ClassMethods
+      def assets_join_table_name
+        "#{Landable.configuration.database_schema_prefix}landable.#{self.name.underscore.split('/').last}_assets"
+      end
+    end
+
+  end
+end

data/app/models/concerns/landable/table_name.rb

@@ -0,0 +1,12 @@
+module Landable
+  module TableName
+    extend ActiveSupport::Concern 
+
+    included do
+      model_name = self.model_name.element.pluralize
+      schema_name = "#{Landable.configuration.database_schema_prefix}landable"
+      self.table_name = "#{schema_name}.#{model_name}"
+    end
+
+  end
+end