flexi_model 0.2.0

data/README.md

@@ -0,0 +1,122 @@
+flexi-model
+===========
+
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/we4tech/flexi-model)
+
+Build flexible database model with dynamic fields (right now based on ActiveRecord soon it will work with mongoid too)
+
+How to do ?
+===========
+
+Define your first model.
+---------
+```ruby
+class User
+  include FlexiModel
+  _string :name, :email
+  _text :bio
+  validates_presence_of :name, :email
+end
+```
+
+Create your new record.
+------------
+```ruby
+User.create name: 'hasan', email: 'hasan@welltreat.us', bio: 'Ruby developer'
+#=> #<User:...>
+```
+
+Find record by id.
+-----------
+```ruby
+User.find(1)
+```
+
+Find records by name
+--------
+```ruby
+User.where(name: 'hasan')
+#=> #<...::Criteria...> # Instance of criteria object
+```
+
+Define belongs to and has many relationship
+---------
+```ruby
+class Blog
+  include FlexiModel
+  _string :title
+  _text :content
+  belongs_to :user
+end
+
+class User
+  include FlexiModel
+  _string :name
+  has_many :blogs
+end
+
+# Create records
+user = User.create(name: 'nafi')
+Blog.create(title: 'Hello world', content: 'Hello content', user: user)
+
+# Find all related blogs
+user.blogs
+
+# Find parent record
+user.blogs.first.user
+```
+
+Define has and belongs to many relationships
+-----------
+```ruby
+class User
+  inlude FlexiModel
+  _string :name
+  has_and_belongs_to_many :roles
+end
+
+class Role
+  include FlexiModel
+  _string :name
+  has_and_belongs_to_many :users
+end
+
+# Create user with roles
+User.create(name: 'khan', roles: [Role.create(name: 'admin'), Role.create(name: 'moderator')])
+
+# Find user roles
+user = User.where(name: 'khan').first
+user.roles
+```
+
+Update attribute
+---------
+```ruby
+user = User.where(...)
+user.update_attribute :name, 'raju'
+```
+
+Update attributes
+-----------
+```ruby
+user = User.where(...)
+user.update_attributes name: 'raju', email: 'hola@hola.com'
+```
+
+Destroy record
+-------
+```ruby
+user.destroy
+User.where(...conditions...).destroy_all
+```
+
+Observers
+--------
+ * Before, After and Around Create
+ * Before, After and Around Update
+ * Before, After and Around Destroy
+
+TODOS
+=====
+
+* Write documentation

data/lib/discover.rb

@@ -0,0 +1,11 @@
+# Include plugins
+require 'autotest/fsevent'
+require 'autotest/growl'
+
+Autotest.add_discovery { "rspec2" }
+
+# Skip some paths
+Autotest.add_hook :initialize do |autotest|
+  %w{.idea .git .DS_Store ._* vendor}.each { |exception| autotest.add_exception(exception) }
+  false
+end

data/lib/flexi_model/ar_models/collection.rb

@@ -0,0 +1,15 @@
+module FlexiModel
+  module ArModels
+    class Collection < ActiveRecord::Base
+      self.table_name = 'flexi_model_collections'
+
+      validates_presence_of :name
+      validates_uniqueness_of :name, :scope => :partition_id, :if => :partition_id
+      has_and_belongs_to_many :fields, :join_table => 'flexi_model_collections_fields'
+      has_many :records, :dependent => :destroy
+
+      attr_accessible :namespace, :name, :partition_id,
+                      :singular_label, :plural_label, :fields
+    end
+  end
+end

data/lib/flexi_model/ar_models/field.rb

