pr 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 679887e96c55e4c6b5c183d1557cd1880c6fb9e2
-  data.tar.gz: baea6db819b904d1a60d32e3db9459a96b6d2211
+  metadata.gz: d1967110cefbe5a002dd832abb9e60df5257bd16
+  data.tar.gz: 66f1fc2292f655b8203599056b0e43fe737d19d5
 SHA512:
-  metadata.gz: deed03062a6e2b737c0c461cf0031f1b2eb849454038fc07b09eadbab8feac28f96d1e74c043e7d31d519bbcc0a090d0789aebcf5c5facf50140feae14241e89
-  data.tar.gz: 32df338de6e44e53fb6fdf5741c77dc8ff310c1a4ba81fc89047964c689e700afc64f2cdb78c7280b9303ac8c8ff63053427fc1734f27d9b9ae83c338fd0958d
+  metadata.gz: 58681a9064ea976b0edb67b0077e2e72411cc5b83aca8936a4dc99d47b3f0869803550881bd4ae3de235bc2c2c11e417c4472acf706499552cca1c953561e962
+  data.tar.gz: b0ac34db4e729c275a082fee6e3f4706edf23fa6581d3c00a085f836826330c541c45674cfc4f33ee3b2e6dd4b955983fd6aff5544acefcd7f9b8ac1c776b4a7

data/.rspec

@@ -1,2 +1,2 @@
 --colour
---format documentation
+--format progress

data/features/active_model_compatibility.feature

@@ -16,5 +16,4 @@ Feature: Active Model compatibility
       """Ruby
         MyForm.new
       """
-
     Then it should pass

data/features/building_forms_from_hashes.feature

@@ -0,0 +1,57 @@
+Feature: Building a form from a hash
+  In order to turn user input into a validated set
+  As a developer
+  I wish to use a defined form to parse user input from a hash
+
+  @form @basic @hash
+  Scenario: Basic Form
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have a hash:
+      """Ruby
+        {
+          "event_name" => "Mien Event",
+          "start_date" => "31/03/2013"
+        }
+      """
+    When I build my form from the hash:
+      """Ruby
+        @form = MyForm.new
+        PR::BuildFromHash[ @form, @hash ]
+      """
+    Then my form should have a event_name of "Mien Event"
+    Then my form should have a start_date of "31/03/2013"
+
+  @form @macro @hash
+  Scenario: Basic Form built using macro
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have a hash:
+      """Ruby
+        {
+          "event_name" => "Mien Event",
+          "start_date" => "31/03/2013"
+        }
+      """
+      When I build my form using the macro:
+      """Ruby
+        @form = MyForm.from_hash @hash
+      """
+    Then my form should have a event_name of "Mien Event"
+    Then my form should have a start_date of "31/03/2013"

data/features/building_forms_from_models.feature

@@ -0,0 +1,50 @@
+Feature: Building a form from an existing models
+  In order to apply user input to an existing model
+  As a developer
+  I wish to use a defined form to display existing data
+
+  @form @basic @model
+  Scenario: Basic Form
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have a model defined as:
+      """Ruby
+        @model = Struct.new(:event_name,:start_date).new 'An Event', Date.civil(2013,2,28)
+      """
+    When I build my form from a model:
+      """Ruby
+        @form = PR::BuildFromModel[ MyForm, @model ]
+      """
+    Then my form should have a event_name of "An Event"
+    Then my form should have a start_date of "28/02/2013"
+
+  @form @macro @model
+  Scenario: Basic Form built using macro
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have a model defined as:
+      """Ruby
+        @model = Struct.new(:event_name,:start_date).new 'An Event', Date.civil(2013,2,28)
+      """
+    When I build my form using the macro:
+      """Ruby
+        @form = MyForm.from_model @model
+      """
+    Then my form should have a event_name of "An Event"
+    Then my form should have a start_date of "28/02/2013"

data/features/building_models_from_form.feature

