contents_core 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 75a1c3e706d549e2a1760b2986ab6ed1c947e62c
-  data.tar.gz: 50c1f08869d686fb75509b3d26a92c8b59873196
+  metadata.gz: 33b635a47b2e5a090eea2d2c99dba30eef64c508
+  data.tar.gz: 93e8aa348c86bc228f0b0572a7fbdbec58fe5ad4
 SHA512:
-  metadata.gz: 9ac52395df24233ceda982dceab0871716058adf72bfd99cb5fbb98b67ce519b7830186c37b68441a7542b7a11658a0127c9ea5f7084a4bf0875228a4fafe9e2
-  data.tar.gz: 92ccd52237adcb6bf89352b9d6d583984daac7c54aadb3659268efdca2dfe298eff598c24a0e6ca0545afa9f0286e75dbae82e6817fdf1a25fe63caa63bdd9fb
+  metadata.gz: cb9f8914cbd38b7d91ae103c317c8cbc6310153f2a35d9b294d98c5abfcc84ee919cbbd406e89590ab935bf23cc82dab254e4ed315734c63350957cd0887594e
+  data.tar.gz: 3b341cdfe78f537cf7118fedc018d49bf834d4677fd1358cecdc2522bef8747411e951e92adee917df5556cadc04c8fb294ef0d31e35d5104513484e2fe74db5

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2017 
+Copyright 2017, Mattia Roccoberton
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,15 +1,16 @@
 # ContentsCore [![Gem Version](https://badge.fury.io/rb/contents_core.svg)](https://badge.fury.io/rb/contents_core) [![Build Status](https://travis-ci.org/blocknotes/contents_core.svg)](https://travis-ci.org/blocknotes/contents_core)
 
-A Rails gem which offer a simple structure to manage contents in a flexible way.
+A Rails gem which offer a structure to manage contents in a flexible way: blocks with recursive nested blocks + items as "leaves"
 
 Disclaimer: this component is in ALPHA, major changes could happen
 
 Goals:
 - attach the contents structure to a model transparently
-- improve block views management
 - add fields to blocks without migrations
+- offer helpers to render blocks in views
+- cache-ready
 
-### Install
+## Install
 
 - Add to the Gemfile:
 `gem 'contents_core'`
@@ -17,24 +18,85 @@ Goals:
 `rails contents_core:install:migrations`
 - Execute migrations
 - Add the concern *Blocks* to your model (ex. *Page*): `include ContentsCore::Blocks`
-- Add the blocks to a view (ex. *page show*): `= render partial: 'contents_core/blocks', locals: { container: @page }`
+- Optionally add the blocks to a view (ex. *page show*): `= render partial: 'contents_core/blocks', locals: { container: @page }`
 
-### Config
+## Usage
+
+### Working with blocks/items
+
+- Basic operations (example parent model: *Page*):
+```ruby
+page = Page.first
+page.create_block :slider, name: 'a-slider', create_children: 3  # Create a silder with 3 slides
+page.current_blocks.map{ |block| block.name }  # current_blocks -> all published ordered blocks and query cached
+block = page.get_block 'a-slider'
+block.tree  # list all items of a block
+block.get 'slide-2.title'  # get value of 'title' field of sub block with name 'slide-2' (name automatically generated at creation)
+block.set 'slide-2.title'  # set field value
+block.save
+```
+
+- Other operations:
+```ruby
+block = ContentsCore::Block.last
+ContentsCore.create_block_in_parent block, :text  # create a sub block in a block
+block.create_item :item_string, name: 'a-field'
+```
+
+## Config
 
 Edit the conf file: `config/initializers/contents_core.rb`
 
 ```ruby
-conf = ContentsCore.config
-# Adds a new custom block
-conf[:cc_blocks][:custom] = {
-  name: 'Custom block',
-  items: {
-    title: :item_string,
-    content: :item_text,
-    image: :item_file
+module ContentsCore
+  @@config = {
+    blocks: {
+      text: {
+        name: :text_only,       # used as reference / for translations
+        children: {             # children: sub blocks & items
+          title: :item_string,
+          content: :item_text
+        }
+      },
+      image: {
+        name: :image_only,
+        children: {
+          img: :item_file
+        }
+      },
+      slide: {
+        name: :a_slide,
+        child_only: true,       # used only as child of another block (slider)
+        children: {
+          img: :item_file,
+          link: :item_string,
+          title: :item_string
+        }
+      },
+      slider: {
+        name: :a_slider,
+        new_children: :slide,   # block type used when creating a new child with default params
+        children: {
+          slide: :slide
+        }
+      },
+    },
+    items: {
+      item_boolean: {},
+      item_datetime: {},
+      item_float: {},
+      item_hash: {},
+      item_file: {
+        input: :file_image
+      },
+      item_integer: {},
+      item_string: {},
+      item_text: {
+        input: :html
+      },
+    }
   }
-}
-ContentsCore.config( { components: conf[:cc_blocks] } )
+end
 ```
 
 Create the new view blocks: `app/views/contents_core/_block_custom.html.slim`
