tableless_model 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,50 @@
+PATH
+  remote: .
+  specs:
+    tableless_model (0.0.1)
+      activerecord
+      hashie
+      validatable
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.3)
+      activesupport (= 3.0.3)
+      builder (~> 2.1.2)
+      i18n (~> 0.4)
+    activerecord (3.0.3)
+      activemodel (= 3.0.3)
+      activesupport (= 3.0.3)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.3)
+    arel (2.0.6)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    hashie (0.4.0)
+    i18n (0.5.0)
+    mocha (0.9.10)
+      rake
+    rake (0.8.7)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+    tzinfo (0.3.23)
+    validatable (1.6.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  hashie
+  mocha
+  rspec
+  tableless_model!
+  validatable

data/README.rdoc

@@ -0,0 +1,97 @@
+= 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.
+
+
+
+== Installation
+
+Tableless Model is available as a Rubygem:
+
+		gem install tableless_model
+
+
+
+== Usage
+
+For example's sake, say we have these two models:
+
+1)
+
+		class Page < ActiveRecord::Base
+
+			# having columns such as id, title, etc
+	
+			has_one :seo_settings
+	
+		end
+
+2) 
+
+		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 in the pages table, in a YAML::serialized form. So the models become:
+
+
+1)
+
+		class Page < ActiveRecord::Base
+
+			# having columns such as id, title, seo, etc
+
+			has_tableless :seo => SeoOptions
+	
+		end
+
+2) 
+
+		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 
+
+		end
+
+
+That's it. Each instance of Page will now store directly its YAML-serialized SEO settings in the column named "seo". This is how the content of that column would look like in the database:
+
+		--- !map:SeoOptions 
+		noarchive: false
+		meta_description: 
+		meta_keywords: 
+		nofollow: false
+		title_tag: 
+		noindex: false
+
+
+
+== TODO
+
+* Support for associations
+
+
+== Authors
+
+* Vito Botta ( http://vitobotta.com )
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/activerecord/base/class_methods.rb

@@ -0,0 +1,97 @@
+module Base
+  module ClassMethods
+
+    # 
+    # 
+    # Macro to attach a tableless model to a parent, table-based model.
+    # The parent model is expected to own a property/column having as name the first argument
+    # (or the key if the argument is a hash )
+    # 
+    # Can be used this way:
+    # 
+    #     class Parent < ActiveRecord::Base
+    #     
+    #       has_tableless :settings
+    # 
+    #       # or...
+    # 
+    #       has_tableless :settings => ParentSettings
+    # 
+    #     end
+    # 
+    # 
+    # NOTE: the serialized column is expected to be of type string or text in the database
+    # 
+    def has_tableless(column)
+      column_name = column.class == Hash ? column.collect{|k,v| k}.first.to_sym : column
+      
+      # 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
+
+
+      # injecting in the parent object a getter and a setter for the
+      # attribute that will store an instance of a tableless model
+      class_eval do
+        
+        # Making sure the serialized column contains a new instance of the tableless model
+        # if it hasn't been set yet
+        default_value_for column_name => class_type.new 
+        
+        # Telling AR that the column has to store an instance of the given tableless model in 
+        # YAML serialized format
+        serialize column_name, ActiveRecord::TablelessModel
+
+        # Adding getter for the serialized column,
+        # making sure it always returns an instance of the specified tableless
+        # model and not just a normal hash or the value of the attribute in the database,
+        # which is plain text
+        define_method column_name.to_s do
+          class_type.new(read_attribute(class_name.to_sym) || {})
+        end
+
+        # Adding setter for the serialized column,
+        # making sure it always stores in it an instance of 
+        # the specified tableless model (as the argument may also be a regular hash)
+        define_method "#{column_name.to_s}=" do |value|
+          super class_type.new(value)
+        end
+      end
+    end
+    
+    
+    # 
+    # 
+    # Overriding the setter for the serialized column in the AR model,
+    # to make sure that, if it is still nil, the column always
+    # returns at least a new instance of the specified tableless model
+    # having the default values, if any, declared in the tableless model itself
+    # 
+    def default_value_for(property, default_value)
+      unless method_defined? "after_initialize_with_default_value_for_#{property.to_s}"
+
+        unless method_defined? "after_initialize"
+          define_method "after_initialize" do |*args|
+          end
+        end
+
+        define_method "after_initialize_with_default_value_for_#{property.to_s}" do |*args| 
+          send("after_initialize_without_default_value_for_#{property.to_s}", *args)
+          return unless new_record? 
+          return unless self.respond_to?(property.to_sym)
+
+          self.send("#{property.to_s}=".to_sym, self.send(property.to_sym) || default_value)    
+        end
+
+        alias_method_chain "after_initialize", "default_value_for_#{property.to_s}"
+      end
+    end
+
+  end
+end
+
+
+# Extending ActiveRecord::Base class with a macro required by the Tableless model,
+# and another one that can be used to serialize a tableless model instance into
+# a parent object's column
+
+ActiveRecord::Base.extend Base::ClassMethods

data/lib/tableless_model/class_methods.rb

@@ -0,0 +1,81 @@
+module Tableless
+  module ClassMethods
+
+    # 
+    # 
+    # Macro to define an attribute of the Tableless model.
+    # To be used as follows in a tableless model:
+    # 
+    #     class Example < ActiveRecord::TablelessModel
+    # 
+    #       attribute :name,    :type => :string
+    #       attribute :active,  :type => :boolean, :default => true
+    # 
+    #     end
+    # 
+    # 
+    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
+    
+      # 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}"]
+        end
+    
+        def #{attribute_name}=(value)
+          self["#{attribute_name}"] = value
+        end
+      }
+    end
+  
+  
+    # 
+    # 
+    # Initialises @attributes in the context of the class inheriting from the Tableless model
+    # 
+    def inherited(klass)
+      super
+      (@subclasses ||= Set.new) << klass
+      klass.instance_variable_set("@attributes",  Hash.new)
+    end
+  
+  
+    # 
+    # 
+    # If a data type has been specified for an attribute, its value
+    # will be converted accordingly (if necessary) when getting or setting it
+    # 
+    # 
+    def cast(attribute_name, value)
+      return nil if value.nil?
+
+      type = self.attributes[attribute_name.to_s][:type]
+    
+      return value if type.nil?
+    
+      begin
+        case type
+          when :string    then (value.is_a?(String) ? value : String(value))
+          when :integer   then (value.is_a?(Integer) ? value : Integer(value))
+          when :float     then (value.is_a?(Float) ? value : Float(value))
+          when :decimal   then (value.is_a?(Float) ? value : Float(value))
+          when :time      then (value.is_a?(Time) ? value : Time.parse(value))
+          when :date      then (value.is_a?(Date) ? value : Date.parse(value))
+          when :datetime  then (value.is_a?(DateTime) ? value : DateTime.parse(value))
+          when :boolean   then (value == true || value == 1 || value.to_s =~ /^(true|1)$/i)
+          else value
+        end
+      rescue Exception => e
+        raise StandardError, "Invalid value '#{value.inspect}' for attribute #{attribute_name} - expected data type is #{type} but value is a #{value.class} (Exception details: #{e})"    
+        value
+      end
+    end
+
+  end
+end

