arstotzka 1.0.0

data/lib/arstotzka/exception.rb

@@ -0,0 +1,3 @@
+module Arstotzka::Exception
+  class KeyNotFound < StandardError; end
+end

data/lib/arstotzka/fetcher.rb

@@ -0,0 +1,50 @@
+class Arstotzka::Fetcher
+  include Sinclair::OptionsParser
+
+  attr_reader :path, :json, :instance
+
+  delegate :after, :flatten, to: :options_object
+  delegate :wrap, to: :wrapper
+
+  def initialize(json, instance, path:, **options)
+    @path = path.to_s.split('.')
+    @json = json
+    @instance = instance
+    @options = options
+  end
+
+  def fetch
+    value = crawler.value(json)
+    value.flatten! if flatten && value.respond_to?(:flatten!)
+    value = instance.send(after, value) if after
+    value
+  end
+
+  private
+
+  def crawler
+    @crawler ||= buidl_crawler
+  end
+
+  def buidl_crawler
+    Arstotzka::Crawler.new(crawler_options) do |value|
+      wrap(value)
+    end
+  end
+
+  def crawler_options
+    options.slice(:case_type, :compact, :default).merge(path: path)
+  end
+
+  def wrapper
+    @wrapper ||= build_wrapper
+  end
+
+  def build_wrapper
+    Arstotzka::Wrapper.new(wrapper_options)
+  end
+
+  def wrapper_options
+    options.slice(:clazz, :type)
+  end
+end

data/lib/arstotzka/reader.rb

@@ -0,0 +1,44 @@
+module Arstotzka
+  class Reader
+    attr_reader :path, :case_type
+
+    def initialize(path:, case_type:)
+      @case_type = case_type
+      @path = path.map(&self.method(:change_case))
+    end
+
+    def read(json, index)
+      key = path[index]
+
+      check_key!(json, key)
+
+      json.key?(key) ? json[key] : json[key.to_sym]
+    end
+
+    def is_ended?(index)
+      index >= path.size
+    end
+
+    private
+
+    def check_key!(json, key)
+      return if has_key?(json, key)
+      raise Exception::KeyNotFound
+    end
+
+    def has_key?(json, key)
+      json&.key?(key) || json&.key?(key.to_sym)
+    end
+
+    def change_case(key)
+      case case_type
+      when :lower_camel
+        key.camelize(:lower)
+      when :upper_camel
+        key.camelize(:upper)
+      when :snake
+        key.underscore
+      end
+    end
+  end
+end

data/lib/arstotzka/type_cast.rb

@@ -0,0 +1,15 @@
+module Arstotzka::TypeCast
+  extend ActiveSupport::Concern
+
+  def to_integer(value)
+    value.to_i if value.present?
+  end
+
+  def to_string(value)
+    value.to_s
+  end
+
+  def to_float(value)
+    value.to_f if value.present?
+  end
+end

data/lib/arstotzka/version.rb

@@ -0,0 +1,3 @@
+module Arstotzka
+  VERSION = '1.0.0'
+end

data/lib/arstotzka/wrapper.rb

@@ -0,0 +1,36 @@
+class Arstotzka::Wrapper
+  include Arstotzka::TypeCast
+
+  attr_reader :clazz, :type
+
+  def initialize(clazz: nil, type: nil)
+    @clazz = clazz
+    @type = type
+  end
+
+  def wrap(value)
+    return wrap_array(value) if value.is_a?(Array)
+    wrap_element(value)
+  end
+
+  private
+
+  def wrap_element(value)
+    value = cast(value) if has_type? && !value.nil?
+    return if value.nil?
+
+    clazz ? clazz.new(value) : value
+  end
+
+  def wrap_array(array)
+    array.map { |v| wrap v }
+  end
+
+  def has_type?
+    type.present? && type != :none
+  end
+
+  def cast(value)
+    public_send("to_#{type}", value)
+  end
+end

data/spec/fixtures/accounts.json