@@ -46,7 +108,7 @@ Create the new view blocks: `app/views/contents_core/_block_custom.html.slim`
   .image = image_tag block.get( 'image' ).url( :thumb )
 ```
 
-#### Images
+### Images
 
 To add support for images add CarrierWave gem to your Gemfile and execute: `rails generate uploader Image` and update che config file *config/initializers/contents_core.rb* with:
 
@@ -84,36 +146,36 @@ module ContentsCore
 end
 ```
 
-#### Customizations
+## Customizations
 
 To create a "free form" block just use: `Page.first.create_block :intro, name: 'IntroBlock', schema: { intro: :item_string, subtitle: :item_string }`
 
 Then create a *app/view/contents_core/_block_intro* view.
 
-To list the blocks of a page: `Page.first.cc_blocks.pluck :name`
+To list the blocks of a page manually (but *current_blocks* method is the preferred way): `Page.first.cc_blocks.pluck :name`
 
 To add a new field to an existing block (ex. to first Page, on the first Block):
 
 ```rb
 block = Page.first.get_block 'text-1'
-block.create_item( 'ContentsCore::ItemString', 'new-field' ).set( 'A test...' ).save
+block.create_item( :item_string, name: 'new-field' ).set( 'A test...' ).save
 ```
 
 Then add to the block view: `block.get( 'new-field' )`
 
 To set a field value: `block.set( 'new-field', 'Some value' )`
 
-#### ActiveAdmin
+### ActiveAdmin
 
 If you use ActiveAdmin as admin interface you can find a sample model configuration: [page](extra/active_admin_page.rb) plus a js [page](extra/active_admin.js)
 
-### Notes
+## Notes
 
-- Blocks enum: `ContentsCore::Block.block_enum`
-- Blocks types: `ContentsCore::Block.block_types`
+- Blocks enum: `ContentsCore::Block.enum`
+- Blocks types: `ContentsCore::Block.types`
 - Default blocks [here](config/initializers/contents_core.rb)
 
-#### Structure
+### Structure
 
 - Including the Blocks concern to a model will add `has_many :cc_blocks` relationship (the list of blocks attached to a container) and some utility methods
 - Block: UI component, a group of items (ex. a text with a title, a slider, a 3 column text widget, etc.); built with a list of sub blocks (for nested components) and a list of items

data/Rakefile

@@ -21,7 +21,6 @@ load 'rails/tasks/engine.rake'
 load 'rails/tasks/statistics.rake'
 
 
-
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'

data/app/models/contents_core/block.rb

@@ -1,33 +1,35 @@
 module ContentsCore
   class Block < ApplicationRecord
-    EMPTY_DATA = OpenStruct.new( { data: '' } )
+    # --- constants -----------------------------------------------------------
+    # EMPTY_DATA = OpenStruct.new( { data: '' } )
 
+    # --- misc ----------------------------------------------------------------
     attr_accessor :create_children
+    serialize :conf, Hash
 
-    # --- fields options ----------------------------------------------------- #
-    serialize :options, JSON
-    serialize :validations, JSON
-
-    # --- relations ---------------------------------------------------------- #
-    belongs_to :parent, polymorphic: true
+    # --- associations --------------------------------------------------------
+    belongs_to :parent, polymorphic: true, touch: true
     has_many :cc_blocks, as: :parent, dependent: :destroy, foreign_key: 'parent_id', class_name: 'Block'
     has_many :items, dependent: :destroy
     accepts_nested_attributes_for :cc_blocks, allow_destroy: true
     accepts_nested_attributes_for :items
 