data/lib/tableless_model/instance_methods.rb

@@ -0,0 +1,80 @@
+module Tableless
+  module InstanceMethods
+
+    # 
+    # 
+    # On initialising an instance of a tableless model,
+    # sets the default values for all the attributes defined.
+    # Optionally, initialises the tableless model with the values 
+    # specified as arguments, instead, overriding the default values
+    # 
+    # 
+    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
+    end
+
+
+    # 
+    # 
+    # Returns true if the method name specified corresponds 
+    # to the key of an attribute defined for the tableless model
+    # 
+    # 
+    def respond_to?(method_name)
+      key?(method_name) ? true : super
+    end
+
+
+    # 
+    # 
+    # Overriding getter for the underlying hash keys
+    # 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))
+    end
+
+
+    # 
+    # 
+    # Overriding setter for the underlying hash keys
+    # 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
+      super attribute_name.to_s, self.class.cast(attribute_name, value)
+    end
+
+
+    # 
+    # 
+    # The Hash object displays inspect information in the format
+    # 
+    #   "{:a=>1, :b=>2}"
+    # 
+    # to make the tableless model look a bit more like regular models,
+    # it shows instead the inspect information in this format:
+    # 
+    #   "<#MyTablelessModel a=1 b=2>"
+    # 
+    def inspect
+      "<##{self.class.to_s}" << self.keys.sort.inject(""){|result, k| result << " #{k}=#{self[k].inspect}"; result }  << ">"
+    end
+    
+    
+    # 
+    # 
+    # Ensures that when merging with a given hash
+    # all the keys are stringified as the keys are always handled 
+    # as strings in the tableless model
+    # 
+    def merge(hash)
+      super hash.stringify_keys
+    end
+
+  end
+end

