slices 1.0.0

data/lib/slices/container_parser.rb

@@ -0,0 +1,70 @@
+module Slices
+  class ContainerParser
+    class MissingLayoutError < StandardError; end
+
+    def initialize(path)
+      raise MissingLayoutError if path.nil?
+      @path = path
+      @containers = {}
+    end
+
+    def parse
+      @page = Page.new
+      erb_template = File.read(@path)
+      @erb = ActionView::Template::Handlers::Erubis.new(erb_template)
+      parse_with_block {}
+      @containers
+    end
+
+    # Define a +container+ in a layout, a container holds slices on a page.
+    #
+    # This container is called Title and only allows title and You Tube slices
+    #
+    #   container "title", :only => [TitleSlice, YouTubeSlice]
+    #
+    # Here's a container called body which is the primary and does not allow
+    # title slices.
+    #
+    #   container "body", :primary => true, :except => TitleSlice
+    #
+    # @param  [String]     name                               Name of container
+    # @param  [Hash]       options
+    # @option options [Boolean] :primary (false)              Is this container the primary
+    # @option options [Class,Array] :except                   Disallow these slice(s) from this container
+    # @option options [Class,Array] :only                     Only allow these slice(s) from this container
+    # @return [String]
+    #
+    def container(name, options = {})
+      [:except, :only].each do |type|
+        if options.has_key? type
+          options[type] = convert_slice_classes_to_symbols(options[type])
+        end
+      end
+
+      @containers[name] = options.reverse_merge name: name.titleize
+    end
+
+    def method_missing(meth, *args, &block)
+      yield if block_given?
+    end
+
+    private
+
+    def parse_with_block(&block)
+      @erb.result(binding)
+    end
+
+    def convert_slice_classes_to_symbols(options = [])
+      [options].flatten.select do |klass|
+        klass.is_a?(Class)
+      end.map do |klass|
+        convert_slice_class_to_symbol(klass)
+      end
+    end
+
+    def convert_slice_class_to_symbol(klass)
+      klass.name.underscore.split('_')[0 .. -2].join('_').to_sym
+    end
+  end
+end
+

data/lib/slices/generator_macros.rb

@@ -0,0 +1,36 @@
+module Slices
+  module GeneratorMacros
+    # Defines a generator method.
+    #
+    # e.g.
+    #
+    #     generator :home do
+    #       Page.where(path: '/').first || Page.make(
+    #         name: 'Home'
+    #       )
+    #     end
+    #
+    # Results in:
+    #
+    #     MyStandardTree.home
+    #
+    #
+    # @param [Symbol] name
+    # @param [Proc] block macro body
+    #
+    def generator name, &block
+      define_singleton_method name, &block
+      generators << name
+    end
+
+    # Simple catalogue of generators.
+    def generators
+      @generators ||= []
+    end
+
+    # Invokes all generators.
+    def generate!
+      generators.map { |m| send m }
+    end
+  end
+end

data/lib/slices/has_attachments.rb