-    # --- hooks -------------------------------------------------------------- #
+    # --- callbacks -----------------------------------------------------------
+    # after_initialize :on_after_initialize
     before_create :on_before_create
     after_create :on_after_create
 
-    # --- scopes ------------------------------------------------------------- #
+    # --- scopes --------------------------------------------------------------
     default_scope { order( :position ) }
     scope :published, -> { where( published: true ) unless ContentsCore.editing }
     scope :with_nested, -> { includes( :items, cc_blocks: :items ) }
 
-    # --- validations -------------------------------------------------------- #
+    # --- validations ---------------------------------------------------------
     validates_presence_of :block_type, :position
+    validates_associated :cc_blocks
+    validates_associated :items
 
-    # --- misc --------------------------------------------------------------- #
+    # --- tmp -----------------------------------------------------------------
     ## amoeba do
     ##   enable
     ##   # customize( lambda { |original_obj, new_obj|
@@ -53,11 +55,13 @@ module ContentsCore
     #
     # # scope :published, -> { where( published: true ) unless ApplicationController.edit_mode }
 
+    # --- methods -------------------------------------------------------------
     def initialize( attributes = {}, &block )
       super( attributes, &block )
-      @create_children = 1
+      @create_children = 0
+      self.conf = {} unless self.conf
       self.group = config[:group]
-      self.block_type = parent.config[:children_type] if attributes[:block_type].nil? && self.parent_type == 'ContentsCore::Block'
+      self.block_type = parent.config[:new_children] if attributes[:block_type].nil? && self.parent_type == 'ContentsCore::Block'
     end
 
     def as_json( options = nil )
@@ -68,19 +72,21 @@ module ContentsCore
       "#{self.class.to_s.split('::').last}-#{self.id}"
     end
 
-    def children_type
-      config[:children_type]
-    end
-
     def config
-      ContentsCore.config[:cc_blocks][block_type.to_sym] ? ContentsCore.config[:cc_blocks][block_type.to_sym] : {}
-    end
-
-    def create_item( item_type, item_name = nil )
-      new_item = ContentsCore::Item.new( type: item_type )
-      new_item.name = item_name if item_name
-      self.items << new_item
-      new_item
+      !self.conf.blank? ? self.conf : ( ContentsCore.config[:blocks][block_type.to_sym] ? ContentsCore.config[:blocks][block_type.to_sym] : {} )
+    end
+
+    def create_item( item_type, options = {} )
+      if ContentsCore.config[:items].keys.include? item_type
+        attrs = { type: "ContentsCore::#{item_type.to_s.classify}" }  # TODO: check if model exists
+        attrs[:name] = options[:name]  if options[:name]
+        attrs[:data] = options[:value] if options[:value]
+        item = self.items.new attrs
+        item.save
+        item
+      else
+        raise "Invalid item type: #{item_type} - check defined items in config"
+      end
     end
 
     def editable
@@ -94,25 +100,27 @@ module ContentsCore
         } :
         {
           'data-ec-block': self.id,
-          'data-ec-container': self.children_type,
+          'data-ec-container': self.new_children,
           'data-ec-ct': self.block_type,
           'data-ec-pub': self.published
         }
       ).map { |k, v| "#{k}=\"#{v}\"" }.join( ' ' ).html_safe : ''
     end
 
-    # Returns an item by name
+    # Returns an item value by name
     def get( name )
       item = get_item( name )
-      item.data if item
+      item && item.is_a?( Item ) ? item.data : nil
     end
 
+    # Returns an item by name
     def get_item( name )
-      unless @_items
-        @_items = {}
-        items.each { |item| @_items[item.name] = item }
+      t = tree
+      name.split( '.' ).each do |tok|
+        return nil unless t[tok]
+        t = t[tok]
       end
-      @_items[name]
+      t
     end
 
     def has_parent?
@@ -124,21 +132,30 @@ module ContentsCore
     end
 
     def is_sub_block?
-      parent.present? && parent_type == 'ContentsCore::Block'
+      self.parent.present? && self.parent.is_a?( Block )
+    end
+
+    def new_children
+      config[:new_children]
     end
 
     def on_after_create
       # TODO: validates type before creation!