@@ -0,0 +1,66 @@
+Feature: Building a model from a form
+  In order to turn user input into a model
+  As a developer
+  I wish to user a defined form to build a model
+
+  @form @basic @build
+  Scenario: Basic Form
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have preloaded the form with data:
+      """Ruby
+        @form = MyForm.new
+        @form.event_name = 'Event'
+        @form.start_date = '31/03/2013'
+      """
+    And I have a model defined as:
+      """Ruby
+        class Event < Struct.new(:event_name,:start_date)
+        end
+      """
+    When I build my model from the form:
+      """Ruby
+        @model = Event.new
+        PR::BuildModel[ @form, @model ]
+      """
+    Then my model should have a string for event_name "Event"
+    And my model should have a date for start_date `Date.civil(2013,3,31)`
+
+
+  @form @macro @build
+  Scenario: Basic Form using macro
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    And I have preloaded the form with data:
+      """Ruby
+        @form = MyForm.new
+        @form.event_name = 'Event'
+        @form.start_date = '31/03/2013'
+      """
+    And I have a model defined as:
+      """Ruby
+        class AnEvent < Struct.new(:event_name,:start_date)
+        end
+      """
+    When I build my model from the form:
+      """Ruby
+        @form.build_model (@model = AnEvent.new)
+      """
+    Then my model should have a string for event_name "Event"
+    And my model should have a date for start_date `Date.civil(2013,3,31)`

data/features/defining_a_form.feature

@@ -0,0 +1,36 @@
+Feature: Defining a basic form
+  In order to utilise some user input
+  As a developer
+  I wish to define a basic form to capture input
+
+  @form @basic
+  Scenario: Basic Form
+    Given I have a form defined as:
+      """Ruby
+      class MyForm
+
+        DefineField[ self, :event_name, PR::Fields::StringField ]
+        DefineField[ self, :start_date, PR::Fields::DateField ]
+
+      end
+      """
+    When I initialise MyForm
+    Then my form should have a string input "event_name"
+    And my form should have a date input "start_date"
+
+
+  @form
+  Scenario: Form (with macros)
+    Given I have a form defined as:
+      """Ruby
+        class MyForm
+          include PR::Form
+
+          field :event_name, :string
+          field :start_date, :date
+
+        end
+      """
+    When I initialise MyForm
+    Then my form should have a string input "event_name"
+    And my form should have a date input "start_date"

data/features/step_definitions/active_model_steps.rb

@@ -19,7 +19,7 @@ class TestActiveModelCompliance < Test::Unit::TestCase
 
 end
 TEST
-  run_simple unescape 'ruby -Itest test_active_model_compliance.rb'
+  run_simple 'ruby -Itest test_active_model_compliance.rb', true, 5
 end
 
 Then "it should pass" do

data/features/step_definitions/form_steps.rb

@@ -0,0 +1,23 @@
+Given "I have a form defined as:" do |code|
+  define_form code
+end
+
+Given "I have preloaded the form with data:" do |code|
+  run_test code
+end
+
+When "I build my form from a model:" do |code|
+  run_test code
+end
+
+When /^I initialise (\w+)$/ do |klass|
+  @form = fetch(klass).new
+end
+
+Then /^my form should have a string input "(\w+)"$/ do |name|
+  set @form, name, "my demo string"
+end
+
+Then /^my form should have a date input "(\w+)"$/ do |name|
+  set @form, name, "31/03/2013"
+end

data/features/step_definitions/hash_steps.rb

@@ -0,0 +1,15 @@
+Given "I have a hash:" do |code|
+  define_hash code
+end
+
+Given "I build my form using the macro:" do |code|
+  run_test code
+end
+
+When "I build my form from the hash:" do |code|
+  run_test code
+end
+
+Then /^my form should have a ([\w_]+) of "(.*)"$/ do |field_name,field_data|
+  access("@form").send(field_name).should == field_data
+end

data/features/step_definitions/model_steps.rb

@@ -0,0 +1,15 @@
+Given "I have a model defined as:" do |code|
+  define_model code
+end
+
+When "I build my model from the form:" do |code|
+  run_test code
+end
+
+Then /^my model should have a string for (\w+) "(\w+)"$/ do |field_name,field_data|
+  access("@model").send(field_name).should == field_data
+end
+
+Then /^my model should have a date for ([^\s]+) `(.*)`$/ do |field_name,field_data|
+  access("@model").send(field_name).should == eval(field_data)
+end

data/features/support/dsl.rb

@@ -0,0 +1,39 @@
+module DSL
+
+  class World
+    require 'pr'
+
+    def run code
+      eval code
+    end
+  end
+
+
+  def run_test code
+    world.run code
+  end
+  alias define_form  run_test
+  alias define_model run_test
+
+  def define_hash code
+    world.instance_variable_set '@hash', world.run(code)
+  end
+
+  def fetch klass
+    world.class.const_get klass
+  end
+
+  def access var
+    world.instance_variable_get var
+  end
+
+  def world
+    @world ||= Class.new(World).new
+  end
+
+  def set thing, attribute, value
+    thing.send "#{attribute}=", value
+  end
+
+end
+World DSL

data/lib/pr.rb

