slices 1.0.0

data/lib/slices/renderer.rb

@@ -0,0 +1,52 @@
+module Slices
+  class Renderer
+    include ActiveSupport::Benchmarkable
+
+    def initialize(options = {})
+      options.assert_valid_keys(:controller, :current_page, :slices, :params)
+
+      @controller   = options[:controller] || SlicesController.new
+      @current_page = options[:current_page]
+      @slices       = options[:slices]
+      @params       = options[:params] || {}
+    end
+
+    def render_slices(slices = @slices)
+      [].tap do |rendered|
+        slices.each do |slice|
+          benchmark "Prepared #{slice.reference}" do
+            slice.setup(setup_options)
+            slice.prepare(@params)
+          end
+          rendered << slice.render
+        end
+      end.join("\n").html_safe
+    end
+
+    def render_container(container, slices = @slices)
+      render_slices slices.where(container: container)
+    end
+
+    def render_to_string(*args)
+      @controller.render_to_string(*args)
+    end
+
+    def fragment_exist?(cache_key)
+      @controller.fragment_exist?(cache_key)
+    end
+
+    private
+
+    def setup_options
+      {
+        renderer:     self,
+        current_page: @current_page
+      }
+    end
+
+    def logger
+      Rails.logger
+    end
+  end
+end
+

data/lib/slices/slices_engine.rb

@@ -0,0 +1,51 @@
+module Slices
+  class Engine < Rails::Engine; end
+
+  def self.autoload_slices(app, root)
+    slice_dirs = Dir.glob(File.expand_path('app/slices/*', root))
+    app.config.autoload_paths.push(*slice_dirs.select { |f| File.directory?(f) })
+  end
+
+  # We need to add the app's own app/slices/* directories to the load
+  # path so that slices created within the application are automatically
+  # detected. This means that we need a Railtie as well as an engine, as
+  # an engine's initializer can't add autoload_paths that aren't scoped
+  # within the engine itself (for some stupid reason).
+  class Railtie < Rails::Railtie
+    initializer :autoload_slices, before: :set_autoload_paths do |app|
+      Slices.autoload_slices(app, Slices.gem_path) if Slices.test_environment?
+      Slices.autoload_slices(app, Rails.root)
+    end
+
+    initializer :active_mongoid_observers do
+      config.mongoid.observers.concat [:page_observer, :asset_observer]
+    end
+
+    initializer :load_config_initializers, after: :config_initializers do |app|
+      Dir.glob('config/initializers/*.rb').each do |initializer|
+        load(initializer)
+      end
+    end
+
+    initializer :slices_will_paginate_active_view, after:  'will_paginate.action_view' do
+      load Slices.gem_path + '/lib/set_link_renderer.rb'
+    end
+
+    initializer :slices_precompile_hook do |app|
+      app.config.assets.precompile += %w(slices/slices.css slices/slices.js)
+    end
+
+    config.after_initialize do
+      Slices.load_slice_classes_into_object_space(Rails.root)
+    end
+
+    rake_tasks do
+      root = Slices.gem_path + '/lib/'
+
+      Dir[root + 'slices/tasks/*.rake'].each do |taskfile|
+        load taskfile.sub root, ''
+      end
+    end
+
+  end
+end

data/lib/slices/split_date_time_field.rb

@@ -0,0 +1,14 @@
+module Slices #:nodoc:
+  module SplitDateTimeField #:nodoc:
+    extend ActiveSupport::Concern #:nodoc:
+
+    module ClassMethods #:nodoc:
+
+      def split_date_time_field(name)
+        raise Error, 'Split date time is depreciated use dateField instead'
+      end
+
+    end
+  end
+end
+

data/lib/slices/tasks/assets.rake

@@ -0,0 +1,35 @@
+module Slices
+  module Tasks
+
+    def self.remove_all_unused_styles
+      Asset.all.each do |asset|
+        remove_unused_styles(asset)
+      end
+    end
+
+    def self.remove_unused_styles(asset)
+      asset.remove_attribute :dimensions
+
+      used_styles = asset.file_dimensions.symbolize_keys.keys << :original
+      styles_to_clear = asset.file.styles.keys - used_styles
+      asset.file.clear(*styles_to_clear)
+      asset.save
+    end
+  end
+end
+
+namespace :slices do
+  namespace :assets do
+
+    desc "Mark assets for reprocessing"
+    task reprocess: :environment do
+      Asset.update_all(file_dimensions: {})
+    end
+
+    desc "Remove unused asset styles"
+    task remove_unused_styles: :environment do
+      Slices::Tasks.remove_all_unused_styles
+    end
+  end
+end
+

