arstotzka 1.1.0 → 1.2.0

data/lib/arstotzka/{builder.rb → method_builder.rb}

@@ -8,6 +8,8 @@ module Arstotzka
   #
   # @example
   #   class MyModel
+  #     include Arstotzka
+  #
   #     attr_reader :json
   #
   #     def initialize(json)
@@ -22,37 +24,37 @@ module Arstotzka
   #   )
   #
   #   options = Arstotzka::Options.new(full_path: 'name.first')
-  #   builder = Arstotzka::Builder.new([ :first_name ], MyModel, options)
+  #   builder = Arstotzka::MethodBuilder.new([ :first_name ], MyModel, options)
   #   builder.build
   #
   #   instance.first_name # returns 'John'
   #
   #   options = Arstotzka::Options.new(type: :integer)
-  #   builder = Arstotzka::Builder.new([ :age, :cars ], MyModel, options)
+  #   builder = Arstotzka::MethodBuilder.new([ :age, 'cars' ], MyModel, options)
   #   builder.build
   #
   #   instance.age  # returns 20
   #   instance.cars # returns 2
   #
   # @see https://www.rubydoc.info/gems/sinclair Sinclair
-  class Builder < Sinclair
+  class MethodBuilder < Sinclair
     include Base
-    # Returns new instance of Arstotzka::Builder
+    # Returns new instance of Arstotzka::MethodBuilder
     #
     # @param attr_names [Array] list of attributes to be fetched from the hash/json
-    # @param clazz [Class] class to receive the methods
+    # @param klass [Class] class to receive the methods
     #   (using {https://www.rubydoc.info/gems/sinclair Sinclair})
     #
-    # @overload initialize(attr_names, clazz, options_hash={})
+    # @overload initialize(attr_names, klass, options_hash={})
     #   @param options_hash [Hash] hash containing extra options
     #
-    # @overload initialize(attr_names, clazz, options)
+    # @overload initialize(attr_names, klass, options)
     #   @param options [Arstotzka::Options] options of initialization object
     #
     # @see https://www.rubydoc.info/gems/sinclair Sinclair
     # @see Arstotzka::Options
-    def initialize(attr_names, clazz, options = {})
-      super(clazz)
+    def initialize(attr_names, klass, options = {})
+      super(klass)
       self.options = options
 
       @attr_names = attr_names
@@ -63,7 +65,7 @@ module Arstotzka
 
     # @private
     attr_reader :attr_names, :options
-    delegate :json_name, :path, :full_path, :cached, to: :options
+    delegate :path, :full_path, :cached, to: :options
 
     # @private
     #
@@ -76,75 +78,46 @@ module Arstotzka
       end
     end
 
-    # @private
-    #
-    # builds the complete key path to fetch value
-    #
-    # @param [String/Symbol] attribute name of the method / attribute
-    #
-    # @return [String] the keys path
-    def real_path(attribute)
-      full_path || [path, attribute].compact.join('.')
-    end
-
-    # @private
-    #
-    # Options needed by fetcher
-    #
-    # @param [String/Symbol] attribute name of the method / attribute
-    #
-    # @return [Hash] options
-    #
-    # @see Arstotzka::Fetcher
-    def fetcher_options(attribute)
-      options.to_h.slice(:klass, :case, :compact, :after, :type, :flatten, :default).merge(
-        path: real_path(attribute)
-      )
-    end
-
     # @private
     #
     # Add method to the list of methods to be built
     #
-    # @param [String/Symbol] attribute name of method / attribute
+    # @param [String,Symbol] attribute name of method / attribute
     #
     # @return nil
     #
     # @see Sinclair
     def add_attr(attribute)
+      klass.add_fetcher(attribute, options)
       add_method attribute, (cached ? cached_fetcher(attribute) : attr_fetcher(attribute)).to_s
     end
 
-    def json_name
-      options.json
-    end
-
     # Returns the code needed to initialize fetcher
     #
-    # @param [String/Symbol] attribute name of method / attribute
+    # @param [String,Symbol] attribute name of method / attribute
     #
-    # @return [String] code
+    # @return [String] method code
     #
     # @see Sinclair
     # @see Artotzka::Fetcher
     def attr_fetcher(attribute)
       <<-CODE
