flexi_model 0.2.0

data/lib/flexi_model/ar_queryable.rb

@@ -0,0 +1,239 @@
+module FlexiModel
+  module ArQueryable
+    extend ActiveSupport::Concern
+
+    RECORD = FlexiModel::ArPersistence::RECORD
+
+    module ClassMethods
+      # Return count of items from the model
+      def count
+        _build_criteria.count
+      end
+
+      # Alias to :count
+      def length;
+        self.count
+      end
+
+      # Find a record instance by id
+      # Returns model instance
+      def find(id_or_ids)
+        records = RECORD.includes(:values).where(id: id_or_ids)
+
+        if records.present?
+          if id_or_ids.is_a?(Array)
+            records.map { |_record| initialize_with_record(_record)  }
+          else
+            initialize_with_record(records.first)
+          end
+        else
+          nil
+        end
+      end
+
+      # Load all records from the model
+      def all
+        _build_criteria
+      end
+
+      # Load first record from the model
+      def first
+        _build_criteria.first
+      end
+
+      # Load last record from the model
+      def last
+        _build_criteria.last
+      end
+
+      # Apply conditions using hash map
+      def where(conditions = {})
+        _build_criteria.where(conditions)
+      end
+
+    private
+      def _build_criteria
+        Criteria.new(RECORD, self, self.get_flexi_namespace)
+      end
+
+    end
+
+    def count;
+      Criteria.new(RECORD, self, self.get_flexi_namespace).count
+    end
+
+    def length;
+      self.class.count
+    end
+
+    class Criteria
+      include Enumerable
+
+      attr_accessor :offset, :limit, :conditions, :host, :orders, :joins,
+                    :groups, :select_field
+      attr_reader :target_model
+
+      protected :"joins=", :joins, :"orders=", :orders, :"groups=", :groups
+
+      def initialize(host, target_model, namespace)
+        @conditions = {namespace: namespace}
+        @joins = []
+        @orders = {}
+        @groups = []
+        @target_model = target_model
+        @select_object = nil
+
+        # By default Max 100 items will be retrieved
+        @limit = 100
+        @offset = 0
+        @host = host
+        @members = nil
+      end
+
+      def where(hash)
+        self._convert_query(hash)
+        self
+      end
+
+      def offset(num)
+        self.offset = num
+        self
+      end
+
+      def get_offset
+        @offset
+      end
+
+      def limit(num)
+        self.limit = num
+        self
+      end
+
+      def get_limit
+        @limit
+      end
+
+      def select_field(field)
+        self.select_field = field
+        self
+      end
+
+      def destroy_all
+        _perform_query.destroy_all
+      end
+
+      DEFAULT_SORTABLE_FIELDS = [:created_at, :updated_at]
+
+      # Order query by the given field and order type
+      #
+      #   key - field name in symbol or string
+      #   order_type - order type :asc or :desc
+      #     :asc - stands for ascending order
+      #     :desc - stands for descending order
+      # Returns self instance
+      def order(key, order_type)
+        if DEFAULT_SORTABLE_FIELDS.include?(key.to_sym)
+          self.orders[key.to_sym] = order_type
+        else
+          field = _find_field(key)
+          _join_table :values
+          column = "`#{FlexiModel::ArModels::Value.table_name}`.`#{field.value_column}`"
+          self.orders[column] = order_type
+          self.groups << "`#{FlexiModel::ArModels::Record.table_name}`.`id`"
+        end
+
+        self
+      end
+
+      def each(&block)
+        _members.each {|m| block.call _convert_to_model(m) }
+      end
+
+      def last
+        @target_model.initialize_with_record(_members.last)
+      end
+
+      def to_sql
+        self._perform_query.to_sql
+      end
+
+      protected
+        def _convert_query(hash = {})
+          hash.each do |k, v|
+            case k.to_sym
+
+              when :namespace
+                self.conditions[:namespace] = v
+
+              when :id
+                self.conditions[:id] = v
+
+              else
+                _join_table :values
+
+                # Find associated field
+                field = _find_field(k)
+                self.conditions["#{FlexiModel::ArModels::Value.table_name}.field_id"] = field.id
+                self.conditions["#{FlexiModel::ArModels::Value.table_name}.#{field.value_column.to_s}"] = v
+            end
+          end
+        end
+
+        def _join_table(model)
+          unless @joins.include?(model)
+            @joins.push(model)
+          end
+        end
+
+        def _find_field(k)
+          field = (@empty_inst ||= @target_model.new)
+            .get_flexi_fields_map[k.to_sym]
+          raise "Invalid field - #{k}" unless field
+
+          field
+        end
+
+        def _convert_to_model(r)
+          _inst = @target_model.initialize_with_record(r)
+          if @select_field.present?
+            _inst.send(@select_field.to_sym)
+          else
+            _inst
+          end
+        end
+
+        def _singular_field(class_name)
+          class_name.name.split('::').last.underscore
+        end
+
+        def _members
+          @members ||= _perform_query
+        end
+
+        def _perform_query
+          # Prepare conditions
+          _host = self.host
+            .where(self.conditions)
+            .limit(self.get_limit)
+            .offset(self.get_offset)
+
+          # Join tables
+          if self.joins.present?
+            _host = _host.joins(@joins)
+          end
+
+          # Add orders
+          self.orders.each do |k, v|
+            _host = _host.order("#{k} #{v.to_sym == :desc ? 'DESC' : 'ASC'}")
+          end
+
+          # Add groups
+          if self.groups.present?
+            _host = _host.group(self.groups)
+          end
+
+          _host
+        end
+    end
+  end
+end