data/lib/slices/tasks/db.rake

@@ -0,0 +1,50 @@
+module Slices
+  module Tasks
+    def self.create_indexes
+      [
+        Slices.gem_path + '/app/models/**/*.rb',
+        Rails.root.join('app/slices/**/*.rb')
+      ].each do |pattern|
+        Dir.glob(pattern).each do |file|
+          model = determine_model(file)
+          if model
+            model.create_indexes
+            Logger.new($stdout).info("Generated indexes for #{model}")
+          end
+        end
+      end
+    end
+
+    def self.determine_model(file)
+      segments = file[0 .. -4].split('/')
+      start = if segments.include?('slices')
+                segments.rindex('slices') + 2
+              else
+                segments.rindex('models') + 1
+              end
+      model_path = segments[start .. -1]
+      klass = model_path.map { |path| path.camelize }.join('::').constantize
+      if klass.ancestors.include?(::Mongoid::Document) && !klass.embedded
+        return klass
+      end
+    end
+  end
+end
+
+namespace :slices do
+  namespace :db do
+    desc "Create indexes for slices models"
+    task create_indexes: "db:mongoid:create_indexes" do
+      Slices::Tasks.create_indexes
+    end
+  end
+
+  namespace :migrate do
+    desc "Rename description field to meta_description"
+    task meta_description: :environment do
+      Page.collection.update({},
+        {'$rename' => {'description' => 'meta_description'}},
+        multi: true)
+    end
+  end
+end

data/lib/slices/tasks/seeds.rake

@@ -0,0 +1,93 @@
+require 'highline/import'
+
+module Slices
+  module Tasks
+    class Exists < RuntimeError; end
+
+    def self.with_message(text)
+      print "#{text} ... "
+      yield
+      puts "ok"
+    rescue Exists
+      puts "(exists)"
+    end
+
+    def self.make_virtual(role, name, status)
+      with_message("Creating #{status} page") do
+        if Page.where(role: role).count > 0
+          raise Exists
+        end
+        Page.make(role: role, name: name, active: true)
+      end
+    end
+
+    def self.make_home
+      with_message("Creating home page") do
+        raise Exists if Page.where(path: '/').any?
+        Page.make(name:         'Home',
+                  permalink:    '',
+                  show_in_nav:  true,
+                  active:       true)
+      end
+    end
+
+    def self.make_errors
+      make_virtual('not_found', 'Page not found', 404)
+      make_virtual('error', 'Whoops', 500)
+    end
+
+    def self.make_admin
+      if Admin.exists?
+        say "Creating admin user ... (exists)"
+        return
+      end
+
+      say("Creating admin user ...")
+
+      admin = Admin.create!(
+        name: ask('Enter a name: '),
+        email: ask('Enter an email address: '),
+        password: ask('Enter a password: ') { |q| q.echo = false }
+      )
+      admin.super_user = true
+      admin.save!
+
+      say("... ok")
+    end
+
+    def self.make_all
+      make_home
+      make_errors
+      make_admin
+    end
+  end
+end
+
+namespace :slices do
+  namespace :seed do
+    task :foo do
+      puts "Bar"
+    end
+
+    desc "Create the home page"
+    task :home => :environment do
+      Slices::Tasks.make_home
+    end
+
+    desc "Create 404 and 500 pages"
+    task :errors => :home do
+      Slices::Tasks.make_errors
+    end
+
+    desc "With Associates admin user"
+    task :admin => :environment do
+      Slices::Tasks.make_admin
+    end
+  end
+
+  desc "Seed home, errors and admin user"
+  task :seed => :environment do
+    Slices::Tasks.make_all
+  end
+end
+

data/lib/slices/tasks/validate.rake

