padrino-hstore 0.1.1

data/LICENSE.md

@@ -0,0 +1,7 @@
+Copyright (c) 2012 Cory Buecker
+
+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.md

@@ -0,0 +1,14 @@
+# padrino-hstore
+
+A hstore plugin for padrino using Activerecord on PostgreSQL.
+
+All the really good parts are based on https://github.com/softa/activerecord-postgres-hstore; huge kudos there!
+
+## Installation
+Add the following to your Gemfile (note that Padrino must be loaded first):
+
+    gem "padrino"
+    gem "padrino-hstore"
+    
+## Usage
+Not much to tell here. You can use hstore as a column type and all string/hash conversions are handled for you. Check https://github.com/softa/activerecord-postgres-hstore for more details.

data/lib/padrino-hstore.rb

@@ -0,0 +1,6 @@
+require "padrino-hstore/string"
+require "padrino-hstore/hash"
+
+Padrino.after_load do
+  require "padrino-hstore/activerecord"
+end

data/lib/padrino-hstore/activerecord.rb

@@ -0,0 +1,150 @@
+module ActiveRecord
+
+  # Adds methods for deleting keys in your hstore columns
+  class Base
+
+    # Deletes all keys from a specific column in a model. E.g.
+    #   Person.delete_key(:info, :father)
+    # The SQL generated will be:
+    #   UPDATE "people" SET "info" = delete("info",'father');
+    def self.delete_key attribute, key
+      raise "invalid attribute #{attribute}" unless column_names.include?(attribute.to_s)
+      update_all([%(#{attribute} = delete("#{attribute}",?)),key])
+    end
+
+    # Deletes many keys from a specific column in a model. E.g.
+    #   Person.delete_key(:info, :father, :mother)
+    # The SQL generated will be:
+    #   UPDATE "people" SET "info" = delete(delete("info",'father'),'mother');
+    def self.delete_keys attribute, *keys
+      raise "invalid attribute #{attribute}" unless column_names.include?(attribute.to_s)
+      delete_str = "delete(#{attribute},?)"
+      (keys.count-1).times{ delete_str = "delete(#{delete_str},?)" }
+      update_all(["#{attribute} = #{delete_str}", *keys])
+    end
+
+    # Deletes a key in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_key(:info, :father)
+    # It does not save the record, so you'll have to do it.
+    def destroy_key attribute, key
+      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
+      new_value = send(attribute)
+      new_value.delete(key.to_s)
+      send("#{attribute}=", new_value)
+      self
+    end
+
+    # Deletes a key in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_key(:info, :father)
+    # It does save the record.
+    def destroy_key! attribute, key
+      destroy_key(attribute, key).save
+    end
+
+    # Deletes many keys in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_keys(:info, :father, :mother)
+    # It does not save the record, so you'll have to do it.
+    def destroy_keys attribute, *keys
+      for key in keys
+        new_value = send(attribute)
+        new_value.delete(key.to_s)
+        send("#{attribute}=", new_value)
+      end
+      self
+    end
+
+    # Deletes many keys in a record. E.g.
+    #   witt = Person.find_by_name("Ludwig Wittgenstein")
+    #   witt.destroy_keys!(:info, :father, :mother)
+    # It does save the record.
+    def destroy_keys! attribute, *keys
+      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
+      destroy_keys(attribute, *keys).save
+    end
+
+    # This method is replaced for Rails 3 compatibility.
+    # All I do is add the condition when the field is a hash that converts the value
+    # to hstore format.
+    # IMHO this should be delegated to the column, so it won't be necessary to rewrite all
+    # this method.
+    def arel_attributes_values(include_primary_key = true, include_readonly_attributes = true, attribute_names = @attributes.keys)
+      attrs = {}
+      attribute_names.each do |name|
+        if (column = column_for_attribute(name)) && (include_primary_key || !column.primary)
+          if include_readonly_attributes || (!include_readonly_attributes && !self.class.readonly_attributes.include?(name))
+            value = read_attribute(name)
+            if self.class.columns_hash[name].type == :hstore && value && value.is_a?(Hash)
+              value = value.to_hstore # Done!
+            elsif value && self.class.serialized_attributes.has_key?(name) && (value.acts_like?(:date) || value.acts_like?(:time) || value.is_a?(Hash) || value.is_a?(Array))
+              value = value.to_yaml
+            end
+            attrs[self.class.arel_table[name]] = value
+          end
+        end
+      end
+      attrs
+    end
+
+  end
+
+  # This erro class is used when the user passes a wrong value to a hstore column.
+  # Hstore columns accepts hashes or hstore valid strings. It is validated with
+  # String#valid_hstore? method.
+  class HstoreTypeMismatch < ActiveRecord::ActiveRecordError
+  end
+
+  module ConnectionAdapters
+
+    class TableDefinition
+
+      # Adds hstore type for migrations. So you can add columns to a table like:
+      #   create_table :people do |t|
+      #     ...
+      #     t.hstore :info
+      #     ...
+      #   end
+      def hstore(*args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each { |name| column(name, 'hstore', options) }
+      end
+
+    end
+
+    class PostgreSQLColumn < Column
+      # Does the type casting from hstore columns using String#from_hstore or Hash#from_hstore.
+      def type_cast_code_with_hstore(var_name)
+        type == :hstore ? "#{var_name}.from_hstore" : type_cast_code_without_hstore(var_name)
+      end
+
+      # Adds the hstore type for the column.
+      def simplified_type_with_hstore(field_type)
+        field_type == 'hstore' ? :hstore : simplified_type_without_hstore(field_type)
+      end
+    
+      alias_method_chain :type_cast_code, :hstore
+      alias_method_chain :simplified_type, :hstore
+    end
+
+    class PostgreSQLAdapter < AbstractAdapter
+      def native_database_types_with_hstore
+        native_database_types_without_hstore.merge({:hstore => { :name => "hstore" }})
+      end
+
+      # Quotes correctly a hstore column value.
+      def quote_with_hstore(value, column = nil)
+        if value && column && column.sql_type == 'hstore'
+          raise HstoreTypeMismatch, "#{column.name} must have a Hash or a valid hstore value (#{value})" unless value.kind_of?(Hash) || value.valid_hstore?          
+          return quote_without_hstore(value.to_hstore, column)
+        end
+        quote_without_hstore(value,column)
+      end
+      
+      alias_method_chain :quote, :hstore
+      alias_method_chain :native_database_types, :hstore 
+    end
+  end
+end

data/lib/padrino-hstore/hash.rb

@@ -0,0 +1,29 @@
+class Hash
+
+  # Generates an hstore string format. This is the format used
+  # to insert or update stuff in the database.
+  def to_hstore
+    return "" if empty?
+
+    map { |idx, val| 
+      iv = [idx,val].map { |_| 
+        e = _.to_s.gsub(/"/, '\"')
+        if _.nil?
+          'NULL'
+        elsif e =~ /[,\s=>]/ || e.blank?
+          '"%s"' % e
+        else
+          e
+        end
+      }
+
+      "%s=>%s" % iv
+    } * ","
+  end
+
+  # If the method from_hstore is called in a Hash, it just returns self.
+  def from_hstore
+    self
+  end
+
+end

data/lib/padrino-hstore/string.rb

@@ -0,0 +1,43 @@
+class String
+
+  # If the value os a column is already a String and it calls to_hstore, it
+  # just returns self. Validation occurs afterwards.
+  def to_hstore
+    self
+  end
+
+  # Validates the hstore format. Valid formats are:
+  # * An empty string
+  # * A string like %("foo"=>"bar"). I'll call it a "double quoted hstore format".
+  # * A string like %(foo=>bar). Postgres doesn't emit this but it does accept it as input, we should accept any input Postgres does
+
+  def valid_hstore?
+    pair = hstore_pair
+    !!match(/^\s*(#{pair}\s*(,\s*#{pair})*)?\s*$/)
+  end
+
+  # Creates a hash from a valid double quoted hstore format, 'cause this is the format
+  # that postgresql spits out.
+  def from_hstore
+    token_pairs = (scan(hstore_pair)).map { |k,v| [k,v =~ /^NULL$/i ? nil : v] }
+    token_pairs = token_pairs.map { |k,v|
+      [k,v].map { |t| 
+        case t
+        when nil then t
+        when /^"(.*)"$/ then $1.gsub(/\\(.)/, '\1')
+        else t.gsub(/\\(.)/, '\1')
+        end
+      }
+    }
+    Hash[ token_pairs ]
+  end
+
+  private
+
+  def hstore_pair
+    quoted_string = /"[^"\\]*(?:\\.[^"\\]*)*"/
+    unquoted_string = /[^\s=,][^\s=,\\]*(?:\\.[^\s=,\\]*|=[^,>])*/
+    string = /(#{quoted_string}|#{unquoted_string})/
+    /#{string}\s*=>\s*#{string}/
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: padrino-hstore
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Cory Buecker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - <
+      - !ruby/object:Gem::Version
+        version: '4'
+description: This gem adds support for hstore to Activerecord (< version 4) on the
+  Padrino framework. It is based on the excellent work from https://github.com/softa/activerecord-postgres-hstore.
+email: email@corybuecker.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+files:
+- lib/padrino-hstore.rb
+- lib/padrino-hstore/activerecord.rb
+- lib/padrino-hstore/string.rb
+- lib/padrino-hstore/hash.rb
+- LICENSE.md
+- README.md
+homepage: https://github.com/thegreyjoy/padrino-hstore
+licenses:
+- MIT
+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.24
+signing_key: 
+specification_version: 3
+summary: This gem adds support for hstore to Activerecord (< version 4) on the Padrino
+  framework.
+test_files: []
+has_rdoc: