hstore_attribute_support 0.0.3

data/.gitignore

@@ -0,0 +1,3 @@
+nbproject/
+.DS_Store
+*.gem

data/README

@@ -0,0 +1,44 @@
+== hstore_attribute_support
+
+A class that has hstore attribute support will get the ability to set up virtual
+attributes stored in hstore columns very easily.
+
+Consider a Person class with two hstore columns named "work_details" and
+"address". This class will, upon activation of the hstore attribute support, get
+new class methods: work_details_hstore_accessor and address_hstore_accessor.
+
+These methods can be used on class level (like attr_accessor) to set up getter
+and setter methods for virtual attributes stored in these hstore columns.
+Additionally it will allow you to give a type hint and default values along.
+Because of that, new instances will be able to use an "after_initialize"
+callback to set up their hstore'd attributes to the default value which was
+provided, as well as enabling the getter methods to return values typecasted
+(hstore data looses its type and was returned as a string otherwise...)
+
+**Example:**
+
+    # Schema for User:
+    # - id:   int
+    # - name: string
+    # - data: hstore
+    class User < ActiveRecord::Base
+
+      has_hstore_columns  # activates hstore support and mixes in the new methods
+
+      # the explicit definition of a boolean attribute admin (stored in hstore
+      # column 'data', initialized with default value false) looks like this:
+      hstore_attr_accessor :admin, :boolean, false
+
+      # however for each hstore column there are autogenerated prefixed methods:
+      data_hstore_accessor :age,    :integer          # defaults to nil
+      data_hstore_accessor :salary, :float,   1234.56 # with default value 1234.56
+
+      # it is even possible to define a custom typecast via a lambda
+      data_hstore_accessor :icq, lambda{|n| n.blank? ? 'UIN: n/a' : "UIN: \##{n}"}
+
+      # as accessors get defined, validation and other stuff works out of the box:
+      validates :salary,
+        :numericality => {:greater_than => 2000},
+        :if => Proc.new { |u| u.admin? }
+
+    end

data/hstore_attribute_support.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name          = 'hstore_attribute_support'
+  s.version       = '0.0.3'
+  s.date          = '2011-11-07'
+  s.summary       = "Adds AR Attributes support for Postgres hstore columns "
+  s.description   = "Adds AR Attributes support for Postgres hstore columns "
+  s.authors       = ["Andreas Schwarzkopf"]
+  s.email         = 'asmailbox@gmx.de'
+  s.homepage      = 'http://rubygems.org/gems/hstore_attributes_support'
+  s.has_rdoc      = true
+  s.rdoc_options  = ['--charset=UTF-8']
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord-postgres-hstore', '>= 0.1.2'
+end