-      Block::init_items( self, config[:items] ) if Block::block_types( false ).include?( self.block_type.to_sym )
+      Block.initialize_children( self, config[:children] ) if Block.types( false ).include?( self.block_type.to_sym )
     end
 
+    # def on_after_initialize
+    #   self.conf = {} unless self.conf
+    # end
+
     def on_before_create
-      if self.name.blank?
-        names = parent.cc_blocks.map( &:name )
+      names = parent.cc_blocks.map( &:name )
+      if self.name.blank? || names.include?( self.name )  # Search a not used name
+        n = self.name.blank? ? block_type : self.name
         i = 0
-        while( ( i += 1 ) < 1000 )  # Search an empty group
-          unless names.include? "#{block_type}-#{i}"
-            self.name = "#{block_type}-#{i}"
+        while( ( i += 1 ) < 1000 )
+          unless names.include? "#{n}-#{i}"
+            self.name = "#{n}-#{i}"
             break
           end
         end
@@ -148,14 +165,15 @@ module ContentsCore
     def props
       pieces = {}
 
-      Item::item_types.each do |type|
-        pieces[type.pluralize.to_sym] = []
+      Item.types.each do |type|
+        pieces[type.to_s.pluralize.to_sym] = []
       end
       items.each do |item|  # TODO: improve me
+        pieces[item.class.type_name.pluralize.to_sym] = [] unless pieces[item.class.type_name.pluralize.to_sym]
         pieces[item.class.type_name.pluralize.to_sym].push item
       end
-      Item::item_types.each do |type|
-        pieces[type.to_sym] = pieces[type.pluralize.to_sym].any? ? pieces[type.pluralize.to_sym].first : nil  # EMPTY_DATA - empty Item per sti class?
+      Item.types.each do |type|
+        pieces[type] = pieces[type.pluralize.to_sym].any? ? pieces[type.pluralize.to_sym].first : nil  # EMPTY_DATA - empty Item per sti class?
       end
 
       # pieces = {
@@ -174,44 +192,62 @@ module ContentsCore
     end
 
     def set( name, value )
-      items.each do |item|
-        if item.name == name
-          item.data = value
-          break
-        end
-      end
+      item = get_item( name )
+      item && item.is_a?( Item ) ? item.data = value : nil
+    end
+
+    def tree
+      # return @items_tree if @items_tree
+      @items_tree = {}  # prepare a complete list of items
+      self.items.each{ |item| @items_tree[item.name] = item }
+      self.cc_blocks.each_with_index{ |block, i| @items_tree[block.name] = block.tree }  # @items_tree[i] = block.tree
+      @items_tree
     end
 
-    def self.block_enum( include_children = true )
-      ContentsCore.config[:cc_blocks].map{|k, v| [v[:name], k.to_s] if !include_children || !v[:child_only]}.compact.sort_by{|b| b[0]}
+    def validations
+      config[:validations] || {}
     end
 
-    def self.block_types( include_children = true )
-      ContentsCore.config[:cc_blocks].select{|k, v| !include_children || !v[:child_only]}.keys
+    def self.enum( include_children = true )
+      ContentsCore.config[:blocks].map{|k, v| [I18n.t( 'contents_core.blocks.' + v[:name].to_s ), k.to_s] if !include_children || !v[:child_only]}.compact.sort_by{|b| b[0]}
     end
 
-    def self.init_items( block, items, options = {} )
-      items.each do |name, type|
+    def self.initialize_children( block, children, options = {} )
+      children.each do |name, type|
         t = type.to_sym
-        if type.to_s.start_with? 'item_'
+        if Item.types.include? t
           c = 'ContentsCore::' + ActiveSupport::Inflector.camelize( t )
           begin
             model = c.constantize
           rescue Exception => e
-            Rails.logger.error '[ERROR] ContentsCore - init_items: ' + e.message
+            Rails.logger.error '[ERROR] ContentsCore - initialize_children: ' + e.message
             model = false
           end
-          block.items << model.new( name: name ).init if model
-        elsif Block::block_types( false ).include? t.to_sym
+          if model
+            block.items.new( type: model.name, name: name )
+          end
+        elsif Block.types( false ).include? t
           block.create_children.times do