data/lib/tableless_model/version.rb

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

data/lib/tableless_model.rb

@@ -0,0 +1,30 @@
+require "validatable"
+require File.expand_path(File.join(File.dirname(__FILE__), "activerecord/base/class_methods"))
+
+Dir[File.join(File.dirname(__FILE__), "tableless_model/*rb")].each {|f| require File.expand_path(f)}
+
+module ActiveRecord
+  
+  # TablelessModel class is basically an Hash with method-like keys that must be defined in advance
+  # as for an ActiveRecord model, but without a table. Trying to set new keys not defined at class level
+  # result in NoMethodError raised 
+
+  class TablelessModel < Hash
+
+    extend   Tableless::ClassMethods
+    include  Tableless::InstanceMethods
+    
+    # 
+    # 
+    # Exposes an accessors that will store the names of the attributes defined for the Tableless model,
+    # and their default values
+    # This accessor is an instance of Set defined in the inheriting class (see self.inherited)
+    # 
+    # 
+    class << self
+      attr_reader :attributes
+    end
+
+  end
+end
+

data/spec/tableless_model_spec.rb

@@ -0,0 +1,8 @@
+require "lib/tableless_model"
+
+describe ActiveRecord::TablelessModel do
+  it "should say bla" do
+    true
+  end
+  
+end

data/tableless_model.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tableless_model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tableless_model"
+  s.version     = TablelessModel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Vito Botta"]
+  s.email       = ["vito@botta.name"]
+  s.homepage    = "http://rubygems.org/gems/tableless_model"
+  s.summary     = %q{A serialisable and validatable table-less model with support for associations, useful to store settings, options, etc in a serialized form in a parent object}
+  s.description = %q{A serialisable and validatable table-less model with support for associations, useful to store settings, options, etc in a serialized form in a parent object}
+
+  s.add_dependency "hashie"
+  s.add_dependency "validatable"
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+  
+  s.rubyforge_project = "tableless_model"
+
+  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"]
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: tableless_model
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Vito Botta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-02 00:00:00 +00:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: validatable
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: A serialisable and validatable table-less model with support for associations, useful to store settings, options, etc in a serialized form in a parent object
+email: 
+- vito@botta.name
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.rdoc
+- Rakefile
+- lib/activerecord/base/class_methods.rb
+- lib/tableless_model.rb
+- lib/tableless_model/class_methods.rb
+- lib/tableless_model/instance_methods.rb
+- lib/tableless_model/version.rb
+- spec/tableless_model_spec.rb
+- tableless_model.gemspec
+has_rdoc: true
+homepage: http://rubygems.org/gems/tableless_model
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: tableless_model
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: A serialisable and validatable table-less model with support for associations, useful to store settings, options, etc in a serialized form in a parent object
+test_files: 
+- spec/tableless_model_spec.rb