surus 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/surus/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Jack Christensen
+
+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,35 @@
+Surus
+=====
+
+# Description
+
+Surus extends ActiveRecord with PostgreSQL specific functionality. At the
+moment this is limited to hstore.
+
+# Installation
+
+    gem install surus
+
+# Hstore
+
+Hashes can be serialized to an hstore column.
+
+    class User < ActiveRecord::Base
+      serialize :properties, Hstore::Serializer.new
+    end
+    
+Even though the underlying hstore can only use strings for keys and values
+(and NULL for values) Surus can successfully maintain type for integers,
+floats, bigdecimals, and dates. It does this by storing an extra key
+value pair (or two) to maintain type information.
+
+Hstores can be searched with helper scopes.
+
+    User.hstore_has_pairs(:properties, "favorite_color" => "green")
+    User.hstore_has_key(:properties, "favorite_color")
+    User.hstore_has_all_keys(:properties, "favorite_color", "gender")
+    User.hstore_has_any_keys(:properties, "favorite_color", "favorite_artist")
+
+# License
+
+MIT

data/Rakefile

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

data/lib/surus/hstore/scope.rb

@@ -0,0 +1,21 @@
+module Hstore
+  module Scope
+    def hstore_has_pairs(column, hash)
+      where("#{connection.quote_column_name(column)} @> ?", Serializer.new.dump(hash))
+    end
+    
+    def hstore_has_key(column, key)
+      where("#{connection.quote_column_name(column)} ? :key", :key => key)    
+    end
+    
+    def hstore_has_all_keys(column, *keys)
+      where("#{connection.quote_column_name(column)} ?& ARRAY[:keys]", :keys => keys.flatten)
+    end
+    
+    def hstore_has_any_keys(column, *keys)
+      where("#{connection.quote_column_name(column)} ?| ARRAY[:keys]", :keys => keys.flatten)
+    end
+  end
+end
+
+ActiveRecord::Base.extend Hstore::Scope

data/lib/surus/hstore/serializer.rb

