foraneus 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5dd151153010e57f4108ce2e054238b10b2d0b46
-  data.tar.gz: b582478fbb77f95ef5f924b1e7ae2b5bb492c15b
+  metadata.gz: f3f668a304ebd112cf2651006dc871679cac85db
+  data.tar.gz: 607492a6bd176a001eca2f2f0971e2f6f6dca73f
 SHA512:
-  metadata.gz: 6a0c78292a5a51eb6d59dbb6000bed04e4669b95e0b3a78b09e84a9d4c302db1a426930a141166291cab1d2b34279a5837625932655f29270e25b7c82abef74f
-  data.tar.gz: c9385cc3522459024a4d68f148dbb08200411099b3d809e85f54d4c51d4ab99bc8a2965466f278b960d093d15e9d0fe929bd687dffd75e5c4e0f24d7a2a1135d
+  metadata.gz: 1954c53b5f18b2099d55a2e4c0d92dc09cb6cfca491e0db191b220a997cb8abedd580392edcb70c8ab3d80363d97b938fee4d6e99531d2fe13436b0074eb1f8c
+  data.tar.gz: 8689562a31c5c06aade9b290f663539f0e8f042bddb1a71638b92a70f24944f853ee48fa3458b7310cfac8dc304b0d09db019023bded19bb9d6fd694b8d415f3

data/README.md

@@ -62,16 +62,16 @@ Declare source classes by inheriting from `Foraneus` base class.
   end
   ```
 
-Fields are declared in two ways:
+Fields are declared by two ways:
 
  - calling `.field`
  - calling a shortcut method, like `.float`
 
 
-There are handy methods for any of the built-in converters: boolean, date, decimal, float, integer,
+There are shortcut methods for any of the built-in converters: boolean, date, decimal, float, integer,
 noop, and string.
 
-When no converter is passed to `.field`, Foraneus::Converters::Noop is assigned to the declared
+When no converter is passed to `.field`, `Foraneus::Converters::Noop` is assigned to the declared
 field.
 
 ## Instantiation
@@ -91,10 +91,10 @@ Converters have two interrelated responsibilities:
  - Parse data, like the string `"3,000"`, into an object, `like 3_000`.
  - Serialize data, like integer `3_000`, into string `"3,000"`
 
-A converter is simply an object that responds to `#parse(s)`, `#raw(v)`, and `#opts` methods.
+A converter is an object that responds to `#parse(s)`, `#raw(v)`, and `#opts` methods.
 
 When `#parse(s)` raises a StandardError exception, or any of its descendants, the exception is
-rescued and a Foraneus::Error instance is added to `Foraneus#errors` map.
+rescued and a `Foraneus::Error` instance is added to `Foraneus#errors` map.
 
 `#opts` should return the opts hash used to instantiate the converter.
 
@@ -119,7 +119,7 @@ Valid instance:
 
   ``` ruby
   form.valid?     # => true
-  form[:errors]   # => {}
+  form.errors   # => {}
   ```
 
 Invalid one:
@@ -129,15 +129,15 @@ Invalid one:
 
   form.valid?                     # => false
 
-  form[:errors][:delay].key       # => 'ArgumentError'
-  form[:errors][:delay].message   # => 'invalid value for Integer(): "INVALID"'
+  form.errors[:delay].key       # => 'ArgumentError'
+  form.errors[:delay].message   # => 'invalid value for Integer(): "INVALID"'
   ```
 
 `#errors` is a map in which keys correspond to field names, and values are instances of
 `Foraneus::Error`.
 
 The name of the exception raised by `#parse` is the error's `key` attribute, and the exception's
-message is added to the error's `message` attribute.
+message is set to the error's `message` attribute.
 
 Data coming from the inside is assumed to be valid, so `.raw` won't return an instance having
 errors neither being invalid.
@@ -152,15 +152,15 @@ Fields can be declared as required.
   end
   ```
 
-If an external value is not fed into a required field, an error with key 'KeyError' will be assigned.
+If an external value is not fed into a required field, an error with key `KeyError` will be assigned.
 
   ``` ruby
   form = MyForm.parse
 
   form.valid?                       # => false
 