@@ -0,0 +1,27 @@
+{
+  "banks": [
+    {
+      "name": "bank_1",
+      "accounts": [
+        {
+          "type": "savings",
+          "balance": 1000.00
+        }, {
+          "type": "checking",
+          "balance": 1500.00
+        }
+      ]
+    }, {
+      "name": "bank_2",
+      "accounts": [
+        {
+          "type": "savings",
+          "balance": 50.00
+        }, {
+          "type": "checking",
+          "balance": -500.00
+        }
+      ]
+    }
+  ]
+}

data/spec/fixtures/accounts_missing.json

@@ -0,0 +1,23 @@
+{
+  "banks": [
+    {
+      "name": "bank_1",
+      "accounts": [
+        {
+          "type": "savings",
+          "balance": 1000.00
+        }, {
+          "type": "checking"
+        }, {
+          "type": "investiment",
+          "balance": null
+        }
+      ]
+    }, {
+      "name": "bank_2",
+      "accounts": null
+    }, {
+      "name": "bank_3"
+    }
+  ]
+}

data/spec/fixtures/arstotzka.json

@@ -0,0 +1,38 @@
+{
+  "id": 100,
+  "user": {
+    "name": "usuario"
+  },
+  "age": 20,
+  "father": {
+    "name": "father full name"
+  },
+  "hasMoney": true,
+  "house": {
+    "age": 20,
+    "value": 1000,
+    "floors": 3
+  },
+  "oldHouse": {
+    "age": 30,
+    "value": 500,
+    "floors": 1
+  },
+  "games": [
+    {
+      "name": "zelda",
+      "publisher": "nintendo"
+    }, {
+      "name": "mario",
+      "publisher": "nintendo"
+    }, {
+      "name": "sonic",
+      "publisher": "sega"
+    }
+  ],
+  "animals":[
+    {"race": {"species": {"name": "European squid"}}},
+    {"race": {"species": {"name": "Macaque monkey"}}},
+    {"race": {"species": {"name": "Mexican redknee tarantula"}}}
+  ]
+}

data/spec/fixtures/complete_person.json

@@ -0,0 +1,9 @@
+{
+  "user": {
+    "name": "Robert",
+    "full_name": "Robert Smith",
+    "LoginName": "robsmith",
+    "birthDate": "03/07/1980",
+    "password_reminder": null
+  }
+}

data/spec/fixtures/person.json

@@ -0,0 +1,5 @@
+{
+  "user": {
+    "name": null
+  }
+}

data/spec/integration/readme/default_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'default option' do
+  subject do
+    StarGazer.new(hash).favorite_star
+  end
+
+  let(:hash) { {} }
+
+  context 'when node is not found' do
+    it 'returns the default before wrapping' do
+      expect(subject.name).to eq('Sun')
+    end
+
+    it 'wraps the returned value in a class' do
+      expect(subject).to be_a(Star)
+    end
+  end
+
+  context 'when node is not missing' do
+    let(:hash) do
+      {
+        universe: {
+          star: { name: 'Antares' }
+        }
+      }
+    end
+
+    it 'returns the value before wrapping' do
+      expect(subject.name).to eq('Antares')
+    end
+
+    it 'wraps the returned value in a class' do
+      expect(subject).to be_a(Star)
+    end
+  end
+end

