flexite 0.0.2

data/app/forms/flexite/base_form.rb

@@ -0,0 +1,24 @@
+class Flexite::BaseForm
+  include ActiveModel::Validations
+  include ActiveModel::Conversion
+  extend ActiveModel::Naming
+
+  attr_reader :attributes
+
+  def initialize(attributes = {})
+    @attributes = HashWithIndifferentAccess.new
+
+    attributes.each do |name, value|
+      send("#{name}=", value) rescue next
+      @attributes[name] = value
+    end
+  end
+
+  def persisted?
+    respond_to?(:id) && id.present?
+  end
+
+  def new_record?
+    !persisted?
+  end
+end

data/app/forms/flexite/config/form.rb

@@ -0,0 +1,12 @@
+require_dependency 'flexite/base_form'
+
+module Flexite
+  class Config::Form < BaseForm
+    attr_accessor :id, :name, :config_id, :created_by, :selectable
+    validates :name, presence: true
+
+    def self.model_name
+      Config.model_name
+    end
+  end
+end

data/app/forms/flexite/entry/array_form.rb

@@ -0,0 +1,11 @@
+module Flexite
+  class Entry
+    class ArrayForm < Form
+      attr_accessor :entries, :new_entries
+
+      def entries
+        @entries ||= []
+      end
+    end
+  end
+end

data/app/forms/flexite/entry/form.rb

@@ -0,0 +1,16 @@
+require_dependency 'flexite/base_form'
+
+module Flexite
+  class Entry::Form < BaseForm
+    attr_accessor :id, :type, :value, :parent_id, :parent_type
+    validates :type, presence: true
+
+    def self.model_name
+      Entry.model_name
+    end
+
+    def view_type
+      type.demodulize.underscore
+    end
+  end
+end

data/app/helpers/flexite/application_helper.rb

@@ -0,0 +1,15 @@
+module Flexite
+  module ApplicationHelper
+    def present(model)
+      unless model.respond_to?(:presenter)
+        raise "#{model.class.name} is not presentable"
+      end
+
+      yield(model.presenter(self))
+    end
+
+    def back_to_app
+      link_to "Back to #{Flexite.config.app_name}", Flexite.config.app_link, class: 'btn btn-default'
+    end
+  end
+end

data/app/helpers/flexite/configs_helper.rb

@@ -0,0 +1,4 @@
+module Flexite
+  module ConfigsHelper
+  end
+end

data/app/helpers/flexite/entries_helper.rb

@@ -0,0 +1,46 @@
+module Flexite
+  module EntriesHelper
+    ENTRY_TYPE_OPTIONS = [
+      ['String', 'Flexite::StrEntry'],
+      ['Symbol', 'Flexite::SymEntry'],
+      ['Boolean', 'Flexite::BoolEntry'],
+      ['Array', 'Flexite::ArrEntry'],
+      ['Integer', 'Flexite::IntEntry']
+    ].freeze
+
+    def render_entries(entries, form)
+      content_tag :div, id: "array-entries-#{form.options[:index]}" do
+        entries.each_with_index do |entry, index|
+          concat render_entry(entry, form, index)
+        end
+      end
+    end
+
+    def entry_type_select(f = nil)
+      if f.present?
+        f.select :type, options_for_select(ENTRY_TYPE_OPTIONS), {}, class: 'form-control'
+      else
+        select_tag :new_entry_type, options_for_select(ENTRY_TYPE_OPTIONS), class: 'form-control'
+      end
+    end
+
+    private
+
+    def render_entry(entry, form, index)
+      cache entry do
+        entry_form = entry.class.form(entry.form_attributes)
+
+        concat(form.simple_fields_for(:entries, entry_form, index: index) do |fields|
+          delete_link = link_to 'Delete', destroy_array_entries_path(id: entry.id, selector: "#{fields.object_name}-#{index}-#{entry.id}"),
+                                remote: true, method: :delete, class: 'btn btn-danger'
+
+          concat(content_tag(:div, id: "#{fields.object_name}-#{index}-#{entry.id}") do
+            concat fields.input :id, as: :hidden
+            concat fields.input :type, as: :hidden
+            concat render "types/#{entry_form.view_type}", f: fields, delete_link: delete_link
+          end)
+        end)
+      end
+    end
+  end
+end

data/app/models/flexite/arr_entry.rb

