flms 0.0.3 → 0.1.0

data/app/models/flms/layer.rb

@@ -1,7 +1,96 @@
 module Flms
   class Layer < ActiveRecord::Base
-    attr_accessible :name, :type
+    attr_accessible :name, :type,
+                    :width, :height, :z_index,
+                    :width_percent, :height_percent,
+                    :dom_remove, :active,
+                    :start_state_keyframe_attributes, :target_state_keyframe_attributes, :end_state_keyframe_attributes
 
     belongs_to :block
+
+    has_one :start_state_keyframe, dependent: :destroy
+    has_one :target_state_keyframe, dependent: :destroy
+    has_one :end_state_keyframe, dependent: :destroy
+    accepts_nested_attributes_for :start_state_keyframe, :target_state_keyframe, :end_state_keyframe
+
+    validates_presence_of :start_state_keyframe, :target_state_keyframe, :end_state_keyframe
+    validates :name, :'flms/css_name' => true
+    validates_uniqueness_of :name, scope: :block_id
+    validates_numericality_of :width, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :height, greater_than_or_equal_to: 0, allow_nil: true
+    validates_numericality_of :z_index, allow_nil: false
+
+    scope :ordered_by_scroll_start, joins: [ :start_state_keyframe ], order: 'flms_keyframes.scroll_start'
+    scope :is_active, conditions: { active: true }
+
+    before_save :calculate_scroll_starts
+
+    after_initialize :set_defaults
+
+    IMAGE_DISPLAY_MODES = %w(contain cover)
+
+    def view_object
+      @view_object ||= Flms::LayerViewObject.new(self)
+    end
+
+    def build_default_keyframes
+      self.start_state_keyframe ||= build_start_state_keyframe(layer: self)
+      self.target_state_keyframe ||= build_target_state_keyframe(layer: self)
+      self.end_state_keyframe ||= build_end_state_keyframe(layer: self)
+      self
+    end
+
+    def keyframes
+      [ start_state_keyframe, target_state_keyframe, end_state_keyframe ]
+    end
+
+    def scroll_start
+      start_state_keyframe.scroll_start
+    end
+
+    def scroll_end
+      start_state_keyframe.scroll_start +
+          start_state_keyframe.scroll_duration +
+          target_state_keyframe.scroll_duration +
+          end_state_keyframe.scroll_duration
+    end
+
+    def calculate_scroll_starts
+      target_state_keyframe.scroll_start = start_state_keyframe.scroll_start + start_state_keyframe.scroll_duration
+      end_state_keyframe.scroll_start = target_state_keyframe.scroll_start + target_state_keyframe.scroll_duration
+    end
+
+	  def width_percent
+      # It's ok for a layer to have an undefined width, so account for that here:
+      self.width ? (self.width * 100).to_i : nil
+    end
+
+    def width_percent= val
+      self.width = val.to_i / 100.0
+    end
+
+    def height_percent
+      # It's ok for a layer to have an undefined height, so account for that here:
+      self.height ? (self.height * 100).to_i : nil
+    end
+
+    def height_percent= val
+      self.height = val.to_i / 100.0
+    end
+
+  protected
+
+    # Set default values for this type of layer. Override this method in subclasses to customize.
+    def set_defaults
+      self.width ||= 0.20
+      self.height ||= 0.20
+    end
+
+  private
+
+    def must_be_css_hex_value
+      self.errors[:color] << 'must be a valid CSS hex color code' unless color =~ /^([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/i
+    end
+
   end
-end
+end

data/app/models/flms/page.rb

@@ -1,15 +1,16 @@
 module Flms
   class Page < ActiveRecord::Base
-    attr_accessible :title, :url
+    attr_accessible :title, :url, :block_ids
 
     has_many :blocks_pages, dependent: :destroy
     has_many :blocks, through: :blocks_pages
+    has_many :active_blocks, source: :block, through: :blocks_pages, conditions: ['active = ?', true ], order: 'ordering'
 
     validates :title, :url, presence: true
 
     # Returns the blocks_pages of this page, in the right order to display them.
     def ordered_blocks_pages
-      blocks_pages.order('ordering').includes(:block)
+      blocks_pages.ordered
     end
 
     # Returns the BlocksPage object for the given block on this page.
@@ -21,5 +22,16 @@ module Flms
     def to_param
       url
     end
+
+    # Returns an array containing blocks and associated scroll offsets for display.
+    def blocks_to_display_with_offsets
+      scroll_offset = 0
+      blocks_for_display = []
+      blocks_pages.ordered.is_active.each do |block_page|
+        blocks_for_display << { block: block_page.block, scroll_offset: scroll_offset }
+        scroll_offset += block_page.block.scroll_duration
+      end
+      blocks_for_display
+    end
   end
 end

data/app/models/flms/paragraph_layer.rb

@@ -0,0 +1,21 @@
+module Flms
+  class ParagraphLayer < Layer
+    attr_accessible :header, :body, :color
+
+    validates :header, presence: true
+    validates :body, presence: true
+    validate :color, :must_be_css_hex_value
+
+    def view_object
+      @view_object ||= Flms::ParagraphLayerViewObject.new(self)
+    end
+
+  protected
+
+    def set_defaults
+      self.width ||= 0.20
+      self.color ||= 'fff'
+    end
+
+  end
+end

data/app/models/flms/start_state_keyframe.rb

@@ -0,0 +1,17 @@
+module Flms
+  class StartStateKeyframe < Keyframe
+    after_initialize :set_default_values
+
+    def set_default_values
+      self.scroll_start ||= 0
+      self.scroll_duration ||= 100
+      self.width ||= 1.0
+      self.height ||= 1.0
+      self.position_x ||= 0.5
+      self.position_y ||= 0.5
+      self.opacity ||= 0.0
+      self.scale ||= 1.0
+      self.blur ||= 0.0
+    end
+  end
+end

data/app/models/flms/target_state_keyframe.rb

@@ -0,0 +1,17 @@
+module Flms
+  class TargetStateKeyframe < Keyframe
+    after_initialize :set_default_values
+
+    def set_default_values
+      # scroll_start is auto-calculated in layer prior to saving the records
+      self.scroll_duration ||= 100
+      self.width ||= 1.0
+      self.height ||= 1.0
+      self.position_x ||= 0.5
+      self.position_y ||= 0.5
+      self.opacity ||= 1.0
+      self.scale ||= 1.0
+      self.blur ||= 0.0
+    end
+  end
+end

data/app/models/flms/text_layer.rb

@@ -0,0 +1,20 @@
+module Flms
+  class TextLayer < Layer
+    attr_accessible :text, :font_size, :color
+
+    validates :text, presence: true
+    validates_numericality_of :font_size, greater_than_or_equal_to: 0
+    validate :color, :must_be_css_hex_value
+
+    def view_object
+      @view_object ||= Flms::TextLayerViewObject.new(self)
+    end
+
+  protected
+
+    def set_defaults
+      self.color ||= 'fff'
+    end
+
+  end
+end

data/app/uploaders/image_uploader.rb

@@ -4,59 +4,46 @@ require 'carrierwave/processing/mime_types'
 require 'carrierwave/orm/activerecord'
 
 class ImageUploader < CarrierWave::Uploader::Base
-
-  # Process MIME types.
   include CarrierWave::MimeTypes
   process :set_content_type
 
-  # Include RMagick or MiniMagick support:
-  # include CarrierWave::RMagick
-  # include CarrierWave::MiniMagick
-
-  # Include the Sprockets helpers for Rails 3.1+ asset pipeline compatibility:
   include Sprockets::Helpers::RailsHelper
   include Sprockets::Helpers::IsolatedHelper
 
-  # Choose what kind of storage to use for this uploader:
-  storage :file
-  # storage :fog
+  # include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
+
+  attr_reader :geometry
 
-  # Override the directory where uploaded files will be stored.
-  # This is a sensible default for uploaders that are meant to be mounted:
   def store_dir
-    "public/uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
 
-  # Provide a default URL as a default if there hasn't been a file uploaded:
   def default_url
-  #   # For Rails 3.1+ asset pipeline compatibility:
     asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
-  #
-  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
   end
 
-  # Process files as they are uploaded:
-  # process :scale => [200, 300]
-  #
-  # def scale(width, height)
-  #   # do something
-  # end
+  version :normal do
+    process :get_geometry
+  end
 
-  # Create different versions of your uploaded files:
-  # version :thumb do
-  #  process :scale => [50, 50]
-  # end
+  version :small do
+    process resize_to_fit: [200, 200]
+  end
+
+  version :thumb, from_version: :small do
+    process resize_to_fill: [48, 48]
+  end
 
-  # Add a white list of extensions which are allowed to be uploaded.
-  # For images you might use something like this:
   def extension_white_list
     %w(jpg jpeg gif png)
   end
 
-  # Override the filename of the uploaded files:
-  # Avoid using model.id or version_name here, see uploader/store.rb for details.
-  # def filename
-  #   "something.jpg" if original_filename
-  # end
+  def get_geometry
+    if @file
+      img = ::MiniMagick::Image::read(@file)
+      @geometry = [ img[:width], img[:height] ]
+    end
+  end
 
 end

data/app/uploaders/thumbnail_image_uploader.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'carrierwave'
+require 'carrierwave/processing/mime_types'
+require 'carrierwave/orm/activerecord'
+
+class ThumbnailImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::MimeTypes
+  process :set_content_type
+
+  include Sprockets::Helpers::RailsHelper
+  include Sprockets::Helpers::IsolatedHelper
+
+  # include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  def default_url
+    asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  end
+
+  version :small do
+    process resize_to_fit: [200, 200]
+  end
+
+  version :thumb, from_version: :small do
+    process resize_to_fill: [48, 48]
+  end
+
+  def extension_white_list
+    %w(jpg jpeg gif png)
+  end
+
+end

data/app/view_objects/flms/animation_layer_view_object.rb

@@ -0,0 +1,45 @@
+module Flms
+  class AnimationLayerViewObject < Flms::LayerViewObject
+
+    def src
+      @layer.image.url
+    end
+
+    def attributes(scroll_offset = 0)
+      attributes = { id: @layer.name }
+      attributes.merge keyframe_data_hash(scroll_offset)
+    end
+
+    # Define attributes related to animating the sprited image
+    def frames_attributes(scroll_offset = 0)
+      data = { }
+      (0...@layer.frame_count).each do |frame_index|
+        y_offset = -(frame_index * frame_sprite_height)
+        data["data-#{ frame_pixel_start(frame_index, scroll_offset) }"] = "background-position: 0 #{ y_offset }px;"
+        data["data-#{ frame_pixel_end(frame_index, scroll_offset) }"] = "background-position: 0 #{ y_offset }px;"
+      end
+      data[:style] = "width: #{ @layer.image_width }px; height: #{ frame_sprite_height }px;" \
+                     "background-image: url(#{ src }); background-size: #{ @layer.image_display_mode };"
+      data
+    end
+
+    # Pixel start of specified frame (frame number is 0..n)
+    def frame_pixel_start(frame, scroll_offset = 0)
+      (scroll_offset + (frame * @layer.frame_rate)).to_i
+    end
+
+    # Pixel end of specified frame (frame number is 0..n)
+    def frame_pixel_end(frame, scroll_offset = 0)
+      (scroll_offset + ((frame + 1) * @layer.frame_rate) - 1).to_i
+    end
+
+    # Calculate the pixel size of a single frame of animation;
+    # since animation sprites contain multiple frames stiched together
+    # vertically, the pixel height will be the image height divided
+    # by the number of frames contained within the sprite.
+    def frame_sprite_height
+      @layer.image_height / @layer.frame_count
+    end
+
+  end
+end

data/app/view_objects/flms/embed_layer_view_object.rb

@@ -0,0 +1,15 @@
+module Flms
+  class EmbedLayerViewObject < Flms::LayerViewObject
+
+    def embed_code
+      @layer.embed_code
+    end
+
+    def attributes(scroll_offset = 0)
+      attributes = keyframe_data_hash(scroll_offset)
+      attributes[:id] = @layer.name
+      attributes
+    end
+
+  end
+end

data/app/view_objects/flms/image_layer_view_object.rb

@@ -0,0 +1,22 @@
+module Flms
+  class ImageLayerViewObject < Flms::LayerViewObject
+
+    def src
+      @layer.image.url
+    end
+
+    def inner_attributes
+      { style: """
+          background-image: url(#{src});
+          background-size: #{@layer.image_display_mode};
+        """ }
+    end
+
+    def attributes(scroll_offset = 0)
+      attributes = keyframe_data_hash(scroll_offset)
+      attributes[:id] = @layer.name
+      attributes
+    end
+
+  end
+end

data/app/view_objects/flms/keyframe_view_object.rb

@@ -0,0 +1,92 @@
+module Flms
+
+  # A keyframe presenter encapsulates translation of flms keyframe attributes to the CSS-friendly 'data--...'
+  # attributes used by Skrollr.
+  class KeyframeViewObject
+
+    # All attributes need a formatter function:
+    KEYFRAME_ATTRIBUTE_FORMATTERS = { width: :format_as_percent,
+                                      height: :format_as_percent,
+                                      position_x: :format_as_percent,
+                                      position_y: :format_as_percent,
+                                      opacity: :format_as_decimal,
+                                      scale: :format_as_transform,
+                                      blur: :format_as_filter }
+
+    # If a keyframe attribute on the model is not the same as it's corresponding CSS,
+    # provide translations here:
+    CSS_NAMES_FOR_KEYFRAME_ATTRIBUTES = { position_x: 'left',
+                                          position_y: 'top' }
+
+    def initialize(keyframe)
+      @keyframe = keyframe
+    end
+
+    # Generate a string of CSS styling for each attribute provided by the keyframe
+    # Available options are:
+    #   :width        - default 0, affects width and margin-left of layer
+    #   :height       - default 0, affects height and margin-top of layer
+    #   :free_height  - if true, will suppress generation of height style
+    # Will add margins using provided values, and pin the layer within the viewport
+    # using width and height.
+    def styles(options = {})
+      options[:width] ||= 0
+      options[:height] ||= 0
+      options[:free_height] ||= false
+
+      attribs = [ :position_x, :position_y,
+                  :opacity,
+                  :blur ].map { |attribute| style_for_attribute(attribute) }.join ' '
+      attribs += pinning(options[:width],
+                         options[:height],
+                         options[:free_height])
+      attribs
+    end
+
+    # Generate position styling so that the layer remains fully in the viewport.
+    # (Pinned to top-left if positioned top-left, pinned center if centered, etc.)
+    def pinning(width, height, free_height = false)
+      # (Round calculated values here so we can prevent floating-point errors from
+      # giving us unpredictable results in specs)
+      width_style = "#{ style_for_attribute(:width, (@keyframe.scale * width).round(2)) }; "
+      height_style = free_height ? '' : "#{ style_for_attribute(:height, (@keyframe.scale * height).round(2)) }; "
+      margin_left_style = "margin-left: #{ ((@keyframe.position_x * @keyframe.scale * -width * 100) + @keyframe.margin_left_percent) }%; "
+      margin_top_style = "margin-top: #{ ((@keyframe.position_y * @keyframe.scale * -height * 100) + @keyframe.margin_top_percent) }%;"
+      "#{width_style}#{height_style}#{margin_left_style}#{margin_top_style}"
+    end
+
+    # Generate CSS style string for specified attribute.
+    # Uses value of attribute in associated keyframe, unless override is specified,
+    # in which case will generate style using overridden value.
+    def style_for_attribute(attr, override = nil)
+      value = override || @keyframe.send(attr)
+      name = CSS_NAMES_FOR_KEYFRAME_ATTRIBUTES[attr] || attr.to_s
+      formatter = KEYFRAME_ATTRIBUTE_FORMATTERS[attr]
+      "#{ self.send(formatter, name, value) };"
+    end
+
+    #### Attribute formatters are below; formatters must accept an attribute name (string)
+    #### and value parameter (number or string), and return a string.
+
+    def format_as_decimal(name, value)
+      "#{name}: #{value}"
+    end
+    
+    def format_as_percent(name, value)
+      "#{name}: #{value * 100}%"
+    end
+
+    def format_as_px(name, value)
+      "#{name}: #{value}px"
+    end
+
+    def format_as_transform(name, value)
+      "transform: #{name.to_s}(#{value})"
+    end
+
+    def format_as_filter(name, value)
+      "filter: #{name.to_s}(#{value})"
+    end
+
+  end
+end