@@ -0,0 +1,111 @@
+module Slices
+  module HasAttachments
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def has_attachments(embed_name = :attachments, options = {})
+        klass = if options.has_key?(:class_name)
+                  options[:class_name].constantize
+                else
+                  Attachment
+                end
+
+        default = options[:default] || options[:singular] ? nil : []
+        type = options[:singular] ? Hash : Array
+
+        if options[:singular]
+          define_method embed_name do
+            if embed = read_attribute(embed_name)
+              klass.new embed
+            end
+          end
+        else
+          define_method embed_name do
+            (read_attribute(embed_name) || []).collect do |embed|
+              klass.new embed
+            end
+          end
+        end
+
+        attachment_fields << embed_name
+
+        field embed_name, type: type, default: default
+      end
+
+      def attachment_fields
+        @attachment_fields ||= if superclass.respond_to?(:attachment_fields)
+                                 superclass.attachment_fields.dup
+                               else
+                                 []
+                               end
+      end
+
+    end
+
+    module PageInstanceMethods
+
+      def attachment_assets
+        attachment_asset_ids.inject([]) do |memo, asset_id|
+          begin
+            memo << ::Asset.find(asset_id)
+          rescue Mongoid::Errors::DocumentNotFound
+          end
+          memo
+        end
+      end
+
+      def slice_attachment_asset_ids
+        [].tap do |asset_ids|
+          self.class.slice_embeds.each do |slice_embed|
+            slices_for(slice_embed).each do |slice|
+              if slice.respond_to? :attachment_asset_ids
+                asset_ids.concat slice.attachment_asset_ids
+              end
+            end
+          end
+        end
+      end
+      alias :attachment_asset_ids :slice_attachment_asset_ids
+
+    end
+
+    def as_json options = nil
+      super.merge(attachments_as_json)
+    end
+
+    def attachments_as_json
+      self.class.attachment_fields.inject({}) do |hash, name|
+        value = send name
+
+        hash[name] = if value.respond_to?(:map)
+                       value.map &:as_json
+                     else
+                       value.as_json
+                     end
+
+        hash
+      end
+    end
+
+    def attachment_asset_ids
+      _attachment_asset_ids.tap do |asset_ids|
+        if respond_to? :slice_attachment_asset_ids
+          asset_ids.concat slice_attachment_asset_ids
+        end
+        asset_ids.uniq!
+      end
+    end
+
+    def _attachment_asset_ids
+      attachment_asset_ids = self.class.attachment_fields.collect do |attachments|
+        [send(attachments)].flatten.collect do |attachment|
+          attachment.asset_id
+        end.reject {|i| i.nil? }
+      end.flat_map {|i| i }
+    end
+
+  end
+
+end
+

data/lib/slices/has_slices.rb

@@ -0,0 +1,88 @@
+module Slices
+  module HasSlices
+    extend ActiveSupport::Concern
+
+    included do
+      validate :validate_slices
+    end
+
+    module ClassMethods
+      def has_slices(embed_name)
+        embeds_many embed_name, class_name: 'Slice', validate: false
+        accepts_nested_attributes_for embed_name, allow_destroy: true
+
+        class_attribute :slice_embeds if self == Page
+        if slice_embeds.nil?
+          self.slice_embeds = [embed_name]
+        else
+          self.slice_embeds = slice_embeds + [embed_name]
+        end
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def ordered_#{embed_name}             # def orderd_slices
+            #{embed_name}.ascending(:position)  #   slices.ascending(:position)
+          end                                   # end
+        RUBY
+      end
+    end
+
+    def update_attributes(attributes)
+      [:slices, :set_slices].each do |type|
+        next if attributes[type].nil?
+
+        attributes[type] = attributes[type].map { |slice|
+          slice = slice.symbolize_keys
+          next if slice[:_destroy]
+          slice.delete :_new
+          klass = (slice[:type] + '_slice').camelize.constantize
+          klass.new(slice)
+        }.compact
+      end
+
+      super
+    end
+
+    def slices_for(embed_name)
+      send(embed_name)
+    end
+
+    def ordered_slices_for(embed_name=nil)
+      embed_name = self.class.slice_embeds.first if embed_name.nil?
+      send("ordered_#{embed_name}")
+    end
+
+    def validate_slices
+      embeded_slices do |embed_name|
+        _slice_errors = slice_errors_for(embed_name)
+        if _slice_errors.any?
+          errors.add(embed_name, _slice_errors)
+        end
+      end
+    end
+
+    def slice_errors_for(embed_name)
+      Hash.new.tap do |message|
+        slices_for(embed_name).each do |slice|
+          if ! slice.valid? && ! slice.to_delete?
+            message[slice.id_or_client_id] = messages_from_errors(slice.errors)
+          end
+        end
+      end
+    end
+
+    def embeded_slices(&block)
+      self.class.slice_embeds.each do |embed_name|
+        yield(embed_name)
+      end
+    end
+
+    def messages_from_errors(errors)
+      if errors.respond_to?(:messages)
+        errors.messages
+      else
+        errors
+      end
+    end
+
+  end
+end

data/lib/slices/i18n.rb

@@ -0,0 +1,6 @@
+require 'slices/i18n/backend'
+
+I18n.backend = I18n::Backend::Chain.new(
+  Slices::I18n::Backend.new,
+  I18n.backend
+)

data/lib/slices/i18n/backend.rb