data/lib/hstore_attribute_support/base.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+
+require 'active_support/concern'
+
+module HstoreAttributeSupport
+
+  module Base
+    
+    extend ActiveSupport::Concern
+
+    included do
+      def self.has_hstore_columns?
+        true
+      end
+
+      class_attribute :hstore_attributes
+      
+      # now we autogenerate convenient hstore_attr_accessor delegates, which can
+      # be used to set up this models hstore'd attributes more rails like.
+      # A Person class with a data hstore column could setup its name like this:
+      #
+      # data_hstore_accessor :name, :string, ''
+      #
+      # Which will set up accessors to the virtual attribute "name", defaults to
+      # an empty string and is stored in the data column.
+      # These methods are actually only syntactic sugar for the
+      # hstore_attr_accessor method.
+      self.columns.each do |column|
+        next unless column.type == :hstore
+        class_eval %Q{
+          def self.#{column.name}_hstore_accessor(attribute_name, cast = nil, default = nil)
+            return hstore_attr_accessor(attribute_name, "#{column.name}", cast, default)
+          end
+        }
+      end
+
+      # this will set up an after_initialize callback allowing a new model
+      # instance to set up default values for its hstore'd attributes.
+      after_initialize do
+        # iterate over the class instance variable "hstore_attributes", which
+        # contains types & defaults for virtual hstore attributes and apply them
+        (self.class.hstore_attributes || {}).each do |attr_name, settings|
+          column      = settings[:column]
+          default     = settings[:default]
+          hstore_data = self.send(:"#{column}") || {}
+          hstore_data = { attr_name.to_s => default }.merge(hstore_data)
+          self.send(:"#{column}=", hstore_data)
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # this class method allows descendant classes to set up attributes, which
+      # are stored in a hstore column. this solves two problems:
+      # 1. by providing a cast hint, it will take care of the data type, which
+      #    is lost by the hstore and was a pure string otherwise
+      # 2. it provides an easy way to set up defaults, as rails AR mechanism
+      #    fail here (no database defaults available for virtual attributes)
+      def hstore_attr_accessor(attribute_name, hstore_column, type  = nil, default = nil)
+        self.hstore_attributes ||= {}
+
+        self.hstore_attributes[attribute_name.to_s] = {
+          :column  => hstore_column.to_s,
+          :type    => type,
+          :default => default
+        }
+
+        class_eval %Q{
+          def #{attribute_name}
+            return read_hstore_attribute("#{attribute_name}")
+          end
+
+          def #{attribute_name}?
+            return read_hstore_attribute("#{attribute_name}").present?
+          end
+
+          def #{attribute_name}=(value)
+            return write_hstore_attribute("#{attribute_name}", value)
+          end
+        }
+      end
+    end
+
+    module InstanceMethods
+      
+      def read_hstore_attribute(attribute_name)
+        ha_column   = self.class.hstore_attributes[attribute_name][:column]
+        ha_type     = self.class.hstore_attributes[attribute_name][:type]
+        hstore_data = self.send(:"#{ha_column}").try(:with_indifferent_access)
+
+        return nil unless hstore_data
+
+        value = hstore_data[attribute_name]
+
+        return value unless ha_type
+
+        case ha_type
+        when :integer
+          return value.to_i
+        when :float
+          return value.to_f
+        when :decimal
+          return value.to_s.to_d
+        when :boolean
+          return !(value.to_s == '' || value.to_s == 'false')
+        when :bool
+          return !(value.to_s == '' || value.to_s == 'false')
+        when :string
+          return value.to_s
+        when :datetime
+          return value.to_s.to_datetime
+        when :date
+          return value.to_s.to_date
+        else
+        end
+
+        return ha_type.call(value) if ha_type.is_a?(Proc)
+
+        raise "read_hstore_attribute failed when trying to cast the type \"#{ha_type.inspect}\". Please define the type as one of [:integer, :float, :decimal, :boolean, :string, :datetime, :date] or pass in a lambda with one parameter to perform custom casts."
+      end
+
+      def write_hstore_attribute(attribute_name, value)
+        ha_column   = self.class.hstore_attributes[attribute_name][:column]
+        hstore_data = (self.send(:"#{ha_column}") || {}).with_indifferent_access
+        hstore_data = hstore_data.merge({attribute_name => value})
+        self.send(:"#{ha_column}=", hstore_data)
+        self
+      end
+
+    end
+
+  end
+end

data/lib/hstore_attribute_support/bootstrap.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+
+module HstoreAttributeSupport
+
+  module Bootstrap
+    def has_hstore_columns?
+      false
+    end
+
+    def has_hstore_columns
+      unless self.include? HstoreAttributeSupport::Base
+        self.send :include, HstoreAttributeSupport::Base
+      end
+    end
+  end
+
+end

data/lib/hstore_attribute_support/snippets.rb