-  form[:errors][:delay].key         # => 'KeyError'
-  form[:errors][:delay].message     # => 'required parameter not found: "delay"'
+  form.errors[:delay].key         # => 'KeyError'
+  form.errors[:delay].message     # => 'required parameter not found: "delay"'
   ```
 
 ## Blank values
@@ -197,7 +197,8 @@ Parse data from the ouside:
   form = MyForm.parse
 
   form.name             # => 'Alice'
-  form[:name]           # => nil, data from the outside don't include any value
+  form[:name]           # => nil, because data from the outside
+                        #    don't include any value
   ```
 
 Convert values back from the inside:
@@ -206,7 +207,32 @@ Convert values back from the inside:
   form = MyForm.raw
 
   form[:name]           # => 'Alice'
-  form.name             # => nil, data from the inside don't include any value
+  form.name             # => nil, because data from the inside
+                        #    don't include any value
+  ```
+
+## Prevent name clashes
+
+It is possible to rename methods `#errors` and `#data` so it will not conflict with defined fields.
+
+  ``` ruby
+  MyForm = Class.new(Foraneus) {
+    field :errors
+    field :data
+
+    accessors[:errors] = :non_clashing_errors
+    accessors[:data] = :non_clashing_data
+  }
+  ```
+
+  ``` ruby
+  form = MyForm.parse(:errors => 'some errors', :data => 'some data')
+
+  form.errors                 # => 'some errors'
+  form.data                   # => 'some data'
+
+  form.non_clashing_errors    # []
+  form.non_clashing_data      # { :errors => 'some errors', :data => 'some data' }
   ```
 
 ## Installation
@@ -219,10 +245,16 @@ Convert values back from the inside:
 
 ## Running tests
 
-Tests are written in RSpec. To run them all just execute the following from your command line:
+Tests are written in MiniTest. To run them all just execute the following from your command line:
+
+  ``` shell
+  ruby spec/runner.rb
+  ```
+
+To run a specific test case:
 
   ``` shell
-  rspec
+    ruby -Ispec -Ilib spec/lib/foraneus_spec.rb
   ```
 
 ## Code documentation

data/lib/foraneus.rb

@@ -11,15 +11,9 @@ require_relative 'foraneus/errors'
 class Foraneus
 
 
-  # @return [Hash] Parsed data.
-  attr_accessor :data
-
   # @api private
   def initialize
-    @data = {}
-    @raw_data = {}
-
-    @errors = {}
+    @_ = {}
   end
 
   # Declares a boolean field.
@@ -102,13 +96,38 @@ class Foraneus
     @fields ||= {}
   end
 
+  def self.accessors
+    @accessors ||= {
+      :data => :data,
+      :errors => :errors
+    }
+  end
+
+  def self.create_instance
+    instance = self.new
+    spec = self
+
+    instance.singleton_class.send(:attr_reader, self.accessors[:data])
+
+    instance.instance_exec do
+      instance.instance_variable_set(:"@#{spec.accessors[:data]}", {})
+    end
+
+    instance.singleton_class.send(:attr_reader, self.accessors[:errors])
+    instance.instance_exec do
+      instance.instance_variable_set(:"@#{spec.accessors[:errors]}", {})
+    end
+
+    instance
+  end
+
   # Parses data coming from an external source.
   #
   # @param [Hash<Symbol, String>] data External data.
   #
   # @return [Foraneus] An instance of a form.
   def self.parse(data = {})
-    instance = self.new
+    instance = self.create_instance
 
     parsed_keys = []
 
@@ -138,7 +157,7 @@ class Foraneus
   #
   # @return [Foraneus] An instance of a form.
   def self.raw(data = {})
-    instance = self.new
+    instance = self.create_instance
 
     fields.each do |field, converter|
       given_key = field
@@ -161,7 +180,7 @@ class Foraneus
       end
 
       instance[given_key] = s
-      instance.data[given_key] = v
+      instance.send(self.accessors[:data])[given_key] = v
     end
 
     instance
@@ -171,13 +190,11 @@ class Foraneus
   # @return [Array<Error>] errors when m == :errors.
   # @return [String] raw data value for the field m.
   def [](m = nil)
-    if m == :errors
-      @errors
-    elsif m.nil?
-      @raw_data
+    if m.nil?
+      @_
     else
-      @raw_data.fetch(m) do
-        @raw_data[m.to_s]
+      @_.fetch(m) do
+        @_[m.to_s]
       end
     end
   end
@@ -189,7 +206,10 @@ class Foraneus
   # @param [Symbol] k Field name.
   # @param [String] v Raw value.
   def []=(k, v)
-    @raw_data[k] = v
+    #raw_data = @_
+
+    #raw_data[k] = v
+    @_[k] = v
   end
 
   # Returns true if no conversion errors occurred. false otherwise.
@@ -225,11 +245,11 @@ class Foraneus
     end
 
     foraneus.send("#{field}=", v)
-    foraneus.data[k] = v
+    foraneus.send(self.accessors[:data])[k] = v
 
   rescue
     error = Foraneus::Error.new($!.class.name, $!.message)
-    foraneus.instance_variable_get(:@errors)[k] = error
+    foraneus.send(self.accessors[:errors])[k] = error
   end
   private_class_method :__parse_raw_datum
 

data/lib/foraneus/converters/date.rb

@@ -16,7 +16,10 @@ class Foraneus
         @format = opts[:format] || DEFAULT_FORMAT
       end
 
-      # return [Date]
+
+      # @raise [ArgumentError] with message 'invalid date'
+      #
+      # @return [Date]
       def parse(s)
         ::Date.strptime(s, @format)
       end

data/lib/foraneus/converters/float.rb

@@ -21,6 +21,8 @@ class Foraneus
         @separator = opts[:separator] || DEFAULT_SEPARATOR
       end
 
+      # @raise [ArgumentError] with message 'invalid value for Float(): ...'
+      #
       # @return [Float]
       def parse(s)
         integer_part, fractional_part = split(s)

data/lib/foraneus/converters/integer.rb

@@ -13,6 +13,8 @@ class Foraneus
         @delimiter = opts[:delimiter]
       end
 
+      # @raise [ArgumentError] with message 'invalid value for Integer(): ...'
+      #
       # @return [Integer]
       def parse(s)
         s = s.gsub(@delimiter, '') if @delimiter

data/spec/lib/foraneus/converters/boolean_converter_spec.rb

@@ -2,35 +2,37 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Boolean do
 
+  let(:converter) { Foraneus::Converters::Boolean.new }
+
   describe '#parse' do
     it 'returns true with true' do
-      parsed = subject.parse('true')
+      parsed = converter.parse('true')
 
-      parsed.should be_true
+      assert_equal true, parsed
     end
 
     it 'returns false with sth else' do
-      parsed = subject.parse('false')
+      parsed = converter.parse('false')
 
-      parsed.should be_false
+      assert_equal false, parsed
     end
   end
 
   describe '#raw' do
     it 'returns "true" with true' do
-      subject.raw(true).should eq('true')
+      assert_equal 'true', converter.raw(true)
     end
 
     it 'returns "false" with false' do
-      subject.raw(false).should eq('false')
+      assert_equal 'false', converter.raw(false)
     end
 
     it 'returns "false" with nil' do
-      subject.raw(nil).should eq('false')
+      assert_equal 'false', converter.raw(nil)
     end
 
     it 'returns "true" with everything else' do
-      subject.raw(:default).should eq('true')
+      assert_equal 'true', converter.raw(:default)
     end
   end
 end

data/spec/lib/foraneus/converters/date_converter_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Date do
 
-  subject(:converter) { Foraneus::Converters::Date.new }
+  let(:converter) { Foraneus::Converters::Date.new }
 
   describe '#parse' do
 
@@ -11,13 +11,13 @@ describe Foraneus::Converters::Date do
 
       result = converter.parse(s)
 
-      result.year.should eq(2012)
-      result.month.should eq(04)
-      result.day.should eq(13)
+      assert_equal 2012, result.year
+      assert_equal 4, result.month
+      assert_equal 13, result.day
     end
 