@@ -4,5 +4,15 @@ module PR
 end
 
 require 'pr/fields'
+
+#how we define fields
+require 'pr/field_registry'
+require 'pr/define_field'
+require 'pr/define_and_register'
+
+require 'pr/build_model'
+require 'pr/build_from_hash'
+require 'pr/build_from_model'
+
 require 'pr/form'
 require 'pr/active_form' if defined?(Rails)

data/lib/pr/build_from_hash.rb

@@ -0,0 +1,19 @@
+module PR
+  class BuildFromHash
+
+    def self.[] form, hash
+      new(form).from hash
+    end
+
+    def initialize form
+      @form = form
+    end
+
+    def from hash
+      hash.each_pair do |key,value|
+        @form.send "#{key}=", value
+      end
+    end
+
+  end
+end

data/lib/pr/build_from_model.rb

@@ -0,0 +1,20 @@
+module PR
+  class BuildFromModel
+
+    def self.[] klass, model
+      new(PR::FieldRegistry[klass], klass.new).build_from model
+    end
+
+    def initialize registry, form
+      @registry, @form = registry, form
+    end
+
+    def build_from model
+      @registry.fields.each do |field|
+        @form.send("__#{field}").populate model.send(field) if model.respond_to? field
+      end
+      @form
+    end
+
+  end
+end

data/lib/pr/build_model.rb

@@ -1,24 +1,26 @@
-class BuildModel
-  def self.[] form, model
-    new(PR::FieldRegistry).for form, model
-  end
-
-  def initialize registry
-    @registry = registry
-  end
-
-  def for form, model
-    @registry.fields_for(form) do |field_name|
-      set model, field_name, value(form,field_name)
+module PR
+  class BuildModel
+    def self.[] form, model
+      new(PR::FieldRegistry[form.class]).for form, model
     end
-  end
 
-  private
-    def set thing, name, value
-      thing.send "#{name}=", value
+    def initialize registry
+      @registry = registry
     end
-    def value thing, name
-      thing.send("__#{name}").convert
+
+    def for form, model
+      @registry.fields.each do |field_name|
+        set model, field_name, value(form, field_name)
+      end
     end
 
+    private
+      def set thing, name, value
+        thing.send "#{name}=", value
+      end
+      def value thing, name
+        thing.send("__#{name}").convert
+      end
+
+  end
 end

data/lib/pr/define_and_register.rb

@@ -0,0 +1,28 @@
+module PR
+  class DefineAndRegister
+
+    class << self
+      def [] klass, name, type, options = {}
+        new(klass).define_and_register name, type, options
+      end
+    end
+
+    def initialize klass
+      @registry = FieldRegistry[klass]
+      @klass = klass
+    end
+
+    def define_and_register name, type, options
+      register name, define(name,type,options)
+    end
+
+    def register name, field
+      @registry.register name, field
+    end
+
+    def define name, type, options = {}
+      DefineField[ @klass, name, Fields[type], options ]
+    end
+
+  end
+end

data/lib/pr/define_field.rb

@@ -1,21 +1,21 @@
 class DefineField
+  class << self
+    def on klass, field_name, field, options = {}
+      new.on klass, field_name, field, options
+    end
+    def [] klass, field_name, field, options = {}
+      new.on klass, field_name, field, options
+    end
+  end
 
-  def on klass, field_name, field
+  def on klass, field_name, field, options = {}
     var_name     = "@field_#{field_name}"
     field_setter = "#{field_name}="
     actual_field = "__#{field_name}"
 
-    klass.class_eval do
-      define_method(actual_field) do
-        instance_variable_get(var_name) || send(field_setter,nil)
-      end
-      define_method(field_name) do
-        send(actual_field).raw
-      end
-      define_method(field_setter) do |value|
-        instance_variable_set var_name, field.new(*([value].compact))
-      end
-    end
+    define_field  klass, actual_field, var_name, field_setter
+    define_reader klass, field_name, actual_field
+    define_setter klass, var_name, field_setter, field
   end
 
   private
@@ -23,4 +23,28 @@ class DefineField
       "@field_#{name}"
     end
 
+    def define_field klass, actual_field, var_name, field_setter
+      klass.class_eval do
+        define_method(actual_field) do
+          instance_variable_get(var_name) || send(field_setter,nil)
+        end
+      end
+    end
+
+    def define_reader klass, field_name, actual_field
+      klass.class_eval do
+        define_method(field_name) do
+          send(actual_field).raw
+        end
+      end
+    end
+
+    def define_setter klass, var_name, field_setter, field
+      klass.class_eval do
+        define_method(field_setter) do |value|
+          instance_variable_set var_name, field.new(*([value].compact))
+        end
+      end
+    end
+
 end