@@ -0,0 +1,62 @@
+require 'open-uri'
+
+module Slices
+  module Tasks
+
+    class PageHtml
+      attr_accessor :body
+
+      def initialize(host, path)
+        document = open('http://' + host + path)
+        self.body = document.present? ? document.read : nil
+        self.body.gsub!(/\?[0-9]{10}/, '') # remove cache busting
+      rescue OpenURI::HTTPError
+      end
+
+      def ==(other)
+        body == other.body
+      end
+
+      def temp_path
+        write_to_tempfile unless @tempfile
+        @tempfile.path
+      end
+
+      private
+
+      def write_to_tempfile
+        @tempfile = Tempfile.new('html').tap do |file|
+          file << body
+          file.flush
+        end
+      end
+
+    end
+
+    def self.validate(local, remote)
+      hosts = [local, remote]
+      Page.all.each do |page|
+        puts page.path
+        a, b = hosts.map do |host|
+          PageHtml.new(host, page.path)
+        end
+        if a != b
+          puts `diff #{a.temp_path} #{b.temp_path}`
+          puts ''
+        end
+      end
+
+    end
+  end
+end
+
+namespace :slices do
+
+  desc "Validate localhost is the same is live"
+  task valdiate: :environment do
+    remote = ENV['HOST']
+    local = ENV.include?('LOCAL') ? ENV['LOCAL'] : 'localhost:3000'
+    Slices::Tasks.validate(remote, local)
+  end
+end
+

data/lib/slices/tree.rb

