landable 1.7.0

data/app/responders/landable/page_render_responder.rb

@@ -0,0 +1,15 @@
+module Landable
+  class PageRenderResponder < ActionController::Responder
+    def to_html
+      page = resource
+
+      case page.status_code
+      when 200      then render text: RenderService.call(page, preview: options[:preview], responder: self),
+                                content_type: page.content_type,
+                                layout: (page.theme.try(:file) || false)
+      when 301, 302 then redirect_to page.redirect_url, status: page.status_code
+      else          raise page.error
+      end
+    end
+  end
+end

data/app/serializers/landable/access_token_serializer.rb

@@ -0,0 +1,6 @@
+module Landable
+  class AccessTokenSerializer < ActiveModel::Serializer
+    attributes :id, :expires_at
+    has_one :author, embed: :object
+  end
+end

data/app/serializers/landable/asset_serializer.rb

@@ -0,0 +1,14 @@
+module Landable
+  class AssetSerializer < ActiveModel::Serializer
+    attributes :id, :name, :description
+    attributes :file_size, :mime_type, :md5sum
+    attributes :created_at, :updated_at
+    attributes :public_url
+
+    embed :ids
+
+    has_one  :author, include: true, serializer: AuthorSerializer
+    has_many :pages
+    has_many :themes
+  end
+end

data/app/serializers/landable/author_serializer.rb

@@ -0,0 +1,5 @@
+module Landable
+  class AuthorSerializer < ActiveModel::Serializer
+    attributes :id, :username, :email, :first_name, :last_name
+  end
+end

data/app/serializers/landable/category_serializer.rb

@@ -0,0 +1,5 @@
+module Landable
+  class CategorySerializer < ActiveModel::Serializer
+    attributes :id, :name, :description
+  end
+end

data/app/serializers/landable/directory_serializer.rb

@@ -0,0 +1,8 @@
+module Landable
+  class DirectorySerializer < ActiveModel::Serializer
+    attributes :id, :path
+
+    has_many   :subdirectories, embed: :ids, embed_key: :path
+    has_many   :pages, embed: :ids
+  end
+end

data/app/serializers/landable/page_revision_serializer.rb

@@ -0,0 +1,15 @@
+require_dependency 'landable/author_serializer'
+require_dependency 'landable/theme'
+
+module Landable
+  class PageRevisionSerializer < ActiveModel::Serializer
+    attributes :id, :ordinal, :notes, :is_minor, :is_published
+    attributes :created_at, :updated_at
+    attributes :preview_path
+
+    embed :ids
+    has_one :page
+    has_one :author, include: true, serializer: AuthorSerializer
+
+  end
+end

data/app/serializers/landable/page_serializer.rb

@@ -0,0 +1,31 @@
+module Landable
+  class PageSerializer < ActiveModel::Serializer
+    attributes :id
+    attributes :path
+    attributes :title
+    attributes :body
+    attributes :head_content
+    attributes :redirect_url
+    attributes :meta_tags
+    attributes :is_publishable
+    attributes :preview_path
+    attributes :lock_version
+    attributes :status_code
+    attributes :abstract
+    attributes :hero_asset_name
+
+    embed    :ids
+    has_one  :theme
+    has_one  :published_revision
+    has_one  :category
+    has_one  :updated_by_author, root: :authors, include: true, serializer: AuthorSerializer
+
+    def category
+      object.category || Landable::Category.where(name: 'Uncategorized').first
+    end
+
+    def meta_tags
+      object.meta_tags || {}
+    end
+  end
+end

data/app/serializers/landable/template_serializer.rb

@@ -0,0 +1,5 @@
+module Landable
+  class TemplateSerializer < ActiveModel::Serializer
+    attributes :id, :name, :body, :description, :thumbnail_url, :slug, :is_layout, :editable, :file
+  end
+end

data/app/serializers/landable/theme_serializer.rb

@@ -0,0 +1,7 @@
+module Landable
+  class ThemeSerializer < ActiveModel::Serializer
+    attributes :id, :name, :editable, :body, :description, :thumbnail_url
+
+    embed :ids
+  end
+end