@@ -0,0 +1,142 @@
+
+  module Something
+    module ClassMethods
+      # define an class instance variable - different for each subclass, but the
+      # same for each instance of these subclasses...
+      # its a hash containing sym.-keys representing the "virtual attribute name"
+      # and values which are hashes with :column, :cast, and :default values.
+      #
+      # :column defines the AR hstore column name where the attribute is stored
+      # :type contains a symbol defining the type or a custom proc that converts
+      #   the value in a user defined way
+      # :default is the default value for this attribute
+      #
+      # An example for a person model with a "work_details" and "address" hstore
+      # column could look like this:
+      #
+      # hstore_attributes => {
+      #  :employer=>{:column => work_details, :type => :string,  :default => ""},
+      #  :salary  =>{:column => work_details, :type => :integer, :default =>  0},
+      #  :street  =>{:column => address,      :type => :string,  :default => ""},
+      #  :city    =>{:column => address,      :type => :string,  :default => ""},
+      # }
+      #
+      # thus, the model has four virtual attributes which are stored in two
+      # differrent hstore columns.
+      class << self; attr_accessor :hstore_attributes; end
+
+      class_eval %Q{
+        # this will set up an after_initialize callback allowing a new model
+        # instance to set up default values for its hstore'd attributes.
+        after_initialize do
+          # iterate over the class instance variable "hstore_attributes", which
+          # contains types & defaults for virtual hstore attributes and apply them
+          (self.class.hstore_attributes || {}).each do |attr_name, settings|
+            column      = settings[:column]
+            default     = settings[:default]
+            hstore_data = self.send(:"\#{column}") || {}
+            hstore_data = { attr_name.to_s => default }.merge(hstore_data)
+            self.send(:"\#{column}=", hstore_data)
+          end
+        end
+      }
+
+      # now we autogenerates convenient hstore_attr_accessor delegates, which can
+      # be used to set up this models hstore'd attributes more rails like.
+      # A Person class with a data hstore column could setup its name like this:
+      #
+      # data_hstore_accessor :name, :string, ''
+      #
+      # Which will set up accessors to the virtual attribute "name", defaults to
+      # an empty string and is stored in the data column.
+      # These methods are actually only syntactic sugar for the hstore_attr_accessor
+      # method.
+      columns.each do |column|
+        next unless column.type == :hstore
+        class_eval %Q{
+          def self.#{column.name}_hstore_accessor(attribute_name, cast = nil, default = nil)
+            return hstore_attr_accessor(attribute_name, "#{column.name}", cast, default)
+          end
+        }
+      end
+
+      # this class method allows descendant classes to set up attributes, which are
+      # stored in a hstore column. this solves two problems:
+      # 1. by providing a cast hint, it will take care of the data type, which is
+      #    lost by the hstore and was a pure string otherwise
+      # 2. it provides an easy way of setting up defaults, as rails AR mechanisms
+      #    fail here (no database defaults available for virtual attributes)
+      def self.hstore_attr_accessor(attribute_name, hstore_column, type  = nil, default = nil)
+        self.hstore_attributes ||= {}
+
+        self.hstore_attributes[attribute_name.to_s] = {
+          :column  => hstore_column.to_s,
+          :type    => type,
+          :default => default
+        }
+
+        class_eval %Q{
+          def #{attribute_name}
+            return read_hstore_attribute("#{attribute_name}")
+          end
+
+          def #{attribute_name}?
+            return read_hstore_attribute("#{attribute_name}").present?
+          end
+
+          def #{attribute_name}=(value)
+            return write_hstore_attribute("#{attribute_name}", value)
+          end
+        }
+      end
+
+      private
+
+      def read_hstore_attribute(attribute_name)
+        ha_column   = self.class.hstore_attributes[attribute_name][:column]
+        ha_type     = self.class.hstore_attributes[attribute_name][:type]
+        hstore_data = self.send(:"#{ha_column}").try(:with_indifferent_access)
+
+        return nil unless hstore_data
+
+        value = hstore_data[attribute_name]
+
+        return value unless ha_type
+
+        case ha_type
+        when :integer
+          return value.to_i
+        when :float
+          return value.to_f
+        when :decimal
+          return value.to_s.to_d
+        when :boolean
+          return !(value.to_s == '' || value.to_s == 'false')
+        when :bool
+          return !(value.to_s == '' || value.to_s == 'false')
+        when :string
+          return value.to_s
+        when :datetime
+          return value.to_s.to_datetime
+        when :date
+          return value.to_s.to_date
+        else
+        end
+
+        return ha_type.call(value) if ha_type.is_a?(Proc)
+
+        raise "read_hstore_attribute failed when trying to cast the type \"#{ha_type.inspect}\". Please define the type as one of [:integer, :float, :decimal, :boolean, :string, :datetime, :date] or pass in a lambda with one parameter to perform custom casts."
+      end
+
+      def write_hstore_attribute(attribute_name, value)
+        ha_column   = self.class.hstore_attributes[attribute_name][:column]
+        hstore_data = (self.send(:"#{ha_column}") || {}).with_indifferent_access
+        hstore_data = hstore_data.merge({attribute_name => value})
+        self.send(:"#{ha_column}=", hstore_data)
+      end
+
+    end
+
+    module InstanceMethods
+    end
+  end

data/lib/hstore_attribute_support.rb

@@ -0,0 +1,7 @@
+require "hstore_attribute_support/bootstrap"
+require "hstore_attribute_support/base"
+
+# Attach ourselves to ActiveRecord
+if defined?(ActiveRecord::Base)
+  ActiveRecord::Base.extend HstoreAttributeSupport::Bootstrap
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: hstore_attribute_support
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Andreas Schwarzkopf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord-postgres-hstore
+  requirement: &70277821577800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70277821577800
+description: ! 'Adds AR Attributes support for Postgres hstore columns '
+email: asmailbox@gmx.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README
+- hstore_attribute_support.gemspec
+- lib/hstore_attribute_support.rb
+- lib/hstore_attribute_support/base.rb
+- lib/hstore_attribute_support/bootstrap.rb
+- lib/hstore_attribute_support/snippets.rb
+homepage: http://rubygems.org/gems/hstore_attributes_support
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+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.11
+signing_key: 
+specification_version: 3
+summary: Adds AR Attributes support for Postgres hstore columns
+test_files: []