data/lib/pr/field_registry.rb

@@ -0,0 +1,29 @@
+module PR
+  class FieldRegistry
+
+    def self.[] klass
+      @registers ||= {}
+      @registers[klass] ||= new(klass)
+    end
+
+    def initialize klass
+      @for = klass
+      @fields = {}
+    end
+    attr_reader :for
+
+    def register field_name, field
+      @fields[field_name] = field
+    end
+
+    def fetch field_name
+      @fields.fetch field_name
+    end
+
+    def fields
+      @fields.keys
+    end
+
+
+  end
+end

data/lib/pr/fields.rb

@@ -4,3 +4,34 @@ require 'pr/fields/string_field'
 require 'pr/fields/boolean_field'
 require 'pr/fields/date_field'
 require 'pr/fields/float_field'
+
+module PR
+  module Fields
+
+    PreDefined =
+      {
+        generic: GenericField,
+        string:  StringField,
+        boolean: BooleanField,
+        date:    DateField,
+        float:   FloatField
+      }
+
+    class << self
+
+      def [] name
+        __fields[name]
+      end
+
+      def []= custom_name, field
+        __fields[custom_name] = field
+      end
+
+      def __fields
+        @__fields ||= PreDefined.dup
+      end
+      private :__fields
+
+    end
+  end
+end

data/lib/pr/fields/boolean_field.rb

@@ -4,9 +4,10 @@ module PR
       TrueValues  = [1,"1","true",true]
       FalseValues = [0,"0","false",false, ""]
 
-      def initialize value = nil
-        @value = value
+      def initialize value = nil, options = {}
+        @value, @options = value, options
       end
+      attr_reader :options
 
       def populate value
         @value = value

data/lib/pr/fields/date_field.rb

@@ -4,9 +4,10 @@ module PR
     class DateField
       Format = '%d/%m/%Y'
 
-      def initialize value = ''
-        @value = value
+      def initialize value = '', options = {}
+        @value, @options = value, options
       end
+      attr_reader :options
 
       def raw
         @value

data/lib/pr/fields/float_field.rb

@@ -2,9 +2,10 @@ module PR
   module Fields
     class FloatField
 
-      def initialize value = ''
-        @value = value
+      def initialize value = '', options = {}
+        @value, @options = value, options
       end
+      attr_reader :options
 
       def raw
         @value

data/lib/pr/fields/generic_field.rb

@@ -2,9 +2,10 @@ module PR
   module Fields
     class GenericField
 
-      def initialize value = nil
-        @value = value
+      def initialize value = nil, options = {}
+        @value, @options = value, options
       end
+      attr_reader :options
 
       def raw
         @value

data/lib/pr/fields/string_field.rb

@@ -2,9 +2,10 @@ module PR
   module Fields
     class StringField
 
-      def initialize value = ''
-        @value = value
+      def initialize value = '', options = {}
+        @value, @options = value, options
       end
+      attr_reader :options
 
       def raw
         @value

data/lib/pr/form.rb

@@ -2,12 +2,27 @@ module PR
   module Form
 
     def self.included other
-      other.send :extend, DSL
+      other.send :extend,  DSL
+      other.send :include, Macros
     end
 
     module DSL
-      def field name, options = {}
-        DefineAndRegister[ self, name, options ]
+      def field name, type, options = {}
+        PR::DefineAndRegister[ self, name, type, options ]
+      end
+      def from_hash hash
+        form = new
+        PR::BuildFromHash[ form, hash ]
+        form
+      end
+      def from_model model
+        PR::BuildFromModel[ self, model ]
+      end
+    end
+
+    module Macros
+      def build_model model
+        BuildModel[ self, model ]
       end
     end
 

data/lib/pr/version.rb

@@ -1,3 +1,3 @@
 module PR
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/unit/pr/active_form_spec.rb

@@ -7,11 +7,20 @@ describe 'the PR Form' do
   let(:form_klass) { TestForm }
 
   describe 'when included extends the other with its DSL' do
+    let(:name) { double "field name" }
+    let(:type) { double "field type" }
+
+    before do
+      stub_const 'PR::DefineAndRegister', double
+    end
 
     it 'sets up field to define fields' do
-      stub_const 'DefineAndRegister', double
-      DefineAndRegister.should_receive(:[]).with form_klass, :name, my: :options
-      form_klass.field :name, my: :options
+      PR::DefineAndRegister.should_receive(:[]).with form_klass, name, type, {}
+      form_klass.field name, type
+    end
+    it 'sets up field to define fields and passes in options' do
+      PR::DefineAndRegister.should_receive(:[]).with form_klass, name, type, my: :option
+      form_klass.field name, type, my: :option
     end
 
     it 'sets up an id' do