data/app/services/landable/authentication_service.rb

@@ -0,0 +1,44 @@
+module Landable
+  AuthenticationFailedError = Class.new(StandardError)
+
+  module AuthenticationService
+    def self.call(username, password)
+      strategies = Landable.configuration.authenticators
+
+      strategies.each do |strategy|
+        ident = strategy.call username, password
+        return ident if ident
+      end
+
+      raise AuthenticationFailedError
+    end
+
+    class EchoAuthenticator
+      def self.call(username, password)
+        new(nil, nil).call(username, password)
+      end
+
+      def initialize(username, password)
+        @username = username
+        @password = password
+      end
+
+      def call(username, password)
+        return unless acceptable_environment?
+        return echo_author(username) if @username.nil? && password != 'fail'
+        return echo_author(username) if @username == username && @password == password
+      end
+
+      private
+
+      def acceptable_environment?
+        defined?(::Rails) && (Rails.env.development? || Rails.env.test?)
+      end
+
+      def echo_author(username)
+        { username: username, email: "#{username}@example.com",
+          first_name: 'Trogdor', last_name: 'McBurninator' }
+      end
+    end
+  end
+end

data/app/services/landable/registration_service.rb

@@ -0,0 +1,13 @@
+require_dependency "landable/author"
+
+module Landable
+  class RegistrationService
+    def self.call(attributes)
+      if author = Author.where(username: attributes[:username]).first
+        author
+      else
+        Author.create!(attributes.slice(:username, :email, :first_name, :last_name))
+      end
+    end
+  end
+end

data/app/services/landable/render_service.rb

@@ -0,0 +1,86 @@
+# TODO Handle layouts-as-themes here
+
+require_dependency 'landable/liquid'
+
+module Landable
+  class RenderService
+    def self.call(page, options = nil)
+      new(page, page.theme, options).render!
+    end
+
+    def initialize(page, theme, options = nil)
+      @page  = page
+      @theme = theme
+      @options = options || {}
+    end
+
+    def render!
+      variables = options[:responder].try(:controller).try(:fetch_landable_variables)
+      variables ||= {}
+
+      content = render_template(page.body, variables, registers: {
+        page: page,
+        assets: assets_for_page,
+        responder: options[:responder],
+      })
+
+      if layout?
+        content = render_template(theme.body, {'body' => content}, registers: {
+          page: page,
+          assets: assets_for_theme,
+        })
+      end
+
+      # not completely happy about this
+      if options[:preview]
+        if page.html?
+          # fancy!
+          preview_template = File.open(Landable::Engine.root.join('app', 'views', 'templates', 'preview.liquid')).read
+
+          content = render_template(preview_template, {
+            'content' => content,
+            'is_redirect' => page.redirect?,
+            'is_html' => page.html?,
+            'status_code' => page.status_code,
+            'redirect_url' => page.redirect_url,
+          })
+        else
+          # non-html stuff just gets rendered as plaintext for a preview
+          content = '<pre>' + CGI::escapeHTML(content) + '</pre>'
+        end
+      end
+
+      content
+    end
+
+    private
+
+    attr_reader :page, :theme, :options
+
+    def layout?
+      theme && theme.body.present? && theme.file.blank? && page.html?
+    end
+
+    def parse(body)
+      ::Liquid::Template.parse(body)
+    end
+
+    def assets_for_page
+      @assets_for_page ||=
+        begin
+          from_theme = theme ? theme.assets_as_hash : {}
+          from_theme.merge page.assets_as_hash
+        end
+    end
+
+    def assets_for_theme
+      @assets_for_theme ||= theme ? theme.assets_as_hash : {}
+    end
+
+    def render_template template, variables = {}, liquid_options = {}
+      variables['categories'] = Liquid::CategoriesDrop.new
+
+      parse(template).render!(variables, liquid_options)
+    end
+  end
+end

data/app/services/landable/tidy_service.rb

