surus 0.0.1 → 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 0.1.0 (February 2, 2012)
+
+* Added array serializers
+* Added array scope helpers
+* Moved everything into Surus namespace
+* Add true and false to types that are successfully round-tripped as hstore keys and values
+* Changed default test database name to surus_test
+
+# 0.0.1 (January 31, 2012)
+
+* Initial release

data/README.md

@@ -3,19 +3,23 @@ Surus
 
 # Description
 
-Surus extends ActiveRecord with PostgreSQL specific functionality. At the
-moment this is limited to hstore.
+Surus extends ActiveRecord with PostgreSQL specific functionality. It includes
+hstore and array serializers and helper scopes.
 
 # Installation
 
     gem install surus
+    
+    or add to your Gemfile
+    
+    gem 'surus'
 
 # Hstore
 
 Hashes can be serialized to an hstore column.
 
     class User < ActiveRecord::Base
-      serialize :properties, Hstore::Serializer.new
+      serialize :properties, Surus::Hstore::Serializer.new
     end
     
 Even though the underlying hstore can only use strings for keys and values
@@ -29,6 +33,24 @@ Hstores can be searched with helper scopes.
     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")
+    
+# Array
+
+Ruby arrays can be serialized to PostgreSQL arrays. Surus includes support
+for text, integer, float, and decimal arrays.
+
+    class User < ActiveRecord::Base
+      serialize :permissions, Surus::Array::TextSerializer.new
+      serialize :favorite_integers, Surus::Array::IntegerSerializer.new
+      serialize :favorite_floats, Surus::Array::FloatSerializer.new
+      serialize :favorite_decimals, Surus::Array::DecimalSerializer.new
+    end
+    
+Arrays can be searched with helper scopes.
+
+    User.array_has(:permissions, "admin")
+    User.array_has(:permissions, "manage_accounts", "manage_users")
+    User.array_has_any(:favorite_integers, 7, 11, 42)
 
 # License
 

data/lib/surus.rb

@@ -2,3 +2,8 @@ require 'active_record'
 require 'surus/version'
 require 'surus/hstore/serializer'
 require 'surus/hstore/scope'
+require 'surus/array/text_serializer'
+require 'surus/array/integer_serializer'
+require 'surus/array/float_serializer'
+require 'surus/array/decimal_serializer'
+require 'surus/array/scope'

data/lib/surus/array/decimal_serializer.rb

