typed_fields 0.0.1

data/.gitignore

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,80 @@
+# Typed Fields
+
+## Introduction
+Using ActiveRecord to implement domain objects causes a lot of grief. Often it's just impossible as there is no table that you map your domain objects to. 
+
+ActiveModel is a big step forward and I highly recommend using it. It does a pretty good job doing what AR used to do but without coupling your domain objects to the database. One of a few things I miss though is typed fields. ActiveRecord takes care of all type conversations. You just pass a bunch of strings and it knows what to do with them. You need to do it manually if you use ActiveModel.
+
+That's where the TypedFields gem comes into play. It allows you to specify types for your fields which eases the migration from ActiveRecord to ActiveModel.
+
+
+## How to use TypedFields
+```ruby
+class Person
+  include TypedFields
+
+  string :first_name, :last_name
+  integer :age
+  decimal :income
+
+  def initialize params
+    initialize_fields params
+  end
+end
+```
+
+As you can see from the example above including TypedFields adds several class methods (such as string, integer) and an instance method initializing fields.
+
+## Advanced Features
+
+### Using Custom Types
+Besides having such basic types as integers, decimals, strings and booleans you can specify custom types. 
+
+```ruby
+module UppercaseString
+  def self.parse str
+    str.upcase
+  end
+end
+
+class Person
+  include TypedFields
+  custom :name, type: UppercaseString
+end
+
+p = Person.new
+p.initialize_fields name: "abc" # @name == ABC
+```
+
+### Arrays
+```ruby
+class Service
+  include TypedFields
+  array_of_integers :object_ids
+end
+
+s = Service.new
+s.initialize_fields object_ids => ["1", "2"] # @object_ids == [1,2]
+```
+  
+### Default Values
+```ruby
+class Person
+  include TypedFields
+  string :name
+  integer :age, default: 100
+end
+
+p = Person.new
+p.initialize_fields name: "John" #@name == "John", @age == 100
+```
+
+### Using Proc as a Default Value
+```ruby
+class Person
+  include TypedFields
+  string :name, default: Proc.new{"default value"}
+end
+
+p = Person.new
+p.initialize_fields({}) #@name == "default_value"

data/Rakefile

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

data/lib/typed_fields/version.rb

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

data/lib/typed_fields.rb

@@ -0,0 +1,119 @@
+require "typed_fields/version"
+require 'bigdecimal'
+
+module TypedFields
+  class ObjectType
+    def parse obj
+      obj
+    end
+  end
+  
+  class IntegerType
+    def parse obj
+      return nil if obj.nil?
+      obj.to_i
+    end
+  end
+
+  class DecimalType
+    def parse obj
+      return nil if obj.nil?
+      BigDecimal.new(obj)
+    end
+  end
+
+  class StringType
+    def parse obj
+      return nil if obj.nil?
+      obj.to_s
+    end
+  end
+
+  class BooleanType
+    def parse obj
+      return nil if obj.nil?
+      obj == "true"
+    end
+  end
+
+  class ArrayType
+    def initialize type
+      @type = type
+    end
+    
+    def parse obj
+      return nil if obj.nil?
+      obj.map{|o| @type.parse o}
+    end
+  end
+  
+  module ClassMethods
+    { :object => ObjectType.new,
+      :integer => IntegerType.new,
+      :decimal => DecimalType.new,
+      :string => StringType.new,
+      :boolean => BooleanType.new,
+      :custom => nil}.each do |method_name, type|
+
+      define_method method_name do |*params|
+        declare_fields params, type
+      end
+
+      array_method = "array_of_#{method_name}s"
+      define_method array_method do |*params|
+        declare_fields params, ArrayType.new(type)
+      end
+    end
+
+    def saved_type_info
+      name = :@@fields_type_information
+      if class_variable_defined?(name)
+        class_variable_get(name)
+      else
+        class_variable_set(name, {})
+      end
+    end
+    
+    private
+    def declare_fields params, type
+      options = params.last.is_a?(Hash) ? params.pop : {}
+      options[:type] ||= type
+      
+      params.each do |field_name|
+        saved_type_info[field_name] = options
+      end
+    end
+  end
+
+  module InstanceMethods
+    def initialize_fields params
+      set_default_values
+      params.each do |field_name, value|
+        set_value field_name, value
+      end
+    end
+    
+    private
+    
+    def set_value field_name, value
+      type_info = self.class.saved_type_info[field_name]
+      return unless type_info 
+      type = type_info[:type]
+      parsed_value = type.parse(value)
+      instance_variable_set "@#{field_name.to_s}", parsed_value
+    end
+
+    def set_default_values
+      self.class.saved_type_info.each do |field_name, options|
+        default_value = options[:default]
+        default_value = default_value.call(self) if default_value.respond_to? :call
+        set_value field_name, default_value
+      end
+    end
+  end
+       
+  def self.included clazz
+    clazz.send :include, InstanceMethods
+    clazz.extend ClassMethods
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/typed_fields')

data/spec/typed_fields_spec.rb

@@ -0,0 +1,137 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe TypedFields do
+
+  let(:clazz) do
+    clazz = Class.new
+    clazz.send :include, TypedFields
+    clazz
+  end
+
+  let(:object) do
+    clazz.new
+  end
+
+  context "basic" do
+    it "should declare an object field" do
+      clazz.object :field
+      object.initialize_fields :field => "value"
+      
+      f(:field).should == "value"
+    end
+
+    it "should declare many object fields" do
+      clazz.object :field1, :field2
+      object.initialize_fields :field1 => "value1", :field2 => "value2"
+      
+      f(:field1).should == "value1"
+      f(:field2).should == "value2"
+    end
+
+    it "should ignore fields that were not declared" do
+      clazz.object :field
+      object.initialize_fields :another_field => "value"
+      f(:another_field).should be_nil
+    end
+  end
+
+  context "default values" do
+    it "should be used when field values are not passed" do
+      clazz.object :field, :default => "default"
+      object.initialize_fields({})
+      f(:field).should == "default"
+    end
+
+    it "should not use default values specified for other fields" do
+      clazz.object :field1, :default => "default"
+      clazz.object :field2
+      object.initialize_fields({})
+      f(:field1).should == "default"
+      f(:field2).should be_nil
+    end
+
+    it "should call default value when it is a block" do
+      clazz.object :field, :default => Proc.new {"default"}
+      object.initialize_fields({})
+      f(:field).should == "default"
+    end
+
+    it "should pass the object being constructed to a default block" do
+      default = double("default proc")
+      clazz.object :field, :default => default
+      
+      default.stub(:respond_to?){true}
+      default.should_receive(:call).with(object).and_return("default")
+
+      object.initialize_fields({})
+      f(:field).should == "default"
+    end
+  end
+
+  context "types" do
+    it "should parse integers" do
+      clazz.integer :field
+      object.initialize_fields(:field => "10")
+      f(:field).should == 10
+    end
+
+    it "should parse decimals" do
+      clazz.decimal :field
+      object.initialize_fields(:field => "1.5")
+      f(:field).should == 1.5
+    end
+
+    it "should parse strings" do
+      clazz.string :field
+      object.initialize_fields(:field => 100)
+      f(:field).should == "100"
+    end
+
+    it "should parse booleans" do
+      clazz.boolean :field
+      object.initialize_fields(:field => "true")
+      f(:field).should == true
+    end
+
+    it "should parse an array of integers" do
+      clazz.array_of_integers :field
+      object.initialize_fields(:field => ["1", "2"])
+      f(:field).should == [1,2]
+    end
+    
+    it "should use custom type" do
+      type = stub(:parse => "parsed")
+      clazz.custom :field, :type => type
+      object.initialize_fields(:field => nil)
+      f(:field).should == "parsed"
+    end
+  end
+
+  context "inheritance" do
+    let :object do
+      Child.new
+    end
+    
+    class Parent
+      include TypedFields
+      object :parent_field, :default => 'parent'
+    end
+
+    class Child < Parent
+      include TypedFields
+      object :child_field, :default => 'child'
+    end
+
+    it "should initialize both parent and child fields" do
+      object.initialize_fields({})
+      f(:parent_field).should == "parent"
+      f(:child_field).should == "child"
+    end
+  end
+  
+  private
+
+  def f field_name
+    object.instance_variable_get "@#{field_name.to_s}"
+  end
+end

data/typed_fields.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "typed_fields/version"
+
+Gem::Specification.new do |s|
+  s.name        = "typed_fields"
+  s.version     = TypedFields::VERSION
+  s.authors     = ["Victor Savkin"]
+  s.email       = ["vic.savkin@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{It types all your fields. Adds methods to convert a hash of strings into specified types.}
+  s.description = %q{}
+
+  s.rubyforge_project = "typed_fields"
+
+  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"]
+
+  s.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: typed_fields
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Victor Savkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2156932540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2156932540
+description: ''
+email:
+- vic.savkin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/typed_fields.rb
+- lib/typed_fields/version.rb
+- spec/spec_helper.rb
+- spec/typed_fields_spec.rb
+- typed_fields.gemspec
+homepage: ''
+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: typed_fields
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: It types all your fields. Adds methods to convert a hash of strings into
+  specified types.
+test_files:
+- spec/spec_helper.rb
+- spec/typed_fields_spec.rb