-            block.cc_blocks << Block.new( block_type: t, name: name )
+            block.cc_blocks.new( block_type: t, name: name )
+            block.save
           end
         end
-      end if items
+      end if children
+      block.save
+    end
+
+    def self.items_keys( keys )
+      keys.map do |k, v|
+        v.is_a?( Hash ) ? items_keys( v ) : k
+      end.flatten
     end
 
     def self.permitted_attributes
       [ :id, :name, :block_type, :position, :_destroy, items_attributes: [ :id ] + Item::permitted_attributes, cc_blocks_attributes: [ :id, :name, :block_type, items_attributes: [ :id ] + Item::permitted_attributes ] ]
     end
+
+    def self.types( include_children = true )
+      @@types ||= ContentsCore.config[:blocks].select{|k, v| !include_children || !v[:child_only]}.keys.map( &:to_sym )
+    end
   end
 end

data/app/models/contents_core/item.rb

@@ -1,10 +1,25 @@
 module ContentsCore
   class Item < ApplicationRecord
-    # field :data, type: String
+    # --- associations --------------------------------------------------------
+    belongs_to :block, touch: true
+
+    # --- callbacks -----------------------------------------------------------
+    after_initialize :on_after_initialize
+    before_create :on_before_create
 
+    # --- misc ----------------------------------------------------------------
+    # field :data, type: String
     # embedded_in :cc_blocks
 
-    belongs_to :block
+    # --- validations ---------------------------------------------------------
+    validate :validate_item
+    validates :block, presence: true, allow_blank: false
+
+    # --- methods -------------------------------------------------------------
+    def on_after_initialize
+      self.data = config[:default] if config[:default] && !self.data
+      self.init
+    end
 
     def as_json( options = nil )
       super( {only: [:id, :name, :type], methods: [:data]}.merge(options || {}) )
@@ -15,16 +30,44 @@ module ContentsCore
     end
 
     def class_name
-      self.class.to_s.split('::').last
+      self.class.to_s.split( '::' ).last
+    end
+
+    def config
+      @config ||= ( ContentsCore.config[:items] && ContentsCore.config[:items][self.class_name.underscore.to_sym] ? ContentsCore.config[:items][self.class_name.underscore.to_sym] : {} ).merge( self.block && self.block.config[:options] && self.name && self.block.config[:options][self.name.to_sym] ? self.block.config[:options][self.name.to_sym] : {} )
+    end
+
+    def data_type
+      @data_type ||= ( config[:data_type] || :string ).to_sym
     end
 
     def editable
       ContentsCore.editing ? " data-ec-item=\"#{self.id}\" data-ec-input=\"#{self.opt_input}\" data-ec-type=\"#{self.class_name}\"".html_safe : ''
     end
 
+    def init  # placeholder method (for override)
+    end
+
+    def on_before_create
+      # root_block = self.block
+      # root_block = root_block.parent while root_block.parent.is_a? Block
+      # names = Block.items_keys root_block.tree
+      names = ( self.block.items - [self] ).pluck :name
+      if self.name.blank? || names.include?( self.name )  # Search a not used name
+        n = self.name.blank? ? self.class.type_name : self.name
+        i = 0
+        while( ( i += 1 ) < 1000 )
+          unless names.include? "#{n}-#{i}"
+            self.name = "#{n}-#{i}"
+            break
+          end
+        end
+      end
+    end
+
     def opt_input
-      if self.block.options[self.name] && self.block.options[self.name]['input']
-        self.block.options[self.name]['input'].to_s
+      if self.block.config[self.name] && self.block.config[self.name]['input']
+        self.block.config[self.name]['input'].to_s
       elsif config[:input]
         config[:input].to_s
       else
@@ -50,20 +93,20 @@ module ContentsCore
       self.save
     end
 
-    def self.item_types
-      @@item_types ||= ContentsCore.config[:items].keys.map( &:to_s )
+    def validate_item
+      config[:validate].call( self ) if config[:validate]
     end
 
     def self.permitted_attributes
       [ :data_boolean, :data_datetime, :data_file, :data_float, :data_hash, :data_integer, :data_string, :data_text ]
     end
 