@@ -0,0 +1,35 @@
+module Flexite
+  class ArrEntry < Entry
+    has_many :entries, as: :parent, dependent: :destroy
+
+    def value
+      entries.select([:id, :value, :type]).map(&:value)
+    end
+
+    def entry=(entry)
+      entries << entry
+    end
+
+    def form_attributes
+      attributes.merge(entries: form_entries)
+    end
+
+    def self.form(attributes = {})
+      Entry::ArrayForm.new(attributes)
+    end
+
+    def self.service(type)
+      "arr_entry_#{type}".to_sym
+    end
+
+    private
+
+    def form_entries
+      entries.select([:id, :value, :type, :updated_at])
+    end
+
+    def cast_value
+      # value should be blank
+    end
+  end
+end

data/app/models/flexite/bool_entry.rb

@@ -0,0 +1,19 @@
+module Flexite
+  class BoolEntry < Entry
+    def value
+      self[:value].to_i  == 1 ? true : false
+    end
+
+    def form
+      Entry::Form.new(attributes.merge(value: self[:value].to_i))
+    end
+
+    private
+
+    def check_value
+      unless [1, 0].include?(self[:value].to_i)
+        errors.add(:value, 'not a boolean')
+      end
+    end
+  end
+end

data/app/models/flexite/config.rb

@@ -0,0 +1,64 @@
+module Flexite
+  class Config < ActiveRecord::Base
+    attr_accessible :name
+    belongs_to :config, touch: true
+    belongs_to :owner, foreign_key: :created_by
+    has_one :entry, as: :parent, dependent: :destroy
+    has_many :configs, dependent: :destroy
+
+    scope :not_selectable, -> { select([:id, :name]).where(selectable: false) }
+    delegate :value, to: :entry, allow_nil: true
+    validates :name, uniqueness: { scope: :config_id }
+
+    def to_tree_node
+      {
+        id: id,
+        editHref: Engine.routes.url_helpers.edit_config_path(self),
+        selfHref: Engine.routes.url_helpers.config_path(self),
+        newHref: Engine.routes.url_helpers.new_config_config_path(self),
+        text: name,
+        dataHref: selectable ? entry_href : configs_href,
+        nodes: nodes,
+        selectable: true,
+        ajaxOnSelect: selectable
+      }
+    end
+
+    def self.tree_view(parent_id)
+      joins("LEFT JOIN #{table_name} AS configs_#{table_name} ON configs_#{table_name}.config_id = #{table_name}.id")
+      .joins("LEFT JOIN #{Entry.table_name} ON #{Entry.table_name}.parent_id = #{table_name}.id AND #{Entry.table_name}.parent_type = '#{model_name}'")
+      .select(["#{table_name}.id", "#{table_name}.selectable", "#{table_name}.name", "#{table_name}.updated_at", "COUNT(configs_#{table_name}.id) as nodes_count", "#{Entry.table_name}.id AS entry_id"])
+      .where(config_id: parent_id).group("#{table_name}.id")
+    end
+
+    def nodes_count
+      self[:nodes_count].to_i
+    end
+
+    def entry_id
+      self[:entry_id]
+    end
+
+    def nodes
+      if selectable
+        return nil
+      end
+
+      nodes_count > 0 ? [] : nil
+    end
+
+    private
+
+    def entry_href
+      if entry_id.present?
+        Engine.routes.url_helpers.edit_entry_path(entry_id, format: :js)
+      else
+        Engine.routes.url_helpers.select_type_entries_path(self, format: :js)
+      end
+    end
+
+    def configs_href
+      Engine.routes.url_helpers.config_configs_path(self, format: :json)
+    end
+  end
+end

data/app/models/flexite/entry.rb

@@ -0,0 +1,30 @@
+module Flexite
+  class Entry < ActiveRecord::Base
+    belongs_to :parent, polymorphic: true, touch: true
+    attr_accessible :value
+    before_save :check_value, :cast_value
+
+    def view_value
+      value.to_s
+    end
+
+    def self.form(attributes = {})
+      Form.new(attributes)
+    end
+
+    def self.service(type)
+      "entry_#{type}".to_sym
+    end
+
+    alias :form_attributes :attributes
+
+    private
+
+    def cast_value
+      self[:value] = self[:value].to_s
+    end
+
+    def check_value
+    end
+  end
+end

data/app/models/flexite/int_entry.rb

@@ -0,0 +1,13 @@
+class Flexite::IntEntry < Flexite::Entry
+  def value
+    self[:value].to_i
+  end
+
+  private
+
+  def check_value
+    self[:value].to_i
+  rescue
+    errors.add(:value, 'not an Integer')
+  end
+end

data/app/models/flexite/str_entry.rb

@@ -0,0 +1,2 @@
+class Flexite::StrEntry < Flexite::Entry
+end

data/app/models/flexite/sym_entry.rb