data/spec/integration/readme/my_parser_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe MyParser do
+  subject { described_class.new(hash) }
+
+  let(:hash) do
+    {
+      id: 10,
+      person: {
+        name: 'Robert',
+        age: 22
+      },
+      accounts: [
+        { balance: '$ 1000.50', type: 'checking' },
+        { balance: '$ 150.10', type: 'savings' },
+        { balance: '$ -100.24', type: 'checking' }
+      ],
+      loans: [
+        { value: '$ 300.50', bank: 'the_bank' },
+        { value: '$ 150.10', type: 'the_other_bank' },
+        { value: '$ 100.24', type: 'the_same_bank' }
+      ]
+    }
+  end
+
+  describe 'id' do
+    it 'returns the parsed id' do
+      expect(subject.id).to eq(10)
+    end
+  end
+
+  describe 'name' do
+    it 'returns the parsed name' do
+      expect(subject.name).to eq('Robert')
+    end
+
+    context 'when person is missing' do
+      subject { described_class.new }
+
+      it do
+        expect { subject.name }.not_to raise_error
+      end
+
+      it do
+        expect(subject.name).to be_nil
+      end
+    end
+  end
+
+  describe 'age' do
+    it do
+      expect(subject.age).to be_a(Integer)
+    end
+
+    it 'returns the parsed age' do
+      expect(subject.age).to eq(22)
+    end
+  end
+
+  describe '#total_money' do
+    it do
+      expect(subject.total_money).to be_a(Float)
+    end
+
+    it 'summs all the balance in the accounts' do
+      expect(subject.total_money).to eq(1050.36)
+    end
+
+    context 'when there is a node missing' do
+      let(:hash) { {} }
+      it 'returns nil' do
+        expect(subject.total_money).to be_nil
+      end
+    end
+  end
+
+  describe '#total_owed' do
+    it do
+      expect(subject.total_owed).to be_a(Float)
+    end
+
+    it 'summs all the balance in the accounts' do
+      expect(subject.total_owed).to eq(550.84)
+    end
+  end
+end

data/spec/lib/arstotzka/builder_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Arstotzka::Builder do
+  let(:clazz) do
+    Class.new.tap do |c|
+      c.send(:attr_reader, :json)
+      c.send(:define_method, :initialize) do |json={}|
+        @json = json
+      end
+    end
+  end
+
+  let(:options) { {} }
+  let(:name) { 'Robert' }
+  let(:attr_name) { :name }
+  let(:attr_names) { [ attr_name ] }
+  let(:json) { {} }
+  let(:instance) { clazz.new(json) }
+
+  subject do
+    described_class.new(attr_names, clazz, **options)
+  end
+
+  describe '#build' do
+    it 'adds the reader' do
+      expect do
+        subject.build
+      end.to change { clazz.new.respond_to?(attr_name) }
+    end
+
+    context 'after building' do
+      before { subject.build }
+
+      context 'when building several attributes' do
+        let(:attr_names) { [ :id, :name, :age ] }
+
+        it 'adds all the readers' do
+          attr_names.each do |attr|
+            expect(instance).to respond_to(attr)
+          end
+        end
+
+        it 'fetches safelly empty jsons' do
+          expect(instance.name).to be_nil
+        end
+
+        context 'when json has the property' do
+          let(:json) { { name: name } }
+
+          it 'fetches the value' do
+            expect(instance.name).to eq(name)
+          end
+
+          context 'but key is a string' do
+            let(:json) { { 'name' => name } }
+
+            it 'fetches the value' do
+              expect(instance.name).to eq(name)
+            end
+          end
+        end
+      end
+
+      context 'when value is deep within the json' do
+        let(:json) { { user: { name: name } } }
+
+        context 'when defining a path' do
+          let(:options) { { path: 'user' } }
+
+          it 'fetches the value within the json' do
+            expect(instance.name).to eq(name)
+          end
+        end
+
+        context 'when defining a fullpath' do
+          let(:options) { { full_path: 'user.name' } }
+          let(:attr_name) { :the_name }
+
+          it 'fetches the value within the json' do
+            expect(instance.the_name).to eq(name)
+          end
+        end
+      end
+
+      context 'when wrapping with a class' do
+        let(:json) { { person: name } }
+        let(:options) { { class: Person } }
+        let(:attr_name) { :person }
+
+        it do
+          expect(instance.person).to be_a(Person)
+        end
+
+        it 'fills the new instance with the information fetched' do
+          expect(instance.person.name).to eq(name)
+        end
+      end
+    end
+  end
+end