@@ -0,0 +1,140 @@
+module Hstore
+  class Serializer
+    KEY_VALUE_REGEX = %r{
+      "
+      ((?:[^"\\]|\\.)*)
+      "
+      =>
+      (
+        "
+        (?:[^"\\]|\\.)*
+        "
+        |(NULL)
+      )
+    }x
+
+    def load(string)
+      return unless string
+      stringified_hash = string.scan(KEY_VALUE_REGEX).each_with_object({}) do |key_value, hash|
+        key, value = key_value
+        key = unescape(key)
+        value = if value == "NULL"
+          nil
+        else
+          unescape(value[1..-2])
+        end
+        
+        hash[key] = value
+      end
+
+      key_types = stringified_hash.delete "__key_types"
+      key_types = YAML.load key_types if key_types
+      value_types = stringified_hash.delete "__value_types"
+      value_types = YAML.load value_types if value_types
+      
+      return stringified_hash unless key_types || value_types
+      
+      stringified_hash.each_with_object({}) do |key_value, hash|
+        string_key, string_value = key_value
+        
+        key = if key_types && key_types.key?(string_key) 
+          typecast(string_key, key_types[string_key])
+        else
+          string_key
+        end
+        
+        value = if value_types && value_types.key?(string_key)
+          typecast(string_value, value_types[string_key])
+        else
+          string_value
+        end
+        
+        hash[key] = value
+      end    
+    end
+    
+    def dump(hash)
+      return unless hash
+      
+      key_types = {}
+      value_types = {}
+      
+      stringified_hash = hash.each_with_object({}) do |key_value, stringified_hash|
+        key_string, key_type = stringify(key_value[0])
+        value_string, value_type = stringify(key_value[1])
+        
+        stringified_hash[key_string] = value_string
+        
+        key_types[key_string] = key_type unless key_type == "String"
+        value_types[key_string] = value_type unless value_type == "String"
+      end
+
+      # Use YAML for recording types as it is much simpler than trying to
+      # handle all the special characters that could be in a key or value
+      # and encoding them again to fit into one string. Let YAML handle all
+      # the mess for us.
+      stringified_hash["__key_types"] = YAML.dump(key_types) if key_types.present?
+      stringified_hash["__value_types"] = YAML.dump(value_types) if value_types.present?
+      
+      stringified_hash.map do |key, value|
+        "#{format_key(key)}=>#{format_value(value)}"
+      end.join(", ")
+    end
+    
+    def format_key(key)
+      %Q("#{escape(key)}")
+    end
+    
+    def format_value(value)
+      value ? %Q("#{escape(value)}") : "NULL"
+    end
+    
+    # Escape a value for use as a key or value in an hstore
+    def escape(value)
+      value
+        .gsub('\\', '\\\\\\')
+        .gsub('"', '\\"')
+    end
+    
+    # Unescape a value from a key or value in an hstore
+    def unescape(value)
+      value
+        .gsub('\\\\', '\\')
+        .gsub('\\"', '"')
+    end
+    
+    # Returns an array of value as a string and value type
+    def stringify(value)
+      if value.kind_of?(String)
+        [value, "String"]
+      elsif value.kind_of?(Integer)
+        [value.to_s, "Integer"]
+      elsif value.kind_of?(Float)
+        [value.to_s, "Float"]
+      elsif value.kind_of?(BigDecimal)
+        [value.to_s, "BigDecimal"]
+      elsif value.kind_of?(Date)
+        [value.to_s(:db), "Date"]
+      elsif value == nil
+        [nil, "String"] # we don't actually stringify nil because format_value special cases nil
+      else
+        [value.to_s, "String"] # coerce to string as we don't know how to reconstitue an unknown class
+      end  
+    end
+    
+    def typecast(value, type)
+      case type
+      when "Integer"
+        Integer(value)
+      when "Float"
+        Float(value)
+      when "BigDecimal"
+        BigDecimal(value)
+      when "Date"
+        Date.parse(value)
+      else
+        raise ArgumentError, "Can't typecast: #{type}"
+      end
+    end
+  end
+end  

data/lib/surus/version.rb

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

data/lib/surus.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require 'surus/version'
+require 'surus/hstore/serializer'
+require 'surus/hstore/scope'

data/spec/database.yml

@@ -0,0 +1,4 @@
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: ar_pg_test

data/spec/database_structure.sql

@@ -0,0 +1,9 @@
+CREATE EXTENSION IF NOT EXISTS hstore;
+
+DROP TABLE IF EXISTS hstore_records;
+
+CREATE TABLE hstore_records(
+  id serial PRIMARY KEY,
+  properties hstore
+);
+

data/spec/hstore/scope_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Hstore::Scope do
+  let!(:empty) { HstoreRecord.create! :properties => {} }
+
+  context "hstore_has_pairs" do
+    let!(:match) { HstoreRecord.create! :properties => { "a" => "1", "b" => "2", "c" => "3" } }
+    let!(:missing_key) { HstoreRecord.create! :properties => { "a" => "1", "c" => "3" } }
+    let!(:wrong_value) { HstoreRecord.create! :properties => { "a" => "1", "b" => "5" } }
+    
+    subject { HstoreRecord.hstore_has_pairs(:properties, "a" => "1", "b" => "2").all }
+    
+    it { should include(match) }
+    it { should_not include(missing_key) }
+    it { should_not include(wrong_value) }
+    it { should_not include(empty) }
+  end
+  
+  context "hstore_has_key" do
+    let!(:match) { HstoreRecord.create! :properties => { "a" => "1", "b" => "2" } }
+    let!(:missing_key) { HstoreRecord.create! :properties => { "a" => "1", "c" => "3" } }
+    
+    subject { HstoreRecord.hstore_has_key(:properties, "b").all }
+
+    it { should include(match) }
+    it { should_not include(missing_key) }
+    it { should_not include(empty) }
+  end
+  
+  context "hstore_has_all_keys" do
+    let!(:match) { HstoreRecord.create! :properties => { "a" => "1", "b" => "2", "c" => "3" } }
+    let!(:missing_one_key) { HstoreRecord.create! :properties => { "b" => "2", "c" => "3" } }
+    let!(:missing_all_keys) { HstoreRecord.create! :properties => { "f" => "1", "g" => "2" } }
+    
+    def self.shared_examples
+      it { should include(match) }
+      it { should_not include(missing_one_key) }
+      it { should_not include(missing_all_keys) }
+      it { should_not include(empty) }  
+    end
+    
+    context "with array of keys" do
+      subject { HstoreRecord.hstore_has_all_keys(:properties, ["a", "b"]).all }
+      shared_examples
+    end
+    
+    context "with multiple key arguments" do
+      subject { HstoreRecord.hstore_has_all_keys(:properties, "a", "b").all }
+      shared_examples
+    end
+  end
+  
+  context "hstore_has_any_key" do
+    let!(:match_1) { HstoreRecord.create! :properties => { "a" => "1", "c" => "3" } }
+    let!(:match_2) { HstoreRecord.create! :properties => { "b" => "2", "d" => "4" } }
+    let!(:missing_all_keys) { HstoreRecord.create! :properties => { "c" => "3", "d" => "4" } }
+    
+    def self.shared_examples
+      it { should include(match_1) }
+      it { should include(match_2) }
+      it { should_not include(missing_all_keys) }
+      it { should_not include(empty) }      
+      it { should_not include(empty) }      
+    end
+    
+    context "with array of keys" do
+      subject { HstoreRecord.hstore_has_any_keys(:properties, ["a", "b"]).all }
+      shared_examples
+    end
+    
+    context "with multiple key arguments" do
+      subject { HstoreRecord.hstore_has_any_keys(:properties, "a", "b").all }
+      shared_examples
+    end
+  end
+end

data/spec/hstore/serializer_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Hstore::Serializer do
+  round_trip_examples = [
+    [nil, "nil"],
+    [{}, "empty hash"],
+    [{"foo" => "bar"}, "single key/value pair"],
+    [{"foo" => "bar", "baz" => "quz"}, "multiple key/value pairs"],
+    [{"foo" => nil}, "value is nil"],
+  ]
+  
+  [
+    ['"', 'double quote (")'],
+    ["'", "single quote (')"],
+    ["\\", "backslash (\\)"],
+    ["\\", "multiple backslashes (\\)"],
+    ["=>", "separator (=>)"],
+    [" ", "space"],
+    [%q~\ / / \\ => " ' " '~, "multiple special characters"]
+  ].each do |value, description|
+    round_trip_examples << [{"#{value}foo" => "bar"}, "key with #{description} at beginning"]
+    round_trip_examples << [{"foo#{value}foo" => "bar"}, "key with #{description} in middle"]
+    round_trip_examples << [{"foo#{value}" => "bar"}, "key with #{description} at end"]
+    round_trip_examples << [{value => "bar"}, "key is #{description}"]
+    
+    round_trip_examples << [{"foo" => "#{value}bar"}, "value with #{description} at beginning"]
+    round_trip_examples << [{"foo" => "bar#{value}bar"}, "value with #{description} in middle"]
+    round_trip_examples << [{"foo" => "bar#{value}"}, "value with #{description} at end"]
+    round_trip_examples << [{"foo" => value}, "value is #{description}"]
+  end
+  
+  [
+    [0, "integer 0"],
+    [1, "positive integer"],
+    [-1, "negative integer"],
+    [1_000_000_000_000_000_000_000, "huge positive integer"],
+    [-1_000_000_000_000_000_000_000, "huge negative integer"],
+    [0.0, "float 0.0"],
+    [-0.0, "float -0.0"],
+    [1.5, "positive float"],
+    [-1.5, "negative float"],
+    [Float::MAX, "maximum float"],
+    [Float::MIN, "minimum float"],
+    [BigDecimal("0"), "BigDecimal 0"],
+    [BigDecimal("1"), "positive BigDecimal"],
+    [BigDecimal("-1"), "negative BigDecimal"],
+    [Date.today, "date"]
+  ].each do |value, description|
+    round_trip_examples << [{"foo" => value}, "value is #{description}"]
+    round_trip_examples << [{value => "bar"}, "key is #{description}"]
+    round_trip_examples << [{value => value}, "key and value are each #{description}"]
+  end
+  
+  round_trip_examples.each do |value, description|
+    it "round trips when #{description}" do
+      r = HstoreRecord.create! :properties => value
+      r.reload
+      r.properties.should == value
+    end  
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'surus'
+require 'yaml'
+
+require 'rspec'
+
+database_config = YAML.load_file(File.expand_path("../database.yml", __FILE__))
+ActiveRecord::Base.establish_connection database_config["test"]
+
+
+class HstoreRecord < ActiveRecord::Base
+  serialize :properties, Hstore::Serializer.new
+end
+
+
+
+RSpec.configure do |config|
+  config.around do |example|
+    ActiveRecord::Base.transaction do
+      example.call
+      raise ActiveRecord::Rollback
+    end
+  end
+end
+

data/surus.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "surus/version"
+
+Gem::Specification.new do |s|
+  s.name        = "surus"
+  s.version     = Surus::VERSION
+  s.authors     = ["Jack Christensen"]
+  s.email       = ["jack@jackchristensen.com"]
+  s.homepage    = "https://github.com/JackC/surus"
+  s.summary     = %q{PostgreSQL extensions for ActiveRecord}
+  s.description = %q{PostgreSQL extensions for ActiveRecord}
+
+  s.rubyforge_project = ""
+
+  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"]
+
+  # specify any dependencies here; for example:
+  s.add_dependency 'pg'
+  s.add_dependency 'activerecord', ">= 3.1.0"
+  
+  s.add_development_dependency 'rspec', "~> 2.8.0"
+  s.add_development_dependency 'guard', ">= 0.10.0"
+  s.add_development_dependency 'guard-rspec', ">= 0.6.0"  
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: surus
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jack Christensen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: &10920640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *10920640
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &10916840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *10916840
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &10930900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *10930900
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &10927660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :development
+  prerelease: false
+  version_requirements: *10927660
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &10943960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *10943960
+description: PostgreSQL extensions for ActiveRecord
+email:
+- jack@jackchristensen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/surus.rb
+- lib/surus/hstore/scope.rb
+- lib/surus/hstore/serializer.rb
+- lib/surus/version.rb
+- spec/database.yml
+- spec/database_structure.sql
+- spec/hstore/scope_spec.rb
+- spec/hstore/serializer_spec.rb
+- spec/spec_helper.rb
+- surus.gemspec
+homepage: https://github.com/JackC/surus
+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: ''
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: PostgreSQL extensions for ActiveRecord
+test_files: []