pageflow 0.0.1

data/app/helpers/pageflow/entries_helper.rb

@@ -0,0 +1,56 @@
+module Pageflow
+  module EntriesHelper
+    def pretty_entry_url(entry)
+      if entry.account.cname.present?
+        short_entry_url(entry.to_model, :host => entry.account.cname)
+      else
+        short_entry_url(entry.to_model)
+      end
+    end
+
+    def entry_collection_for_parent(parent)
+      if parent.is_a?(User)
+        parent.account.entries - parent.entries
+      else
+        parent.account.entries
+      end
+    end
+
+    def entry_file_rights(entry)
+      [:audio_files, :image_files, :video_files].map do |collection|
+        entry.send(collection).map do |file|
+          file.rights.presence || entry.account.default_file_rights
+        end
+      end.flatten.sort.uniq * ', '
+    end
+
+    def entry_theme_stylesheet_link_tag(entry)
+      stylesheet_link_tag("pageflow/themes/#{entry.theme.name}.css", :media => 'all')
+    end
+
+    def entry_stylesheet_link_tag(entry)
+      stylesheet_link_tag(polymorphic_path(entry.stylesheet_model, :format => 'css'), :media => 'all')
+    end
+
+    def entry_mobile_navigation_pages(entry)
+      entry.pages.displayed_in_navigation.tap do |pages|
+        if entry.pages.any? && !entry.pages.first.display_in_navigation
+          pages.unshift(entry.pages.first)
+        end
+      end
+    end
+
+    def entry_header_css_class(entry)
+      css_class = 'header'
+      if entry.pages.any? && entry.pages.first.configuration['invert']
+        css_class += ' invert'
+      end
+      css_class
+    end
+
+    def entry_summary(entry)
+      return '' if entry.summary.blank?
+      strip_tags(entry.summary.gsub(/<br ?\/?>/, ' ').squish)
+    end
+  end
+end

data/app/helpers/pageflow/files_helper.rb

@@ -0,0 +1,28 @@
+module Pageflow
+  module FilesHelper
+    def file_format(file)
+      file.format.presence || '-'
+    end
+
+    def file_dimensions(file)
+      if file.width && file.height
+        "#{file.width} x #{file.height}px"
+      else
+        "-"
+      end
+    end
+
+    def file_duration(file)
+      if file.duration_in_ms
+        total_seconds = file.duration_in_ms / 1000
+        seconds = total_seconds % 60
+        minutes = (total_seconds / 60) % 60
+        hours = total_seconds / (60 * 60)
+
+        format("%02d:%02d:%02d", hours, minutes, seconds)
+      else
+        "-"
+      end
+    end
+  end
+end

data/app/helpers/pageflow/folders_helper.rb

@@ -0,0 +1,7 @@
+module Pageflow
+  module FoldersHelper
+    def collection_for_folders(account)
+      account.folders.order('name ASC')
+    end
+  end
+end

data/app/helpers/pageflow/info_box_helper.rb

@@ -0,0 +1,19 @@
+module Pageflow
+  module InfoBoxHelper
+    def info_box(configuration)
+      if configuration['additional_title'].blank? && configuration['additional_description'].blank?
+        css_class = 'add_info_box empty'
+      else
+        css_class = 'add_info_box'
+      end
+
+      render('pageflow/pages/info_box', :configuration => configuration, :css_class => css_class)
+    end
+
+    def info_box_title(title)
+      if title.present?
+        content_tag(:h3, title)
+      end
+    end
+  end
+end

data/app/helpers/pageflow/media_query_helper.rb

@@ -0,0 +1,13 @@
+module Pageflow
+  module MediaQueryHelper
+    def media_query(condition, &block)
+      content = capture(&block)
+
+      if condition == :default
+        content
+      else
+        "@media screen and (#{condition}) {\n#{content}}".html_safe
+      end
+    end
+  end
+end

data/app/helpers/pageflow/page_types_helper.rb

@@ -0,0 +1,19 @@
+module Pageflow
+  module PageTypesHelper
+    include RenderJsonHelper
+
+    def page_type_json_seeds
+      render_json_partial('pageflow/page_types/page_type', :collection => Pageflow.config.page_types, :as => :page_type)
+    end
+
+    def page_type_templates
+      Pageflow.config.page_types.map do |page_type|
+        content_tag(:script, :type => 'text/html', :data => {:template => "#{page_type.name}_page"}) do
+          render_to_string(:template => page_type.template_path,
+                           :locals => {:configuration => {}, :page => Page.new},
+                           :layout => false)
+        end
+      end.join(' ').html_safe
+    end
+  end
+end

data/app/helpers/pageflow/pages_helper.rb