-    context 'when format is given' do
-      subject(:converter) {
+    describe 'when format is given' do
+      let(:converter) {
         Foraneus::Converters::Date.new(:format => '%d/%m/%Y')
       }
 
@@ -26,32 +26,28 @@ describe Foraneus::Converters::Date do
 
         result = converter.parse(s)
 
-        result.year.should eq(2012)
-        result.month.should eq(04)
-        result.day.should eq(13)
+        assert_equal 2012, result.year
+        assert_equal 4, result.month
+        assert_equal 13, result.day
       end
     end
   end
 
   describe '#raw' do
-    let(:d) { Date.today }
+    let(:d) { Date.new(2012, 4, 13) }
 
     it 'returns a date representation' do
-      s = d.strftime('%Y-%m-%d')
-
-      converter.raw(d).should eq(s)
+      assert_equal '2012-04-13', converter.raw(d)
     end
 
-    context 'when format is given' do
+    describe 'when format is given' do
       let(:format) { '%m/%d/%Y' }
-      subject(:converter) {
+      let(:converter) {
         Foraneus::Converters::Date.new(:format => format)
       }
 
       it 'returns a date representation' do
-        s = d.strftime(format)
-
-        converter.raw(d).should eq(s)
+        assert_equal '04/13/2012', converter.raw(d)
       end
     end
   end

data/spec/lib/foraneus/converters/decimal_converter_spec.rb

@@ -2,25 +2,25 @@ require 'spec_helper'
 
 describe Foraneus::Converters::Decimal do
 
-  subject(:converter) { Foraneus::Converters::Decimal.new }
+  let(:converter) { Foraneus::Converters::Decimal.new }
 
   describe '#parse' do
     it 'parses a decimal representation' do
       s = '1234.56'
       n = BigDecimal.new('1234.56')
 
-      converter.parse(s).should eq(n)
+      assert_equal n, converter.parse(s)
     end
 
     it 'parses a decimal representation when no integer part' do
       s = '.56'
       n = BigDecimal.new('0.56')
 
-      converter.parse(s).should eq(n)
+      assert_equal n, converter.parse(s)
     end
 
-    context 'when separator and delimiter are given' do
-      subject(:converter) {
+    describe 'when separator and delimiter are given' do
+      let(:converter) {
         Foraneus::Converters::Decimal.new(:delimiter => '.', :separator => ',')
       }
 
@@ -28,14 +28,14 @@ describe Foraneus::Converters::Decimal do
         s = '1.234.567,89'
         n = BigDecimal.new('1234567.89')
 
-        converter.parse(s).should eq(n)
+        assert_equal n, converter.parse(s)
       end
 
       it 'parses a decimal representation when no integer part' do
         s = ',56'
         n = BigDecimal.new('0.56')
 
-        converter.parse(s).should eq(n)
+        assert_equal n, converter.parse(s)
       end
     end
   end
@@ -46,39 +46,39 @@ describe Foraneus::Converters::Decimal do
     it 'returns a decimal representation' do
       s = '1234567.89'
 
-      converter.raw(n).should eq(s)
+      assert_equal s, converter.raw(n)
     end
 
-    context 'when separator and delimiter are given' do
-      subject(:converter) {
+    describe 'when separator and delimiter are given' do
+      let(:converter) {
         Foraneus::Converters::Decimal.new(:delimiter => '.', :separator => ',')
       }
 
       it 'returns a decimal representation' do
         s = '1.234.567,89'
 
-        converter.raw(n).should eq(s)
+        assert_equal s, converter.raw(n)
       end
     end
 
-    context 'when precision is given' do
-      subject(:converter) {
+    describe 'when precision is given' do
+      let(:converter) {
         Foraneus::Converters::Decimal.new(:precision => 2)
       }
 
       it 'fills with zeros when value precision is smaller than converter precision' do
         n = BigDecimal.new('3.1')
-        converter.raw(n).should eq('3.10')
+        assert_equal '3.10', converter.raw(n)
       end
 
       it 'does not affect the representation when precision and converter precision are both equal' do
         n = BigDecimal.new('3.14')
-        converter.raw(n).should eq('3.14')
+        assert_equal '3.14', converter.raw(n)
       end
 
       it 'does not truncate the representation when precision is larger than converter precision' do
         n = BigDecimal.new('3.145')
-        converter.raw(n).should eq('3.145')
+        assert_equal '3.145', converter.raw(n)
       end
     end
   end