arstotzka 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15a7631fb286cccc364034583007f5a8297fd060
+  data.tar.gz: 21421c75c92d86840b2a622de626e4d83ea58998
+SHA512:
+  metadata.gz: 5a37e563c29470385399555ac5000977a31d6ced5ebc65eed86289426ff1a55e2e2aa96544525c84a1583ec7fb242c942520cebf590354468ad1966980b6c287
+  data.tar.gz: b03337d691634b834270b080ced42eb495189f9ddb5d63bd239b6714cf4ede664ae41d8a9d5de76de0c7e751fa1b78baa4e74194a2d85d4fb8179d45631a8f14

data/.circleci/config.yml

@@ -0,0 +1,13 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.4.1
+    steps:
+      - checkout
+      - run: curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+      - run: chmod +x ./cc-test-reporter
+      - run: ./cc-test-reporter before-build
+      - run: bundle install
+      - run: bundle exec rspec
+      - run: ./cc-test-reporter after-build --exit-code $?

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+Gemfile.lock
+

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :test do
+  gem 'safe_attribute_assignment', '0.0.3'
+end
+

data/Guardfile

@@ -0,0 +1,13 @@
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard :rspec, all_after_pass: true, all_on_start: true do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Favini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+Arstotzka
+========
+[![Code Climate](https://codeclimate.com/github/darthjee/arstotzka/badges/gpa.svg)](https://codeclimate.com/github/darthjee/arstotzka)
+[![Test Coverage](https://codeclimate.com/github/darthjee/arstotzka/badges/coverage.svg)](https://codeclimate.com/github/darthjee/arstotzka/coverage)
+[![Issue Count](https://codeclimate.com/github/darthjee/arstotzka/badges/issue_count.svg)](https://codeclimate.com/github/darthjee/arstotzka)
+
+This project allows for a quick hash / json data fetching in order to avoid code
+that tries to crawl through a hash and has to constantly check for nil values or missing keys
+
+also, this concern, like openstruct, allow the json to be manipulated as an object, but
+avoids method missing by aways having the declarated methods, even if that means nil return
+
+Json Parser is also usefull when you need keys case changed or data type cast
+
+Getting started
+---------------
+1. Add Arstotzka to your `Gemfile` and `bundle install`:
+
+  ```ruby
+  gem 'arstotzka'
+  ```
+
+2. Include in a class that you want to wrap a json/hash
+  ```ruby
+  class MyParser
+    include Arstotzka
+  ```
+
+3. Declare the keys you want to crawl
+  ```ruby
+  class MyParser
+    include Arstotzka
+
+    expose :id
+    expose :name, :age, path: :person
+
+    attr_reader :json
+
+    def initialize(json = {})
+      @json = json
+    end
+  end
+
+  ```
+
+  and let it fetch values from your hash
+
+
+  ```ruby
+  object = MyParser.new(
+    id: 10,
+    age: 22
+    person: {
+      name: 'Robert',
+      age: 22
+    }
+  )
+
+  object.name
+  #returns 'Robert'
+  ```
+
+  this is usefull when trying to fetch data from hashes missing nodes
+
+  ```ruby
+  MyParser.new.name
+  #returns nil
+  ```
+
+  4. fully customise the way you crawl / fetch the information with [Options](#options)
+
+  5. Create custom [typecast](#TypeCast)
+
+Options
+-------
+- path: path where to find the sub hash that contains the key (empty by default)
+- json: method that contains the hash to be parsed (json by default)
+- full_path: full path to fetch the value (empty by default)
+- cached: indicator that once the value has been fetched, it should be cached (false by default)
+- class: class to be used when wrapping the final value
+- compact: indicator telling to ignore nil values inside array (false by default)
+- flatten: indicator telling that to flattern the resulting array (false by default)
+- after: name of a method to be called after with the resulting value
+- case: case of the keys from the json (camel by default)
+- type: Type that the value must be cast into ([TypeCast](#typecast))
+- default: Default value (prior to casting and wrapping, see [Default](#default))
+
+## TypeCast
+The type casting, when the option `type` is passed, is done through the `Arstotzka::TypeCast` which can
+be extended
+
+```ruby
+module Arstotzka::TypeCast
+  def to_money_float(value)
+    value.gsub(/\$ */, '').to_f
+  end
+end
+```
+
+```ruby
+class MyParser
+  include Arstotzka
+
+  expose :total_money, full_path: 'accounts.balance', after: :sum,
+                       cached: true, type: :money_float
+  expose :total_owed, full_path: 'loans.value', after: :sum,
+                       cached: true, type: :money_float
+
+  attr_reader :json
+
+  def initialize(json = {})
+    @json = json
+  end
+
+  private
+
+  #this method will receive the array of values resulting from the initial mapping
+  def sum(balances)
+    balances.sum if balances
+  end
+end
+```
+
+```ruby
+  object = MyParser.new(
+    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' }
+    ]
+  )
+
+  object.balance
+#returns 1050.36
+```
+
+## Default
+Default value returned before typecasting or class wrapping
+
+```ruby
+class Star
+  attr_reader :name
+
+  def initialize(name:)
+    @name = name
+  end
+end
+
+class StarGazer
+  include Arstotzka
+
+  expose :favorite_star, full_path: 'universe.star',
+         default: { name: 'Sun' }, class: ::Star
+
+  attr_reader :json
+
+  def initialize(json = {})
+    @json = json
+  end
+end
+
+```
+
+
+```ruby
+star_gazer = StarGazer.new
+
+star_gazer.favorite_star.name
+#returns "Sun"
+
+star_gazer.favorite_star.class
+#returns Star
+```
+

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task test: :spec

data/arstotzka.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'arstotzka/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "arstotzka"
+  spec.version       = Arstotzka::VERSION
+  spec.authors       = ["Bidu Dev's Team"]
+  spec.email         = ["dev@bidu.com.br"]
+  spec.summary       = "Json Parser"
+  spec.description   = spec.description
+  spec.homepage      = "https://github.com/Bidu/arstotzka"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f)  }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'activesupport', '~> 5.x'
+  spec.add_runtime_dependency 'sinclair'
+
+  spec.add_development_dependency 'safe_attribute_assignment'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", ">= 12.3.1"
+  spec.add_development_dependency "rspec", ">= 3.7"
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'pry-nav'
+end

data/docker-compose.yml

@@ -0,0 +1,18 @@
+version: '2'
+services:
+  base: &base
+    image: ruby:2.4.0
+    working_dir: /home/app/arstotzka
+    volumes:
+      - .:/home/app/arstotzka
+      - arstotzka_gems_2_4_0:/usr/local/bundle
+
+  #################### CONTAINERS ####################
+
+  arstotzka:
+    <<: *base
+    container_name: arstotzka
+    command: /bin/bash -c 'bundle install && bundle exec rspec'
+
+volumes:
+  arstotzka_gems_2_4_0:

data/lib/arstotzka.rb

@@ -0,0 +1,16 @@
+require 'active_support'
+require 'active_support/all'
+require 'sinclair'
+
+module Arstotzka
+  extend ActiveSupport::Concern
+
+  autoload :Builder,      'arstotzka/builder'
+  autoload :ClassMethods, 'arstotzka/class_methods'
+  autoload :Crawler,      'arstotzka/crawler'
+  autoload :Exception,    'arstotzka/exception'
+  autoload :Fetcher,      'arstotzka/fetcher'
+  autoload :Reader,       'arstotzka/reader'
+  autoload :Wrapper,      'arstotzka/wrapper'
+  autoload :TypeCast,     'arstotzka/type_cast'
+end

data/lib/arstotzka/builder.rb

@@ -0,0 +1,73 @@
+class Arstotzka::Builder < Sinclair
+
+  attr_reader :attr_names, :path, :full_path, :cached
+
+  def initialize(attr_names, clazz, path: nil, full_path: nil, cached: false, **options)
+    super(clazz, {
+      after:     false,
+      case:      :lower_camel,
+      class:     nil,
+      compact:   false,
+      default:   nil,
+      flatten:   false,
+      json:      :json,
+      type:      :none
+    }.merge(options.symbolize_keys))
+
+    @attr_names = attr_names
+    @path = path
+    @full_path = full_path
+    @cached = cached
+    init
+  end
+
+  private
+
+  def init
+    attr_names.each do |attr|
+      add_attr(attr)
+    end
+  end
+
+  def real_path(attribute)
+    full_path || [path, attribute].compact.join('.')
+  end
+
+  def json_name
+    options[:json]
+  end
+
+  def wrapper_clazz
+    options[:class]
+  end
+
+  def case_type
+    options[:case]
+  end
+
+  def fetcher_options(attribute)
+    options.slice(:compact, :after, :type, :flatten, :default).merge({
+      clazz: wrapper_clazz,
+      case_type: case_type,
+      path: real_path(attribute)
+    })
+  end
+
+  def add_attr(attribute)
+    add_method attribute, "#{cached ? cached_fetcher(attribute) : attr_fetcher(attribute)}"
+  end
+
+  def attr_fetcher(attribute)
+    <<-CODE
+      ::Arstotzka::Fetcher.new(
+        #{json_name}, self, #{fetcher_options(attribute)}
+      ).fetch
+    CODE
+  end
+
+  def cached_fetcher(attribute)
+    <<-CODE
+      @#{attribute} ||= #{attr_fetcher(attribute)}
+    CODE
+  end
+end

data/lib/arstotzka/class_methods.rb

@@ -0,0 +1,7 @@
+module Arstotzka
+  module ClassMethods
+    def expose(*attr_names, **options)
+      Builder.new(attr_names, self, options).build
+    end
+  end
+end

data/lib/arstotzka/crawler.rb

@@ -0,0 +1,45 @@
+module Arstotzka
+  class Crawler
+    attr_reader :post_process, :path, :case_type, :compact, :default
+
+    def initialize(path:, case_type: :lower_camel, compact: false, default: nil, &block)
+      @case_type = case_type
+      @compact = compact
+      @default = default
+      @path = path
+      @post_process = block
+    end
+
+    def value(json, index = 0)
+      crawl(json, index)
+    rescue Exception::KeyNotFound
+      wrap(default)
+    end
+
+    private
+
+    def crawl(json, index = 0)
+      return wrap(json) if reader.is_ended?(index)
+      return crawl_array(json, index) if json.is_a?(Array)
+
+      crawl(reader.read(json, index), index + 1)
+    end
+
+    def reader
+      @reader ||= Arstotzka::Reader.new(
+        path: path,
+        case_type: case_type
+      )
+    end
+
+    def wrap(json)
+      post_process.call(json)
+    end
+
+    def crawl_array(array, index)
+      array.map { |j| value(j, index) }.tap do |a|
+        a.compact! if compact
+      end
+    end
+  end
+end