data/lib/flexi_model/association.rb

@@ -0,0 +1,303 @@
+module FlexiModel
+  module Association
+    extend ActiveSupport::Concern
+
+    included do
+      class_eval <<-ATTRS, __FILE__, __LINE__ + 1
+        cattr_accessor :associations
+        @@associations = {}
+
+        cattr_accessor :associated_classes
+        @@associated_classes = {}
+      ATTRS
+    end
+
+    module ClassMethods
+
+      # Create relationship between two flexi model based on primary key
+      def belongs_to(model_name, options = { })
+        _id_field     = options[:foreign_key] || "#{model_name.to_s}_id"
+        _target_model = (options[:class_name] || model_name).to_s.classify
+
+        self.flexi_field _id_field.to_sym, :integer
+
+        # Generate dynamic finder method
+        _build_belongs_to_accessors model_name, _target_model, _id_field
+
+        self.associated_classes["#{model_name.to_s.singularize}_id".to_sym] =
+            _target_model.to_sym
+
+        (self.associations[:belongs_to] ||= []) << model_name
+      end
+
+      # Create one to many relationship among the flexi models
+      #
+      #   Options
+      #     - :class_name - Target model class name
+      def has_many(model_name, options = { })
+        _class_name = (options[:class_name] ||
+            model_name.to_s.singularize.classify).to_sym
+
+        _build_has_many_accessors _class_name, model_name
+
+        self.associated_classes["#{model_name.to_s.singularize}_id".to_sym] =
+            _class_name.to_sym
+        (self.associations[:has_many] ||= []) << model_name
+      end
+
+      # Create many to many relationship between two flexi models based
+      # on foreign key
+      #
+      #   Options
+      #     - joining_class - You can define your joining class name or
+      #                       you can leave it to us to generate on the fly.
+      #
+      def has_and_belongs_to_many(method_name, options = { })
+        # Get joining class name (dev can specify over :joining_class option)
+        _self_ref, _class_name = _build_joining_class_name(method_name)
+        _joining_class_name    = (options[:joining_class] || _class_name).to_sym
+
+        # Build field name
+        _fields                = [_build_field_name(self.name), _build_field_name(method_name)]
+
+        # Eval dynamic joining class
+        _joining_class         = _build_joining_class(
+            _joining_class_name, _fields, _self_ref)
+
+        # Create setter for setting all <target> records
+        _build_habtm_class_accessors(
+            _joining_class_name, method_name, _fields, _self_ref)
+
+        self.associated_classes["#{method_name.to_s.singularize}_id".to_sym] =
+            _joining_class.name.to_sym
+        (self.associations[:has_and_belongs_to_many] ||= []) << method_name
+      end
+
+      # Return list of fields excluding relationship's foreign key for
+      def flexi_fields_except_fk
+        _field_names = self.associations.values.flatten.map { |_v| :"#{_v.to_s.singularize}_id" }
+        if none_flexi_fields.present?
+          none_flexi_fields.each do |field|
+            ['file_name', 'content_type', 'file_size', 'updated_at'].each do |_suffix|
+              _field_names << :"#{field.name.to_s}_#{_suffix}"
+            end
+          end
+        end
+        self.flexi_fields.select { |_f| !_field_names.include?(_f.name.to_sym) }
+      end
+
+      private
+      def _build_belongs_to_accessors(model_name, target_model, id_field)
+        self.class_eval <<-ACCESSORS, __FILE__, __LINE__ + 1
+          # Return object instance
+          def #{model_name.to_s}
+            @#{model_name.to_s} ||= self.class.parent::#{target_model}.find(self.#{id_field})
+          end
+
+          def #{model_name.to_s}_type
+            :#{target_model.classify}
+          end
+
+          # Set object instance
+          def #{model_name.to_s}=(inst)
+            inst.save if inst.new_record?
+            self.#{id_field} = inst._id
+            @#{model_name.to_s} = inst
+          end
+        ACCESSORS
+      end
+
+      def _build_habtm_class_accessors(_class_name, method_name, _fields, self_ref)
+        _column_name = if self_ref
+          "first_id"
+        else
+          "#{_fields.first}_id"
+        end
+
+        self.class_eval <<-ACCESSORS, __FILE__, __LINE__ + 1
+          def #{method_name}_changed?; @#{method_name}_changed end
+
+          def #{method_name}
+            @#{method_name} ||= #{_class_name}.
+              #{self_ref ?
+                "where(:first_id => self._id).select_field(:second)" :
+                "where(#{_column_name}: self._id).select_field(:#{_fields.last})"}
+          end
+
+          def #{method_name.to_s.singularize}_ids=(ids)
+            @#{method_name.to_s.singularize}_ids = ids
+            self.#{method_name}= self.class.send(
+              :_find_class, :#{method_name.to_s.classify}).
+                where(id: ids).to_a
+          end
+
+          def #{method_name.to_s.singularize}_ids
+            @#{method_name.to_s.singularize}_ids ||= #{method_name}.to_a.compact.map(&:_id)
+          end
+
+          def #{method_name}=(an_array)
+            @#{method_name} = an_array
+            @#{method_name}_changed = true
+          end
+
+          after_save :_#{method_name}_after_save
+          after_update :_#{method_name}_after_update
+
+          def _#{method_name}_after_save
+            return if @#{method_name}.nil?
+            _create_#{method_name}_mappings!
+          end
+
+          def _#{method_name}_after_update
+            return if @#{method_name}.nil?
+            _update_#{method_name}_mappings!
+          end
+
+          def _update_#{method_name}_mappings!
+            _destroy_#{method_name}_mappings!
+            _create_#{method_name}_mappings!
+          end
+
+          def _destroy_#{method_name}_mappings!
+            #{_class_name}.where(#{_column_name}: self._id).destroy_all
+          end
+
+          def _create_#{method_name}_mappings!
+            @#{method_name}.each do |_target_inst|
+              _target_inst.save if _target_inst.new_record?
+              _map = #{_class_name}.create(
+                #{ self_ref ?
+                    "first: self, second: _target_inst" :
+                    "#{_fields.first}: self, #{_fields.last}: _target_inst"
+                }
+              )
+
+              raise _map.errors.inspect if _map.errors.present?
+            end
+          end
+        ACCESSORS
+      end
+
+      def _build_field_name(name)
+        name.to_s.split("::").last.underscore.singularize
+      end
+
+      def _build_joining_class(class_name, fields, self_ref)
+        _cls = self.send(:_find_class, class_name.to_s.split('::').last.to_sym)
+        _cls if _cls.present?
+
+        _relationships = ''
+
+        if self_ref
+          _relationships << <<-CODE
+            belongs_to :first, :class_name => :#{fields.first}
+            belongs_to :second, :class_name => :#{fields.last}
+            validates_presence_of :first_id, :second_id
+          CODE
+        else
+          _relationships << <<-CODE
+            belongs_to :#{fields.first}
+            belongs_to :#{fields.last}
+            validates_presence_of :#{fields.first}, :#{fields.last}
+          CODE
+        end
+
+        self.class_eval <<-CLASS, __FILE__, __LINE__ + 1
+          class #{class_name}
+            include FlexiModel
+            set_flexi_visible false
+
+            #{_relationships}
+          end
+
+          #{class_name}
+        CLASS
+      end
+
+      def _build_joining_class_name(model_name)
+        _parts    = self.name.to_s.split("::")
+        _name     = _parts.last
+        _self_ref = false
+
+        _name_parts = [model_name.to_s.pluralize.downcase,
+                       _name.pluralize.downcase]
+
+        _class_name = if _name_parts.uniq.count == 2
+          _name_parts.sort.join('_').classify
+        else
+          _self_ref = true
+          _name_parts.join('_').classify
+        end
+
+        [_self_ref, if _parts.length > 1
+          "#{_parts[0..(_parts.length - 2)].join('::')}::#{_class_name}"
+        else
+          _class_name
+        end]
+      end
+
+      def _build_has_many_accessors(_class_name, _method)
+        _field_name = "#{self.name.underscore.split('/').last}_id"
+
+        self.class_eval <<-ACCESSORS, __FILE__, __LINE__ + 1
+          def #{_method}
+            @#{_method} ||= self.class.send(:_find_class, :#{_class_name}).where(#{_field_name}: self._id)
+          end
+
+          def #{_method}=(items)
+            @#{_method} = items
+          end
+
+          after_save :_#{_method}_after_save
+
+          def _#{_method}_after_save
+            return unless @#{_method}.present?
+            @#{_method}.each do |_item|
+              _item.update_attribute(#{_field_name}: self._id)
+            end
+          end
+
+        ACCESSORS
+      end
+
+      def _find_class(_constant)
+        if self.parent && self.parent.constants.include?(_constant)
+          self.parent.const_get(_constant)
+        elsif self.class.parent.constants.include?(_constant)
+          self.class.parent.const_get(_constant)
+        elsif self.class.constants.include?(_constant)
+          self.class.const_get(_constant)
+        else
+          nil
+        end
+      end
+
+      def _find_or_generate_joining_class(_class_name, _fields)
+        _class = _find_class _class_name
+        if _class.nil?
+          _generate_mapping_class _class_name, _fields.first, _fields.last
+        else
+          _class
+        end
+      end
+
+      def _generate_mapping_class(name, _field_1, _field_2)
+        self.class_eval <<-CLASS, __FILE__, __LINE__ + 1
+            class #{name.to_s}
+              include FlexiModel
+
+              set_flexi_visible false
+
+              flexi_field :#{_field_1}_id, :integer
+              flexi_field :#{_field_2}_id, :integer
+
+              belongs_to :#{_field_1}
+              belongs_to :#{_field_2}
+            end
+
+            #{name.to_s}
+        CLASS
+      end
+    end
+  end
+end

data/lib/flexi_model/attachment_field.rb

@@ -0,0 +1,20 @@
+module FlexiModel
+  module AttachmentField
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Set filed definition which is used as attachment accessor.
+      #
+      # Ie. Paperclip exposes < attachment name > method over the host class.
+      # Using this method we can hint admin panel that we have a field which
+      # accepts file
+      def attachment_field(name, options = { })
+        options[:accessors] = false
+        flexi_field name, :attachment, options
+      end
+
+      alias_method :_attachment, :attachment_field
+    end
+  end
+end

data/lib/flexi_model/callbacks.rb

@@ -0,0 +1,41 @@
+module FlexiModel
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      # Set callbacks
+      define_model_callbacks :save, :create, :update, :destroy, :initialize
+    end
+  end
+
+  def initialize(*)
+    run_callbacks(:initialize) { super }
+  end
+
+  def save
+    run_callbacks(:save) { super }
+  end
+
+  def create
+    run_callbacks(:create) { super }
+  end
+
+  def update(*)
+    run_callbacks(:update) { super }
+  end
+
+  def update_attributes(*)
+    run_callbacks(:update) { super }
+  end
+
+  def update_attribute(*)
+    run_callbacks(:update) { super }
+  end
+
+  def destroy
+    run_callbacks(:destroy) { super }
+  end
+end