flexi_model 0.2.0

data/lib/flexi_model/fields.rb

@@ -0,0 +1,290 @@
+# encoding: UTF-8
+module FlexiModel
+  module Fields
+    TYPES = [:integer, :boolean, :multiple, :decimal, :float, :string, :text,
+             :datetime, :date, :time, :email, :phone, :address, :location, :attachment]
+
+    extend ActiveSupport::Concern
+
+    MULTI_PARAMS_FIELDS = ['datetime', 'date', 'time']
+
+    included do
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        attr_accessor :attributes
+
+        @@flexi_visible = true
+        cattr_accessor :flexi_visible
+
+        @@flexi_fields = []
+        cattr_accessor :flexi_fields
+
+        @@none_flexi_fields = []
+        cattr_accessor :none_flexi_fields
+
+        @@_flexi_fields_by_name = {}
+        cattr_accessor :_flexi_fields_by_name
+
+        @@flexi_namespace = nil
+        cattr_accessor :flexi_namespace
+
+        @@flexi_partition_id = 0
+        cattr_accessor :flexi_partition_id
+
+        @@flexi_name_field = :name
+        cattr_accessor :flexi_name_field
+
+      CODE
+    end
+
+    # Define attribute initialization constructor
+    def initialize(args = { })
+      @attributes = { }
+      assign_attributes(args) if args.present?
+    end
+
+    def assign_attributes(args)
+      _all_keys          = args.keys
+      _multi_params_keys = _all_keys.select { |k| k.to_s.match(/\([\w]+\)/) }
+      _normal_keys       = _all_keys - _multi_params_keys
+
+      # Execute only single parameter accessors
+      _normal_keys.each do |k|
+        self.send :"#{k.to_s}=", args[k]
+      end
+
+      # Execute multi params accessors
+      if _multi_params_keys.present?
+        _groups = { }
+        _multi_params_keys.each do |k|
+          _accessor = k.to_s.gsub(/\([\w]+\)/, '')
+          _index    = k.to_s.match(/\(([\w]+)\)/)[1].to_i - 1
+
+          _groups[_accessor] ||= []
+          _groups[_accessor].insert(_index, args[k])
+        end
+
+        _groups.each do |k, values|
+          _int_values = values.map(&:to_i)
+          _field      = self.flexi_fields.select { |f| f.name.to_s == k }.first
+
+          if _field
+            _value = case _field.type
+              when 'datetime'
+                DateTime.new(*_int_values)
+              when 'time'
+                Time.new(*([Time.now.year, Time.now.month, Time.now.day] + _int_values))
+              when 'date'
+                Date.new(*_int_values)
+            end
+
+            self.send :"#{k}=", _value
+          end
+        end
+      end
+    end
+
+    # Return default name from the object instance
+    # This accessor could be set through set_flexi_name_field :title
+    def _name
+      if self.respond_to?(self.flexi_name_field)
+        self.send(self.flexi_name_field)
+      else
+        raise "Define your name field accessor (which may return the object
+              title, name or whatever it describes about the current instance)
+              - set_flexi_name_field :different_accessor"
+      end
+    end
+
+    def to_s
+      %{#<#{self.class.name}:#{sprintf '0x%x', self.object_id} #{@attributes.map { |k, v| ":#{k}=>'#{v}'" }.join(' ')}>}
+    end
+
+    module ClassMethods
+
+      # Set field name to determine default name field.
+      def set_flexi_name_field(field)
+        self.flexi_name_field = field
+      end
+
+      # Set current model as visible or invisible to admin panel
+      # Setting false won't publicize this model over admin panel
+      def set_flexi_visible(bool)
+        self.flexi_visible = bool
+      end
+
+      # Isolate and group all models under a single administration panel
+      # This is useful when we are hosting these models under a single platform.
+      def set_flexi_partition_id(_id)
+        self.flexi_partition_id = _id
+      end
+
+      # Set filed with name, type and default value or proc
+      #
+      # name    - Field name should be downcased multi words separated by underscore
+      # type    - Supported type String, Integer, Time, Date
+      # options - Hash of options
+      #   default   - Default value proc or object
+      #   singular  - Singular label
+      #   plural    - Plural label
+      #
+      # Return +Field+ instance
+      def flexi_field(name, type, options = { })
+        accessible = options.delete(:accessible)
+        default    = options.delete(:default)
+        singular   = options.delete(:singular) || name.to_s.singularize
+        plural     = options.delete(:plural) || name.to_s.pluralize
+        _type      = type.is_a?(Symbol) || type.is_a?(String) ? type : type.name
+
+
+        field            = FlexiField.new(name, _type.to_s.downcase, default)
+        field.accessible = accessible
+        field.singular   = singular
+        field.plural     = plural
+        field.options    = options
+
+        opt_accessors = options.delete(:accessors)
+        generate_accessors = opt_accessors.nil? ? true : opt_accessors
+
+        define_field(field, generate_accessors)
+      end
+
+      alias_method :_ff, :flexi_field
+
+      # Define flexible field definition
+      (TYPES - [:attachment]).each do |_field|
+        self.class_eval <<-CODE
+          def _#{_field.to_s}(*args)
+            options = args.last && args.last.is_a?(Hash) ? args.last : {}
+            args.each do |_field_name|
+              unless _field_name.is_a?(Hash)
+                flexi_field _field_name, :#{_field.to_s}, options
+              end
+            end
+          end
+        CODE
+      end
+
+      # Remove field by field name
+      # Return list of existing fields
+      def remove_flexi_field(name)
+        flexi_fields.reject! { |f| f.name == name }
+      end
+
+      def define_field(field, generate_accessors = true)
+        # Add new field
+        if generate_accessors
+          # Remove existing definition
+          remove_flexi_field field.name
+
+          flexi_fields << field
+
+          # Map name and field
+          _flexi_fields_by_name[
+              (field.name.is_a?(Symbol) ?
+                  field.name : field.name.to_sym)] = field
+
+          _define_accessors(field)
+        else
+          none_flexi_fields << field
+        end
+      end
+
+      private
+      def _define_accessors(field)
+        # Define setter & getter
+        self.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{field.name.to_s}=(v)
+            @attributes[:'#{field.name.to_s}'] = _cast(v, :#{field.type})
+          end
+
+          def #{field.name.to_s}
+            @attributes[:'#{field.name.to_s}'] ||= _cast(_get_value(:'#{field.name.to_s}'), :#{field.type})
+          end
+
+        CODE
+
+        # Define ? method if boolean field
+        if field.type == 'boolean'
+          self.class_eval <<-CODE
+            def #{field.name.to_s}?
+              self.#{field.name.to_s}
+            end
+          CODE
+        end
+      end
+    end
+
+    def _cast(_value, _type)
+      return _value if _value.nil?
+
+      case _type
+        when :decimal, :float
+          _value.to_f
+        when :integer, :number
+          _value.to_i
+        when :multiple
+          if _value.is_a?(String)
+            YAML.load(_value)
+          elsif Array
+            _value.map do |v|
+              if v.is_a?(Hash)
+                if v.values.map(&:blank?).uniq == [true]
+                  nil
+                else
+                  v
+                end
+              else
+                v
+              end
+            end.compact
+          end
+        else
+          _value
+      end
+    end
+
+    def _get_value(field_name)
+      return _load_value_from_record(field_name) if self._record.present?
+
+      _default_value(field_name)
+    end
+
+    def _load_value_from_record(field_name)
+      val = self._record.value_of(field_name.to_s)
+      if val.present?
+        val.value
+      else
+        nil
+      end
+    end
+
+    def _default_value(field_name)
+      _field = _flexi_fields_by_name[field_name]
+      if _field.default.present?
+        _field.value(self)
+      else
+        nil
+      end
+    end
+
+
+    class FlexiField
+      attr_accessor :name, :type, :default, :singular, :plural, :accessible, :options
+
+      def initialize(name, type, default = nil)
+        @name    = name
+        @type    = type
+        @default = default
+        @options = { }
+      end
+
+      def value(context)
+        if default.is_a?(Proc)
+          default.call(context)
+        else
+          default
+        end
+      end
+    end
+  end
+end

data/lib/flexi_model/filter.rb

@@ -0,0 +1,61 @@
+module FlexiModel
+  module Filter
+    extend ActiveSupport::Concern
+
+    included do
+      class_eval <<-CODE
+        @@flexi_filters = {}
+        cattr_accessor :flexi_filters
+      CODE
+    end
+
+    module ClassMethods
+      # Define filter for scoping data
+      #
+      #   name - Set filter name
+      #   options - Hash of options
+      #     field_types - Define renderable field types
+      #     field_values - Define initial field values procs
+      #   proc - Set lambda for the specific filter
+      #
+      # Example -
+      #
+      #   class Category
+      #     include FlexiModel
+      #     filter :by_name, {}, lambda { |param1, param2| ... }
+      #   end
+      #
+      def flexi_filter(name, options = {}, &proc)
+        raise "No lambda is defined for scope :#{name}" if proc.nil?
+
+        accepted_params = proc.parameters.map(&:last)
+
+        self.flexi_filters[name.to_sym] = {
+            param_keys: accepted_params,
+            options: options,
+            proc: proc
+        }
+
+        _define_filter_method(name)
+      end
+
+      def _define_filter_method(name)
+        self.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def self.#{name.to_s}(args = {})
+            _filter_params = self.flexi_filters[:#{name.to_s}]
+            _values = _filter_params[:param_keys].map{ |k| args[k] }
+
+            _inst = args[:instance] || self
+            _block = _filter_params[:proc]
+            _inst.instance_exec(*_values, &_block)
+          end
+
+          def #{name.to_s}(args = {})
+            args[:instance] = self
+            self.class.#{name.to_s}(args)
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/flexi_model/stub_persistence.rb

@@ -0,0 +1,24 @@
+module FlexiModel
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def destroy_all; end
+      def delete_all; end
+
+      def count; 0 end
+      def length; 0 end
+    end
+
+    # Persist data in AR backend or Mongoid backend
+    def save; end
+    def create; end
+    def update_attributes; end
+    def update_attribute; end
+    def destroy; end
+    def destroy_all; end
+    def delete_all; end
+    def count; end
+    def length; end
+  end
+end

data/lib/flexi_model/validations.rb

@@ -0,0 +1,37 @@
+module FlexiModel
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      if defined?(ActiveModel)
+        include ActiveModel
+        include ActiveModel::Validations
+      end
+    end
+  end
+
+  def create(options = { })
+    if perform_validation(options)
+      super
+    else
+      self
+    end
+  end
+
+  def update(options = { })
+    if perform_validation(options)
+      super
+    else
+      self
+    end
+  end
+
+  def perform_validation(options = { })
+    if options[:validate].nil? || options[:validate]
+      valid?
+    else
+      true
+    end
+  end
+
+end

data/lib/flexi_model.rb

@@ -0,0 +1,38 @@
+require 'flexi_model/fields'
+require 'flexi_model/callbacks'
+require 'flexi_model/validations'
+require 'flexi_model/association'
+require 'flexi_model/filter'
+require 'flexi_model/attachment_field'
+
+module FlexiModel
+  extend ActiveSupport::Concern
+
+  included do
+    class_eval <<-RUBY
+      attr_accessor :_id, :_record
+      alias_method :id, :_id
+    RUBY
+  end
+
+  include FlexiModel::Fields
+  include FlexiModel::Callbacks
+  include FlexiModel::Validations
+
+  if defined?(ActiveRecord)
+    require 'flexi_model/ar_models'
+    require 'flexi_model/ar_persistence'
+    require 'flexi_model/ar_queryable'
+
+    include FlexiModel::ArModels
+    include FlexiModel::ArPersistence
+    include FlexiModel::ArQueryable
+  else
+    raise "No Active Record Found"
+  end
+
+  include FlexiModel::Association
+  include FlexiModel::Filter
+  include FlexiModel::AttachmentField
+
+end

data/lib/generators/flexi_model/install/install_generator.rb

@@ -0,0 +1,20 @@
+module FlexiModel
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+      source_root File.expand_path('../templates', __FILE__)
+
+      # Implement the required interface for Rails::Generators::Migration.
+      def self.next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def generate_install
+        Dir.glob(File.join(File.dirname(__FILE__), 'templates/*.rb')).each do |file|
+          migration_template file, "db/migrate/#{file.split('/').last}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_collections.rb

@@ -0,0 +1,18 @@
+class CreateFlexiModelCollections < ActiveRecord::Migration
+  def change
+    create_table "flexi_model_collections" do |t|
+      t.string 'name'
+      t.string 'singular_label'
+      t.string 'plural_label'
+      t.string 'namespace'
+      t.integer 'partition_id'
+
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    add_index "flexi_model_collections", [:namespace, :name]
+    add_index "flexi_model_collections", [:namespace, :name, :partition_id],
+              name: 'index_ns_name_pi', unique: true
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_collections_fields.rb

@@ -0,0 +1,11 @@
+class CreateFlexiModelCollectionsFields < ActiveRecord::Migration
+  def change
+    create_table 'flexi_model_collections_fields', :id => false, :force => true do |t|
+      t.integer 'collection_id'
+      t.integer 'field_id'
+    end
+
+    add_index 'flexi_model_collections_fields', [:collection_id]
+    add_index 'flexi_model_collections_fields', [:field_id]
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_fields.rb

@@ -0,0 +1,20 @@
+class CreateFlexiModelFields < ActiveRecord::Migration
+  def change
+    create_table 'flexi_model_fields', :force => true do |t|
+      t.string 'name'
+      t.string 'singular_label'
+      t.string 'plural_label'
+      t.string 'namespace'
+      t.integer 'partition_id'
+
+      t.string 'field_type'
+      t.text 'default_value'
+    end
+
+    add_index 'flexi_model_fields', [:namespace, :name]
+    add_index 'flexi_model_fields', [:namespace, :name, :field_type]
+    add_index 'flexi_model_fields', [:namespace, :name, :field_type, :partition_id],
+              :unique => true,
+              name: 'index_ns_name_ft_pi'
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_records.rb

@@ -0,0 +1,12 @@
+class CreateFlexiModelRecords < ActiveRecord::Migration
+  def change
+    create_table 'flexi_model_records', :force => true do |t|
+      t.integer 'collection_id'
+      t.string 'namespace'
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    add_index 'flexi_model_records', [:namespace, :collection_id]
+  end
+end

data/lib/generators/flexi_model/install/templates/create_flexi_model_values.rb

@@ -0,0 +1,17 @@
+class CreateFlexiModelValues < ActiveRecord::Migration
+  def change
+    create_table 'flexi_model_values', :force => true do |t|
+      t.integer 'record_id'
+      t.integer 'field_id'
+      t.boolean 'bool_value'
+      t.integer 'int_value'
+      t.decimal 'dec_value'
+      t.string 'str_value'
+      t.text 'txt_value'
+      t.datetime 'dt_value'
+    end
+
+    add_index 'flexi_model_values', [:record_id, :field_id]
+
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: flexi_model
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- nhm tanveer hossain khan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2153893780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153893780
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2153892920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153892920
+description: Flexible Model
+email:
+- hasan83bd@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/discover.rb
+- lib/flexi_model.rb
+- lib/flexi_model/ar_models.rb
+- lib/flexi_model/ar_models/collection.rb
+- lib/flexi_model/ar_models/field.rb
+- lib/flexi_model/ar_models/record.rb
+- lib/flexi_model/ar_models/value.rb
+- lib/flexi_model/ar_persistence.rb
+- lib/flexi_model/ar_queryable.rb
+- lib/flexi_model/association.rb
+- lib/flexi_model/attachment_field.rb
+- lib/flexi_model/callbacks.rb
+- lib/flexi_model/fields.rb
+- lib/flexi_model/filter.rb
+- lib/flexi_model/stub_persistence.rb
+- lib/flexi_model/validations.rb
+- lib/generators/flexi_model/install/install_generator.rb
+- lib/generators/flexi_model/install/templates/create_flexi_model_collections.rb
+- lib/generators/flexi_model/install/templates/create_flexi_model_collections_fields.rb
+- lib/generators/flexi_model/install/templates/create_flexi_model_fields.rb
+- lib/generators/flexi_model/install/templates/create_flexi_model_records.rb
+- lib/generators/flexi_model/install/templates/create_flexi_model_values.rb
+- README.md
+homepage: https://github.com/we4tech/flexi-model/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Build flexible database model with dynamic fields (right now based on ActiveRecord
+  soon it will work with mongoid too)
+test_files: []