@@ -0,0 +1,306 @@
+module Slices
+
+  # Containers the tree behaviour.
+  module Tree
+    extend ActiveSupport::Concern
+
+    # @!attribute [rw] path
+    # The path for the page, this is a unique identifier and directly maps to
+    # the page's url.
+    #
+    # @return [String]
+
+    # @!attribute [rw] external_url
+    # An optional url override for the page, if this is set then this page will
+    # link to the url in any navigation block. Usefull when linking to a
+    # different website.
+    #
+    # @return [String]
+
+    # @!attribute [rw] position
+    # The page's position amongst it's siblings
+    #
+    # @return [Integer]
+
+    # @!attribute [rw] show_in_nav
+    # If the +page+ should be shown in any navigation block.
+    #
+    # @return [Boolean]
+
+    # @!method minimal
+    # A scope with the minmial attributes needed to render navigaiton
+    #
+    # @!scope class
+    # @return [Mongoid::Criteria]
+    #
+    included do
+      field :path
+      field :external_url, type: String, default: ''
+      field :position, type: Integer
+      field :show_in_nav, type: Boolean, default: false
+
+      scope :minimal, only: %w(page_id path external_url name has_content)
+      index :path
+
+      belongs_to :page
+
+      attr_accessor :parent_id
+
+      before_create :ensure_path_unique
+      before_save :ensure_path_unique
+    end
+
+    module ClassMethods
+
+      # Get the home page.
+      #
+      # @return [Page]
+      #
+      def home
+        find_by_path('/')
+      end
+
+      # Finds a page by it's path, a {Page::NotFound} is raised if the page
+      # can't be found.
+      #
+      # @return [Page]
+      #
+      def find_by_path(path)
+        first(conditions: { path: path }) || (raise Page::NotFound.new(path))
+      end
+      alias :f :find_by_path
+
+      # Generate a +path+ from attributes.
+      #
+      # @param [Hash]   attributes
+      # @option attributes [String] :parent_path       Path to parent page
+      # @option attributes [Page] :parent              Parent page
+      # @option attributes [String] :name              Page name
+      # @option attributes [String] :permalink         Permalink
+      # @param [Page]  parent
+      # @return [String]
+      #
+      def path_from_attributes(attributes, parent = nil)
+        parent_path = if parent
+                        parent.path
+                      else
+                        attributes[:parent_path] || attributes[:parent].try(:path).to_s
+                      end
+        permalink = attributes.delete(:permalink) || attributes[:name]
+        File.join(parent_path, permalink.to_url)
+      end
+    end
+
+    # Get the parent page.
+    #
+    # @return [Page]
+    def parent
+      page
+    end
+
+    # Set the parent.
+    #
+    # @param [Page] page      The new parent
+    # @return [Page]
+    #
+    def parent=(page)
+      self.page = page
+    end
+
+    # Is this page the home page
+    #
+    def home?
+      path == '/'
+    end
+
+    # A list of pages descended from this page ordered by +position+
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def children
+      Page.where(page_id: self.id).ascending(:position)
+    end
+
+    # A list of the page's ancestors
+    #
+    # @return [Array<Page>]
+    #
+    def ancestors
+      ancestors = []
+      parent_page = parent
+      while parent_page
+        ancestors << parent_page
+        parent_page = parent_page.parent
+      end
+      ancestors
+    end
+
+    # Is the current page a descendant of +page+
+    #
+    # @param [Page] page
+    #
+    def descended_from?(page)
+      ancestors.include?(page)
+    end
+
+    # The navigaiton path for a page, the navigation differers from +path+
+    # in a few important ways. If #external_url is set then it is returned. If
+    # the page has no content and children then the path of it's first child is
+    # returned
+    #
+    # @return [String]
+    #
+    def navigation_path
+      if external_url?
+        external_url
+      elsif home? || has_content?
+        path
+      else
+        navigable_children.first ? navigable_children.first.path : path
+      end
+    end
+
+    # A list of child pages which have both +active+ and +show_in_nav+ set to
+    # true.  Only the attributes needed to render #navigation are returned,
+    # these are: +page_id+, +path+, +external_url+, +name+ and +has_content+.
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def navigable_children
+      page_children.minimal.where(active: true, show_in_nav: true)
+    end
+
+    # The parent pages's navigable children, including this page
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def peers
+      parent.nil? ? [] : parent.navigable_children
+    end
+
+    # An array of the parent page's children excluding this page
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def siblings
+      parent.nil? ? [] : parent.children.where(:_id.nin => [id])
+    end
+
+    # An array of the parent page's children excluding this page, ordered by
+    # position
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def siblings_by_position
+      siblings.ascending(:position)
+    end
+
+    # Is this page the first child of its parent
+    #
+    def first_sibling?
+      parent.nil? ? false : peers.first == self
+    end
+
+    # Is this page the last child of its parent
+    #
+    def last_sibling?
+      parent.nil? ? false : peers.last == self
+    end
+
+    # The previous page(of the parent's active children), or nil
+    # if this is the first page.
+    #
+    # @return [Page]
+    #
+    def previous_sibling
+      index_in_peers < 1 ? nil : peers[index_in_peers - 1]
+    end
+
+    # The next page(of the parent's active children), or nil
+    # if this is the last page.
+    #
+    # @return [Page]
+    #
+    def next_sibling
+      peers[index_in_peers + 1]
+    end
+
+    # A list of children which are either {Page} or {SetPage}
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def page_children
+      children.where(:_type.in => [nil, 'Page', 'SetPage'])
+    end
+
+    # A list of children which are neither {Page} or {SetPage}
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def entry_children
+      children.where(:_type.nin => ['Page', 'SetPage'])
+    end
+
+    # Recusivly decend from this page and update each descendants path,
+    # useful when changing permalinks.
+    #
+    # @return [Mongoid::Criteria]
+    #
+    def update_path_for_children
+      children.each do |child|
+        child.path = child.generate_path
+        child.save!
+        child.update_path_for_children
+      end
+    end
+
+    # Generate a new +path+ for the page, using it's parent's path and the
+    # permalink.
+    #
+    # @return [String]
+    #
+    def generate_path
+      unless home?
+        File.join(parent.path, permalink)
+      else
+        '/'
+      end
+    end
+
+    # The permalink for the page
+    #
+    # @return [String]
+    #
+    def permalink
+      if path
+        File.basename(path)
+      else
+        name.to_url
+      end
+    end
+
+    private
+
+    # Make sure that a page's path is unique amoungst it's siblings, if there is
+    # a dupliacation then +-1+ is appended
+    #
+    # @return [void]
+    #
+    def ensure_path_unique
+      if parent.present? && path_changed?
+        matching_paths = siblings.where(path: /#{path}(-\d+)?$/)
+        if matching_paths.any?
+          self.path << "-#{matching_paths.length}"
+        end
+      end
+    end
+
+    # The page's position amoung it's peers
+    #
+    # @return [Integer]
+    #
+    def index_in_peers
+      parent.nil? ? 0 : peers.only(:id).entries.index(self)
+    end
+  end
+end