@@ -0,0 +1,148 @@
+module Pageflow
+  module PagesHelper
+    def page_css_class(page)
+      classes = ['page']
+      classes << 'invert' if page.configuration['invert']
+      classes << 'hide_title' if page.configuration['hide_title']
+      classes << "text_position_#{page.configuration['text_position']}" if page.configuration['text_position'].present?
+      classes.join(' ')
+    end
+
+    def shadow_div(options = {})
+      style = options[:opacity] ? "opacity: #{options[:opacity] / 100.0};" : nil
+      content_tag(:div, '', :class => 'shadow', :style => style)
+    end
+
+    def poster_image_div(video_id, poster_image_id)
+      if poster_image_id.present?
+        content_tag(:div, '', :class => "background background_image image_#{poster_image_id}")
+      else
+        content_tag(:div, '', :class => "background background_image video_poster_#{video_id || 'none'}")
+      end
+    end
+
+    def poster_image_tag(video_id, poster_image_id, options = {})
+      video_file = VideoFile.find_by_id(video_id)
+      poster = ImageFile.find_by_id(poster_image_id)
+
+      if poster
+        options = options.merge('data-src' => poster.attachment.url(:medium))
+        options = options.merge('data-printsrc' => poster.attachment.url(:print))
+      elsif video_file
+        options = options.merge('data-src' => video_file.poster.url(:medium))
+        options = options.merge('data-printsrc' => video_file.poster.url(:print))
+      end
+
+      image_tag('', options)
+    end
+
+    def lookup_video_tag(video_id, poster_image_id, options = {})
+
+      defaults = {:class => ['player video-js video-viewport vjs-default-skin', options.delete(:class)].compact * ' ',
+        :preload =>  options.delete(:preload) ? 'metadata' : 'none'}
+
+      options.reverse_merge! defaults
+      url_options = {:unique_id => options.delete(:unique_id)}
+
+      video_file = VideoFile.find_by_id(video_id)
+      poster = ImageFile.find_by_id(poster_image_id)
+
+      options[:data] = {}
+      script_tag_data = {:template => 'video'}
+
+      if poster
+        options[:data][:poster] = poster.attachment.url(:medium)
+        options[:data][:large_poster] = poster.attachment.url(:large)
+      elsif video_file
+        options[:data][:poster] = video_file.poster.url(:medium)
+        options[:data][:large_poster] = video_file.poster.url(:large)
+      end
+
+      if (video_file && video_file.width.present? && video_file.height.present?)
+        script_tag_data[:video_width] = options[:data][:width] = video_file.width
+        script_tag_data[:video_height] = options[:data][:height] = video_file.height
+      end
+
+      render('pageflow/pages/video_tag',
+             :video_file => video_file, :script_tag_data => script_tag_data,
+             :options => options, :url_options => url_options)
+    end
+
+    def video_file_sources(video_file, options = {})
+      [{
+          :type => 'video/webm',
+          :src => video_file.webm_medium.url(options),
+          :high_src => video_file.webm_high.url(options)
+        },
+        {
+          :type => 'application/x-mpegURL',
+          :src => video_file.hls_playlist.url(options),
+          :high_src => video_file.hls_playlist.url(options)
+        },
+        {
+          :type => 'video/mp4',
+          :src => video_file.mp4_medium.url(options),
+          :high_src => video_file.mp4_high.url(options)
+        }]
+    end
+
+    def audio_tag(audio_id, options = {})
+      defaults = {:class => ['audio-js', options.delete(:class)].compact * ' ',
+        :controls => true, :preload => 'none'}
+      options.merge! defaults
+      url_options = {:unique_id => options.delete(:unique_id)}
+
+      if (audio = AudioFile.find_by_id(audio_id))
+        content_tag :audio, options do
+          audio_file_sources(audio, url_options).map do |v|
+            concat tag(:source, :src => v[:src], :type => v[:type])
+          end
+        end
+      end
+    end
+
+    def audio_file_sources(audio_file, options = {})
+      [{:type => 'audio/ogg', :src => audio_file.ogg.url(options)},
+        {:type => 'audio/mp4', :src => audio_file.m4a.url(options)},
+        {:type => 'audio/mpeg', :src => audio_file.mp3.url(options)}]
+    end
+
+    def page_media_breakpoints
+      {
+        :large => :default,
+        :medium => 'max-width: 900px'
+      }
+    end
+
+    def page_thumbnail_item(page_ids, index, layout_name)
+      page_ids ||= {}
+      page = @entry.pages.find_by_perma_id(page_ids[index.to_s])
+
+      content_tag(:li,
+                  page ? page_thumbnail_link(page, page_thumbnail_hero?(index, layout_name)) : '',
+                  :data => {:reference_key => index},
+                  :class => page ? 'title_hover' : 'title_hover empty')
+    end
+
+    def page_thumbnail_hero?(index, layout_name)
+      index == {
+        'hero_top_left' => 1,
+        'hero_top_right' => 1
+      }[layout_name]
+    end
+
+    def page_thumbnail_link(page, hero = false)
+      link_to(content_tag(:span, raw(page.configuration['description']), :class => 'title'),
+              "##{page.perma_id}",
+              :title => page.title,
+              :data => {:page => page.id},
+              :class => ['thumbnail', page_thumbnail_image_class(page, hero)] * ' ')
+    end
+
+    def page_thumbnail_image_class(page, hero)
+      model, attachment, property = page.thumbnail_definition
+      size = hero ? 'large_' : ''
+      "#{model}_link_thumbnail_#{size}#{page.configuration[property]}"
+    end
+  end
+end