-    def config
-      @config ||= self.block && self.block.config[:options] && self.block.config[:options][self.name.to_sym] ? self.block.config[:options][self.name.to_sym] : ( ContentsCore.config[:items][self.class::type_name.to_sym] ? ContentsCore.config[:items][self.class::type_name.to_sym] : {} )
+    def self.type_name
+      ''
     end
 
-    def data_type
-      @data_type ||= ( config[:data_type] || :string ).to_sym
+    def self.types
+      @@types ||= ContentsCore.config[:items].keys.map( &:to_sym )
     end
 
   protected
@@ -88,7 +131,7 @@ module ContentsCore
       end
     end
 
-    def converted_data()
+    def converted_data
       if data_type
         case data_type
         when :boolean

data/app/models/contents_core/item_array.rb

@@ -43,7 +43,11 @@ module ContentsCore
     end
 
     def init
-      self.data_string = []
+      unless self.data
+        self.data_string = []
+        self.data_hash = []
+        self.data_text = []
+      end
       self
     end
 

data/app/models/contents_core/item_boolean.rb

@@ -3,7 +3,7 @@ module ContentsCore
     alias_attribute :data, :data_boolean
 
     def init
-      self.data = 0
+      self.data = false unless self.data
       self
     end
 

data/app/models/contents_core/item_datetime.rb

@@ -3,7 +3,7 @@ module ContentsCore
     alias_attribute :data, :data_datetime
 
     def init
-      self.data = Time.now
+      self.data = Time.now unless self.data
       self
     end
 

data/app/models/contents_core/item_file.rb

@@ -16,7 +16,7 @@ module ContentsCore
     end
 
     def init
-      # self.data_file = File.open( ContentsCore::Engine.root.join( 'lib', 'data', 'img1.jpg' ) )
+      # self.data_file = File.open( ContentsCore::Engine.root.join( 'lib', 'data', 'missing.jpg' ) ) unless self.data
       self
     end
 
@@ -31,7 +31,7 @@ module ContentsCore
     # before_validation :on_before_validation
     #
     # def on_before_validation
-    #   self.data = File.open( 'rails/editable_components_test/public/img/img1.jpg' )
+    #   self.data = File.open( 'test/public/img/img1.jpg' )
     #   # binding.pry
     # end
 

data/app/models/contents_core/item_float.rb

@@ -3,7 +3,7 @@ module ContentsCore
     alias_attribute :data, :data_float
 
     def init
-      self.data = 0
+      self.data = 0 unless self.data
       self
     end
 

data/app/models/contents_core/item_hash.rb

@@ -5,7 +5,7 @@ module ContentsCore
     serialize :data_hash, Hash
 
     def init
-      self.data = {}
+      self.data = {} unless self.data
       self
     end
 

data/app/models/contents_core/item_integer.rb

@@ -3,7 +3,7 @@ module ContentsCore
     alias_attribute :data, :data_integer
 
     def init
-      self.data = 0
+      self.data = 0 unless self.data
       self
     end
 

data/app/models/contents_core/item_object.rb

@@ -1,12 +1,18 @@
 # TODO: needs improvements
 module ContentsCore
   class ItemObject < Item
-    alias_attribute :data, :data_hash
-
     serialize :data_hash, JSON
 
+    def data
+      self.data_hash.deep_symbolize_keys
+    end
+
+    def data=( value )
+      self.data_hash = value
+    end
+
     def init
-      self.data = {}
+      self.data = {} unless self.data
       self
     end
 

data/app/models/contents_core/item_string.rb

@@ -2,20 +2,20 @@ module ContentsCore
   class ItemString < Item
     alias_attribute :data, :data_string
 
-    validate :on_validate
+    # validate :on_validate
 
     def init
-      self.data = self.name.gsub( /-/, ' ' ).humanize
+      self.data = '' unless self.data  # self.name.gsub( /-/, ' ' ).humanize
       self
     end
 
-    def on_validate
-      if self.block.validations[self.name]
-        if self.block.validations[self.name] == 'required'
-          self.errors.add( :base, "#{self.name} is required" ) if self.data_string.blank?
-        end
-      end
-    end
+    # def on_validate
+    #   if self.block.validations[self.name]
+    #     if self.block.validations[self.name] == 'required'
+    #       self.errors.add( :base, "#{self.name} is required" ) if self.data_string.blank?
+    #     end
+    #   end
+    # end
 
     def update_data( value )
       self.data = ActionController::Base.helpers.sanitize( value, tags: [] )