data/spec/unit/pr/build_from_hash_spec.rb

@@ -0,0 +1,14 @@
+require 'pr/build_from_hash'
+
+describe 'building a form from a hash' do
+  let(:form) { Struct.new(:a,:b).new }
+  let(:hash) { { "a" => "a", "b" => "b" } }
+
+  let(:builder)  { PR::BuildFromHash.new form }
+
+  it 'sets hash values on form' do
+    builder.from hash
+    expect(form.a).to eq "a"
+    expect(form.b).to eq "b"
+  end
+end

data/spec/unit/pr/build_from_model_spec.rb

@@ -0,0 +1,27 @@
+require 'pr/build_from_model'
+
+describe 'building forms from models' do
+
+  let(:registry) { double "field registry", fields: [:a,:b] }
+  let(:form)     { double "form", __a: field_a, __b: field_b }
+  let(:field_a)  { double "field a", populate: nil }
+  let(:field_b)  { double "field b" }
+  let(:model)    { Struct.new(:a).new 'a' }
+
+  let(:builder)    { PR::BuildFromModel.new(registry, form) }
+
+  it 'gets fields from the registry' do
+    registry.should_receive(:fields)
+    builder.build_from model
+  end
+
+  it 'populates the form values from the model when it has them' do
+    field_a.should_receive(:populate).with('a')
+    builder.build_from model
+  end
+
+  it 'returns the form' do
+    expect( builder.build_from model ).to eq form
+  end
+
+end

data/spec/unit/pr/build_model_spec.rb

@@ -2,20 +2,16 @@ require 'pr/build_model'
 
 describe 'building a model from a form' do
   let(:model)    { Struct.new(:a,:b).new }
-  let(:registry) { double }
+  let(:registry) { double fields: [:a,:b] }
 
-  let(:field_a)  { double "field", convert: "a_value" }
-  let(:field_b)  { double "field", convert: "b_value" }
-  let(:form)     { double "form", __a: field_a, __b: field_b }
+  let(:field_a)    { double "field", convert: "a_value" }
+  let(:field_b)    { double "field", convert: "b_value" }
+  let(:form)       { double "form", __a: field_a, __b: field_b }
 
-  let(:builder)  { BuildModel.new registry }
+  let(:builder)  { PR::BuildModel.new registry }
 
-  before do
-    registry.stub(:fields_for).and_yield(:a).and_yield(:b)
-  end
-
-  it 'fetches fields from the registry' do
-    registry.should_receive(:fields_for).with(form)
+  it 'gets the fields' do
+    registry.should_receive(:fields)
     builder.for form, model
   end
   it 'converts fields to values' do

data/spec/unit/pr/define_and_register_spec.rb

