landable 1.7.0

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

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

data/app/models/landable/access_token.rb

@@ -0,0 +1,20 @@
+module Landable
+  class AccessToken < ActiveRecord::Base
+    include Landable::TableName
+    
+    belongs_to :author
+    validates_presence_of :author_id
+    validates_presence_of :expires_at
+
+    before_validation do |token|
+      token.expires_at ||= 8.hours.from_now
+    end
+
+    scope :fresh,   -> { where('expires_at > ?',  Time.zone.now) }
+    scope :expired, -> { where('expires_at <= ?', Time.zone.now) }
+
+    def refresh!
+      update_column :expires_at, 8.hours.from_now
+    end
+  end
+end

data/app/models/landable/asset.rb

@@ -0,0 +1,63 @@
+require_dependency 'landable/asset_uploader'
+
+require 'carrierwave/orm/activerecord'
+require 'digest/md5'
+
+module Landable
+  class Asset < ActiveRecord::Base
+    include Landable::TableName
+    
+    mount_uploader :data, Landable::AssetUploader
+    alias :file :data
+    alias :file= :data=
+
+    # This bit of indirection allows us to generate predictable
+    # URLs in the test environment.
+    def self.url_generator
+      @url_generator ||= proc { |asset| asset.data.try(:url) }
+    end
+
+    belongs_to :author
+    has_and_belongs_to_many :pages, join_table: Page.assets_join_table_name
+    has_and_belongs_to_many :page_revisions, join_table: PageRevision.assets_join_table_name
+    has_and_belongs_to_many :themes, join_table: Theme.assets_join_table_name
+
+    before_validation :write_metadata, on: :create
+
+    validates_presence_of     :data, :author
+    validates_presence_of     :name, :mime_type, :md5sum, :file_size
+    validates_uniqueness_of   :md5sum
+    validates_numericality_of :file_size, only_integer: true
+    validates_format_of       :name, :with => /^[\w\._-]+$/, :on => :create, :multiline => true, :message => 'can only contain alphanumeric characters, periods, underscores, and dashes'
+
+    def public_url
+      self.class.url_generator.call(self)
+    end
+
+    def duplicate_of
+      return unless data.present?
+      self.class.where(md5sum: calculate_md5sum).first
+    end
+
+    def associated_pages
+      paths = []
+      Page.where("body like ?", "%#{self.name}%").each do |page|
+        paths.push(page.path)
+      end
+      paths
+    end
+
+    private
+
+    def calculate_md5sum
+      Digest::MD5.hexdigest(data.read) if data.present?
+    end
+
+    def write_metadata
+      return unless data.present?
+      self.md5sum    = calculate_md5sum
+      self.mime_type = data.file.content_type.presence || 'application/octet-stream'
+      self.file_size = data.file.size
+    end
+  end
+end

data/app/models/landable/asset_search_engine.rb

@@ -0,0 +1,20 @@
+require_dependency "landable/search_engine"
+require_dependency "landable/asset"
+
+module Landable
+  class AssetSearchEngine < SearchEngine
+    def initialize(filters)
+      super Asset.all, filters
+    end
+
+    def filter_by!(filters)
+      if ids = as_array(filters[:ids])
+        @scope = @scope.where(asset_id: ids)
+      end
+
+      if name = filters[:name].presence
+        @scope = @scope.where('LOWER(name) LIKE ?', "%#{name}%".downcase)
+      end
+    end
+  end
+end

data/app/models/landable/author.rb

@@ -0,0 +1,12 @@
+module Landable
+  class Author < ActiveRecord::Base
+    include Landable::TableName
+    has_many :access_tokens
+
+    def self.authenticate!(username, token_id)
+      return unless author = where(username: username).first
+      return unless author.access_tokens.fresh.exists?(token_id)
+      author
+    end
+  end
+end

data/app/models/landable/category.rb

@@ -0,0 +1,27 @@
+module Landable
+  class Category < ActiveRecord::Base
+    include Landable::TableName
+
+    has_many :pages
+
+    validates_uniqueness_of :name, case_sensitive: false
+    validates_uniqueness_of :slug
+
+    before_validation :set_slug
+
+    def to_liquid
+      {
+        'name' => name,
+        'pages' => pages.published,
+      }
+    end
+
+
+    protected
+
+    def set_slug
+      self.slug = name.downcase.gsub(/[^\w]/, '_').gsub(/_{2,}/, '_')
+    end
+
+  end
+end

