extend_at 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+.directory
+*~ 

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in acts_as_configuration.gemspec
+gemspec

data/MIT-license.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2011 Andrés Borek
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions of
+the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS
+OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 

data/README.markdown

@@ -0,0 +1,208 @@
+# Extend at
+
+This gem allows you to extend the columns from your model without migrations, you can, i.e., develop your own content types, like in Drupal
+
+## Installation
+
+<code>gem install extend_at</code>
+
+### Rails 3
+Add in your Gemfile:
+<code>gem 'extend_at', :git => 'git://github.com/anga/extend_at.git'</code>
+
+## Usage
+
+Only you need to add the next line in your model.
+
+<code>extend_at :configuration</code>
+
+For example:
+
+    class User < ActiveRecord::Base
+      extend_at :extra
+    end
+
+Now you can write your configuration like:
+
+    user.extra.private_photos = true
+    user.extra.subscribe_to_news = false
+    user.extra.perfil_description = ''
+    user.save
+
+### Columns configuration
+
+You can configurate each column.
+
+#### Set column type
+
+You can set the type of the colum.
+
+    class User < ActiveRecord::Base
+      extend_at :extra, :columns => {
+        :private_photos => {
+          :type => :boolean
+        }, :age => {
+          :type => :get_type
+        }, :perfil_description => {
+          :type => lambda {
+            String
+          }
+        }, :last_loggin => {
+          :type => Time.now.class
+        }, :subscribe_to_rss => :get_rss_config
+      }
+
+      protected
+      def get_type
+        Fixnum
+      end
+
+      def get_rss_config
+        {
+          :type => :boolean
+        }
+      end
+    end
+
+You can use any class, but if you need use boolean values, you must use :boolean.
+
+#### Set default value
+
+    class User < ActiveRecord::Base
+      extend_at :extra, :columns => {
+        :private_photos => {
+          :type => :boolean,
+          :default => true
+        }, :age => {
+          :type => :get_type,
+          :default => 1
+        }, :perfil_description => {
+          :type => lambda {
+            String
+          },
+          :default => :get_default_perfil_description
+        }, :last_loggin => {
+          :type => Time.now.class,
+          :default => lambda {
+            self.created_at.time
+          }
+        }, :subscribe_to_rss => :get_rss_config
+      }
+
+      protected
+      def get_type
+        Fixnum
+      end
+
+      def get_rss_config
+        {
+          :type => :boolean,
+          :default => true
+        }
+      end
+
+      def get_default_perfil_description
+        Description.where(:user_id => self.id).default
+      end
+    end
+
+#### Set validation
+    class User < ActiveRecord::Base
+      extend_at :extra, :columns => {
+        :private_photos => {
+          :type => :boolean,
+          :default => true
+        }, :age => {
+          :type => :get_type,
+          :default => 1,
+          :validate => lambda {
+            |age|
+            errors.add :config_age, "Are you Matusalén?" if age > 150
+            errors.add :config_age, "Are you a fetus?" if age <= 0
+          }
+        }, :perfil_description => {
+          :type => lambda {
+            String
+          },
+          :default => :get_default_perfil_description,
+          :lambda => :must_not_have_strong_language
+        }, :last_loggin => {
+          :type => Time.now.class,
+          :default => lambda {
+            self.created_at.time
+          },
+          :validate => lambda {
+            |time|
+            errors.add :config_last_loggin, "You can't loggin in the future" if time > Time.now
+          }
+        }, :subscribe_to_rss => :get_rss_config
+      }
+
+      protected
+      STRONG_WORD = [
+        #...
+      ]
+      
+      def get_type
+        Fixnum
+      end
+
+      def get_rss_config
+        {
+          :type => :boolean,
+          :default => true
+        }
+      end
+
+      def get_default_perfil_description
+        Description.where(:user_id => self.id).default
+      end
+
+      def must_not_have_strong_language(desc)
+        errors.add :cofig_perfil_description, "You must not have strong language" if desc =~ /(#{STRONG_WORD.join('|')})/
+      end
+    end
+
+### Integration in the views
+
+If you like to use come configuration variable in your views you only need put the name of the input like <code>:config_name</code>, for example:
+
+    <% form_for(@user) do |f| %>
+      ...
+      <div class="field">
+        <%= f.label :extra_private_photos %><br />
+        <%= f.check_box :extra_private_photos %>
+      </div>
+      ...
+    <% end %>
+
+### Tips
+
+If you like to do something more dynamic, like create columns and validations depending of some model or configuration, the you can do something like this:
+
+    class User < ActiveRecord::Base
+      extend_at :extra, :columns => :get_columns
+      serialize :columns_name
+
+      protected
+      def get_columns
+        columns = {}
+        columns_name.each do |name|
+          config = ColumConfig.where(:user_id => self.id, :column => name).first
+          columns[name.to_sym] = {
+            :type => eval(config.class_type),
+            :default => config.default_value,
+            :validate => get_validation(config.validation)
+          }
+        end
+        
+        columns
+      end
+
+      # Accept a name of a validation and return the Proc with the validation code
+      def get_validation(validation_type)
+        # ...
+      end
+    end
+
+This code read the configuration of the columns when you acces to extra column

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/extend_at.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "extend_at/version"
+
+Gem::Specification.new do |s|
+  s.name        = "extend_at"
+  s.version     = ExtendModelAt::VERSION
+  s.authors     = ["Andrés José Borek"]
+  s.email       = ["andres.b.dev@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Create dynamic fields in your models (like content types in Drupal)}
+  s.description = %q{This gem allows you to extend the columns from your model without migrations, you can, i.e., develop your own content types, like in Drupal}
+
+  s.rubyforge_project = "extend_at"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/lib/extend_at/version.rb

@@ -0,0 +1,3 @@
+module ExtendModelAt
+  VERSION = "0.0.1"
+end

data/lib/extend_at.rb

@@ -0,0 +1,294 @@
+# encoding: utf-8
+require "extend_at/version"
+
+module ExtendModelAt
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  # The object how controll the data
+  class Extention
+    def initialize(options={})
+      @model = options[:model]
+      @column_name = options[:column_name].to_s
+      @columns = options[:columns]
+      @value = get_defaults_values options
+
+      raise "#{@column_name} should by text or string not #{options[:model].column_for_attribute(@column_name.to_sym).type}" if not [:text, :stiring].include? options[:model].column_for_attribute(@column_name.to_sym).type
+
+      out = YAML.parse(@model[@column_name].to_s)
+      if out == false
+        db_value = nil
+      else
+        db_value = out.to_ruby
+      end
+      @value.merge! db_value if db_value.kind_of? Hash
+
+      initialize_values
+
+      @model.attributes[@column_name] = @value
+      @model.save(:validate => false)
+    end
+
+    def [](key)
+      @value[key.to_s]
+    end
+
+    def []=(key, value)
+      if @columns[key.to_sym].kind_of? Hash and ((@columns[key.to_sym][:type] == :boolean and (not [true.class, false.class].include? value.class)) or
+          ((not [:boolean, nil].include?(@columns[key.to_sym][:type])) and @columns[key.to_sym][:type] != value.class ))
+        raise "#{value.inspect} is not a valid type, expected #{@columns[key.to_sym][:type]}"
+      end
+      @value[key.to_s] = value
+      @model.send :"#{@column_name}=", @value.to_yaml
+    end
+
+    # Use the undefined method as a column
+    def method_missing(m, *args, &block)
+      # If the method don't finish with "=" is fore read
+      if m !~ /\=$/
+        self[m.to_s]
+      # but if finish with "=" is for wirte
+      else
+        column_name = m.to_s.gsub(/\=$/, '')
+        self[column_name.to_s] = args.first
+      end
+    end
+
+    private
+
+    def initialize_values
+      if not @value.kind_of? Hash
+        @model.attributes[@column_name] = {}.to_yaml
+        @model.save
+      end
+    end
+
+    def get_defaults_values(options = {})
+      defaults_ = {}
+      options[:columns].each do |column, config|
+        defaults_[column.to_s] = @columns[column.to_sym][:default] || nil
+      end
+      defaults_
+    end
+  end
+
+  module ClassMethods
+    def extend_at(column_name, options = {})
+      assign_attributes_eval = "
+      # Rewrite the mass assignment method because we need to accept write code like User.new :config_born => 10.years.ago
+      def assign_attributes(attributes = nil, options = {})
+        attributes.each_pair do |key, value|
+          if key.to_s =~ /^#{column_name}_/
+            rb = \"#{column_name}.\#\{key.to_s.gsub(/^#{column_name}_/,'')\} = value\"
+            eval rb, binding
+          end
+        end
+        attributes.delete_if do |key,value|
+          key.to_s =~ /^#{column_name}_/
+        end
+        super attributes, options
+      end
+
+      # Return the value of <<attributes>> methods like <column name>_<extended column name>
+      def [](column)
+        if column.to_s =~ /^#{column_name}_[a-zA-Z_][a-zA-Z_0-9]*\=?$/
+          rb = \"#{column_name}.\#\{column.to_s.gsub(/^#{column_name}_/,'')\}\"
+          eval rb, binding
+        else
+          super
+        end
+      end
+
+      # Write the value of <<attributes>> methods like <column name>_<extended column name>
+      def []=(column, value)
+        if column.to_s =~ /^#{column_name}_[a-zA-Z_][a-zA-Z_0-9]*\=?$/
+          rb = \"#{column_name}.\#\{column\} = value\"
+          eval rb, binding
+        else
+          super
+        end
+      end
+
+      # Respond to ethod like <column name>_<extended column name> for read or write
+      def self.respond_to?(symbol, include_private=false)
+        if symbol.to_s =~ /^#{column_name}_[a-zA-Z_][a-zA-Z_0-9]*\=?$/
+          return true
+        else
+          super
+        end
+      end
+
+      # Accept method like <column name>_<extended column name> for read or write
+      def method_missing(m, *args, &block)
+        if m.to_s =~ /^#{column_name}_[a-zA-Z_][a-zA-Z_0-9]*\=$/
+          rb = \"self.#{column_name}.\#\{m.to_s.gsub(/^#{column_name}_/, '')} = args.first\"
+          return eval rb, binding
+        elsif m.to_s =~ /^#{column_name}_[a-zA-Z_][a-zA-Z_0-9]*$/
+          rb = \"self.#{column_name}.\#\{m.to_s.gsub(/^#{column_name}_/, '')}\"
+          return eval rb, binding
+        else
+          super
+        end
+      end
+      "
+
+      self.class_eval <<-EOS
+        eval assign_attributes_eval
+      EOS
+      
+      class_eval <<-EOV
+      public
+        validate :extend_at_validations
+        
+        def #{column_name.to_s}
+          if not @#{column_name.to_s}_configuration.kind_of? ExtendModelAt::Extention
+            opts = initialize_options(#{options})
+            options = {
+                :extensible => true    # If is false, only the columns defined in :columns can be used
+              }.merge! opts
+            columns = initialize_columns expand_options(options, { :not_call_symbol => [:boolean], :not_expand => [:validate, :default] }) if options.kind_of? Hash
+            @#{column_name.to_s}_configuration ||= ExtendModelAt::Extention.new({:model => self, :column_name => :#{column_name.to_s}, :columns => columns})
+          end
+          @#{column_name.to_s}_configuration
+        end
+
+      protected
+        def extend_at_validations
+          self.#{column_name}.valid?
+          @extend_at_validation ||= {} if not @extend_at_validation.kind_of? Hash
+          @extend_at_validation.each do |column, validation|
+            if validation.kind_of? Symbol
+              self.send validation, eval("@#{column_name.to_s}_configuration.\#\{column.to_s\}")
+            elsif validation.kind_of? Proc
+              validation.call @#{column_name.to_s}_configuration[column.to_sym]
+            end
+          end
+        end
+
+        def initialize_options(options={})
+          opts = expand_options options, { :not_call_symbol => [:boolean], :not_expand => [:validate, :default] }
+        end
+
+        # Initialize each column configuration
+        def initialize_columns(options = {})
+          columns = {}
+          if options[:columns].kind_of? Hash
+            options[:columns].each do |column, config|
+              columns[column] = initialize_column column, config
+            end
+          elsif options[:columns].kind_of? Symbol
+            hash =  self.send options[:columns]
+            raise "Invalid columns configuration" if not hash.kind_of? Hash
+            columns = initialize_columns :columns => hash
+          elsif options[:columns].kind_of? Proc
+            hash = options[:columns].call
+            raise "Invalid columns configuration" if not hash.kind_of? Hash
+            columns = initialize_columns :columns => hash
+          end
+          columns
+        end
+
+        def initialize_column(column,config={})
+          raise "The column \#\{column\} have an invalid configuration (\#\{config.class\} => \#\{config\})" if not config.kind_of? Hash
+          column = column.to_sym
+          column_config = {}
+
+          # Stablish the type
+          if config[:type].class == Class
+            # If exist :type, is a static column
+            column_config[:type] = config[:type]
+          else
+            # if not, is a dynamic column
+            if config[:type].to_sym == :any
+              column_config[:type] = nil
+            elsif config[:type].to_sym == :boolean
+              column_config[:type] = :boolean
+            else
+              raise "\#\{config[:type]\} is not a valid column type"
+            end
+          end
+
+          # Stablish the default value
+          # if is a symbol, we execute the function from the model
+          if config[:default].kind_of? Symbol
+            column_config[:default] = self.send(:config[:default])
+          elsif config[:default].kind_of? Proc
+            column_config[:default] = config[:default].call
+          else
+            # If the column have a type, we verify the type
+            if not column_config[:type].nil?
+              if  (column_config[:type] == :boolean and (not [true.class, false.class].include? config[:default].class)) or
+                  ((not [:boolean, nil].include?(column_config[:type])) and column_config[:type] != config[:default].class )
+                  raise "The column \#\{column\} has an invalid default value. Expected \#\{column_config[:type]}, not \#\{config[:default].class}"
+              end
+              column_config[:default] = config[:default]
+            else
+              # If is dynamic, only we set the default value
+              column_config[:default] = config[:default]
+            end
+          end
+
+          # Set the validation
+          if [Symbol, Proc].include? config[:validate].class
+            column_config[:validate] = config[:validate]
+            create_validation_for column, config[:validate]
+          else
+            raise "The validation of \#\{column\} is invalid"
+          end
+
+
+          column_config
+        end
+
+        def create_validation_for(column, validation)
+          column = column.to_sym
+          @extend_at_validation ||= {}
+          @extend_at_validation[column] = validation
+        end
+
+        def expand_options(options={}, opts={})
+          config_opts = {
+            :not_expand => [],
+            :not_call_symbol => []
+          }.merge! opts
+          if options.kind_of? Hash
+            opts = {}
+            options.each do |column, config|
+              if not config_opts[:not_expand].include? column.to_sym
+                if not config_opts[:not_call_symbol].include? config
+                  opts[column.to_sym] = expand_options(get_value_of(config), config_opts)
+                else
+                  opts[column.to_sym] = expand_options(config, config_opts)
+                end
+              else
+                opts[column.to_sym] = config
+              end
+            end
+            return opts
+          else
+            return get_value_of options
+          end
+        end
+
+        def get_value_of(value)
+          if value.kind_of? Symbol
+            # If the function exist, we execute it
+            if  self.respond_to? value
+              return self.send value
+            # if the the function not exist, whe set te symbol as a value
+            else
+              return value
+            end
+          elsif value.kind_of? Proc
+            return value.call
+          else
+            return value
+          end
+        end
+      EOV
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval { include ExtendModelAt }

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: extend_at
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrés José Borek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &10360080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *10360080
+description: This gem allows you to extend the columns from your model without migrations,
+  you can, i.e., develop your own content types, like in Drupal
+email:
+- andres.b.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-license.txt
+- README.markdown
+- Rakefile
+- extend_at.gemspec
+- lib/extend_at.rb
+- lib/extend_at/version.rb
+homepage: ''
+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: extend_at
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Create dynamic fields in your models (like content types in Drupal)
+test_files: []