@@ -0,0 +1,93 @@
+require 'pr/define_and_register'
+
+describe 'defining and registering fields' do
+
+  #values
+  let(:form_klass)  { double "form klass" }
+  let(:field_name)  { double "field name" }
+  let(:field_type)  { double "field type" }
+  let(:field_klass) { double "field klass" }
+  let(:registry)    { double "registry", register: true }
+  let(:field)       { double "field" }
+  let(:options)     { Hash.new }
+
+  #services
+  let(:field_registry)   { double "registry",   :[] => registry }
+  let(:field_lookup)     { double "fields",     :[] => field_klass }
+  let(:field_definition) { double "definition", :[] => field }
+
+  before do
+    stub_const 'PR::FieldRegistry', field_registry
+    stub_const 'PR::Fields',        field_lookup
+    stub_const 'PR::DefineField',   field_definition
+  end
+
+  describe 'using the macro' do
+    it 'looks up the field registry for this form klass' do
+      PR::FieldRegistry.should_receive(:[]).with(form_klass).and_return(registry)
+      PR::DefineAndRegister[ form_klass, field_name, field_type ]
+    end
+
+    it 'looks up the the field for this type' do
+      PR::Fields.should_receive(:[]).with(field_type)
+      PR::DefineAndRegister[ form_klass, field_name, field_type ]
+    end
+
+    it 'defines a field on this form klass' do
+      PR::DefineField.should_receive(:[]).with( form_klass, field_name, field_klass, {} )
+      PR::DefineAndRegister[ form_klass, field_name, field_type ]
+    end
+
+    it 'registers this definition' do
+      registry.should_receive(:register).with(field_name,field)
+      PR::DefineAndRegister[ form_klass, field_name, field_type ]
+    end
+
+    context 'with options' do
+      it 'defines a field on this form klass' do
+        PR::DefineField.should_receive(:[]).with( form_klass, field_name, field_klass, options )
+        PR::DefineAndRegister[ form_klass, field_name, field_type, options ]
+      end
+    end
+  end
+
+  describe 'registering field' do
+    let(:definition) { PR::DefineAndRegister.new form_klass }
+
+    it 'looks up the field registry for this form klass' do
+      PR::FieldRegistry.should_receive(:[]).with(form_klass).and_return(registry)
+      definition.register field_name, field
+    end
+
+    it 'registers this definition' do
+      registry.should_receive(:register).with(field_name,field)
+      definition.register field_name, field
+    end
+  end
+
+  describe 'defining field' do
+    let(:definition) { PR::DefineAndRegister.new form_klass }
+
+    it 'looks up the field registry for this form klass' do
+      PR::FieldRegistry.should_receive(:[]).with(form_klass).and_return(registry)
+      definition.define field_name, field_type
+    end
+
+    it 'looks up the the field for this type' do
+      PR::Fields.should_receive(:[]).with(field_type)
+      definition.define field_name, field_type
+    end
+
+    it 'defines a field on this form klass' do
+      PR::DefineField.should_receive(:[]).with( form_klass, field_name, field_klass, {} )
+      definition.define field_name, field_type
+    end
+
+    context 'with options' do
+      it 'defines a field on this form klass' do
+        PR::DefineField.should_receive(:[]).with( form_klass, field_name, field_klass, options )
+        definition.define field_name, field_type, options
+      end
+    end
+  end
+end

data/spec/unit/pr/define_field_spec.rb

@@ -12,13 +12,22 @@ describe 'defining a field on a form' do
     define_field.on form_klass, :name, field
     expect(form.name).to eq field.new.raw
   end
+
   it 'defines a writer which will set the field value' do
     define_field.on form_klass, :name, field
     form.name = new_raw_value
     expect(form.name).to eq new_raw_value
   end
+
   it 'defines a reader to return the actual field' do
     define_field.on form_klass, :name, field
     expect(form.__name).to be_a field
   end
+
+  it 'takes options and passes them to field' do
+    options = Hash.new
+    define_field.on form_klass, :name, field, options
+    expect(form.__name.options).to eq options
+  end
+
 end

data/spec/unit/pr/field_registry_spec.rb

@@ -0,0 +1,45 @@
+require 'pr/field_registry'
+
+describe 'field registry' do
+  let(:registry) { PR::FieldRegistry }
+
+  #values
+  let(:klass) { double "form klass" }
+
+  describe '.[]' do
+    it 'returns a field registry for the klass' do
+      expect(registry[klass]).to be_a registry
+      expect(registry[klass].for).to eq klass
+    end
+    it 'returns the same field registry multiple times' do
+      expect(registry[klass]).to eq registry[klass]
+    end
+  end
+
+  describe '#initialize' do
+    it 'stores the klass for retrieval' do
+      expect(registry.new(klass).for).to eq klass
+    end
+  end
+
+  describe 'registeration' do
+    let(:name)  { double "field name" }
+    let(:field) { double "field" }
+
+    let(:specific_register) { registry.new klass }
+
+    it 'stores the field on the register' do
+      specific_register.register name, field
+    end
+
+    it 'allows retreival of that field' do
+      specific_register.register name, field
+      expect(specific_register.fetch name).to eq field
+    end
+
+    it 'enumerates fields' do
+      specific_register.register name, field
+      expect(specific_register.fields).to eq [name]
+    end
+  end
+end

data/spec/unit/pr/fields/boolean_field_spec.rb

@@ -1,15 +1,23 @@
 require 'pr/fields/boolean_field'
 
 describe 'a boolean field' do
-  let(:klass) { PR::Fields::BooleanField }
-  let(:value) { double "value" }
-  let(:field) { klass.new value }
+  let(:klass)   { PR::Fields::BooleanField }
+  let(:value)   { double "value" }
+  let(:options) { Hash.new }
+  let(:field)   { klass.new value, options }
 
   describe "default value" do
     subject { klass.new }
 
     its(:raw)     { should equal(false) }
     its(:convert) { should equal(false) }
+    its(:options) { should == {} }
+  end
+
+  describe '#options' do
+    it 'has retrievable options' do
+      expect(field.options).to eq options
+    end
   end
 
   describe :raw do