@@ -0,0 +1,32 @@
+module Slices
+  module I18n
+
+    class Backend
+      module Implementation
+        include ::I18n::Backend::Base, ::I18n::Backend::Flatten
+
+        # This method receives a locale, a data hash and options for storing translations.
+        # Should be implemented
+        def store_translations(locale, data, options = {})
+          raise NotImplementedError
+        end
+
+        def available_locales
+          raise NotImplementedError
+        end
+
+        protected
+
+        def lookup(locale, key, scope = [], options = {})
+          key = normalize_flat_keys(locale, key, scope, options[:separator])
+          Snippet.find_value_by_key("#{locale}.#{key}")
+        end
+
+      end
+
+      include Implementation
+    end
+
+  end
+end
+

data/lib/slices/i18n_backend.rb

@@ -0,0 +1,24 @@
+saise 'aaaaa'
+module Slices
+
+  class I18nBackend
+    include I18n::Backend::Simple::Implementation
+
+    # Translates the given local and key. See the I18n API documentation for details.
+    #
+    # @return [Object] the translated key (usually a String)
+    def translate(locale, key, options = {})
+      content = super(locale, key, options.merge(fallback: true))
+      if content.respond_to?(:html_safe)
+        content.html_safe
+      else
+        content
+      end
+    end
+  end
+end
+
+I18n.backend = I18n::Backend::Chain.new(
+  Slices::I18n::Backend.new,
+  I18n.backend
+)

data/lib/slices/paperclip.rb

@@ -0,0 +1,13 @@
+Paperclip.options[:log] = true
+require 'paperclip_validator'
+
+Paperclip.interpolates :mon_year do |attachment, style|
+  attachment.instance.id.generation_time.strftime("%m%Y")
+end
+
+#This is a hack used to access Paperclip's internal cache
+#of attributes it reads from the attachment. Used as part
+#of the file renaming code.
+class Paperclip::Attachment
+  attr_accessor :_file_file_name
+end

data/lib/slices/position_helper.rb

@@ -0,0 +1,98 @@
+module Slices
+  module PositionHelper
+
+    # Returns an array of slices in the same container, including self.
+    #
+    # @return [Array]
+    #
+    def peers
+      @peers ||= normal_or_set_page.ordered_slices.select do |slice|
+        slice.container == self.container
+      end
+    end
+
+    # Returns the previous slice in the container, or +nil+ if this is the
+    # first slice.
+    #
+    # @return [Slice]
+    #
+    def previous_slice
+      index = peers.index(self) - 1
+      index < 0 ? nil : peers[index]
+    end
+
+    # Returns the next slice in the container, or +nil+ if this is the
+    # last slice.
+    #
+    # @return [Slice]
+    #
+    def next_slice
+      peers[peers.index(self) + 1]
+    end
+
+    # Is this the first slice in the container?
+    #
+    def first_in_container?
+      self == peers.first
+    end
+
+    # Is the previous slice of the same type?
+    #
+    def first_adjacent_of_type?
+      previous_slice.try(:class) != self.class
+    end
+
+    # Is this the last slice in the container?
+    #
+    def last_in_container?
+      self == peers.last
+    end
+
+    # Is the next slice the same type?
+    #
+    def last_adjacent_of_type?
+      next_slice.try(:class) != self.class
+    end
+
+    # Is this the only slice in the container?
+    #
+    def alone_in_container?
+      peers.size == 1
+    end
+
+    # Are both the next and previous slices different types?
+    #
+    def alone_in_adjacent_of_type?
+      first_adjacent_of_type? && last_adjacent_of_type?
+    end
+
+    # The position of the slice in the container, the first slice has a position
+    # of 1
+    #
+    # @return [Integer]
+    #
+    def position_in_container
+      peers.index(self) + 1
+    end
+
+    # The position of the slice in a group of the same slices
+    #
+    # For example, given the following slices
+    #   [TitleSlice, CopySlice, CopySlice, CopySlice]
+    #
+    # The second +CopySlice+ would have a +position_in_adjacent_of_type+ of 2
+    #
+    # @return [Integer]
+    #
+    def position_in_adjacent_of_type
+      slices = []
+      reversed = peers.reverse
+      reversed[reversed.index(self)..-1].each do |slice|
+        break unless slice.class == self.class
+        slices << slice
+      end
+      slices.length
+    end
+  end
+
+end