foraneus 0.0.1 → 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjUyZWQ0OTM3OTA4MWE0MzBlNmEyZmUzYWI5ZGM2ZTdlYzBiMTJhOQ==
+  data.tar.gz: !binary |-
+    NTcyZjkzYjM3NWE3N2QzYjQ3MzYyNjMyOGQ3ZTBiZjE1Mjc5Y2VmOQ==
+SHA512:
+  metadata.gz: !binary |-
+    ZTMzMzNhYjg4MmJkYTZkODhmZTllYTgwN2ZhZDQ0NjA5OTM1NWUxNDU5YjA5
+    ZjQ5YzY1NjZhMDc4OThlNmJkN2YxNWE4MDQ0MzQ5YjBjMjMwODQ1MTczZTJl
+    NjExNmI0OWQyMWNlOTNmYjA5NzE0YzUwOWViYjQwZWY2NGU4Mzk=
+  data.tar.gz: !binary |-
+    ZjllNzU3NzQxNWUzZGEzOTk2OWMwNWUwZTY1OGQ4NTkxYWNiZWI1Mjg1N2Jh
+    YzMxZjc3YTI1OGM1MWViNzI4ZDg2ZTdjYzYxOWE0YTM1Yzc0ODMxNDI2MDJh
+    MzcxMzVlYWE0ZTM0OThiYmI1NGY1YmUxZmJlOTc1OTI1MmVkZDM=

data/README.md

@@ -1,5 +1,65 @@
-== .
-Copyright (c) 2012 "snmgian", released under LGPL v3 license. 
+# Foraneus
 
-== .
-Contact at: snmgian at gmail dot com
+## Usage
+
+``` ruby
+class MyForm < Foraneus
+  integer :delay
+  float :duration
+end
+```
+
+ - From the outside:
+
+  ``` ruby
+  form = MyForm.parse(:delay => '5', :duration => '2.14')
+  ```
+
+  ``` ruby
+  form.delay    # => 5
+  form[:delay]  # => '5'
+  ```
+
+  ``` ruby
+  form.data   # => { :delay => 5, :duration => 2.14 }
+  form[]     # => { :delay => '5', :duration => '2.14' }
+  ```
+
+  ``` ruby
+  form.valid?   # => true
+  form.errors   # => {}
+  ```
+
+ - From the inside
+
+  ``` ruby
+  form = MyForm.new
+  ```
+
+  ``` ruby
+  form.delay    # => nil
+  form[:delay]  # => nil
+  ```
+
+ - From the inside
+
+  ``` ruby
+  form = MyForm.raw(:delay => 5, :duration => 2.14)
+  ``` ruby
+
+  ``` ruby
+  form.delay    # => 5
+  form[:delay]  # => '5'
+  ```
+
+  ``` ruby
+  form.data   # => { :delay => 5, :duration => 2.14 }
+  form[]     # => { :delay => '5', :duration => '2.14' }
+  ```
+
+
+## License
+
+This software is licensed under the [LGPL][lgpl] license.
+
+[lgpl]: https://www.gnu.org/licenses/lgpl.html

data/lib/foraneus/converters/boolean.rb

@@ -0,0 +1,23 @@
+class Foraneus
+  module Converters
+
+    class Boolean
+      def parse(s)
+        if s == 'true'
+          true
+        else
+          false
+        end
+      end
+
+      def raw(v)
+        if v
+          'true'
+        else
+          'false'
+        end
+      end
+    end
+
+  end
+end

data/lib/foraneus/converters/date.rb

@@ -0,0 +1,24 @@
+require 'date'
+
+class Foraneus
+  module Converters
+
+    class Date
+
+      DEFAULT_FORMAT = '%Y-%m-%d'
+
+      def initialize(opts = {})
+        @format = opts[:format] || DEFAULT_FORMAT
+      end
+
+      def parse(s)
+        ::Date.strptime(s, @format)
+      end
+
+      def raw(v)
+        v.strftime(@format)
+      end
+    end
+
+  end
+end

data/lib/foraneus/converters/decimal.rb

@@ -0,0 +1,49 @@
+require 'bigdecimal'
+
+class Foraneus
+  module Converters
+
+    class Decimal
+      DEFAULT_DELIMITER = ','
+      DEFAULT_SEPARATOR = '.'
+
+      DELIMITED_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
+
+      def initialize(opts = {})
+        @delimiter = opts[:delimiter] || DEFAULT_DELIMITER
+        @separator = opts[:separator] || DEFAULT_SEPARATOR
+        @precision = opts[:precision]
+      end
+
+      def parse(s)
+        parts = s.split(@separator)
+
+        integer_part = (parts[0] || '0').gsub(@delimiter, '')
+        fractional_part = parts[1] || '0'
+
+        BigDecimal.new("#{integer_part}.#{fractional_part}")
+      end
+
+      def raw(v)
+        left, right = v.to_s('F').split('.')
+
+        if @precision && right.length < @precision
+          right = add_trailing_zeros(right, @precision - right.length)
+        end
+
+        left.gsub!(DELIMITED_REGEX) { "#{$1}#{@delimiter}" }
+
+        "#{left}#{@separator}#{right}"
+      end
+
+      private
+      def add_trailing_zeros(s, n)
+        zeros = '0' * n
+
+        "#{s}#{zeros}"
+      end
+
+    end
+
+  end
+end