data/spec/unit/pr/fields/date_field_spec.rb

@@ -2,15 +2,23 @@ require 'pr/fields/invalid_value'
 require 'pr/fields/date_field'
 
 describe 'a date field' do
-  let(:klass) { PR::Fields::DateField }
-  let(:value) { double "value" }
-  let(:field) { klass.new value }
+  let(:klass)   { PR::Fields::DateField }
+  let(:value)   { double "value" }
+  let(:options) { Hash.new }
+  let(:field)   { klass.new value, options }
 
   describe "default value" do
     subject { klass.new }
 
-    its(:raw) { should == '' }
-    specify   { expect { subject.convert }.to raise_error PR::Fields::InvalidValue }
+    its(:raw)     { should == '' }
+    specify       { expect { subject.convert }.to raise_error PR::Fields::InvalidValue }
+    its(:options) { should == {} }
+  end
+
+  describe '#options' do
+    it 'has retrievable options' do
+      expect(field.options).to eq options
+    end
   end
 
   describe "raw" do

data/spec/unit/pr/fields/float_field_spec.rb

@@ -2,13 +2,21 @@ require 'pr/fields/invalid_value'
 require 'pr/fields/float_field'
 
 describe 'a float field' do
-  let(:klass) { PR::Fields::FloatField }
-  let(:value) { double "value" }
-  let(:field) { klass.new value }
+  let(:klass)   { PR::Fields::FloatField }
+  let(:value)   { double "value" }
+  let(:options) { Hash.new }
+  let(:field)   { klass.new value, options }
 
   describe "default value" do
-    subject   { klass.new }
-    its(:raw) { should == '' }
+    subject       { klass.new }
+    its(:raw)     { should == '' }
+    its(:options) { should == {} }
+  end
+
+  describe '#options' do
+    it 'has retrievable options' do
+      expect(field.options).to eq options
+    end
   end
 
   describe "#raw" do

data/spec/unit/pr/fields/generic_field_spec.rb

@@ -1,15 +1,23 @@
 require 'pr/fields/generic_field'
 
 describe 'a generic field' do
-  let(:klass) { PR::Fields::GenericField }
-  let(:value) { double "value" }
-  let(:field) { klass.new value }
+  let(:klass)   { PR::Fields::GenericField }
+  let(:value)   { double "value" }
+  let(:options) { Hash.new }
+  let(:field)   { klass.new value, options }
 
   describe "default value" do
     subject { klass.new }
 
     its(:raw)     { should == nil }
     its(:convert) { should == nil }
+    its(:options) { should == {} }
+  end
+
+  describe '#options' do
+    it 'has retrievable options' do
+      expect(field.options).to eq options
+    end
   end
 
   describe :raw do

data/spec/unit/pr/fields/string_field_spec.rb

@@ -1,15 +1,23 @@
 require 'pr/fields/string_field'
 
 describe 'a string field' do
-  let(:klass) { PR::Fields::StringField }
-  let(:value) { double "value" }
-  let(:field) { klass.new value }
+  let(:klass)   { PR::Fields::StringField }
+  let(:value)   { double "value" }
+  let(:options) { Hash.new }
+  let(:field)   { klass.new value, options }
 
   describe "default value" do
     subject { klass.new }
 
     its(:raw)     { should == '' }
     its(:convert) { should == '' }
+    its(:options) { should == {} }
+  end
+
+  describe '#options' do
+    it 'has retrievable options' do
+      expect(field.options).to eq options
+    end
   end
 
   describe "#populate" do

data/spec/unit/pr/fields_spec.rb

@@ -0,0 +1,26 @@
+require 'pr/fields'
+
+describe 'accessing fields' do
+
+  let(:lookup) { PR::Fields }
+
+  describe 'finding fields via constant' do
+    subject { lookup }
+
+    its([:generic]) { should eq PR::Fields::GenericField }
+    its([:string])  { should eq PR::Fields::StringField }
+    its([:boolean]) { should eq PR::Fields::BooleanField }
+    its([:date])    { should eq PR::Fields::DateField }
+    its([:float])   { should eq PR::Fields::FloatField }
+  end
+
+  describe 'extending with custom fields' do
+    let(:my_custom_field) { double "my custom field" }
+
+    it 'allows extension with a custom field' do
+      lookup[:custom] = my_custom_field
+      expect(lookup[:custom]).to eq my_custom_field
+    end
+  end
+
+end

data/spec/unit/pr/form_spec.rb

@@ -8,10 +8,20 @@ describe 'the PR Form' do
   end
 
   describe 'when included extends the other with its DSL' do