data/app/models/contents_core/item_text.rb

@@ -3,7 +3,7 @@ module ContentsCore
     alias_attribute :data, :data_text
 
     def init
-      self.data = self.name.gsub( /-/, ' ' ).humanize
+      self.data = '' unless self.data  # self.name.gsub( /-/, ' ' ).humanize
       self
     end
 

data/config/initializers/contents_core.rb

@@ -2,44 +2,49 @@ module ContentsCore
   @@editing = false
 
   @@config = {
-    cc_blocks: {
+    blocks: {
       image: {
         name: 'Image block',
-        items: {
+        children: {
           img: :item_file
         }
       },
       multi_text: {
-        children_type: :text,
         name: 'Multi columns block',
-        items: {
+        new_children: :text,
+        children: {
           column: :text
-        }
+        },
       },
       slide: {
         name: 'Slide block',
-        items: {
+        children: {
           img: :item_file,
           title: :item_string
         }
       },
       slider: {
-        children_type: :slide,
         name: 'Slider block',
-        items: {
+        new_children: :slide,
+        children: {
           slide: :slide
         }
       },
       text: {
         name: 'Text block',
-        items: {
+        children: {
           title: :item_string,
           content: :item_text
-        }
+        },
+        # options: {
+        #   title: {
+        #     validate: ->( item ) { item.errors.add( :data_string, "can't be blank" ) if item.data.blank? }
+        #   }
+        # }
       },
       text_with_image: {
         name: 'Text with image block',
-        items: {
+        children: {
           img: :item_file,
           title: :item_string,
           content: :item_text
@@ -47,18 +52,18 @@ module ContentsCore
       },
     },
     items: {
-      array: {},
-      boolean: {},
-      datetime: {},
-      float: {},
-      hash: {},
-      file: {
+      item_array: {},
+      item_boolean: {},
+      item_datetime: {},
+      item_float: {},
+      item_hash: {},
+      item_file: {
         input: :file_image
       },
-      integer: {},
-      object: {},
-      string: {},
-      text: {
+      item_integer: {},
+      item_object: {},
+      item_string: {},
+      item_text: {
         input: :html
       },
     }

data/db/migrate/20170414173603_create_contents_core_blocks.rb

@@ -1,16 +1,16 @@
 class CreateContentsCoreBlocks < ActiveRecord::Migration[5.0]
   def change
     create_table :contents_core_blocks do |t|
-      t.string  :block_type, null: false, default: 'text'
-      t.integer :version, null: false, default: 0
-      t.string  :name, null: false, default: ''
-      t.string  :group
-      t.integer :position, null: false, default: 0
-      t.boolean :published, null: false, default: true
-      t.string  :options, null: false, default: '{}'
-      t.string  :validations, null: false, default: '{}'
-      t.integer :parent_id
-      t.string  :parent_type
+      t.string     :block_type, null: false, default: 'text'
+      t.string     :name
+      t.string     :group
+      t.integer    :version, null: false, default: 0
+      t.integer    :position, null: false, default: 0
+      t.boolean    :published, null: false, default: true
+      t.text       :conf
+      t.integer    :parent_id
+      t.string     :parent_type
+      t.timestamps null: false
     end
 
     add_index :contents_core_blocks, [:parent_id, :parent_type]

data/db/migrate/20170414173610_create_contents_core_items.rb

@@ -1,9 +1,18 @@
 class CreateContentsCoreItems < ActiveRecord::Migration[5.0]
   def change
     create_table :contents_core_items do |t|
-      t.string  :type
-      t.string  :name, null: false, default: 'data'
-      t.integer :block_id
+      t.string     :type
+      t.string     :name
+      t.integer    :block_id
+      t.boolean    :data_boolean
+      t.datetime   :data_datetime
+      t.string     :data_file  # , null: false, default: ''
+      t.float      :data_float
+      t.text       :data_hash
+      t.integer    :data_integer
+      t.string     :data_string  # , null: false, default: ''
+      t.text       :data_text
+      t.timestamps null: false
     end
 
     add_index :contents_core_items, :block_id

data/lib/contents_core.rb

@@ -10,11 +10,18 @@ module ContentsCore
   def self.create_block_in_parent( parent, type = :text, params = {} )
     block = Block.new( block_type: type )
     block.name = params[:name] if params[:name]
-    block.options = params[:options] if params[:options]
-    block.validations = params[:validations] if params[:validations]
+    block.conf = params[:conf] if params[:conf]
+    # block.validations = params[:validations] if params[:validations]
     block.create_children = params[:create_children].to_i if params[:create_children]
-    parent.cc_blocks << block
-    Block::init_items block, params[:schema], {create_children: params[:create_children]} if params[:schema]
+    parent.cc_blocks << block  # TODO: change me (with cc_blocks.new)
+    Block::initialize_children block, params[:schema], {create_children: params[:create_children]} if params[:schema]
+    if params[:values]
+      traverse_hash block.tree, params[:values]
+      block.save
+    elsif params[:values_list]
+      params[:values_list].each{ |k, v| block.set k.to_s, v }
+      block.save
+    end
     block
   end
 
@@ -22,4 +29,25 @@ module ContentsCore
     @@editing = editing unless editing.nil?
     @@editing
   end
+
+  def self.traverse_hash( hash, values )
+    ret = {}
+    values.each do |k, v|
+      if v.is_a? Hash
+        ret = traverse_hash hash[k.to_s], values[k]
+      else
+        hash[k.to_s].data = values[k]
+      end
+    end
+    ret
+  end
+
+  # def self.parse_attr( attribute )
+  #   attr = attribute.to_s
+  #   if attr.include?( '.' )
+  #     attrs = attr.split( '.' )
+  #     attr  = attrs.shift + attrs.map{|tok| "[#{tok}]"}.join
+  #   end
+  #   attr
+  # end
 end

data/lib/contents_core/blocks.rb

@@ -12,9 +12,11 @@ module ContentsCore
       end
 
       def current_blocks( version = 0 )
-        return @current_blocks if @current_blocks
+        # return @current_blocks if @current_blocks
         version = 0 unless ContentsCore.editing  # no admin = only current version
-        @current_blocks = cc_blocks.where( version: version.to_i ).with_nested.published
+        Rails.cache.fetch( "#{cache_key}/current_blocks/#{version}", expires_in: 12.hours ) do
+          self.cc_blocks.where( version: version.to_i ).with_nested.published
+        end
       end
 
       def get_block( name, version = 0 )
@@ -23,6 +25,12 @@ module ContentsCore
         end
         nil
       end
+
+      protected
+
+        def cache_key
+          self.cc_blocks.published.select( :updated_at ).order( updated_at: :desc ).first.try( :updated_at ).to_i
+        end
     end
   end
 end

data/lib/contents_core/version.rb

@@ -1,3 +1,3 @@
 module ContentsCore
-  VERSION = '0.2.5'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contents_core
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Mat
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-02 00:00:00.000000000 Z
+date: 2017-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,44 +16,58 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: A Rails gem which offer a simple structure to manage contents in a flexible
-  way
+        version: '0.15'
+description: 'A Rails gem which offer a structure to manage contents in a flexible
+  way: blocks with recursive nested blocks + items as "leaves"'
 email:
 - mat@blocknot.es
 executables: []
@@ -89,7 +103,6 @@ files:
 - config/routes.rb
 - db/migrate/20170414173603_create_contents_core_blocks.rb
 - db/migrate/20170414173610_create_contents_core_items.rb
-- db/migrate/20170414173611_add_extra_items.rb
 - lib/contents_core.rb
 - lib/contents_core/blocks.rb
 - lib/contents_core/engine.rb

data/db/migrate/20170414173611_add_extra_items.rb

@@ -1,12 +0,0 @@
-class AddExtraItems < ActiveRecord::Migration[5.0]
-  def change
-    add_column :contents_core_items, :data_boolean, :boolean
-    add_column :contents_core_items, :data_datetime, :datetime
-    add_column :contents_core_items, :data_file, :string  # , null: false, default: ''
-    add_column :contents_core_items, :data_float, :float
-    add_column :contents_core_items, :data_hash, :text
-    add_column :contents_core_items, :data_integer, :integer
-    add_column :contents_core_items, :data_string, :string  # , null: false, default: ''
-    add_column :contents_core_items, :data_text, :text
-  end
-end