slices 1.0.0

data/lib/mongo_search.rb

@@ -0,0 +1,84 @@
+module MongoSearch
+  class KeywordsExtractor
+    def self.extract(text)
+      if text.blank?
+        []
+      else
+        text.mb_chars.normalize(:kd).to_s
+          .gsub(/[^\x00-\x7F]/,'')
+          .downcase
+          .split(/[\s\.\-_]+/)
+      end
+    end
+  end
+
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :search_fields, :match
+    end
+
+    module ClassMethods
+      def text_search_in(*args)
+        options = args.pop if args.last.has_key?(:match)
+        self.match = options[:match]
+      rescue NoMethodError
+      ensure
+        self.match ||= :all
+        self.search_fields = args
+
+        field :_keywords, type: Array
+        index :_keywords
+
+        before_save :set_keywords
+      end
+
+      def search_in(*args)
+        warn('[DEPRECATION `search_in` is deprecated. Please use `text_search_in` instead.')
+        text_search_in(args)
+      end
+
+      def text_search(query)
+        words = KeywordsExtractor.extract(query).map { |word| /#{word}/ }
+        self.send("#{self.match}_in", _keywords: words)
+      end
+
+      def search(query)
+        warn("[DEPRECATION] `search` is deprecated. Please use `text_search` instead.")
+        text_search(query)
+      end
+    end
+
+    private
+      def set_keywords
+        self._keywords = []
+        search_fields.each do |field|
+          if field.respond_to?(:each)
+            field.each do |name, attribute|
+              extract_keywords_for_association(name, attribute)
+            end
+          elsif respond_to?(field)
+            extract_keywords(send(field))
+          else
+            extract_keywords(self[field])
+          end
+        end
+        self._keywords.uniq!
+      end
+
+      def extract_keywords(text)
+        self._keywords += KeywordsExtractor.extract(text) unless text.nil?
+      end
+
+      def extract_keywords_for_association(name, attribute)
+        association = send(name)
+        return [] if association.nil?
+        if association.respond_to?(:each)
+          association.each { |doc| extract_keywords(doc[attribute]) }
+        else
+          extract_keywords(association[attribute])
+        end
+      end
+  end
+end

data/lib/paperclip_validator.rb

@@ -0,0 +1,5 @@
+class PaperclipValidator < ActiveModel::Validator
+  def validate(record)
+    record.errors[:file] << 'Must specify a file' unless record.file_file_name.present?
+  end
+end

data/lib/rack_utf8_fix.rb

@@ -0,0 +1,10 @@
+require 'escape_utils'
+
+module Rack
+  module Utils
+    def escape s
+      EscapeUtils.escape_url s.to_s
+    end
+  end
+end
+

data/lib/set_link_renderer.rb

@@ -0,0 +1,31 @@
+require 'will_paginate/view_helpers/action_view'
+
+class SetLinkRenderer < WillPaginate::ViewHelpers::LinkRenderer
+  protected
+    # This method has been largely robbed from will_paginate's
+    # lib/will_paginate/view_helpers/action_view.rb file, whose
+    # implementation only differs in that it assumes that you're using
+    # controller: 'foo', action: 'bar' compatible routes.
+    #
+    def url(page)
+      @base_url_params ||= begin
+        url_params = base_url_params
+        merge_optional_params(url_params)
+        url_params
+      end
+
+      url_params = @base_url_params.dup
+      path = url_params.delete(:path)
+      add_current_page_param(url_params, page)
+      remove_unwanted_params(url_params)
+      if url_params.empty?
+        "/#{path}"
+      else
+        "/#{path}?" + url_params.map { |k, v| "#{k}=#{v}" }.join('&')
+      end
+    end
+
+    def remove_unwanted_params(url_params)
+      [:controller, :action, :escape].each { |p| url_params.delete(p) }
+    end
+end

data/lib/slices.rb

@@ -0,0 +1,68 @@
+require 'rails'
+require 'bson'
+require 'devise'
+require 'mongo'
+require 'mongoid'
+require 'mongoid_paperclip'
+require 'RedCloth'
+require 'redcarpet'
+require 'stringex'
+
+require 'slices/paperclip'
+require 'slices/version'
+
+require 'mongo_search'
+require 'ext/file_store_cache'
+
+module Slices
+  autoload :Config,                     'slices/config'
+  autoload :CmsFormBuilder,             'slices/cms_form_builder'
+  autoload :AvailableSlices,            'slices/available_slices'
+  autoload :ContainerParser,            'slices/container_parser'
+  autoload :GeneratorMacros,            'slices/generator_macros'
+  autoload :HasSlices,                  'slices/has_slices'
+  autoload :HasAttachments,             'slices/has_attachments'
+  autoload :Renderer,                   'slices/renderer'
+  autoload :PositionHelper,             'slices/position_helper'
+  autoload :SplitDateTimeField,         'slices/split_date_time_field'
+  autoload :Tree,                       'slices/tree'
+
+  module Asset
+    autoload :Maker,                    'slices/asset/maker'
+    autoload :Rename,                   'slices/asset/rename'
+  end
+
+  def self.gem_path
+    File.expand_path('..', File.dirname(__FILE__))
+  end
+
+  def self.load_slice_classes_into_object_space(root)
+    Dir.glob(File.join(root, 'app', 'slices', '**/*.rb')).each do |file|
+      constant = File.basename(file, '.rb').camelize
+      Object.const_get(constant)
+    end
+  end
+
+  def self.test_environment?
+    Rails.env.test? && Rails.root.to_s == Slices.gem_path
+  end
+
+end
+
+require 'slices/slices_engine' if defined?(Rails)
+require 'slices/i18n'
+require 'slices/will_paginate_mongoid'
+require 'slices/will_paginate'
+require 'set_link_renderer'
+
+if Rails.env.development?
+  Slices::Config.use_snippets!
+end
+if Rails.env.test? || Rails.env.development?
+  require 'standard_tree'
+end
+
+Mime::Type.register_alias 'text/plain', :hbs
+Time::DATE_FORMATS.merge!(
+  day_month_year: '%d %B %Y'
+)

data/lib/slices/asset/maker.rb

@@ -0,0 +1,55 @@
+module Slices
+  module Asset
+    class Maker
+
+      attr_accessor :args, :new_asset
+
+      def self.run(args)
+        new(args).run
+      end
+
+      def initialize(args)
+        self.args = args
+      end
+
+      def create_new_asset
+        ::Asset.create!(args)
+      end
+
+      def find_matching_asset(new_asset)
+        ::Asset.first(conditions: {
+          file_fingerprint: new_asset.file_fingerprint, :_id.ne => new_asset.id
+        })
+      end
+
+      def tempfile_stored_on_s3?
+        Slices::Config.s3_storage? &&
+          args[:file].is_a?(URI)
+      end
+
+      def s3_path
+        s3_path = args[:file].path
+        s3_path[s3_path.index(Slices::Config::S3_TEMPFILE_KEY_PREFIX) .. -1]
+      end
+
+      def delete_tempfile_from_s3
+        directory = new_asset.file.send(:directory)
+        directory.files.new(key: s3_path).destroy
+      end
+
+      def run
+        self.new_asset = create_new_asset
+        delete_tempfile_from_s3 if tempfile_stored_on_s3?
+        matching_asset = find_matching_asset(new_asset)
+
+        if matching_asset.present?
+          new_asset.destroy
+          matching_asset.soft_restore!
+          matching_asset
+        else
+          new_asset
+        end
+      end
+    end
+  end
+end

data/lib/slices/asset/rename.rb

@@ -0,0 +1,67 @@
+require 'active_support/inflector'
+
+module Slices
+  module Asset
+    module Rename
+      class UnsupportedStorage < ::StandardError; end
+
+      def self.run(file, new_file_name)
+        klass = ('Slices::Asset::Rename::' + file.options[:storage].to_s.classify).constantize
+        klass.new(file, new_file_name).run
+      rescue NameError
+        raise UnsupportedStorage,
+        "Renaming files with '#{file.options[:storage]}' is not supported"
+      end
+
+      class Base
+        attr_accessor :file, :new_file_name
+
+        def initialize(file, new_file_name)
+          self.file = file
+          self.new_file_name = new_file_name
+        end
+
+        def run
+          (file.styles.keys + [:original]).each do |style|
+            next unless file.exists?(style)
+            rename(style)
+          end
+        end
+
+        def rename(style)
+          @old_path = file.path(style)
+          @new_path = File.join(File.dirname(@old_path), @new_file_name)
+        end
+      end
+
+      class Filesystem < Base
+        def rename(style)
+          super
+          File.rename(@old_path, @new_path)
+        end
+      end
+
+      class Fog < Base
+        def new_path
+          @new_path[1 .. -1]
+        end
+
+        def rename(style)
+          super
+          file = directory.files.new(key: @old_path)
+          file.copy(
+            directory.key,
+            @new_path,
+            {'x-amz-acl' => 'public-read'}
+          )
+          file.destroy
+        end
+
+        def directory
+          @directory ||= file.send(:directory)
+        end
+      end
+    end
+
+  end
+end

data/lib/slices/available_slices.rb

@@ -0,0 +1,43 @@
+module Slices
+  class AvailableSlices
+
+    def self.all
+      # We've memoized the slices so that we never try and load them all
+      # twice. If we iterate over ObjectSpace twice (see find_all_slices)
+      # we sometimes find that an incomplete set of slices objects is
+      # returned on subsequent calls.
+      @all ||= find_all_slices
+    end
+
+    private
+
+    def self.find_all_slices
+      slices = []
+
+      Dir.glob(File.join(Rails.root, 'app/slices/**/*_slice.rb')).each do |path|
+
+        slice_name = File.basename(path, '.rb')
+        klass      = slice_name.camelize.constantize
+        basename   = File.basename(path, '_slice.rb')
+        folder     = File.basename(File.dirname(path))
+
+        fields = {
+          'name' => basename.humanize.titleize,
+          'template' => File.join(folder, basename),
+          'restricted' => klass.restricted?
+        }
+
+        klass.fields.each do |name, field|
+          next if Slice.fields[name]
+          fields[name] = field.default
+        end
+
+        slices << [basename, fields]
+
+      end
+
+      Hash[*slices.sort.flatten]
+    end
+  end
+end
+

data/lib/slices/cms_form_builder.rb

@@ -0,0 +1,42 @@
+module Slices
+  class CmsFormBuilder < ActionView::Helpers::FormBuilder
+
+    FIELD_ERROR_PROC = proc do |html_tag, instance_tag|
+      html_tag
+    end
+
+    %w{email_field password_field select text_area text_field}.each do |selector|
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def cms_#{selector}(attribute, options = {})       # def cms_text_field(attribute, options = {})
+          wrap_field(:#{selector}, attribute, options)     #   wrap_field(:text_field, attribute, options)
+        end                                                # end
+      RUBY_EVAL
+    end
+
+    private
+
+    def wrap_field(selector, attribute, options)
+      with_custom_field_error_proc do
+        content = send(selector, attribute, options)
+        options = {}
+        errors = @object.errors[attribute]
+
+        if errors.any?
+          options[:class] = 'error'
+          content << @template.send(:content_tag, :p, errors.join(' and '))
+        end
+
+        @template.content_tag(:li, label(attribute) + content, options)
+      end
+    end
+
+    def with_custom_field_error_proc(&block)
+      default_field_error_proc = ::ActionView::Base.field_error_proc
+      ::ActionView::Base.field_error_proc = FIELD_ERROR_PROC
+      yield
+    ensure
+      ::ActionView::Base.field_error_proc = default_field_error_proc
+    end
+  end
+
+end

data/lib/slices/config.rb

@@ -0,0 +1,93 @@
+module Slices
+  class Config
+    S3_TEMPFILE_KEY_PREFIX = 'uploads'
+
+    # Set the asset styles for the app, this is a hash with the keys as the
+    # style names and Papcerlip resize options
+    #
+    #   Slices::Config.add_asset_styles(
+    #     :thumbnail      => "220x146#",
+    #     :full_width     => "971x440#",
+    #     :feature_full   => "971x475#",
+    #     :slideshow      => "723x440>",
+    #   )
+    #
+    # @param [Hash] options
+    def self.add_asset_styles(options = {})
+      @asset_styles = options.merge(admin_asset_styles)
+    end
+
+    # The list of asset styles in use
+    #
+    # @return [Hash]
+    def self.asset_styles
+      @asset_styles || add_asset_styles
+    end
+
+    # Enable snippets
+    def self.use_snippets!
+      @snippets = true
+    end
+
+    # Does this app use snippets?
+    # @return [Boolean]
+    def self.snippets?
+      @snippets || false
+    end
+
+    def self.s3_storage?
+      Paperclip::Attachment.default_options[:storage].to_sym == :fog
+    end
+
+    # S3 credentaials taken from the papercip defaults
+    #
+    #   {
+    #     :bucket => 'slices-demo',
+    #     :access_key_id => 'access key id',
+    #     :secret_access_key => 'secret access key',
+    #   }
+    #
+    # @return Hash
+    def self.s3_credentials
+      default_options = Paperclip::Attachment.default_options
+      {
+        bucket: default_options[:fog_directory],
+        access_key_id: default_options[:fog_credentials][:aws_access_key_id],
+        secret_access_key: default_options[:fog_credentials][:aws_secret_access_key],
+      }
+    end
+
+    # Google Apps domain for quick auth.
+    #
+    # @return [String] the domain
+    def self.google_apps_domain
+      @google_apps_domain
+    end
+
+    # Set Google Apps domain for quick auth.
+    #
+    # @param [String] the domain
+    def self.google_apps_domain=(domain)
+      @google_apps_domain = domain
+    end
+
+    private
+    def self.admin_asset_styles
+      { admin: '180x180#' }
+    end
+
+    # Addition Paperclip convert options which are applied to all styles.
+    # This removes colour profiles, sets the dpi to 72 dpi (the image is not
+    # resampled). The colour depth is set to 8 bits per pixel
+    def self.asset_convert_options
+      Hash.new.tap do |options|
+        asset_styles.keys.each do |style|
+          next if style == :original
+          options[style] = "-strip -density 72x72 -depth 8"
+        end
+      end
+    end
+
+  end
+
+end