data/lib/foraneus/converters/float.rb

@@ -0,0 +1,15 @@
+class Foraneus
+  module Converters
+
+    class Float
+      def parse(s)
+        Kernel.Float(s)
+      end
+
+      def raw(v)
+        v.to_s
+      end
+    end
+
+  end
+end

data/lib/foraneus/converters/integer.rb

@@ -0,0 +1,15 @@
+class Foraneus
+  module Converters
+
+    class Integer
+      def parse(s)
+        Kernel.Integer(s)
+      end
+
+      def raw(v)
+        v.to_s
+      end
+    end
+
+  end
+end

data/lib/foraneus/converters/string.rb

@@ -0,0 +1,15 @@
+class Foraneus
+  module Converters
+
+    class String
+      def parse(s)
+        s
+      end
+
+      def raw(v)
+        v
+      end
+    end
+
+  end
+end

data/lib/foraneus/errors.rb

@@ -1,59 +1,8 @@
-module Foraneus
+class Foraneus
 
-  # An error during the parsing of a value.
-  class ValueError
-
-    # @!attribute name
-    #   @return [String] Name of the field value
-    attr_accessor :name
-
-    # @!attribute value
-    #   @return [String] Value attempted to be parsed
-    attr_accessor :value
-
-    # @!attribute expected_type
-    #   @return [String] The expected type to be parsed
-    attr_accessor :expected_type
-
-    # @param [String] name The name of the field in the value_set
-    # @param [String] value The value attempted to be parsed
-    # @param [Symbol] expected_type The expected type to be parsed
-    def initialize(name, value, expected_type)
-      @name = name
-      @value = value
-      @expected_type = expected_type
-    end
-  end
-
-  # Raised on an attempt to create a value_set from invalid value
-  class ValueSetError < StandardError
-
-    # @!attribute value_set
-    #   @return [ValueSet] ValueSet with errors
-    attr_accessor :value_set
-
-    # @param [Foraneus::ValueSet] value_set ValueSet with errors
-    def initialize(value_set)
-      @value_set = value_set
-    end
-  end
-
-  # Raised on an attempt to parse an invalid value
-  class ConverterError < StandardError
-
-    # @!attribute value
-    #   @return [String] Value attempted to be parsed
-    attr_accessor :value
-    
-    # @!attribute value
-    #   @return [String] Name of the converter that raised the error
-    attr_accessor :converter_name
-
-    # @param [String] value The value attempted to be parsed
-    # @param [Symbol] converter_name Name of the converter
-    def initialize(value, converter_name)
-      @value = value
-      @converter_name = converter_name
+  Error = Struct.new(:key, :message) do
+    def to_s
+      "#{key} - #{message}"
     end
   end
 

data/lib/foraneus.rb

@@ -1,57 +1,132 @@
+require_relative 'foraneus/converters/boolean'
+require_relative 'foraneus/converters/date'
+require_relative 'foraneus/converters/decimal'
+require_relative 'foraneus/converters/float'
+require_relative 'foraneus/converters/integer'
+require_relative 'foraneus/converters/string'
+require_relative 'foraneus/errors'
+
 # Foraneus is library for parsing external data.
 #
-# It allows to define value_sets that specify how the external data is structured and how should be parsed.
-module Foraneus
+# It allows to define value_sets that specify how the external data is structured
+#   and how it should be parsed.
+class Foraneus
+
+  attr_accessor :data
+
+  def initialize
+    @data = {}
+    @raw_data = {}
+
+    @errors = {}
+  end
+
+  def self.boolean(name)
+    converter = Foraneus::Converters::Boolean.new
+    field(name, converter)
+  end
+
+  def self.date(name, *args)
+    converter = Foraneus::Converters::Date.new(*args)
+    field(name, converter)
+  end
+
+  def self.decimal(name, *args)
+    converter = Foraneus::Converters::Decimal.new(*args)
+    field(name, converter)
+  end
+
+  def self.float(name)
+    converter = Foraneus::Converters::Float.new
+    field(name, converter)
+  end
+
+  def self.integer(name)
+    converter = Foraneus::Converters::Integer.new
+    field(name, converter)
+  end
+
+  def self.string(name)
+    converter = Foraneus::Converters::String.new
+    field(name, converter)
+  end
 
-  @registry = {}
+  def self.field(name, converter)
+    fields[name.to_s] = converter
+    self.send(:attr_accessor, name)
+  end
 
-  # Returns the converters registry
-  # @return [Hash<Symbol, ConverterDecorator>] A hash of registered converters
-  def self.registry
-    @registry
+  def self.fields
+    @fields ||= {}
   end
 
-  # Registers a converter.
-  #
-  # @param [Class<? extends Converters::AbstractConverter>] converter_class The converter
-  def self.register(converter_class)
+  def self.parse(raw_data)
+    instance = self.new
+
+    parsed_data = {}
+
+    raw_data.each do |k, v|
+      field = k.to_s
+      converter = fields[field]
+      next unless converter
 