@@ -0,0 +1,36 @@
+module FlexiModel
+  module ArModels
+    class Field < ActiveRecord::Base
+      self.table_name = 'flexi_model_fields'
+      attr_accessible :name, :singular_label,:plural_label, :namespace,
+                      :partition_id, :field_type, :default_value
+
+      COLUMNS_MAP     = {
+          boolean:  :bool_value,
+          integer:  :int_value,
+          decimal:  :dec_value,
+          float:    :dec_value,
+          string:   :str_value,
+          email:    :str_value,
+          phone:    :str_value,
+          location: :str_value,
+          address:  :txt_value,
+          text:     :txt_value,
+          multiple: :txt_value,
+          datetime: :dt_value,
+          date:     :dt_value,
+          time:     :dt_value
+      }
+
+      has_and_belongs_to_many :collections, :join_table => 'flexi_model_collections_fields'
+      has_many :values, :dependent => :destroy
+
+      validates_presence_of :name, :field_type
+      validates_uniqueness_of :name, :scope => [:namespace, :partition_id, :field_type]
+
+      def value_column
+        FlexiModel::ArModels::Field::COLUMNS_MAP[self.field_type.to_sym]
+      end
+    end
+  end
+end

data/lib/flexi_model/ar_models/record.rb

@@ -0,0 +1,31 @@
+module FlexiModel
+  module ArModels
+    class Record < ActiveRecord::Base
+      self.table_name = 'flexi_model_records'
+
+      attr_accessible :collection_id, :namespace, :values, :values_attributes,
+                      :collection
+
+      belongs_to :collection
+      has_many :values, :dependent => :destroy
+      has_many :fields, :through => :values
+
+      scope :by_namespace, lambda { |n| where(namespace: n) }
+      scope :recent, order('created_at DESC')
+
+      accepts_nested_attributes_for :values
+
+      def value_of(field_name)
+        values.select{|v| v.field.present? }.
+            select{|v| v.field.name.downcase == field_name.to_s.downcase}.first
+      end
+
+      def title
+        _value = value_of(:name) || value_of(:title)
+        return _value.value if _value.present?
+
+        self.collection.singular_label
+      end
+    end
+  end
+end

data/lib/flexi_model/ar_models/value.rb

@@ -0,0 +1,52 @@
+module FlexiModel
+  module ArModels
+    class Value < ActiveRecord::Base
+      self.table_name = 'flexi_model_values'
+
+      attr_accessible :record_id, :field_id, :bool_value, :int_value,
+                      :dec_value, :str_value, :txt_value, :dt_value, :field,
+                      :value
+
+      belongs_to :record
+      belongs_to :field
+
+      # Set value based on field type.
+      # ie. if it is `string` type it will store value in str_value
+      #
+      # List of field value mappings -
+      #   Boolean   'bool_value'
+      #   Integer   'int_value'
+      #   Decimal   'dec_value'
+      #   String    'str_value'
+      #   Text      'txt_value'
+      #   Datetime  'dt_value'
+      def value=(val)
+        self.send :"#{_mapped_value_column}=", val
+      end
+
+      # Get value from corresponding column based on field type
+      def value
+        self.send :"#{_mapped_value_column}"
+      end
+
+      def column_for_attribute(name)
+        if :value == name.to_sym
+          self.class.columns_hash[self.field.value_column.to_s]
+        else
+          self.class.columns_hash[name.to_s]
+        end
+      end
+
+    private
+      def _mapped_value_column
+        raise 'No field is set' if field.nil?
+
+        value_col =
+            FlexiModel::ArModels::Field::COLUMNS_MAP[field.field_type.to_sym]
+        raise "Unknown field type - #{field.field_type}" if value_col.nil?
+
+        value_col
+      end
+    end
+  end
+end

data/lib/flexi_model/ar_models.rb

@@ -0,0 +1,10 @@
+module FlexiModel
+  module ArModels
+
+  end
+end
+
+require 'flexi_model/ar_models/collection'
+require 'flexi_model/ar_models/field'
+require 'flexi_model/ar_models/record'
+require 'flexi_model/ar_models/value'

data/lib/flexi_model/ar_persistence.rb

