nocms-blocks 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d1a4d1f3cc485767a9980d24903923abc0e0cb81
-  data.tar.gz: 9af340e08b7aaf235058f114877d040216d005bd
+  metadata.gz: bbc9eae202e6ec4df5bdba9d91c4a842e03e2f3d
+  data.tar.gz: 2523df1872e26d06a714b3bc9c8552c49c07c279
 SHA512:
-  metadata.gz: 29c7920341189899327e206dbe3581996a35304580d33e5d6213c5abc34909c3e3faceb5f63599b3c5503dfe731d12d320ff50d710387bab57d6f34f25e66028
-  data.tar.gz: fa197c2daa8a2a407551c923c58eebe71d76b703de6fbc1cc4f18f2239165f292d97f86bc704c55b5ded6ce05e613d0b2d0d3d7f88714af91285694228e3f6ba
+  metadata.gz: 841a55342e8a5b30e2a4c4a5c2771d9d231a4ce68fbe483896159823d44332130fc2b09b8ba214927cb395858301565bac8ef03a98e34c9df8e1ca67b7911ec3
+  data.tar.gz: cefb0459db81a0af3dd4e10f3da524b6c6d5359a0aecfe5b1b6cd5664d30c1d09315bc0a5615dab8ad2cea01f16cc5ffd5a3f0b2bc9a0c36c37b883529e0c1fe

data/CHANGELOG

@@ -1,3 +1,13 @@
+1.1.0
+
+  - I18n behaviour fixed
+    * Separated objects cache for translations
+    * fields info both in the block and the translation
+
+  - Globalize dependency correctly specified in the gemspec
+
+  - Latest versions of awesome-nested-set (3.0.2) and globalize (5.0.1)
+
 1.0.0
 
   - First released version.

data/README.md

@@ -6,15 +6,19 @@ This is a Rails engine with a basic functionality of customizable blocks of cont
 
 ## How do I install it?
 
-Right now there's no proper gem, although we have a couple of projects making extensive use of it.
+Just include in your Gemfile:
 
-To install it just put the repo in your Gemfile:
+```ruby
+gem "nocms-blocks"
+```
+
+If you're brave and want to use the last development version you can use:
 
 ```ruby
 gem "nocms-blocks", git: 'git@github.com:simplelogica/nocms-blocks.git'
 ```
 
