tableless_model 0.0.7 → 0.0.8

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile.lock

@@ -1,27 +1,45 @@
 PATH
   remote: .
   specs:
-    tableless_model (0.0.4)
+    tableless_model (0.0.7)
       validatable
 
 GEM
   remote: http://rubygems.org/
   specs:
-    ansi (1.2.2)
-    ffi (1.0.4)
-      rake (>= 0.8.7)
-    minitest (2.0.2)
-    rake (0.8.7)
-    sqlite3 (0.1.1)
-      ffi (>= 0.6.3)
+    activemodel (3.0.9)
+      activesupport (= 3.0.9)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.9)
+      activemodel (= 3.0.9)
+      activesupport (= 3.0.9)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.9)
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sqlite3 (1.3.3)
+    timecop (0.3.5)
+    tzinfo (0.3.29)
     validatable (1.6.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  ansi
-  minitest
+  activerecord
+  rspec
   sqlite3
   tableless_model!
-  validatable
+  timecop

data/README.md

@@ -0,0 +1,274 @@
+Original blog post (January 3, 2011)
+http://vitobotta.com/serialisable-validatable-tableless-model/
+
+
+# Tableless Model
+
+This is an extended Hash that has a defined collection of method-like attributes, and only these attributes can be set or read from the hash. 
+Optionally, you can also set default values and enforce data types for these attributes.
+
+Tableless Model behaves in a similar way to normal ActiveRecord models in that it also supports validations and can be useful, for example, to reduce database complexity in some cases, by removing associations and therefore tables. 
+
+In particular, by using Tableless Model, you could save tables whenever you have one to one associations between a parent model and a child model containing options, settings, debugging information or any other collection of attributes that belongs uniquely to a single parent object.
+
+Removing database tables also means reducing the number of queries to fetch associations, therefore it can also help a little bit with performance.
+
+
+## Installation
+
+Tableless Model is available as a Rubygem:
+
+``` bash
+gem install tableless_model
+``` 		
+
+== Usage
+
+For example's sake, say we have these two models:
+
+1)
+
+``` ruby
+class Page < ActiveRecord::Base
+
+	# having columns such as id, title, etc
+
+	has_one :seo_options
+
+end
+```
+
+2) 
+
+``` ruby
+class SeoOptions < ActiveRecord::Base
+
+	set_table_name "seo_options"
+
+	# having columns such as id, title_tag, meta_description, meta_keywords, 
+	# noindex, nofollow, noarchive, page_id
+
+	belongs_to :page
+
+end
+```
+
+So that each instance of Page has its own SEO options, and these options/settings only belong to a page, so we have a one to one association, and our database will have the tables "pages", and "seo_options".
+
+Using Tableless Model, we could remove the association and the table seo_options altogether, by storing those options in a column of the pages table, in a YAML-serialized form. So the models become:
+
+
+1)
+
+``` ruby
+class Page < ActiveRecord::Base
+
+	# having columns such as id, title, seo, etc
+
+	has_tableless :seo => SeoOptions
+
+end
+```
+
+2) 
+
+``` ruby
+class SeoOptions < ActiveRecord::TablelessModel
+
+  attribute :title_tag,         :type => :string,  :default => "default title tag"
+  attribute :meta_description,  :type => :string,  :default => ""  
+  attribute :meta_keywords,     :type => :string,  :default => ""  
+  attribute :noindex,           :type => :boolean, :default => false 
+  attribute :nofollow,          :type => :boolean, :default => false 
+  attribute :noarchive,         :type => :boolean, :default => false 
+
+end
+``` 
+
+That's it. 
+
+When you now create an instance of SeoOptions, you can get and set its attributes as you would do with a normal model:
+
+``` ruby
+seo_options = SeoOptions.new
+ 	=> <#SeoOptions meta_description="" meta_keywords="" noarchive=false nofollow=false noindex=false title_tag="default title tag">
+
+seo_options.title_tag
+	=> "default title tag"
+
+seo_options.title_tag = "new title tag"
+	=> "new title tag"
+``` 
+			
+Note that inspect	shows the properties of the Tableless Model in the same way it does for ActiveRecord models.
+Of course, you can also override the default values for the attributes when creating a new instance:
+
+``` ruby
+seo_options = SeoOptions.new( :title_tag => "a different title tag" )
+ 	=> <#SeoOptions meta_description="" meta_keywords="" noarchive=false nofollow=false noindex=false title_tag="a different title tag">
+``` 
+
+Now, if you have used the has_tabless macro in the parent class, Page, each instance of Page will store directly its YAML-serialized SEO settings in the column named "seo". 
+
+``` ruby
+page = Page.new
+
+page.seo
+ 	=> <#SeoOptions meta_description="" meta_keywords="" noarchive=false nofollow=false noindex=false title_tag="default title tag">
+
+page.seo.title_tag = "changed title tag"
+ 	=> <#SeoOptions meta_description="" meta_keywords="" noarchive=false nofollow=false noindex=false title_tag="changed title tag">
+``` 
+
+And this is how the content of the serialized column would look like in the database if you saved the changes as in the example
+
+``` yaml
+--- !map:SeoOptions 
+noarchive: false
+meta_description: 
+meta_keywords: 
+nofollow: false
+title_tag: "changed title tag"
+noindex: false
+``` 
+
+You can also pass a lambda/Proc when defining the default value of an attribute, so that the actual value will be calculated at runtime when a new instance of the tableless mode is being initialised:
+
+``` ruby
+class SeoOptions < ActiveRecord::TablelessModel
+
+  attribute :created_at, :type => :time, :default => lambda { Time.now }   
+
+end
+
+```
+
+Then, when the tableless model is initialised together with the parent model, the default value will be calculated and assigned in that moment:
+
+``` ruby
+>> SeoOptions.new
+=> <#SeoOptions created_at_=Sun Jul 24 19:26:33 +0100 2011>
+>> SeoOptions.new
+=> <#SeoOptions created_at_=Sun Jul 24 19:26:37 +0100 2011>
+>> SeoOptions.new
+=> <#SeoOptions created_at_=Sun Jul 24 19:26:43 +0100 2011>
+```
+
+Of course, if a value is specified for an attribute when creating an instance of the tableless mode, the default value specified for that attribute will be ignored, including lambdas/procs:
+
+``` ruby
+>> SeoOptions.new :created_at => Time.local(2011, 7, 24, 18, 47, 0)
+=> <#SeoOptions created_at=Sun Jul 24 18:47:00 +0100 2011>
+```
+
+For each of the attribute defined in the tableless model, shortcuts for both setter and getter are automatically defined in the parent model, unless the parent model already has a method of its own by the same name.
+
+So, for instance, if you have the tableless model:
+
+``` ruby
+class SeoOptions < ActiveRecord::TablelessModel
+
+  attribute :title_tag,         :type => :string,  :default => "default title tag"
+
+end
+```
+
+which is used by a parent model:
+
+``` ruby
+class Page < ActiveRecord::Base
+
+	has_tableless :seo => SeoOptions
+
+end
+```
+
+you can get/set attributes of the tableless model directly from the parent model:
+
+
+``` ruby
+# this...
+>> page.title_tag
+=> "default title tag"
+
+# is same as...
+>> page.seo_options.title_tag
+=> "default title tag"
+```
+
+For boolean attributes (or also truthy/falsy ones) you can also make calls to special getters ending with "?", so to get true or false in return, depending on the actual value of the attribute:
+
+``` ruby
+# this...
+>> page.title_tag?
+=> true
+```
+
+
+## Validations
+
+Tableless Model uses the Validatable gem to support validations methods and callbacks (such as "after_validation").
+Note: it currently uses the Rails 2.x syntax only.
+
+Example:
+
+``` ruby
+class SeoOptions < ActiveRecord::TablelessModel
+
+  attribute :title_tag,         :type => :string,  :default => ""
+  attribute :meta_description,  :type => :string,  :default => ""  
+  attribute :meta_keywords,     :type => :string,  :default => ""  
+  attribute :noindex,           :type => :boolean, :default => false 
+  attribute :nofollow,          :type => :boolean, :default => false 
+  attribute :noarchive,         :type => :boolean, :default => false 
+
+  validates_presence_of :meta_keywords
+	
+end
+``` 
+
+Testing:
+
+``` ruby
+x = SeoOptionsSettings.new
+ => <#SeoOptions meta_description="" meta_keywords="" noarchive=false nofollow=false noindex=false title_tag="">
+
+x.valid?
+ => false
+
+x.meta_keywords = "test"
+ => "test"
+
+x.valid?
+ => true 
+``` 
+
+## TODO
+
+* Update validations syntax to that of Rails 3
+* Support for associations
+
+
+## Authors
+
+* Vito Botta ( http://vitobotta.com )
+
+## Contributing
+
+* Fork the project on Github.
+* Make your feature addition or bug fix.
+* Add specs for it, making sure all specs green.
+* Commit, and send me a pull request.
+
+## Compatibility
+
+* Tested with REE/1.8.7, 1.9.2
+
+## Change log
+
+24.07.2011 - Added support for passing Proc/lamba when defining the default attribute of a value
+
+## License
+
+MIT License. Copyright 2010 Vito Botta. http://vitobotta.com
+

data/lib/activerecord/base/class_methods.rb

@@ -1,6 +1,9 @@
 module Base
   module ClassMethods
 
+    attr_reader :tableless_models
+    
+    
     # 
     # 
     # Macro to attach a tableless model to a parent, table-based model.
@@ -24,6 +27,10 @@ module Base
     # 
     def has_tableless(column)
       column_name = column.class == Hash ? column.collect{|k,v| k}.first.to_sym : column
+
+      @tableless_models ||= []
+      @tableless_models << column_name
+      
       
       # if only the column name is given, the tableless model's class is expected to have that name, classified, as class name
       class_type = column.class == Hash ? column.collect{|k,v| v}.last : column.to_s.classify.constantize
@@ -35,7 +42,7 @@ module Base
 
         # Telling AR that the column has to store an instance of the given tableless model in 
         # YAML serialized format
-        serialize column_name, ActiveRecord::TablelessModel
+        serialize column_name
     
         # Adding getter for the serialized column,
         # making sure it always returns an instance of the specified tableless

data/lib/activerecord/base/instance_methods.rb

@@ -0,0 +1,15 @@
+class ActiveRecord::Base
+  # 
+  #  
+  # delegates method calls for unknown methods to the tableless model
+  # 
+  def method_missing method, *args, &block
+    self.class.tableless_models.each do |column_name| 
+      serialized_attribute = send(column_name)
+      return serialized_attribute.send(method, *args, &block) if serialized_attribute.respond_to?(method) 
+    end
+    
+    super method, *args, &block
+  end
+end
+

data/lib/tableless_model.rb

@@ -1,7 +1,12 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require "validatable"
-require File.expand_path(File.join(File.dirname(__FILE__), "activerecord/base/class_methods"))
+require "activerecord/base/class_methods"
+require "activerecord/base/instance_methods"
+require "tableless_model/class_methods"
+require "tableless_model/instance_methods"
+require "tableless_model/version"
 
-Dir[File.join(File.dirname(__FILE__), "tableless_model/*rb")].each {|f| require File.expand_path(f)}
 
 module ActiveRecord
   

data/lib/tableless_model/class_methods.rb

@@ -15,21 +15,20 @@ module Tableless
     # 
     # 
     def attribute(name, options = {})
-      # Stringifies all keys... uses a little more memory but it's a bit easier to handle keys internally...
       attribute_name = name.to_s
     
       # Defining the new attribute for the tableless model
-      self.attributes[attribute_name] = options
+      self.attributes[name] = options
     
       # Defining method-like getter and setter for the new attribute
       # so it can be used like a regular object's property
       class_eval %Q{
         def #{attribute_name}
-          self["#{attribute_name}"]
+          self[:#{attribute_name}]
         end
     
         def #{attribute_name}=(value)
-          self["#{attribute_name}"] = value
+          self[:#{attribute_name}] = value
         end
       }
     end
@@ -53,7 +52,7 @@ module Tableless
     # 
     # 
     def cast(attribute_name, value)
-      type = self.attributes[attribute_name.to_s][:type] || :string
+      type = self.attributes[attribute_name][:type] || :string
 
       return nil if value.nil? && ![:string, :integer, :boolean, :float, :decimal].include?(type)
     

data/lib/tableless_model/instance_methods.rb

@@ -12,8 +12,8 @@ module Tableless
     def initialize(init_attributes = {}, &block)
       super &block
 
-      self.class.attributes.each_pair {|attribute_name, options| self.send("#{attribute_name}=", options[:default])}
-      init_attributes.each_pair {|k,v| self.send("#{k}=", v)} if init_attributes
+      self.class.attributes.each_pair {|attribute_name, options| self.send("#{attribute_name}=".to_sym, options[:default].is_a?(Proc) ? options[:default].call : options[:default])}
+      init_attributes.each_pair {|k,v| self[k] = v } if init_attributes
     end
 
 
@@ -34,8 +34,9 @@ module Tableless
     # so that only the defined attributes can be read 
     # 
     def [](attribute_name)
-      raise NoMethodError, "The attribute #{attribute_name} is undefined" unless self.class.attributes.has_key? attribute_name.to_s
-      self.class.cast(attribute_name, super(attribute_name.to_s))
+      raise NoMethodError, "The attribute #{attribute_name} is undefined" unless self.class.attributes.has_key? attribute_name
+      default = super(attribute_name)
+      self.class.cast(attribute_name, default.is_a?(Proc) ? default.call : default)
     end
 
 
@@ -45,9 +46,9 @@ module Tableless
     # so that only the defined attributes can be set
     # 
     def []=(attribute_name, value)
-      raise NoMethodError, "The attribute #{attribute_name} is undefined" unless self.class.attributes.has_key? attribute_name.to_s
+      raise NoMethodError, "The attribute #{attribute_name} is undefined" unless self.class.attributes.has_key? attribute_name
       
-      return_value = super(attribute_name.to_s, self.class.cast(attribute_name, value))
+      return_value = super(attribute_name, self.class.cast(attribute_name, value))
 
       if self.__owner_object 
         # This makes the tableless model compatible with partial_updates:
@@ -72,7 +73,10 @@ module Tableless
     #   "<#MyTablelessModel a=1 b=2>"
     # 
     def inspect
-      "<##{self.class.to_s}" << self.keys.sort.inject(""){|result, k| result << " #{k}=#{self[k].inspect}"; result }  << ">"
+      "<##{self.class.to_s}" << self.keys.sort{ |a,b| a.to_s <=> b.to_s  }.inject("") do |result, k| 
+        result += " #{k}=#{ self[k].is_a?(Time) ? self[k].strftime("%Y-%m-%d %H:%M:%S %Z") : self[k].inspect}"
+        result 
+      end + ">"
     end
     
     
@@ -85,5 +89,23 @@ module Tableless
       raise NoMethodError
     end
 
+    
+    # 
+    # allows calls to attribute_name?, returning a true or false depending
+    # on whether the actual value of the attribute is truthy or falsy
+    # 
+    def method_missing sym, *args, &block
+      attribute_name = sym.to_s.gsub(/^(.*)\?$/, "\\1")
+      if respond_to?(attribute_name)
+        !!send(attribute_name, *args, &block) 
+      else
+        super sym, *args, &block
+      end
+    end
+
+    def respond_to?(method)
+      super || self.class.attributes.keys.include?(method) || self.class.attributes.keys.include?("#{method}=".to_sym) || super(method.to_s.gsub(/^(.*)\?$/, "\\1"))
+    end
+
   end
 end