-      ::Arstotzka::Fetcher.new(
-        #{json_name}, self, #{fetcher_options(attribute)}
-      ).fetch
+        begin
+          self.class.fetcher_for(:#{attribute}, self).fetch
+        end
       CODE
     end
 
     # Returns the code needed to initialize a fetche and cache it
     #
-    # @param [String/Symbol] attribute name of method / attribute
+    # @param [String,Symbol] attribute name of method / attribute
     #
-    # @return [String] code
+    # @return [String] method code
     #
     # @see #attr_fetcher
     def cached_fetcher(attribute)
       <<-CODE
-      @#{attribute} ||= #{attr_fetcher(attribute)}
+        @#{attribute} ||= #{attr_fetcher(attribute)}
       CODE
     end
   end

data/lib/arstotzka/options.rb

@@ -24,14 +24,14 @@ module Arstotzka
     # @param options [Hash] options hash
     #   Options hash will be merged with {DEFAULT_OPTIONS}
     # @option options [Class] klass class to receive the methods
-    # @option options [String/Symbol] path path of hash attributes to find the root
+    # @option options [String,Symbol] path path of hash attributes to find the root
     #   where the attribute live (then fetching it using the attribute name)
-    # @option options [String/Symbol] full_path: path of hash attributes to find exacttly where the
+    # @option options [String,Symbol] full_path: path of hash attributes to find exacttly where the
     #   value live (ignoring the attribute name)
-    # @option options [String/Symbol] json: name of the method containing the hash to be crawled
+    # @option options [String,Symbol] json: name of the method containing the hash to be crawled
     # @option options [Boolean] cached: flag if the result should be memorized instead of repeating
     #   the crawling
-    # @option options [String/Symbol] case:  {Reader} flag definining on which case will
+    # @option options [String,Symbol] case:  {Reader} flag definining on which case will
     #   the keys be defined
     #   - lower_camel: keys in the hash are lowerCamelCase
     #   - upper_camel: keys in the hash are UpperCamelCase
@@ -40,11 +40,11 @@ module Arstotzka
     #   removing nil results
     # @option options [Class] klass:  {Fetcher} option thatwhen passed, wraps the result in an
     #   instance of the given class
-    # @option options [String/Symbol] after:  {Fetcher} option with the name of the method to be
+    # @option options [String,Symbol] after:  {Fetcher} option with the name of the method to be
     #   called once the value is fetched for mapping the value
     # @option options [Boolean] flatten:  {Fetcher} flag to aplly Array#flatten thus
     #   avoing nested arrays
-    # @option options [String/Symbol] type:  {Fetcher} option declaring the type of the returned
+    # @option options [String,Symbol] type:  {Fetcher} option declaring the type of the returned
     #   value (to use casting)
     #   - integer
     #   - string
@@ -68,5 +68,12 @@ module Arstotzka
     def merge(options)
       self.class.new(to_h.merge(options))
     end
+
+    def keys
+      return full_path.split('.') if full_path
+      return [key.to_s] unless path&.present?
+
+      [path, key].compact.join('.').split('.')
+    end
   end
 end

data/lib/arstotzka/reader.rb

@@ -43,19 +43,19 @@ module Arstotzka
     #     ]
     #   }
     #
-    #   reader = Arstotzka::Reader.new(keys: %w(person full_name), case: :snake)
+    #   reader = Arstotzka::Reader.new(full_path: 'person.full_name', case: :snake)
     #   reader.read(hash, 1) # returns 'John'
     #
     # @example
-    #   reader = Arstotzka::Reader.new(keys: %w(person age), case: :upper_camel)
+    #   reader = Arstotzka::Reader.new(full_path: 'person.age', case: :upper_camel)
     #   reader.read(hash, 1) # returns 23
     #
     # @example
-    #   reader = Arstotzka::Reader.new(keys: %w(person car_collection model), case: :snake)
+    #   reader = Arstotzka::Reader.new(full_path: 'person.car_collection.model', case: :snake)
     #   reader.read(hash, 1) # raises {Arstotzka::Exception::KeyNotFound}
     #
     # @example
-    #   reader = Arstotzka::Reader.new(keys: %w(person car_collection model), case: :lower_camel)
+    #   reader = Arstotzka::Reader.new(full_path: 'person.car_collection.model', case: :lower_camel)
     #   reader.read(hash, 1) # returns [
     #                        #   { maker: 'Ford', 'model' => 'Model A' },
     #                        #   { maker: 'BMW', 'model' => 'Jetta' }

data/lib/arstotzka/type_cast.rb

@@ -5,7 +5,7 @@ module Arstotzka
   #
   # Concern with all the type cast methods to be used by {Wrapper}
   #
-  # Usage of typecast is defined by the configuration of {Builder} by the usage of
+  # Usage of typecast is defined by the configuration of {MethodBuilder} by the usage of
   # option type
   #
   # TypeCast can also be extended to include more types
@@ -45,6 +45,7 @@ module Arstotzka
   #     attr_reader :json
   #
   #     expose :cars, full_path: 'cars.unit', type: :car
+  #
   #     def initialize(hash)
   #       @json = hash
   #     end
@@ -73,7 +74,7 @@ module Arstotzka
     #   class TypeCaster
     #     include Arstotzka
     #
-    #     expose :age,     type: :integer, json: :@hash
+    #     expose :age, type: :integer, json: :@hash
     #
     #     def initialize(hash)
     #       @hash = hash

data/lib/arstotzka/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Arstotzka
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

data/lib/arstotzka/wrapper.rb

@@ -13,7 +13,7 @@ module Arstotzka
     # @overload initialize(options_hash={})
     #   @param options_hash [Hash] options of initialization
     #   @option options_hash klass [Class] class to wrap the value
-    #   @option options_hash type [String/Symbol] type to cast the value. The
+    #   @option options_hash type [String,Symbol] type to cast the value. The
     #     possible type_cast is defined by {TypeCast}
     #
     # @overload initialize(options)

data/spec/integration/yard/arstotzka/crawler_spec.rb

@@ -5,11 +5,12 @@ require 'spec_helper'
 describe Arstotzka::Crawler do
   describe 'yard' do
     subject(:crawler) do
-      described_class.new(keys: keys, **options)
+      described_class.new(full_path: full_path, **options)
     end
 
-    let(:options) { {} }
-    let(:keys)    { %w[person information first_name] }
+    let(:options)   { {} }
+    let(:keys)      { %w[person information first_name] }
+    let(:full_path) { keys.join('.') }
     let(:hash) do
       {
         person: {
@@ -64,7 +65,7 @@ describe Arstotzka::Crawler do
 
         context 'when block is given' do
           subject(:crawler) do
-            described_class.new(keys: keys, **options) { |value| value&.to_sym }
+            described_class.new(full_path: full_path, **options) { |value| value&.to_sym }
           end
 
           it 'returns the post processed values' do

data/spec/integration/yard/arstotzka/fetcher_builder_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::FetcherBuilder do
+  describe 'yard' do
+    describe '#build' do
+      subject(:builder) { described_class.new(options) }
+
+      let(:options)  { Arstotzka::Options.new(options_hash) }
+      let(:fetcher)  { builder.build(instance) }
+      let(:instance) { MyModel.new(hash) }
+
+      context 'with sample usage' do
+        let(:options_hash) { { key: :id, path: :person } }
+
+        let(:hash) do
+          {
+            person: {
+              id: 101
+            }
+          }
+        end
+
+        it 'builds a fetcher capable of fetching value' do
+          expect(fetcher.fetch).to eq(101)
+        end
+      end
+
+      context 'with passing full path' do
+        let(:options_hash) do
+          {
+            key:       :player_ids,
+            full_path: 'teams.players.person_id',
+            flatten:   true,
+            case:      :snake
+          }
+        end
+
+        let(:hash) do
+          {
+            teams: [
+              {
+                name: 'Team War',
+                players: [
+                  { person_id: 101 },
+                  { person_id: 102 }
+                ]
+              }, {
+                name: 'Team not War',
+                players: [
+                  { person_id: 201 },
+                  { person_id: 202 }
+                ]
+              }
+            ]
+          }
+        end
+
+        it 'builds a fetcher capable of fetching value' do
+          expect(fetcher.fetch).to eq([101, 102, 201, 202])
+        end
+      end
+
+      context 'when filtering the result' do
+        let(:instance) { StarGazer.new(hash) }
+        let(:hash) do
+          {
+            stars: [
+              { name: 'Sun',         color: 'yellow' },
+              { name: 'HB2840-B',    color: 'blue' },
+              { name: 'Krypton Sun', color: 'red' },
+              { name: 'HB0124-C',    color: 'yellow' },
+              { name: 'HB0942-C',    color: 'red' }
+            ]
+          }
+        end
+        let(:options_hash) do
+          { key: :stars, klass: Star, after: :only_yellow }
+        end
+
+        it 'builds a fetcher capable of fetching and filtering value' do
+          expect(fetcher.fetch).to eq([
+                                        Star.new(name: 'Sun', color: 'yellow'),
+                                        Star.new(name: 'HB0124-C', color: 'yellow')
+                                      ])
+        end
+      end
+    end
+  end
+end

data/spec/integration/yard/arstotzka/fetcher_spec.rb

@@ -5,9 +5,9 @@ require 'spec_helper'
 describe Arstotzka::Fetcher do
   describe 'yard' do
     describe '#fetch' do
-      subject(:fetcher) { described_class.new(hash, instance, **options) }
+      subject(:fetcher) { described_class.new(instance, **options) }
 
-      let(:instance) { Account.new }
+      let(:instance) { Account.new(hash) }
       let(:options) do
         {
           path:  'transactions',

data/spec/integration/yard/arstotzka/{builder_spec.rb → method_builder_spec.rb}

@@ -2,8 +2,10 @@
 
 require 'spec_helper'
 
-describe Arstotzka::Builder do
+describe Arstotzka::MethodBuilder do
   describe 'yard' do
+    subject(:builder) { described_class.new(attributes, klass, options) }
+
     let!(:instance) { klass.new(hash) }
     let(:options)   { Arstotzka::Options.new(options_hash) }
     let(:hash) do
@@ -13,7 +15,6 @@ describe Arstotzka::Builder do
         'cars' => 2.0
       }
     end
-    let(:builder) { described_class.new(attributes, klass, options) }
 
     describe '#first_name' do
       let(:klass)        { Class.new(MyModel) }

data/spec/integration/yard/arstotzka/reader_spec.rb

@@ -4,9 +4,10 @@ require 'spec_helper'
 
 describe Arstotzka::Reader do
   describe 'yard' do
-    subject(:reader) { described_class.new(keys: keys, case: case_type) }
+    subject(:reader) { described_class.new(full_path: full_path, case: case_type) }
 
     let(:keys)      { %w[person full_name] }
+    let(:full_path) { keys.join('.') }
     let(:case_type) { :snake }
 
     describe '#read' do

data/spec/lib/arstotzka/crawler_spec.rb

@@ -8,8 +8,9 @@ describe Arstotzka::Crawler do
   end
 
   let(:block)           { proc { |v| v } }
-  let(:keys)            { '' }
-  let(:default_options) { { keys: keys, case: :lower_camel } }
+  let(:keys)            { [] }
+  let(:full_path)       { keys.join('.') }
+  let(:default_options) { { full_path: full_path, case: :lower_camel } }
   let(:options)         { {} }
   let(:json_file)       { 'arstotzka.json' }
   let(:json)            { load_json_fixture_file(json_file) }

data/spec/lib/arstotzka/fetcher_builder_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Arstotzka::FetcherBuilder do
+  subject(:builder) do
+    described_class.new options
+  end
+
+  let(:instance) { Arstotzka::Dummy.new(hash) }
+  let(:options)  { { path: 'person', key: :id } }
+
+  let(:hash) do
+    {
+      person: { id: 10 }
+    }
+  end
+
+  describe '#build' do
+    let(:fetcher) { builder.build(instance) }
+
+    it do
+      expect(fetcher).to be_a(Arstotzka::Fetcher)
+    end
+
+    it 'builds a fetcher capable of fetching' do
+      expect(fetcher.fetch).to eq(10)
+    end
+  end
+end