@@ -0,0 +1,17 @@
+class Flexite::SymEntry < Flexite::Entry
+  def value
+    self[:value].to_sym
+  end
+
+  def view_value
+    ":#{value}"
+  end
+
+  private
+
+  def check_value
+    self[:value].to_sym
+  rescue
+    errors(:value, 'cannot be casted to Symbol')
+  end
+end

data/app/services/flexite/action_service/result.rb

@@ -0,0 +1,44 @@
+class Flexite::ActionService::Result
+  def initialize(options = {})
+    @options = options
+    @errors = Hash.new { |h, k| h[k] = [] }
+  end
+
+  def succeed?
+    @options.fetch(:succeed, true)
+  end
+
+  def failed?
+    !succeed?
+  end
+
+  def render?
+    @options.fetch(:render, true)
+  end
+
+  def redirect?
+    !render?
+  end
+
+  def data
+    @options[:data]
+  end
+
+  alias :record :data
+
+  def add_error(name, value)
+    @errors[name] << value
+  end
+
+  def add_errors(name, values)
+    @errors[name] += values
+  end
+
+  def endpoint
+    @options.fetch(:endpoint, {})
+  end
+
+  def flash
+    @options.fetch(:flash, {})
+  end
+end

data/app/services/flexite/action_service.rb

@@ -0,0 +1,30 @@
+class Flexite::ActionService
+  def self.inherited(child)
+    child.const_set(:Result, Result)
+  end
+
+  def initialize(form, params = {})
+    @form = form
+    @params = params
+  end
+
+  def call
+    raise NotImplementedError
+  end
+
+  protected
+
+  def success
+    raise NotImplementedError
+  end
+
+  def failure
+    raise NotImplementedError
+  end
+
+  def save_errors(result)
+    @form.errors.messages.each do |key, values|
+      result.add_errors(key, values)
+    end
+  end
+end

data/app/services/flexite/config/create_service.rb

@@ -0,0 +1,25 @@
+require_dependency 'flexite/action_service'
+
+module Flexite
+  class Config::CreateService < ActionService
+    def call
+      if @form.invalid?
+        return failure
+      end
+
+      @record = Config.create(@form.attributes, without_protection: true)
+      success
+    end
+
+    protected
+
+    def failure
+      Result.new(success: false, endpoint: { status: 400 })
+    end
+
+    def success
+      Result.new(flash: { type: :success, message: 'Config was created!' },
+                 data: { record: @record })
+    end
+  end
+end

data/app/services/flexite/config/update_service.rb

@@ -0,0 +1,28 @@
+module Flexite
+  class Config
+    class UpdateService < ActionService
+      def call
+        if @form.invalid?
+          return failure
+        end
+
+        @record = Config.find(@form.id)
+        @record.config_id = @form.config_id
+        @record.selectable = @form.selectable
+        @record.name = @form.name
+        @record.save
+        success
+      end
+
+      protected
+
+      def failure
+        Result.new(success: false, endpoint: { status: 400 })
+      end
+
+      def success
+        Result.new(flash: { type: :success, message: 'Config was updated!' }, data: { record: @record })
+      end
+    end
+  end
+end

data/app/services/flexite/data/hash.rb

@@ -0,0 +1,17 @@
+class Flexite::Data::Hash < Hashie::Mash
+  extend Hashie::Extensions::DeepMerge
+
+  def initialize(*)
+    super { |h, k| h[k] = {} }
+  end
+
+  def self.name
+    Hash.name
+  end
+
+  class Hashie::Array
+    def self.name
+      Array.name
+    end
+  end
+end

data/app/services/flexite/data/migrators/yaml.rb

@@ -0,0 +1,62 @@
+module Flexite
+  class Data::Migrators::Yaml
+    def initialize
+      @paths = Flexite.config.paths
+      @roots = Flexite.config.source_roots
+      @hierarchy = Flexite.config.hierarchy
+      @data = Data::Hash.new
+    end
+
+    def call
+      @paths.each_with_object(@data) do |(name, paths), data|
+        paths.each do |p|
+          next unless File.exists?(p)
+          load_data(data, name, p)
+        end
+      end
+    end
+
+    private
+
+    def load_data(data, name, path)
+      with_hierarchy(path) do |configs|
+        with_source_roots(data[name], configs, @roots[name])
+      end
+    end
+
+    def with_source_roots(data, configs, roots)
+      data.deep_merge!(configs) and return if roots.blank?
+
+      roots.each do |root|
+        next if configs[root].blank?
+        data.deep_merge!(root => configs[root])
+      end
+    end
+
+    # hierarchy = [:a, :b, :c]
+    #
+    # {
+    #   a: {
+    #         b: {
+    #              c: {}
+    #            }
+    #      }
+    # }
+    #
+    #
+
+    def with_hierarchy(path)
+      hierarchy = @hierarchy[path]
+      return yield(YAML.load_file(path)) if hierarchy.blank?
+
+      new_hash = {}
+      leveling = new_hash
+      hierarchy.each do |level|
+        leveling = leveling[level] = {}
+      end
+
+      leveling.merge!(YAML.load_file(path))
+      yield(new_hash)
+    end
+  end
+end

