constructor-pages 0.7.0 → 0.7.2

data/{app → pages/app}/models/constructor_pages/field.rb

@@ -2,14 +2,14 @@
 
 module ConstructorPages
   # Field model. Fields allows to add custom fields for template.
-  #
   # Each field has type of value such as float, integer, string...
   class Field < ActiveRecord::Base
     # Adding code_name_uniqueness method
     include CodeNameUniq
 
     # Array of available field types
-    TYPES = %w{string integer float boolean text date html image}
+    TYPES = %w{string integer float boolean text date html image}.tap {|_t|
+    _t.each {|t| class_eval %{has_many :#{t}_types, dependent: :destroy, class_name: 'Types::#{t.titleize}Type'}}}
 
     validates_presence_of :name
     validates_uniqueness_of :code_name, scope: :template_id
@@ -18,25 +18,17 @@ module ConstructorPages
     after_create :create_page_fields
     after_destroy :destroy_all_page_fields
 
-    belongs_to :template
-
-    # Adding has_many for all field types
-    TYPES.each do |t|
-      class_eval %{
-        has_many :#{t}_types, dependent: :destroy, class_name: 'Types::#{t.titleize}Type'
-      }
-    end
-
     has_many :pages, through: :template
+    belongs_to :template
 
-    acts_as_list  scope: :template_id
+    acts_as_list scope: :template_id
     default_scope -> { order :position }
 
     # Return constant of model type_value
     def type_class; "constructor_pages/types/#{type_value}_type".classify.constantize end
 
     # Return object of type_value by page
-    def find_type_object(page); type_class.where(field_id: id, page_id: page.id).first end
+    def find_type_object(page); type_class.find_by(field_id: id, page_id: page.id) end
 
     # Create object of type_value by page
     def create_type_object(page); type_class.create(field_id: id, page_id: page.id) end
@@ -45,43 +37,23 @@ module ConstructorPages
     def remove_type_object(page); find_type_object(page).destroy end
 
     # Get value from type_field for specified page
-    def get_value_for(page)
-      _type_object = find_type_object(page)
-      _type_object ? _type_object.value : nil
-    end
+    def get_value_for(page); find_type_object(page).tap {|t| return t && t.value} end
 
     # Set value type_field for specified page
-    def set_value_for(page, value)
-      _type_object = find_type_object(page)
-
-      if _type_object
-        _type_object.value = value
-        _type_object.save!
-      end
-    end
+    def set_value_for(page, value); find_type_object(page).tap {|t| t || return; t.update value: value} end
 
     private
 
     # Check if there is code_name in template branch
     def check_code_name(code_name)
-      [code_name.pluralize, code_name.singularize].each do |name|
-        %w{self_and_ancestors descendants}.each do |m|
-          if template.send(m).map{|t| t.code_name}.include?(name)
-            return false
-          end
-        end
-      end
-
+      [code_name.pluralize, code_name.singularize].each {|name|
+        %w{self_and_ancestors descendants}.each {|m|
+          return false if template.send(m).map(&:code_name).include?(name)}}
       true
     end
 
     # Create and destroy page fields
-    %w{create destroy_all}.each do |m|
-      class_eval %{
-          def #{m}_page_fields
-            template.pages.each {|page| type_class.#{m} page_id: page.id, field_id: id}
-          end
-      }
-    end
+    %w{create destroy_all}.each {|m| class_eval %{
+      def #{m}_page_fields; template.pages.each {|page| type_class.#{m} page_id: page.id, field_id: id} end }}
   end
 end

data/{app → pages/app}/models/constructor_pages/page.rb

@@ -5,11 +5,10 @@ module ConstructorPages
   class Page < ActiveRecord::Base
     # Adding has_many for all field types
     Field::TYPES.each do |t|
-      class_eval %{ has_many :#{t}_types,  dependent: :destroy, class_name: 'Types::#{t.titleize}Type'}
+      class_eval %{has_many :#{t}_types,  dependent: :destroy, class_name: 'Types::#{t.titleize}Type'}
     end
 
     has_many :fields, through: :template
-
     belongs_to :template
 
     default_scope -> { order :lft }
@@ -48,31 +47,12 @@ module ConstructorPages
       end
 
       def search(what_search = nil)
-        if @where_search
-          if @where_search.is_a?(String)
-            _page = Page.find_by full_url: @where_search
-          elsif @where_search.is_a?(Page)
-            _page = @where_search
-          end
-
-          @result = _page ? _page.descendants : []
-        else
-          @result = Page.all
-        end
-
-        if what_search
-          _template = Template.find_by code_name: what_search.to_s.singularize.downcase
-          @result = _template ? @result.where(template: _template) : []
-        end
-
-        if @params_search
-          @params_search.each_pair do |k, v|
-            @result = @result.select { |p| p.send(k) == v }
-          end
-        end
-
+        (@where_search.is_a?(String) ? Page.find_by(full_url: @where_search) : @where_search)
+        .tap {|p| @result = @where_search ? p ? p.descendants : [] : Page.all }
+        what_search && Template.find_by(code_name: what_search.to_s.singularize.downcase)
+        .tap {|t| @result = t ? @result.where(template: t) : [] }
+        @params_search && @params_search.each_pair {|k,v| @result = @result.select {|p| p.send(k) == v}}
         @where_search = @params_search = nil
-
         @result
       end
 
@@ -84,6 +64,7 @@ module ConstructorPages
     end
 
     def search(what_search = nil); Page.in(self).search(what_search) end
+    def by(params_search = nil); Page.by(params_search); self end
     def search_by(params_search = nil); Page.by(params_search).in(self).search end
 
     # Get field by code_name
@@ -105,28 +86,19 @@ module ConstructorPages
     # @param params should looks like <tt>{price: 500, content: 'Hello'}</tt>
     # @param reset_booleans reset all boolean fields to false before assign params
     def update_fields_values(params, reset_booleans = true)
-      return if params.nil?
-
-      fields.each do |field|
-        value = params[field.code_name.to_sym]
-
-        _type_object = field.find_type_object(self)
+      params || return
 
-        if _type_object
-          _type_object.value = 0 if field.type_value == 'boolean' and reset_booleans
-          _type_object.value = value if value
-          _type_object.save
-        end
-      end
+      fields.each {|f| f.find_type_object(self).tap {|t| t || break
+        t.value = 0 if f.type_value == 'boolean' && reset_booleans
+        params[f.code_name.to_sym].tap {|v| v && t.value = v}
+        t.save }}
     end
 
     # Create fields values
-    def create_fields_values; fields.each {|f| f.create_type_object(self) } end
+    def create_fields_values; fields.each {|f| f.create_type_object self} end
 
     # Remove all fields values
-    def remove_fields_values
-      fields.each {|f| f.remove_type_object self}
-    end
+    def remove_fields_values; fields.each {|f| f.remove_type_object self} end
 
     # Search page by template code_name in same branch of pages and templates.
     # It allows to call page.category.brand.series.model etc.
@@ -135,16 +107,11 @@ module ConstructorPages
     # and return array of pages if founded in descendants
     #
     # It determines if code_name is singular or nor
-    # @param code_name template code name
-    def find_page_in_branch(code_name)
-      _template = Template.find_by code_name: code_name.singularize
-
-      if _template
-        result = []
-        result = descendants.where(template_id: _template.id) if code_name == code_name.pluralize
-        result = ancestors.find_by(template_id: _template.id) if result.empty?
-        result
-      end
+    # @param cname template code name
+    def find_page_in_branch(cname)
+      Template.find_by(code_name: cname.singularize).tap {|t| t || return
+        (descendants.where(template_id: t.id) if cname == cname.pluralize).tap {|r| r ||= []
+          return r.empty? ? ancestors.find_by(template_id: t.id) : r}}
     end
 
     alias_method :find_pages_in_branch, :find_page_in_branch
@@ -159,9 +126,7 @@ module ConstructorPages
     # @param options default merge name and title page attributes
     def as_json(options = {})
       {name: self.name, title: self.title}.merge(options).tap do |options|
-        fields.each do |f|
-          options.merge!({f.code_name.to_sym => f.get_value_for(self)})
-        end
+        fields.each {|f| options.merge!({f.code_name.to_sym => f.get_value_for(self)})}
       end
     end
 
@@ -175,12 +140,9 @@ module ConstructorPages
     #   puts page.price
     #   page.brand.models.each do...
     def method_missing(name, *args, &block)
-      if new_record?
-        super
-      else
-        name = name.to_s
-        name[-1] == '=' ? set_field_value(name[0..-2], args[0]) : get_field_value(name) || find_pages_in_branch(name)
-      end
+      super && return if new_record?
+      name = name.to_s
+      name[-1] == '=' ? set_field_value(name[0..-2], args[0]) : get_field_value(name) || find_pages_in_branch(name)
     end
 
     private
@@ -192,19 +154,13 @@ module ConstructorPages
 
     # TODO: add more languages
     # translit to english
-    def translit(str)
-      Russian.translit(str)
-    end
+    def translit(str); Russian.translit(str) end
 
     # Page is not valid if there is no template
-    def template_check
-      errors.add_on_empty(:template_id) if Template.count == 0
-    end
+    def template_check; errors.add_on_empty(:template_id) if Template.count == 0 end
 
     # If template_id is nil then get first template
-    def template_assign
-      self.template_id = Template.first.id unless template_id
-    end
+    def template_assign; self.template_id = Template.first.id unless template_id end
 
     # Update full_url
     def full_url_update

data/{app → pages/app}/models/constructor_pages/template.rb

@@ -23,23 +23,15 @@ module ConstructorPages
 
     # Return child corresponding child_id or children first
     def child
-      if child_id.nil? and !leaf?
-        children.first
-      else
-        Template.find child_id
-      end
+      !child_id && !leaf? ? children.first : self.class.find(child_id)
     end
 
     private
 
     # Check if there is code_name in same branch
-    def check_code_name(code_name)
-      [code_name.pluralize, code_name.singularize].each do |name|
-        if root.descendants.map{|t| t.code_name unless t.code_name == code_name}.include?(name)
-          return false
-        end
-      end
-
+    def check_code_name(cname)
+      [cname.pluralize, cname.singularize].each {|name|
+        return false if root.descendants.map{|t| t.code_name unless t.code_name == cname}.include?(name)}
       true
     end
   end

data/pages/config/routes.rb

@@ -0,0 +1,26 @@
+ConstructorPages::Engine.routes.draw do
+  scope '/admin' do
+    resources :pages, except: [:show]
+    resources :templates, except: [:show]
+    resources :fields, except: [:show, :new, :edit]
+
+    %w{page template field}.each do |c|
+      %w{up down}.each do |d|
+        get "#{c.pluralize}/move/#{d}/:id" => "#{c.pluralize}#move_#{d}", as: "#{c}_move_#{d}"
+      end
+    end
+
+    scope '/fields' do
+      get ':template_id/new/' => 'fields#new', as: :new_field
+      get ':id/:template_id/edit/' => 'fields#edit', as: :edit_field
+    end
+
+    get '/pages/:page/new' => 'pages#new', as: :new_child_page
+  end
+
+  root :to => 'pages#show'
+
+  get '*all/search/:what_search' => 'pages#search', format: false
+  get '*all.:format' => 'pages#show'
+  get '*all' => 'pages#show'
+end