-And then import all the migrations:
+Once the gem is installed you can import all the migrations:
 
 ```
 rake no_cms_blocks:install:migrations

data/app/models/no_cms/blocks/block.rb

@@ -9,152 +9,55 @@ module NoCms::Blocks
     scope :no_drafts, ->() { where_with_locale(draft: false) }
     scope :roots, ->() { where parent_id: nil }
 
-    accepts_nested_attributes_for :children, allow_destroy: true
-
-    attr_reader :cached_objects
+    translates :draft
+    include  NoCms::Blocks::Concerns::SerializingFields
 
-    translates :layout, :fields_info, :draft
-    accepts_nested_attributes_for :translations
-
-    class Translation
-      serialize :fields_info, Hash
+    ##
+    # In the block we get all the fields so it can accept all of them
+    def fields_configuration
+      layout_config.fields
     end
 
-    after_initialize :set_blank_fields
-    before_save :save_related_objects
-
-    validates :fields_info, presence: { allow_blank: true }
     validates :layout, presence: true
 
-    def cache_enabled
-      layout_config.has_key?(:cache_enabled) ? layout_config[:cache_enabled] : NoCms::Blocks.cache_enabled
-    end
-
-
-    def layout_config
-      NoCms::Blocks.block_layouts.stringify_keys[layout]
-    end
+    ##
+    # A block dups all it's children and the translations
+    def duplicate_self new_self
 
-    def template
-      layout_config[:template] if layout_config
-    end
-
-    def has_field? field
-      # We have the field if...
-      !layout_config.nil? && # We have a layout configuration AND
-        (
-          !layout_config[:fields].symbolize_keys[field.to_sym].nil? || # We have this field OR
-          !layout_config[:fields].symbolize_keys[field.to_s.gsub(/\_id$/, '').to_sym].nil? # we remove the final _id and then we have the field
-        )
-    end
-
-    def field_type field
-      return nil unless has_field?(field)
-      layout_config[:fields].symbolize_keys[field.to_sym]
-    end
-
-    def read_field field
-      return nil unless has_field?(field)
-
-      value = fields_info[field.to_sym] || # first, we get the value
-                @cached_objects[field.to_sym] # or we get it from the cached objects
-
-      # If value is still nil, but the field exists we must get the object from the database
-      if value.nil?
-        field_type = field_type(field)
-        field_id = fields_info["#{field}_id".to_sym]
-        value = @cached_objects[field.to_sym] = field_type.find(field_id) unless field_id.nil?
-      end
+      new_self.translations = translations.map(&:dup)
+      new_self.translations.each { |t| t.globalized_model = new_self }
 
-      # If value is still nil, and the field_type is an ActiveRecord class, then we
-      if value.nil? && field_type.is_a?(Class)
-        value = @cached_objects[field.to_sym] = field_type.new
+      children.each do |child|
+        new_self.children << child.dup
       end
-      value
     end
 
-    def write_field field, value
-      return nil unless has_field?(field)
-      field_type = field_type field
-      # If field type is a model then we update the cached object
-      if field_type.is_a?(Class) && field_type < ActiveRecord::Base
-        # First, we initialize the object if we don't read the object (it loads it into the cached objects)
-        @cached_objects[field.to_sym] = field_type.new if read_field(field).nil?
-        # Then, assign attributes
-        @cached_objects[field.to_sym].assign_attributes value
-      else # If it's a model then  a new object or update the previous one
-        self.fields_info = fields_info.merge field.to_sym => value # when updating through an object (i.e. the page updates through nested attributes) fields_info[field.to_sym] = value doesn't work. Kudos to Rubo for this fix
-      end
-    end
+    class Translation
 
-    # In this missing method we check wether we're asking for one field
-    # in which case we will read or write ir
-    def method_missing(m, *args, &block)
-      # We get the name of the field stripping out the '=' for writers
-      field = m.to_s
-      write_accessor = field.ends_with? '='
-      field.gsub!(/\=$/, '')
-
-      # If this field actually exists, then we write it or read it.
-      if has_field?(field)
-        write_accessor ?
-          write_field(field, args.first) :
-          read_field(field.to_sym)
-      else
-        super
+      ##
+      # In the translation we get only the translated fields
+      def fields_configuration
+        layout_config.translated_fields
       end
-    end
-
-    # When we are assigning attributes (this method is called in new, create...)
-    # we must split those fields from our current layout and those who are not
-    # (they must be attributes).
-    # Attributes are processed the usual way and fields are written later
-    def assign_attributes new_attributes
-      fields = []
-
-      set_blank_fields
-
-      # We get the layout
-      new_layout = new_attributes[:layout] || new_attributes['layout']
-      self.layout = new_layout unless new_layout.nil?
-
-      Rails.logger.info "Searching #{new_attributes.keys.inspect} fields in #{self.layout} layout"
-
-      # And now separate fields and attributes
-      fields = new_attributes.select{|k, _| has_field? k }.symbolize_keys
-      new_attributes.reject!{|k, _| has_field? k }
 
-      super(new_attributes)
+      ##
+      # Sometimes the translation still won't have the globalized_model linked
+      # (e.g. before it's saved for the first time) and we must have a mechanism
+      # to be able to store a temporary layout
+      attr_accessor :layout
 
-      Rails.logger.info "Writing #{fields.inspect} to #{self.layout} block"
-
-      fields.each do |field_name, value|
-        self.write_field field_name, value
+      ##
+      # If we don't have a globalized model yet we return our temporary layout
+      def layout
+        globalized_model.nil? ? @layout : globalized_model.layout
       end
-    end
 
-    def reload *args
-      @cached_objects = {}
-      super
+      include  NoCms::Blocks::Concerns::SerializingFields
     end
 
-    private
-
-    def set_blank_fields
-      self.fields_info ||= {}
-      @cached_objects ||= {}
-    end
+    accepts_nested_attributes_for :children, allow_destroy: true
+    accepts_nested_attributes_for :translations
 
-    def save_related_objects
-      # Now we save each activerecord related object
-      cached_objects.each do |field, object|
-        # Notice that we don't care if the object is actually saved
-        # We don't care because there may be some cases where no real information is sent to an object but something is sent (i.e. the locale in a new Globalize translation) and then the object is created empty
-        # When this happens if we save! the object an error is thrown and we can't leave the object blank
-        if object.is_a?(ActiveRecord::Base) && object.save
-          fields_info["#{field}_id".to_sym] = object.id
-        end
-      end
-    end
   end
+
 end

data/app/models/no_cms/blocks/concerns/serializing_fields.rb

@@ -0,0 +1,386 @@
+module NoCms
+  module Blocks
+    module Concerns
+      module SerializingFields
+        extend ActiveSupport::Concern
+
+        self.included do
+
+          serialize :fields_info, Hash
+
+          after_initialize :set_blank_fields
+
+          before_save :save_related_objects
+
+          validates :fields_info, presence: { allow_blank: true }
+
+          ##
+          # This attribute stores all the objects referenced on those fields
+          # from an AR subtype.
+          #
+          # It acts both as a cache and as a way to edit or create AR objects
+          # and save them when the block is saved.
+          attr_reader :cached_objects
+
+
+          ##
+          # This method checks wether the block's layout has cache configured
+          # and returns it.
+          #
+          # If it hasn't it returns the global cache_enabled configuration for
+          # NoCms::Blocks
+          def cache_enabled?
+            layout_config.cache_enabled?
+          end
+
+          ##
+          # Old version without '?' mantained for historical reasons
+          alias_method :cache_enabled, :cache_enabled?
+
+          ##
+          # Returns a hash with the layout information read from the blocks
+          # initializer and the 'layout' field on the corresponding object.
+          def layout_config
+            return if layout.nil?
+            @layout_config ||= NoCms::Blocks::Layout.find layout
+          end
+
+          ##
+          # Returns the template read from the layout configuration
+          def template
+            layout_config.template if layout_config
+          end
+
+          ##
+          # This method checks that we have the field passed as parameter in our
+          # layout configuration.
+          #
+          # It also takes into account the case where we have an AR object and
+          # we're asking just for its id.
+          def has_field? field
+            # We have the field if...
+            !layout_config.nil? && # We have a layout configuration AND
+            !layout_config.field(field).nil? # We have this field
+          end
+
+          ##
+          # This method tells wether we are in a translation and we must manage
+          # translated fields or not
+          def is_translation?
+            !self.respond_to?(:translations)
+          end
+
+          ##
+          # Returns the type of a field in the current layout configuration of
+          # this block.
+          #
+          # If the field is not present in the layout configuration it returns
+          # nil.
+          def field_type field
+            return nil unless has_field?(field)
+            fields_configuration.symbolize_keys[field.to_sym][:type]
+          end
+
+          ##
+          # Returns the stored value of the field for this block.
+          #
+          # If the field is not present in the layout configuration it returns
+          # nil.
+          #
+          # If the field is an Active Record object but it's not present on our
+          # objects cache we fetch it from the database using the id stored in
+          # the #{field}_id field.
+          #
+          # If it's an Active Record object but we don't have the #{field}_id
+          # field then it creates (with new, not with create) a new one and
+          # stores it in the objects cache. Later, if the block is saved, this
+          # object will be saved too.
+          def read_field field
+            raise  NoMethodError.new("field #{field} is not defined in the block layout") unless has_field?(field)
+
+            # first, we get the value
+            value = fields_info[field.to_sym] ||
+                      # or we get it from the cached objects
+                      @cached_objects[field.to_sym]
+
+            # If value is still nil, but the field exists we must get the object
+            # from the database
+            if value.nil?
+              field_type = field_type(field)
+              field_id = fields_info["#{field}_id".to_sym]
+              unless field_id.nil?
+                value = field_type.find(field_id)
+                @cached_objects[field.to_sym] = value
+              end
+            end
+
+            # If value is still nil, and the field_type is an ActiveRecord
+            # class, then we build a new one
+            if value.nil? && field_type.is_a?(Class)
+              value = field_type.new
+              @cached_objects[field.to_sym] = value
+            end
+            value
+          end
+
+          ##
+          # This method stores the parameter value into the corresponding field.
+          #
+          # If the field is an Active Record object then we load it into the
+          # objects cache and assign it the value through an assign_attributes.
+          # This solves the scenario of a nested form where a hash is passed as
+          # the value of the field.
+          def write_field field, value
+            raise NoMethodError.new("field #{field} is not defined in the block layout") unless has_field?(field)
+            field_type = field_type field
+            # If field type is a model then we update the cached object
+            if field_type.is_a?(Class) && field_type < ActiveRecord::Base
+
+              # We read the object and assign it the attributes attributes.
+              # Since we use the read_field method it will take into account
+              # if the AR object needs to be build
+              read_field(field).assign_attributes value
+
+              # Even if the fields_info has not changed we need to store the
+              # modification, so an association may be saved in cascade (e.g.
+              # the translation of a block would not be saved if we don't force
+              # this)
+              fields_info_will_change!
+            else
+            # If it's not a model then we merge with the previous value
+
+              # when updating through an object (i.e. the page updates through
+              # nested attributes) fields_info[field.to_sym] = value doesn't
+              # work. Kudos to Rubo for this fix
+              self.fields_info = fields_info.nil? ?
+                { field.to_sym => value } :
+                fields_info.merge(field.to_sym => value)
+
+            end
+          end
+
+          ##
+          # This method duplicates a field and stores its value.
+          #
+          # It takes into account that the field may be an AR object and updates
+          # the cached objects.
+          #
+          # We have different options of duplication depending on the field's
+          # configuration:
+          #
+          #  * duplication: It's the default behaviour. It just performs a dup
+          #    of the field and expects the attached object to implement dup in
+          #    a proper way.
+          #
+          #  * nullify: It doesn't dup the field, it empties it. It's useful for
+          #    objects we don't want to duplicate, like images in S3 (it can
+          #    raise a timeout exception when duplicating).
+          #
+          #  * link: It doesn't dup the field but stores the same object. It's
+          #    useful in Active Record fields so we can store the same id and
+          #    not creating a duplicate of the object (e.g. if we have a block
+          #    with a related post we don't want the post to be duplicated)
+          def duplicate_field field
+            field_type = field_type field
+            field_value = read_field(field)
+
+            dupped_value = case layout_config.field(field)[:duplicate]
+              # When dupping we just dp the object and expect it has the right
+              # behaviour. If it's nil we save nil (you can't dup NilClass)
+              when :dup
+                field_value.nil? ? nil : field_value.dup
+              # When nullifying we return nil
+              when :nullify
+                nil
+              when :link
+                field_value
+            end
+
+            if field_type.is_a?(Class) && field_type < ActiveRecord::Base
+              # We save in the objects cache the dupped object
+              @cached_objects[field.to_sym] = dupped_value
+              # and then we store the new id in the fields_info hash
+              fields_info["#{field}_id".to_sym] =
+                dupped_value.nil? ? nil : dupped_value.id
+            else
+              # else we just dup it and save it into fields_info.
+              fields_info[field.to_sym] = dupped_value
+            end
+          end
+
+          ##
+          # Saves every related object from the objects cache
+          def save_related_objects
+            # Now we save each activerecord related object
+            @cached_objects.each do |field, object|
+              # Notice that we don't care if the object is actually saved.
+              #
+              # We don't care because there may be some cases where no real
+              # information is sent to an object but something is sent (i.e. the
+              # locale in a new Globalize translation) and then the object is
+              # created empty.
+              #
+              # When this happens if we save! the object an error is thrown and
+              # we can't leave the object blank
+              if object.is_a?(ActiveRecord::Base) && object.save
+                fields_info["#{field}_id".to_sym] = object.id
+              end
+            end
+          end
+
+          ##
+          # In this missing method we check wether we're asking for one field
+          # in which case we will read or write it.
+          #
+          # If there's no field we just let it go to super.
+          def method_missing(m, *args, &block)
+            # We get the name of the field stripping out the '=' for writers
+            field = m.to_s
+            write_accessor = field.ends_with? '='
+            field.gsub!(/\=$/, '')
+
+
+            # If we don't have this field then we send it to super and pry
+            if field == 'layout' || !has_field?(field)
+              super
+            # If this field exists, and it's not translated, then we do whatever
+            # we need to do
+            elsif !layout_config.field(field)[:translated]
+              write_accessor ?
+                write_field(field, args.first) :
+                read_field(field.to_sym)
+
+              # If it's translated but we are not in the translation (we check
+              # this by checking if we have translations) then we use the
+              # default translation to obtain it
+            elsif !self.is_translation? &&
+                layout_config.field(field)[:translated]
+
+                # When we are creating the block we still have no translation
+                # and we need to fill the layout. Otherwise no write or read
+                # field will work
+                translation.layout = self.layout
+
+                  write_accessor ?
+                    translation.write_field(field, args.first) :
+                    translation.read_field(field.to_sym)
+            end
+          end
+
+          ##
+          # When we are assigning attributes (this method is called in new,
+          # create...) we must split those fields from our current layout and
+          # those who are not (they must be attributes).
+          #
+          # Attributes are processed the usual way and fields are written later
+          def assign_attributes new_attributes
+            fields = []
+
+            set_blank_fields
+
+            # We get the layout
+            new_layout = new_attributes[:layout] || new_attributes['layout']
+            self.layout = new_layout unless new_layout.nil?
+
+            Rails.logger.info "Searching #{new_attributes.keys.inspect} fields"+
+              "in #{self.layout} layout"
+
+            # And now separate fields and attributes
+            fields = new_attributes.select{|k, _| has_field? k }.symbolize_keys
+            # Now we filter those fields we must not manage because we are (or
+            # not) in a translation. I.e: if we have a translated field, but we
+            # are not in a translation then we let the translated field go and
+            # not manage it here
+            fields.select!{|k, _| layout_config.field(k)[:translated] == is_translation? }
+
+            # We purge the fields from the attributes
+            new_attributes.reject!{|k, _| fields.has_key? k }
+
+            # If we have translations we're going to need the layout in their
+            # attributes too so they can validate the fields.
+            # This is actually only neccesary when creating the translations,
+            # but we can afford to send the layout always to the translations
+            if new_attributes.has_key? :translations_attributes
+              new_attributes[:translations_attributes].each do |translation|
+                translation[:layout] = self.layout
+              end
+            end
+
+            super(new_attributes)
+
+            Rails.logger.info "Writing #{fields.inspect} to #{self.layout} block"
+
+            fields.each do |field_name, value|
+              self.write_field field_name, value
+            end
+          end
+
+          ##
+          # It cleans the objects cache and executes the default behaviour.
+          def reload *args
+            @cached_objects = {}
+            super
+          end
+
+          ##
+          # Overwriting duplication method. This method relies on super for any
+          # default behaviour, then duplicate the fields just as their
+          # configuration demands and then allow the object to custimize the
+          # duplication through the duplicate_self method.
+          def dup
+            new_self = super
+
+            # Now we recover all the fields that must be duplicated here
+            fields_to_duplicate.keys.each do |field_to_duplicate|
+              new_self.duplicate_field field_to_duplicate
+            end
+
+            # And allow the class itself to append some behaviour
+            duplicate_self new_self
+
+            new_self
+          end
+
+          ##
+          # This method allows us to introduce some custom duplication for each
+          # class that includes the concern.
+          #
+          # Basic behaviour is... doing nothing
+          def duplicate_self new_self
+          end
+
+          ##
+          # This method returns a list of the fields to duplicate in this
+          # object. In the concern we will use all the fields and if the classes
+          # need to modify it they will.
+          #
+          # Notice that if the behaviour is that when duplicating the field is
+          # nullfied we will return the field here and the duplicate_field will
+          # manage it properly.
+          def fields_to_duplicate
+            fields_configuration
+          end
+
+          ##
+          # When dupping we need to overwrite the cached_objects attribute.
+          # Otherwise the cached_object from the original object would start to
+          # be populated with the objects of the dupped one.
+          def initialize_dup(other)
+            @cached_objects = {}
+            super
+          end
+
+          private
+
+          ##
+          # Initializes both the fields_info hash and the objects cache.
+          def set_blank_fields
+            @fields_info ||= {}
+            @cached_objects ||= {}
+          end
+
+        end
+      end
+    end
+  end
+end