data/app/helpers/pageflow/render_json_helper.rb

@@ -0,0 +1,32 @@
+module Pageflow
+  module RenderJsonHelper
+    # Renders `image_files/_image_file.json.jbuilder` when given a
+    # collection of `ImageFile` records.
+    def render_json_seed(records, options = {})
+      if records.respond_to?(:to_model)
+        name = records.to_model.class.model_name.to_s.split('::').last.underscore.downcase
+        render_json_partial(['pageflow/editor', name.pluralize, name.singularize] * '/', name.singularize.to_sym => records)
+      else
+        return '[]'.html_safe if records.empty?
+        name = records.first.to_model.class.model_name.to_s.split('::').last.underscore.downcase
+        render_json_partial(['pageflow/editor', name.pluralize, name.singularize] * '/', :collection => records, :as => name.singularize.to_sym)
+      end
+    end
+
+    def render_json_partial(*args)
+      render_with_format(:json) do
+        JbuilderTemplate.encode(self) do |json|
+          json.partial!(*args)
+        end.html_safe
+      end
+    end
+
+    def render_with_format(format, &block)
+      old_formats = formats
+      self.formats = [format] # hack so partials resolve with json not html format
+      yield
+    ensure
+      self.formats = old_formats
+    end
+  end
+end

data/app/helpers/pageflow/stub_page_configuration.rb

@@ -0,0 +1,13 @@
+module Pageflow
+  class StubPageConfiguration
+    attr_reader :template
+
+    def initialize(template)
+      @template = template
+    end
+
+    def method_missing(name, *args)
+      template.tag(:span, :data => {:property => name})
+    end
+  end
+end

data/app/helpers/pageflow/users_helper.rb

@@ -0,0 +1,15 @@
+module Pageflow
+  module UsersHelper
+    def collection_for_user_roles
+      User.roles_accessible_by(current_ability).index_by { |role| t(role, :scope => 'admin.users.roles') }
+    end
+
+    def user_collection_for_parent(parent)
+      if parent.is_a?(Entry)
+        parent.account.users - parent.users
+      else
+        parent.account.users
+      end
+    end
+  end
+end

data/app/jobs/pageflow/poll_zencoder_job.rb

@@ -0,0 +1,57 @@
+module Pageflow
+  class PollZencoderJob
+    @queue = :resizing
+
+    extend StateMachineJob
+
+    def self.perform_with_result(file, options, api = ZencoderApi.instance)
+      result = catch(:halt) do
+        poll_zencoder(file, api)
+        fetch_input_details(file, api)
+        fetch_thumbnail(file)
+        :ok
+      end
+    ensure
+      file.save!
+    end
+
+    private
+
+    def self.poll_zencoder(file, api)
+      info = api.get_info(file.job_id)
+
+      file.encoding_progress = info[:finished] ? 100 : info[:progress];
+      file.encoding_error_message = nil
+
+      if info[:state] === 'failed'
+        throw(:halt, :error)
+      elsif !info[:finished]
+        throw(:halt, :pending)
+      end
+    rescue ZencoderApi::RecoverableError => e
+      file.encoding_error_message = e.message
+      throw(:halt, :pending)
+    rescue ZencoderApi::Error => e
+      file.encoding_error_message = e.message
+      raise
+    end
+
+    def self.fetch_thumbnail(file)
+      return unless file.respond_to?(:thumbnail)
+      file.thumbnail = URI.parse(file.zencoder_thumbnail.url)
+      file.poster = URI.parse(file.zencoder_poster.url)
+    rescue OpenURI::HTTPError
+      throw(:halt, :pending)
+    end
+
+    def self.fetch_input_details(file, api)
+      file.meta_data_attributes = api.get_input_details(file.job_id)
+    rescue ZencoderApi::RecoverableError => e
+      file.encoding_error_message = e.message
+      throw(:halt, :pending)
+    rescue ZencoderApi::Error => e
+      file.encoding_error_message = e.message
+      raise
+    end
+  end
+end

data/app/jobs/pageflow/process_image_file_job.rb

@@ -0,0 +1,18 @@
+module Pageflow
+  class ProcessImageFileJob
+    @queue = :resizing
+
+    extend StateMachineJob
+
+    def self.perform_with_result(image_file, options)
+      image_file.processed_attachment = image_file.unprocessed_attachment
+      image_file.save!
+
+      :ok
+    rescue ActiveRecord::RecordInvalid, Errno::ENAMETOOLONG
+      image_file.processed_attachment = nil
+      image_file.save!
+      :error
+    end
+  end
+end

data/app/jobs/pageflow/submit_file_to_zencoder_job.rb

@@ -0,0 +1,13 @@
+module Pageflow
+  class SubmitFileToZencoderJob
+    @queue = :default
+
+    extend StateMachineJob
+
+    def self.perform_with_result(file, options, api = ZencoderApi.instance)
+      file.job_id = api.create_job(file.output_definition)
+      file.save!
+      :ok
+    end
+  end
+end