@@ -0,0 +1,28 @@
+module Surus
+  module Array
+    class DecimalSerializer
+      ARRAY_REGEX = %r{
+        (?<=[\{,])                 (?# All elements are prefixed with either the opening brace or a comma)
+        \-?\d+\.?\d*
+        |
+        NULL
+      }x
+
+      def load(string)
+        return unless string
+        string.scan(ARRAY_REGEX).map do |match|
+          match == "NULL" ? nil : BigDecimal(match)
+        end
+      end
+      
+      def dump(array)
+        return unless array
+        '{' + array.map { |s| format(s) }.join(",") + '}'
+      end
+      
+      def format(value)
+        value == nil ? "NULL" : value
+      end
+    end
+  end  
+end

data/lib/surus/array/float_serializer.rb

@@ -0,0 +1,28 @@
+module Surus
+  module Array
+    class FloatSerializer
+      ARRAY_REGEX = %r{
+        (?<=[\{,])                 (?# All elements are prefixed with either the opening brace or a comma)
+        \-?\d+(?:\.\d+)?(?:e[+-])?\d*
+        |
+        NULL
+      }x
+
+      def load(string)
+        return unless string
+        string.scan(ARRAY_REGEX).map do |match|
+          match == "NULL" ? nil : Float(match)
+        end
+      end
+      
+      def dump(array)
+        return unless array
+        '{' + array.map { |s| format(s) }.join(",") + '}'
+      end
+      
+      def format(value)
+        value == nil ? "NULL" : value
+      end
+    end
+  end  
+end

data/lib/surus/array/integer_serializer.rb

@@ -0,0 +1,28 @@
+module Surus
+  module Array
+    class IntegerSerializer
+      ARRAY_REGEX = %r{
+        (?<=[\{,])                 (?# All elements are prefixed with either the opening brace or a comma)
+        \-?\d+
+        |
+        NULL
+      }x
+
+      def load(string)
+        return unless string
+        string.scan(ARRAY_REGEX).map do |match|
+          match == "NULL" ? nil : Integer(match)
+        end
+      end
+      
+      def dump(array)
+        return unless array
+        '{' + array.map { |s| format(s) }.join(",") + '}'
+      end
+      
+      def format(value)
+        value == nil ? "NULL" : value
+      end
+    end
+  end  
+end

data/lib/surus/array/scope.rb

@@ -0,0 +1,15 @@
+module Surus
+  module Array
+    module Scope
+      def array_has(column, *values)
+        where("#{connection.quote_column_name(column)} @> ARRAY[?]", values.flatten)
+      end
+      
+      def array_has_any(column, *values)
+        where("#{connection.quote_column_name(column)} && ARRAY[?]", values.flatten)    
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend Surus::Array::Scope

data/lib/surus/array/text_serializer.rb

@@ -0,0 +1,47 @@
+module Surus
+  module Array
+    class TextSerializer
+      ARRAY_REGEX = %r{
+        [{,]                 (?# All elements are prefixed with either the opening brace or a comma)
+        (?:
+          "
+          (?<quoted_string>(?:[^"\\]|\\.)*)
+          "
+          |
+          (?<null>NULL)
+          |
+          (?<unquoted_string>[^,}]+)
+        )
+      }x
+
+      def load(string)
+        return unless string
+        string.scan(ARRAY_REGEX).map do |quoted_string, null, unquoted_string|
+          element = quoted_string || unquoted_string
+          element ? unescape(element) : nil
+        end
+      end
+      
+      def dump(array)
+        return unless array
+        '{' + array.map { |s| format(s) }.join(",") + '}'
+      end
+      
+      def format(value)
+        value == nil ? "NULL" : '"' + escape(value) + '"'
+      end
+      
+      def escape(value)
+        value
+          .gsub('\\', '\\\\\\')
+          .gsub('"', '\\"')
+      end
+
+      def unescape(value)
+        value
+          .gsub('\\\\', '\\')
+          .gsub('\\"', '"')
+      end      
+    end
+  end  
+end

data/lib/surus/hstore/scope.rb

@@ -1,21 +1,23 @@
-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)
+module Surus
+  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
 end
 
-ActiveRecord::Base.extend Hstore::Scope
+ActiveRecord::Base.extend Surus::Hstore::Scope

data/lib/surus/hstore/serializer.rb

@@ -1,140 +1,150 @@
-module Hstore
-  class Serializer
-    KEY_VALUE_REGEX = %r{
-      "
-      ((?:[^"\\]|\\.)*)
-      "
-      =>
-      (
+module Surus
+  module Hstore
+    class Serializer
+      KEY_VALUE_REGEX = %r{
         "
-        (?:[^"\\]|\\.)*
+        ((?:[^"\\]|\\.)*)
         "
-        |(NULL)
-      )
-    }x
+        =>
+        (
+          "
+          (?:[^"\\]|\\.)*
+          "
+          |(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])
+      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
         
-        hash[key] = value
+        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
-
-      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
+      def dump(hash)
+        return unless hash
         
-        key = if key_types && key_types.key?(string_key) 
-          typecast(string_key, key_types[string_key])
-        else
-          string_key
-        end
+        key_types = {}
+        value_types = {}
         
-        value = if value_types && value_types.key?(string_key)
-          typecast(string_value, value_types[string_key])
-        else
-          string_value
+        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?
         
-        hash[key] = value
-      end    
-    end
-    
-    def dump(hash)
-      return unless hash
+        stringified_hash.map do |key, value|
+          "#{format_key(key)}=>#{format_value(value)}"
+        end.join(", ")
+      end
       
-      key_types = {}
-      value_types = {}
+      def format_key(key)
+        %Q("#{escape(key)}")
+      end
       
-      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"
+      def format_value(value)
+        value ? %Q("#{escape(value)}") : "NULL"
       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}"
+      # 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.kind_of?(TrueClass)
+          [value.to_s, "TrueClass"]
+        elsif value.kind_of?(FalseClass)
+          [value.to_s, "FalseClass"]
+        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)
+        when "TrueClass"
+          true
+        when "FalseClass"
+          false
+        else
+          raise ArgumentError, "Can't typecast: #{type}"
+        end
       end
     end
-  end
-end  
+  end  
+end

data/lib/surus/version.rb

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

data/spec/array/decimal_serializer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Surus::Array::DecimalSerializer do
+  round_trip_examples = [
+    [nil, "nil"],
+    [[], "empty array"],
+    [[BigDecimal("0.0")], "single element"],
+    [[BigDecimal("1.0"), BigDecimal("2.0")], "multiple elements"],
+    [[BigDecimal("-1.0"), BigDecimal("-2.0")], "negative element"],
+    [[BigDecimal("1232493289348929843.323422349274382923")], "high magnitude element"], 
+    [[BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("2.0")], "duplicated elements"],
+    [[BigDecimal("1.0"), nil], "an element is nil"],
+    [(10_000.times.map { |n| n * BigDecimal("1.13312") }).to_a, "huge array"]
+  ]
+  
+  round_trip_examples.each do |value, description|
+    it "round trips when #{description}" do
+      r = DecimalArrayRecord.create! :decimals => value
+      r.reload
+      r.decimals.should == value
+    end    
+  end
+end

data/spec/array/float_serializer_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Surus::Array::FloatSerializer do
+  round_trip_examples = [
+    [nil, "nil"],
+    [[], "empty array"],
+    [[0.0], "single element"],
+    [[1.0, 2.0], "multiple elements"],
+    [[-1.0, -2.0], "negative element"],
+    [[4.4325349e+45, 1.2324323e+77, 1.1242342e-57, 3e99], "high magnitude elements"], 
+    [[1.0, 2.0, 2.0, 2.0], "duplicated elements"],
+    [[1.0, nil], "an element is nil"],
+    [(10_000.times.map { |n| n * 1.0 }).to_a, "huge array"]
+  ]
+  
+  round_trip_examples.each do |value, description|
+    it "round trips when #{description}" do
+      r = FloatArrayRecord.create! :floats => value
+      r.reload
+      r.floats.should == value
+    end    
+  end
+end

data/spec/array/integer_serializer_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Surus::Array::IntegerSerializer do
+  round_trip_examples = [
+    [nil, "nil"],
+    [[], "empty array"],
+    [[0], "single element"],
+    [[1, 2], "multiple elements"],
+    [[-1, -2], "negative element"],
+    [[1, 2, 2, 2], "duplicated elements"],
+    [[1, nil], "an element is nil"],
+    [(1..10_000).to_a, "huge array"]
+  ]
+  
+  round_trip_examples.each do |value, description|
+    it "round trips when #{description}" do
+      r = IntegerArrayRecord.create! :integers => value
+      r.reload
+      r.integers.should == value
+    end    
+  end
+end

data/spec/array/scope_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Surus::Array::Scope do
+  let!(:empty) { TextArrayRecord.create! :texts => [] }
+
+  context "array_has" do
+    let!(:match) { TextArrayRecord.create! :texts => %w{a b} }
+    let!(:missing_element) { TextArrayRecord.create! :texts => %w{a} }
+    
+    def self.shared_examples
+      it { should include(match) }
+      it { should_not include(missing_element) }
+      it { should_not include(empty) }
+    end
+    
+    context "with one element" do
+      subject { TextArrayRecord.array_has(:texts, "b").all }
+      shared_examples
+    end
+    
+    context "with array of elements" do
+      subject { TextArrayRecord.array_has(:texts, ["a", "b"]).all }
+      shared_examples
+    end
+    
+    context "with multiple elements" do
+      subject { TextArrayRecord.array_has(:texts, "a", "b").all }
+      shared_examples
+    end
+  end
+  
+  context "array_has_any" do
+    let!(:match) { TextArrayRecord.create! :texts => %w{a b} }
+    let!(:missing_element) { TextArrayRecord.create! :texts => %w{a} }
+    
+    def self.shared_examples
+      it { should include(match) }
+      it { should_not include(missing_element) }
+      it { should_not include(empty) }
+    end
+    
+    context "with one element" do
+      subject { TextArrayRecord.array_has_any(:texts, "b").all }
+      shared_examples
+    end
+    
+    context "with array of elements" do
+      subject { TextArrayRecord.array_has_any(:texts, ["b", "c"]).all }
+      shared_examples
+    end
+    
+    context "with multiple elements" do
+      subject { TextArrayRecord.array_has_any(:texts, "b", "c").all }
+      shared_examples
+    end
+  end  
+end

data/spec/array/text_serializer_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Surus::Array::TextSerializer do
+  round_trip_examples = [
+    [nil, "nil"],
+    [[], "empty array"],
+    [["foo"], "single element"],
+    [["foo", "bar"], "multiple elements"],
+    [["foo", "bar", "bar", "bar"], "duplicated elements"],
+    [["foo bar", nil], "an element is nil"],
+    [["foo bar", 'NULL'], "an element is the string 'NULL'"],
+    [["foo bar", "baz"], "an element has a space"],
+    [["foo,bar", "baz"], "an element has a comma (,)"],
+    [["foo'bar", "baz"], "an element has a single quote (')"],
+    [['foo"bar', "baz"], "an element has a double quote (\")"],
+    [['foo\\bar', "baz"], "an element has a backslash (\\)"],
+    [['foo{}bar', "{baz}"], "an element has a braces ({})"],
+    [[%q~foo \\ / " ; ' ( ) {}bar \\'~, "bar"], "an element many special characters"],
+    [("aaa".."zzz").to_a, "huge array"]
+  ]
+  
+  round_trip_examples.each do |value, description|
+    it "round trips when #{description}" do
+      r = TextArrayRecord.create! :texts => value
+      r.reload
+      r.texts.should == value
+    end    
+  end
+end

data/spec/database.yml

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

data/spec/database_structure.sql

@@ -7,3 +7,38 @@ CREATE TABLE hstore_records(
   properties hstore
 );
 
+
+
+DROP TABLE IF EXISTS text_array_records;
+
+CREATE TABLE text_array_records(
+  id serial PRIMARY KEY,
+  texts text[]
+);
+
+
+
+DROP TABLE IF EXISTS integer_array_records;
+
+CREATE TABLE integer_array_records(
+  id serial PRIMARY KEY,
+  integers integer[]
+);
+
+
+
+DROP TABLE IF EXISTS float_array_records;
+
+CREATE TABLE float_array_records(
+  id serial PRIMARY KEY,
+  floats float[]
+);
+
+
+
+DROP TABLE IF EXISTS float_array_records;
+
+CREATE TABLE decimal_array_records(
+  id serial PRIMARY KEY,
+  decimals decimal[]
+);

data/spec/hstore/scope_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hstore::Scope do
+describe Surus::Hstore::Scope do
   let!(:empty) { HstoreRecord.create! :properties => {} }
 
   context "hstore_has_pairs" do

data/spec/hstore/serializer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hstore::Serializer do
+describe Surus::Hstore::Serializer do
   round_trip_examples = [
     [nil, "nil"],
     [{}, "empty hash"],
@@ -44,6 +44,8 @@ describe Hstore::Serializer do
     [BigDecimal("0"), "BigDecimal 0"],
     [BigDecimal("1"), "positive BigDecimal"],
     [BigDecimal("-1"), "negative BigDecimal"],
+    [true, "true"],
+    [false, "false"],
     [Date.today, "date"]
   ].each do |value, description|
     round_trip_examples << [{"foo" => value}, "value is #{description}"]

data/spec/spec_helper.rb

@@ -7,8 +7,25 @@ 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
+  serialize :properties, Surus::Hstore::Serializer.new
+end
+
+class TextArrayRecord < ActiveRecord::Base
+  serialize :texts, Surus::Array::TextSerializer.new
+end
+
+class IntegerArrayRecord < ActiveRecord::Base
+  serialize :integers, Surus::Array::IntegerSerializer.new
+end
+
+class FloatArrayRecord < ActiveRecord::Base
+  serialize :floats, Surus::Array::FloatSerializer.new
+end
+
+class DecimalArrayRecord < ActiveRecord::Base
+  serialize :decimals, Surus::Array::DecimalSerializer.new
 end
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: surus
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-01 00:00:00.000000000 Z
+date: 2012-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &10920640 !ruby/object:Gem::Requirement
+  requirement: &17079080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *10920640
+  version_requirements: *17079080
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &10916840 !ruby/object:Gem::Requirement
+  requirement: &17091280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: 3.1.0
   type: :runtime
   prerelease: false
-  version_requirements: *10916840
+  version_requirements: *17091280
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &10930900 !ruby/object:Gem::Requirement
+  requirement: &17089120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *10930900
+  version_requirements: *17089120
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &10927660 !ruby/object:Gem::Requirement
+  requirement: &17086120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: 0.10.0
   type: :development
   prerelease: false
-  version_requirements: *10927660
+  version_requirements: *17086120
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &10943960 !ruby/object:Gem::Requirement
+  requirement: &17102600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,7 @@ dependencies:
         version: 0.6.0
   type: :development
   prerelease: false
-  version_requirements: *10943960
+  version_requirements: *17102600
 description: PostgreSQL extensions for ActiveRecord
 email:
 - jack@jackchristensen.com
@@ -75,15 +75,26 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/surus.rb
+- lib/surus/array/decimal_serializer.rb
+- lib/surus/array/float_serializer.rb
+- lib/surus/array/integer_serializer.rb
+- lib/surus/array/scope.rb
+- lib/surus/array/text_serializer.rb
 - lib/surus/hstore/scope.rb
 - lib/surus/hstore/serializer.rb
 - lib/surus/version.rb
+- spec/array/decimal_serializer_spec.rb
+- spec/array/float_serializer_spec.rb
+- spec/array/integer_serializer_spec.rb
+- spec/array/scope_spec.rb
+- spec/array/text_serializer_spec.rb
 - spec/database.yml
 - spec/database_structure.sql
 - spec/hstore/scope_spec.rb