-    decorated = Converters::ConverterDecorator.new(converter_class.new)
-    @registry[decorated.name] = decorated 
+      instance[k] = v
+      begin
+        v = if v.nil?
+          nil
+        else
+          converter.parse(v)
+        end
 
-    self.define_type_method(decorated.name)
+        instance.send("#{field}=", v)
+        instance.data[k] = v
+      rescue
+        error = Foraneus::Error.new($!.class.name, $!.message)
+        instance.instance_variable_get(:@errors)[k] = error
+      end
+    end
+
+    instance
   end
 
-  # Defines a class method in {ValueSet} that corresponds to a converter.
-  #
-  # The defined method will be invoked when defining a value_set
-  #
-  # @api private
-  #
-  # @param [String] name The name of the converter
-  def self.define_type_method(name)
-    Foraneus::ValueSet.singleton_class.send :define_method, name do |field|
-      self.send :attr_reader, field
+  def self.raw(data)
+    instance = self.new
+
+    data.each do |k, v|
+      next unless fields.has_key?(k.to_s)
+      instance.send("#{k}=", v)
+      converter = fields[k.to_s]
+
+      s = if v.nil?
+        nil
+      else
+        converter.raw(v)
+      end
 
-      @meta ||= {}
-      @meta[field] = name
+      instance[k] = s
+      instance.data[k] = v
     end
+
+    instance
   end
 
-end
+  def [](m = nil)
+    if m == :errors
+      @errors
+    elsif m.nil?
+      @raw_data
+    else
+      @raw_data.fetch(m) do
+        @raw_data[m.to_s]
+      end
+    end
+  end
 
-[
-  :converters,
-  :errors,
-  :hashlike,
-  :markers,
-  :simple_converters,
-  :raw_value_set_builder,
-  :value_set,
-  :value_set_builder,
-].each { |f| require_relative "foraneus/#{f}" }
-
-Foraneus.register(Foraneus::Converters::Boolean)
-Foraneus.register(Foraneus::Converters::Float)
-Foraneus.register(Foraneus::Converters::Integer)
-Foraneus.register(Foraneus::Converters::String)
+  def []=(k, v)
+    @raw_data[k] = v
+  end
+
+  def valid?
+    @errors.empty?
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Foraneus::Converters::Boolean do
+
+  describe '#parse' do
+    it 'returns true with true' do
+      parsed = subject.parse('true')
+
+      parsed.should be_true
+    end
+
+    it 'returns false with sth else' do
+      parsed = subject.parse('false')
+
+      parsed.should be_false
+    end
+  end
+
+  describe '#raw' do
+    it 'returns "true" with true' do
+      subject.raw(true).should eq('true')
+    end
+
+    it 'returns "false" with false' do
+      subject.raw(false).should eq('false')
+    end
+
+    it 'returns "false" with nil' do
+      subject.raw(nil).should eq('false')
+    end
+
+    it 'returns "true" with everything else' do
+      subject.raw(:default).should eq('true')
+    end
+  end
+end

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

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

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

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Foraneus::Converters::Decimal do
+
+  subject(:converter) { Foraneus::Converters::Decimal.new }
+
+  describe '#parse' do
+    it 'parses a decimal representation' do
+      s = '1,234.56'
+      n = BigDecimal.new('1234.56')
+
+      converter.parse(s).should eq(n)
+    end
+
+    it 'parses a decimal representation when no integer part' do
+      s = '.56'
+      n = BigDecimal.new('0.56')
+
+      converter.parse(s).should eq(n)
+    end
+
+    context 'when separator and delimiter are given' do
+      subject(:converter) {
+        Foraneus::Converters::Decimal.new(:delimiter => '.', :separator => ',')
+      }
+
+      it 'parses a decimal representation' do
+        s = '1.234.567,89'
+        n = BigDecimal.new('1234567.89')
+
+        converter.parse(s).should eq(n)
+      end
+
+      it 'parses a decimal representation when no integer part' do
+        s = ',56'
+        n = BigDecimal.new('0.56')
+
+        converter.parse(s).should eq(n)
+      end
+    end
+  end
+
+  describe '#raw' do
+    let(:n) { BigDecimal.new('1234567.89') }
+
+    it 'returns a decimal representation' do
+      s = '1,234,567.89'
+
+      converter.raw(n).should eq(s)
+    end
+
+    context 'when separator and delimiter are given' do
+      subject(:converter) {
+        Foraneus::Converters::Decimal.new(:delimiter => '.', :separator => ',')
+      }
+
+      it 'returns a decimal representation' do
+        s = '1.234.567,89'
+
+        converter.raw(n).should eq(s)
+      end
+    end
+
+    context 'when precision is given' do
+      subject(:converter) {
+        Foraneus::Converters::Decimal.new(:precision => 2)
+      }
+
+      it 'x' do
+        n = BigDecimal.new('3.1')
+        converter.raw(n).should eq('3.10')
+      end
+
+      it 'y' do
+        n = BigDecimal.new('3.145')
+        converter.raw(n).should eq('3.145')
+      end
+    end
+  end
+
+end