@@ -0,0 +1,318 @@
+module FlexiModel
+  module ArPersistence
+    extend ActiveSupport::Concern
+
+    RECORD     = FlexiModel::ArModels::Record
+    COLLECTION = FlexiModel::ArModels::Collection
+    FIELD      = FlexiModel::ArModels::Field
+    VALUE      = FlexiModel::ArModels::Value
+
+    included do
+      class_eval <<-RUBY
+        @@_flexi_collection = nil
+        cattr_accessor :_flexi_collection
+
+        @@_flexi_metadata = { }
+        cattr_accessor :_flexi_metadata
+
+        @@_flexi_fields_map = nil
+        cattr_accessor :_flexi_fields_map
+
+      RUBY
+    end
+
+    module ClassMethods
+      # Set collection label
+      #
+      # singular - Set singular name for the collection
+      # plural - Set plural name for the collection
+      def set_flexi_label(singular, plural)
+        _flexi_metadata[:label_singular] = singular
+        _flexi_metadata[:label_plural]   = plural
+      end
+
+      # Return singular and plural collection label
+      # If not defined it will take class name as collection name
+      #
+      # Returns array of singular and plural labels
+      def get_flexi_label
+        labels = [_flexi_metadata[:label_singular],
+                  _flexi_metadata[:label_plural]].compact
+
+        if labels.empty?
+          _f_name = _friendly_name(self.name)
+          [_f_name.singularize, _f_name.pluralize]
+        else
+          labels
+        end
+      end
+
+      # Return collection name based on parametrized class name
+      def flexi_collection_name
+        self.name.parameterize
+      end
+
+      def get_flexi_namespace
+        self.flexi_collection_name.parameterize
+      end
+
+      # Initialize new instance and set data from record
+      def initialize_with_record(record)
+        inst = self.new
+        inst.send(:_record=, record)
+        inst.send(:_id=, record.id)
+        inst
+      end
+
+      # Return by default plural label
+      def flexi_label(singular = false)
+        if singular
+          self._flexi_collection.singular_label
+        else
+          self._flexi_collection.plural_label
+        end
+      end
+
+      def flexi_collection;
+        _flexi_collection
+      end
+
+      delegate :id, :to => :_flexi_collection
+
+      def destroy_all;
+        RECORD.by_namespace(self.get_flexi_namespace).each do |record|
+          inst = initialize_with_record(record)
+          inst.destroy
+        end
+      end
+
+      def delete_all;
+        RECORD.by_namespace(self.get_flexi_namespace).delete_all
+      end
+
+      # Create does exactly as `save`, but it initiates `:create` callbacks
+      def create(attributes = { })
+        inst = self.new(attributes)
+        inst.save
+
+        inst
+      end
+
+      private
+      def _friendly_name(long_name)
+        long_name.to_s.split("::").last
+      end
+    end
+
+    def initialize(*)
+      super
+      _find_or_update_or_build_collection!
+    end
+
+    # Ensure object with same _id returns true on equality check
+    def ==(another_instance)
+      self._id && self._id == another_instance._id
+    end
+
+    # Return true if record is not saved
+    def new_record?
+      !_id.present?
+    end
+
+    # Store record in persistent storage
+    def save
+      create_or_update
+      _id.present?
+    end
+
+    # Update stored attributes by give hash
+    def update_attributes(_params)
+      assign_attributes _params
+      save
+    end
+
+    # Update single attribute by key and value
+    def update_attribute(key, value)
+      self.update_attributes(key => value)
+    end
+
+    def destroy
+      if _id.present?
+        RECORD.delete(self._id)
+      else
+        false
+      end
+    end
+
+    # Reload object instance
+    def reload
+      self.class.find(self._id)
+    end
+
+    # Forcefully load all attributes
+    def load_attributes!
+      self.flexi_fields.map { |f| self.send(f.name.to_sym) }
+    end
+
+    # Return existing or create new collection set
+    def get_flexi_collection
+      _find_or_update_or_build_collection!
+
+      self._flexi_collection
+    end
+
+    # Return flexi fields in name and field object map
+    def get_flexi_fields_map
+      self._flexi_fields_map ||=
+          Hash[get_flexi_collection.fields.
+                   map { |_field| [_field.name.to_sym, _field] }]
+    end
+
+    delegate :created_at, :updated_at, :to => :_get_record, :prefix => :flexi
+
+    private
+    def create_or_update
+      _id.nil? ? create : update
+    end
+
+    def create(*)
+      # Initialize AR record and store
+      record = _get_record
+      record.save
+
+      # Set Id and errors to the parent host object
+      self._id = record.id
+      @errors  = record.errors
+
+      record
+    end
+
+    def update(*)
+      record = _get_record
+      record.values.destroy_all
+      record.update_attributes(values: _get_values)
+      record
+    end
+
+    def _get_record
+      _load_record_instance!
+      self._record
+    end
+
+    def _load_record_instance!
+      self._record ||= _record_load_or_initialize
+    end
+
+    def _record_load_or_initialize
+      collection = _find_or_update_or_build_collection!
+
+      if self._id.nil?
+        RECORD.new(
+            namespace:  self.class.get_flexi_namespace,
+            collection: collection,
+            values:     self.send(:_get_values)
+        )
+      else
+        RECORD.find(self._id)
+      end
+    end
+
+    # Return `Value` object based on flexi attributes
+    def _get_values
+      _fields_map = get_flexi_fields_map
+
+      @attributes.map do |k, v|
+        field = _fields_map[k]
+        raise "Field - #{k} not defined" if field.nil?
+        VALUE.new(:field => field, value: self.send(:"#{k}"))
+      end
+    end
+
+    # Find existing collection object
+    #   If not found create new collection
+    #   If found but schema is back dated
+    #     update schema
+    def _find_or_update_or_build_collection!
+      return _flexi_collection if _flexi_collection.present?
+
+      # Find existing collection
+      self._flexi_collection = COLLECTION.where(
+          namespace:    self.class.get_flexi_namespace,
+          name:         self.class.flexi_collection_name,
+          partition_id: self.class.flexi_partition_id
+      ).first
+
+      # Update if schema changed
+      if self._flexi_collection
+        _update_schema
+      else
+        _build_collection
+      end
+
+      self._flexi_collection
+    end
+
+    # Check whether update is back dated
+    # This update is verified through comparing stored collection
+    # and new definition
+    def _update_schema
+      singular_label, plural_label = self.class.get_flexi_label
+      existing                     = self._flexi_collection
+
+      # Check labels
+      if existing.singular_label != singular_label
+        existing.update_attribute :singular_label, singular_label
+      end
+
+      if existing.plural_label != plural_label
+        existing.update_attribute :plural_label, plural_label
+      end
+
+
+      # Check fields
+      fields = _build_fields
+      if _fields_changed? fields, existing
+        # TODO: Dangerous need to fix it up
+        existing.fields.destroy_all
+        existing.update_attribute :fields, fields
+      end
+    end
+
+    def _fields_changed?(fields, existing)
+      added_or_removed = existing.fields.length != fields.length
+      name_changed     = existing.fields.map(&:name).sort != fields.map(&:name).sort
+      type_changed     = existing.fields.map(&:field_type).sort != fields.map(&:field_type).sort
+
+      added_or_removed || name_changed || type_changed
+    end
+
+    def _build_collection
+      singular_label, plural_label = self.class.get_flexi_label
+
+      self._flexi_collection = COLLECTION.create(
+          namespace:      self.class.get_flexi_namespace,
+          name:           self.class.flexi_collection_name,
+          partition_id:   self.class.flexi_partition_id,
+          singular_label: singular_label,
+          plural_label:   plural_label,
+
+          fields:         _build_fields
+      )
+    end
+
+    def _build_fields
+      self.flexi_fields.map do |field|
+        params = {
+            namespace:      self.class.get_flexi_namespace,
+            name:           field.name.to_s,
+            partition_id:   self.class.flexi_partition_id,
+            field_type:     field.type,
+            singular_label: field.singular,
+            plural_label:   field.plural
+        }
+
+        FIELD.send(:"find_or_create_by_#{params.keys.map(&:to_s).join('_and_')}", params)
+      end
+    end
+  end
+end