data/app/services/flexite/data/new.rb

@@ -0,0 +1,87 @@
+module Flexite
+  class Data::New
+    def initialize(migrator)
+      @migrator = migrator
+      @errors = Hash.new { |h, k| h[k] = [] }
+      @result = {}
+    end
+
+    def call
+      @migrator.call.each do |root, configs|
+        begin
+          @result[root] = save_root(root, configs)
+        rescue => exc
+          @errors[root] << [exc.message, exc.backtrace]
+        end
+      end
+
+      @result.tap do |result|
+        result[:errors] = @errors
+      end
+    end
+
+    private
+
+    def save_root(root, configs)
+      @result[root] = {}
+
+      Config.create!(name: root) do |record|
+        begin
+          save_hash_value(record, configs)
+        rescue => exc
+          @errors[record] << [exc.message, exc.backtrace]
+        end
+      end
+    end
+
+    def save_entry(parent, entry)
+      send("save_#{entry.class.name.underscore}_value", parent, entry)
+    rescue => exc
+      @errors[parent] << [exc.message, exc.backtrace]
+    end
+
+    def save_hash_value(parent, hash)
+      parent.selectable = false
+
+      hash.each do |name, value|
+        entry = Config.new(name: name)
+        save_entry(entry, value)
+        parent.configs << entry
+      end
+    end
+
+    def save_array_value(parent, array)
+      entry = ArrEntry.new
+
+      array.each do |value|
+        save_entry(entry, value)
+      end
+
+      parent.entry = entry
+    end
+
+    def save_symbol_value(parent, symbol)
+      parent.entry = SymEntry.new(value: symbol)
+    end
+
+    def save_string_value(parent, string)
+      parent.entry = StrEntry.new(value: string)
+    end
+
+    def save_true_class_value(parent, _)
+      parent.entry = BoolEntry.new(value: 1)
+    end
+
+    def save_false_class_value(parent, _)
+      parent.entry = BoolEntry.new(value: 0)
+    end
+
+    def save_fixnum_value(parent, fixnum)
+      parent.entry = IntEntry.new(value: fixnum)
+    end
+
+    def save_nil_class_value(parent, nil_val)
+      parent.entry = Entry.new(value: nil_val)
+    end
+  end
+end

data/app/services/flexite/entry/array_create_service.rb

@@ -0,0 +1,69 @@
+require_dependency 'flexite/action_service'
+
+module Flexite
+  class Entry
+    class ArrayCreateService < ActionService
+      def call
+        if @form.invalid?
+          return failure
+        end
+
+        process_entry
+      end
+
+      private
+
+      def process_entry
+        @record = ArrEntry.create do |record|
+          record.parent_id = @form.parent_id
+          record.parent_type = @form.parent_type
+        end
+
+        Entry.transaction do
+          create_entries(@form.new_entries, @record.id)
+        end
+
+        success
+      rescue => exc
+        exc_failure(exc)
+      end
+
+      def create_entries(new_entries, parent_id)
+        return if new_entries.blank?
+
+        new_entries.each do |_, entry|
+          if respond_to?("save_#{entry[:type].demodulize.underscore}", true)
+            send("save_#{entry[:type].demodulize.underscore}", entry, parent_id)
+          else
+            save_entry(entry, parent_id)
+          end
+        end
+      end
+
+      def save_arr_entry(entry, parent_id)
+        klass = entry[:type].constantize
+        record = klass.create({ parent_id: parent_id, parent_type: klass.base_class.sti_name }, without_protection: true)
+        create_entries(entry[:new_entries], record.id)
+      end
+
+      def save_entry(entry, parent_id)
+        klass = entry[:type].constantize
+        klass.create({ parent_id: parent_id, parent_type: klass.base_class.sti_name, value: entry[:value] }, without_protection: true)
+      end
+
+      protected
+
+      def failure
+        Result.new(success: false, endpoint: { status: 400 })
+      end
+
+      def exc_failure(exc)
+        Result.new(success: false, message: exc.message, endpoint: { status: 500 })
+      end
+
+      def success
+        Result.new(flash: { type: :success, message: 'Entry was created!' }, data: { record: @record })
+      end
+    end
+  end
+end