data/app/models/landable/directory.rb

@@ -0,0 +1,23 @@
+module Landable
+  class Directory
+    include ActiveModel::SerializerSupport
+
+    def self.listing(parent)
+      parent_with_slash = parent.gsub(/^(.*?)\/?$/, '\1/')
+      pages   = Page.where('path LIKE ?', "#{parent_with_slash}%").to_a
+      subdirs = pages.group_by { |page| page.directory_after(parent_with_slash) }
+      notdirs = subdirs.delete(nil) || []
+      subdirs = subdirs.map { |name, contents| Directory.new("#{parent}/#{name}") }
+      Directory.new(parent, subdirs.sort_by(&:path), notdirs.sort_by(&:path))
+    end
+
+    attr_reader :path, :subdirectories, :pages
+    alias_attribute :id, :path
+
+    def initialize(path, subdirectories = [], pages = [])
+      @path = path.squeeze '/'
+      @subdirectories = subdirectories
+      @pages = pages
+    end
+  end
+end

data/app/models/landable/page.rb

@@ -0,0 +1,259 @@
+require_dependency 'landable/theme'
+require_dependency 'landable/page_revision'
+require_dependency 'landable/category'
+require_dependency 'landable/has_assets'
+require_dependency 'landable/author'
+
+module Landable
+  class Page < ActiveRecord::Base
+    include ActionView::Helpers::TagHelper
+    include Landable::HasAssets
+    include Landable::Engine.routes.url_helpers
+    include Landable::TableName
+
+    validates_presence_of   :path, :status_code
+    validates_presence_of   :redirect_url, if: -> page { page.redirect? }
+
+    validates_inclusion_of  :status_code, in: [200, 301, 302, 410]
+
+    validates_with PathValidator, fields: [:path]
+    validates_uniqueness_of :path
+    validates :path, presence: true
+
+    validate :forbid_changing_path, on: :update
+
+    validate :body_strip_search
+    validates :redirect_url, url: true, allow_blank: true
+    validate :hero_asset_existence
+
+    belongs_to :theme,                class_name: 'Landable::Theme',        inverse_of: :pages
+    belongs_to :published_revision,   class_name: 'Landable::PageRevision'
+    belongs_to :category,             class_name: 'Landable::Category'
+    belongs_to :updated_by_author,    class_name: 'Landable::Author'
+    belongs_to :hero_asset,           class_name: 'Landable::Asset'
+    has_many   :revisions,            class_name: 'Landable::PageRevision'
+    has_many   :screenshots,          class_name: 'Landable::Screenshot',   as: :screenshotable
+
+    scope :imported, -> { where("imported_at IS NOT NULL") }
+    scope :sitemappable, -> { where("COALESCE(meta_tags -> 'robots' NOT LIKE '%noindex%', TRUE)") 
+                              .where(status_code: 200)}
+    scope :published, -> { where("published_revision_id is NOT NULL") }
+
+    before_validation :downcase_path!
+
+    before_save -> page {
+      page.lock_version ||= 0
+      page.is_publishable = true unless page.published_revision_id_changed?
+    }
+
+    class << self
+      def missing
+        new(status_code: 410)
+      end
+
+      def by_path(path)
+        where(path: path).first || missing
+      end
+
+      def by_path!(path)
+        where(path: path).first!
+      end
+
+      def with_fuzzy_path(path)
+        select("*, similarity(path, #{Page.sanitize path}) _sml").
+          where('path LIKE ?', "%#{path}%").
+          order('_sml DESC, path ASC')
+      end
+
+      def example(attrs)
+        defaults = {
+          title: 'Example page',
+          body:  '<div>Example page contents would live here</div>'
+        }
+
+        new defaults.merge(attrs)
+      end
+
+
+      def generate_sitemap(options = {})
+        pages = Landable::Page.sitemappable
+        xml = Builder::XmlMarkup.new( :indent => 2 )
+        xml.instruct! :xml, encoding: "UTF-8"
+        xml.urlset(xmlns: "http://www.sitemaps.org/schemas/sitemap/0.9") do |xml|
+          pages.each do |page|
+            next if options[:exclude_categories].to_a.include? page.category.try(:name)
+            xml.url do |p|
+              p.loc "#{options[:protocol]}://#{options[:host]}#{page.path}"
+              p.lastmod page.updated_at.to_time.iso8601
+              p.changefreq 'weekly'
+              p.priority '1'
+            end
+          end
+
+          if options[:sitemap_additional_paths].present?
+            options[:sitemap_additional_paths].each do |page|
+              xml.url do |p|
+                p.loc "#{options[:protocol]}://#{options[:host]}#{page}"
+                p.changefreq 'weekly'
+                p.priority '1'
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def downcase_path!
+      path.try :downcase!
+    end
+
+    def path_extension
+      path.match(/\.(\w{2,})$/).try(:[], 1) if path
+    end
+
+    def content_type
+      case path_extension
+      when nil, 'htm', 'html'
+        'text/html'
+      when 'json'
+        'application/json'
+      when 'xml'
+        'application/xml'
+      else
+        'text/plain'
+      end
+    end
+
+    def html?
+      content_type == 'text/html'
+    end
+
+    def directory_after(prefix)
+      remainder = path.gsub(/^#{prefix}\/?/, '')
+      segments  = remainder.split('/', 2)
+      if segments.length == 1
+        nil
+      else
+        segments.first
+      end
+    end
+
+    def redirect?
+      status_code == 301 || status_code == 302
+    end
+
+    def path=(name)
+      # if not present, add a leading slash for a non-empty path
+      if name and not name.empty?
+        name = name.gsub(/^\/?(.*)/, '/\1')
+      end
+
+      self[:path] = name
+    end
+
+    def hero_asset_name
+      self.hero_asset.try(:name)
+    end
+
+    def hero_asset_name=(name)
+      @hero_asset_name = name
+      asset = Asset.find_by_name(name)
+      self.hero_asset_id = asset.try(:asset_id)
+    end
+
+    def hero_asset_url
+      self.hero_asset.try(:public_url)
+    end
+
+    def publish!(options)
+      transaction do
+        published_revision.unpublish! if published_revision
+        revision = revisions.create! options
+        update_attributes!(published_revision: revision, is_publishable: false)
+      end
+    end
+
+    def published?
+      published_revision.present?
+    end
+
+    def revert_to!(revision)
+      self.title          = revision.title
+      self.path           = revision.path
+      self.body           = revision.body
+      self.head_content   = revision.head_content
+      self.category_id    = revision.category_id
+      self.theme_id       = revision.theme_id
+      self.status_code    = revision.status_code
+      self.meta_tags      = revision.meta_tags
+      self.redirect_url   = revision.redirect_url
+
+      save!
+    end
+
+    def preview_path
+      public_preview_page_path(self)
+    end
+
+    def preview_url
+      public_preview_page_url(self)
+    end
+
+    def forbid_changing_path
+      errors[:path] = "can not be changed!" if self.path_changed?
+    end
+
+    def body_strip_search
+      begin
+        RenderService.call(self)
+      rescue ::Liquid::Error => error
+        errors[:body] = 'contains a Liquid syntax error'
+      rescue StandardError => error
+        errors[:body] = 'had a problem: ' + error.message
+      end
+    end
+
+    def hero_asset_existence
+      return true if @hero_asset_name.blank?
+      unless Asset.find_by_name(@hero_asset_name)
+        errors[:hero_asset_name] = "System can't find an asset with this name"
+      end
+    end
+
+    def to_liquid
+      {
+        "title" => title,
+        "url" => path,
+        "hero_asset" => hero_asset ? true : false,
+        "hero_asset_url" => hero_asset_url,
+        "abstract" => abstract
+      }
+    end
+
+    module Errors
+      extend ActiveSupport::Concern
+
+      class GoneError < Error
+        STATUS_CODE = 410
+      end
+
+      def error?
+        (400..599).cover? status_code
+      end
+
+      def error
+        return nil unless error?
+
+        case status_code
+        when 410
+          GoneError.new
+        else
+          Landable::Error.new "Missing a Page error class for #{status_code}"
+        end
+      end
+    end
+
+    include Errors
+
+  end
+end