@@ -0,0 +1,155 @@
+module Landable
+  module TidyService
+
+    class TidyError < StandardError; end
+
+    mattr_accessor :options
+    @@options = [
+      # is what we have
+      '-utf8',
+
+      # two-space soft indents
+      '-indent',
+
+      # no wrapping
+      '--wrap 0',
+
+      # make some guesses about how the code should look
+      '--clean true',
+
+      # kill microsoft word crap
+      '--bare true',
+
+      # quote 'em up
+      '--quote-ampersand true',
+
+      # whitespace niceness
+      '--break-before-br true',
+
+      # allow <div ...><div ...></div></div>
+      '--merge-divs false',
+
+      # silence will fall
+      '--quiet true',
+      '--show-warnings false',
+    ]
+
+    # list of liquid tags that also render tags - things that we should
+    # consider to be element-level, and therefore to be tidied along with the
+    # rest of the dom
+    mattr_accessor :liquid_elements
+    @@liquid_elements = [
+      'template',
+      'title_tag',
+      'meta_tags',
+      'img_tag',
+    ]
+
+
+    def self.call! input
+      self.call input, raise_on_error: true
+    end
+
+    def self.call input, runtime_options={}
+      if not tidyable?
+        raise TidyError, 'Your system doesn\'t seem to have tidy installed. Please see https://github.com/w3c/tidy-html5.'
+      end
+
+      # wrapping known liquid in a span to allow tidy to format them nicely
+      input = wrap_liquid input
+
+      # off to tidy
+      output = IO.popen("tidy #{options.join(' ')}", 'r+') do |io|
+        io.puts input
+        io.close_write
+        io.read
+      end
+
+      # 0: success
+      # 1: warning
+      # 2: error
+      # 3: ???
+      # 4: profit
+      if $?.exitstatus >= 2 and runtime_options[:raise_on_error]
+        raise TidyError, "Tidy exited with status #{$?} - check stderr."
+      end
+
+      # unnwrapping the liquid that we wrapped earlier
+      output = unwrap_liquid output
+
+      # create and return a Result, allowing access to specific bits of the output
+      Result.new output
+    end
+
+    def self.tidyable?
+      @@is_tidyable ||= Kernel.system('which tidy > /dev/null')
+    end
+
+    protected
+
+    def self.wrap_liquid input
+      output = input.dup
+
+      output.scan(/(\s*(\{% *(?:#{liquid_elements.join('|')}) *.*?%})\s*)/).each do |match, liquid|
+        # encode and stash in a div, inserted between newlines, to allow tidy
+        # to nudge this element around as appropriate
+        encoded = Base64.encode64(liquid).strip
+        output.gsub! match, " <div data-liquid=\"#{encoded}\"></div> "
+      end
+
+      output
+    end
+
+    def self.unwrap_liquid input
+      output = input.dup
+
+      output.scan(/(<div data-liquid="(.*?)"><\/div>)/).each do |match, liquid|
+        # ensure we match utf8 for utf8
+        decoded = Base64.decode64(liquid).force_encoding(match.encoding)
+        output.gsub! match, decoded
+      end
+
+      output
+    end
+
+
+    class Result < Object
+      def initialize source
+        @source = source
+      end
+
+      def to_s
+        @source
+      end
+
+      def body
+        if match = @source.match(/<body(?: [^>]*)?>(.*)<\/body>/m)
+          deindent match[1]
+        end
+      end
+
+      def head
+        if match = @source.match(/<head>(.*)<\/head>/m)
+          deindent match[1]
+        end
+      end
+
+      def css
+        links = head.try :scan, /<link [^>]*type=['"]text\/css['"][^>]*>/
+        styles = head.try :scan, /<style[^>]*>.*?<\/style>/m
+        [links.to_a, styles.to_a].flatten.join("\n\n")
+      end
+
+      protected
+
+      def deindent string
+        if match = string.match(/^([ \t]*)[^\s]/)
+          string.gsub(/^#{match[1]}/, '').strip
+        else
+          string.strip
+        end
+      end
+    end
+
+  end
+end

data/app/uploaders/landable/asset_uploader.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+require 'carrierwave'
+
+module Landable
+  class AssetUploader < CarrierWave::Uploader::Base
+    include CarrierWave::MimeTypes
+    process :set_content_type
+  end
+end