+    let(:name) { double "field name" }
+    let(:type) { double "field type" }
+
+    before do
+      stub_const 'PR::DefineAndRegister', double
+    end
+
     it 'sets up field to define fields' do
-      stub_const 'DefineAndRegister', double
-      DefineAndRegister.should_receive(:[]).with form_klass, :name, my: :options
-      form_klass.field :name, my: :options
+      PR::DefineAndRegister.should_receive(:[]).with form_klass, name, type, {}
+      form_klass.field name, type
+    end
+    it 'sets up field to define fields and passes in options' do
+      PR::DefineAndRegister.should_receive(:[]).with form_klass, name, type, my: :option
+      form_klass.field name, type, my: :option
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pr
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jon Rowe
@@ -29,7 +29,7 @@ cert_chain:
   2feWfO4gCNmvfFjULOAYHq9JHEjN5SLSXvj5HdSnDcCyIfJKn5Ya3JahWQaWIsXf
   /NPE/mB57TOwj+d7XUa2NC4HUadF8R51IYEcIB0PpIEzJlKtfXFcOZxO
   -----END CERTIFICATE-----
-date: 2013-03-31 00:00:00.000000000 Z
+date: 2013-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -115,12 +115,24 @@ files:
 - README.md
 - Rakefile
 - features/active_model_compatibility.feature
+- features/building_forms_from_hashes.feature
+- features/building_forms_from_models.feature
+- features/building_models_from_form.feature
+- features/defining_a_form.feature
 - features/step_definitions/active_model_steps.rb
+- features/step_definitions/form_steps.rb
+- features/step_definitions/hash_steps.rb
+- features/step_definitions/model_steps.rb
 - features/support/aruba.rb
+- features/support/dsl.rb
 - lib/pr.rb
 - lib/pr/active_form.rb
+- lib/pr/build_from_hash.rb
+- lib/pr/build_from_model.rb
 - lib/pr/build_model.rb
+- lib/pr/define_and_register.rb
 - lib/pr/define_field.rb
+- lib/pr/field_registry.rb
 - lib/pr/fields.rb
 - lib/pr/fields/boolean_field.rb
 - lib/pr/fields/date_field.rb
@@ -133,13 +145,18 @@ files:
 - pr.gemspec
 - spec/spec_helper.rb
 - spec/unit/pr/active_form_spec.rb
+- spec/unit/pr/build_from_hash_spec.rb
+- spec/unit/pr/build_from_model_spec.rb
 - spec/unit/pr/build_model_spec.rb
+- spec/unit/pr/define_and_register_spec.rb
 - spec/unit/pr/define_field_spec.rb
+- spec/unit/pr/field_registry_spec.rb
 - spec/unit/pr/fields/boolean_field_spec.rb
 - spec/unit/pr/fields/date_field_spec.rb
 - spec/unit/pr/fields/float_field_spec.rb
 - spec/unit/pr/fields/generic_field_spec.rb
 - spec/unit/pr/fields/string_field_spec.rb
+- spec/unit/pr/fields_spec.rb
 - spec/unit/pr/form_spec.rb
 homepage: https://github.com/JonRowe/PR
 licenses: []
@@ -166,15 +183,28 @@ specification_version: 4
 summary: Public Relations tools for Rails
 test_files:
 - features/active_model_compatibility.feature
+- features/building_forms_from_hashes.feature
+- features/building_forms_from_models.feature
+- features/building_models_from_form.feature
+- features/defining_a_form.feature
 - features/step_definitions/active_model_steps.rb
+- features/step_definitions/form_steps.rb
+- features/step_definitions/hash_steps.rb
+- features/step_definitions/model_steps.rb
 - features/support/aruba.rb
+- features/support/dsl.rb
 - spec/spec_helper.rb
 - spec/unit/pr/active_form_spec.rb
+- spec/unit/pr/build_from_hash_spec.rb
+- spec/unit/pr/build_from_model_spec.rb
 - spec/unit/pr/build_model_spec.rb
+- spec/unit/pr/define_and_register_spec.rb
 - spec/unit/pr/define_field_spec.rb
+- spec/unit/pr/field_registry_spec.rb
 - spec/unit/pr/fields/boolean_field_spec.rb
 - spec/unit/pr/fields/date_field_spec.rb
 - spec/unit/pr/fields/float_field_spec.rb
 - spec/unit/pr/fields/generic_field_spec.rb
 - spec/unit/pr/fields/string_field_spec.rb
+- spec/unit/pr/fields_spec.rb
 - spec/unit/pr/form_spec.rb