cascade-rb 0.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in elasticquery.gemspec
+gemspec

data/README.md

@@ -0,0 +1,25 @@
+# [Cascade]
+
+[![Codeship Status for ignat-zakrevsky/cascade](https://codeship.com/projects/d7590880-9943-0132-4aa6-1e41bc68e178/status?branch=master)](https://codeship.com/projects/63625) [![Code Climate](https://codeclimate.com/github/ignat-zakrevsky/cascade/badges/gpa.svg)](https://codeclimate.com/github/ignat-zakrevsky/cascade) [![Test Coverage](https://codeclimate.com/github/ignat-zakrevsky/cascade/badges/coverage.svg)](https://codeclimate.com/github/ignat-zakrevsky/cascade)
+
+The main aim of this repo is to provide some kind of template for parsers.
+Usually, parsing file process contains next steps:
+
+ 1. Retreiving info from file
+ 2. Distinguish content from each file line
+ 3. Parse each column with corresponding parser
+ 4. Generate some kind of data record
+ 5. Save obtained record
+ 6. Handle errors
+ 7. Generate report
+
+Cascade pretends to simplify main part of this step to save your time.
+
+## Usage
+- Configure database config
+	`cp config/database.yml.sample config/database.yml`
+- Change `./config/columns_match.yml` to correspond your scheme
+- Create necessary ActiveRecord models
+- Add necessary parsers
+- Run it
+

data/Rakefile

@@ -0,0 +1,9 @@
+require "rake/testtask"
+
+Rake::TestTask.new do |task|
+  task.libs << "lib"
+  task.libs << "spec"
+  task.pattern = "spec/**/*_spec.rb"
+end
+
+task default: [:test]

data/cascade.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cascade/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cascade-rb"
+  spec.version       = Cascade::VERSION
+  spec.authors       = ["Ignat Zakrevsky"]
+  spec.email         = %w(iezakrevsky@gmail.com)
+  spec.summary       = "Ruby data parser gem."
+  spec.description   = "Highly customizable ruby parser with a lot of DI"
+  spec.homepage      = "https://github.com/ignat-zakrevsky/cascade"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "iso_country_codes"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rr"
+  spec.add_development_dependency "shoulda-matchers"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/lib/cascade.rb

@@ -0,0 +1,11 @@
+require "cascade/version"
+require "cascade/columns_matching"
+require "cascade/row_processor"
+require "cascade/helpers/configuration"
+
+# Base gem module
+module Cascade
+  extend Configuration
+
+  autoload :DataParser, "cascade/data_parser"
+end

data/lib/cascade/cascade_csv.rb

@@ -0,0 +1,13 @@
+require "csv"
+
+module Cascade
+  class CascadeCsv
+    # Delegates oepn method to CSV with passed and alredy-defined params
+    # This method opens an IO object, and wraps that with CSV.
+    #
+    def self.open(*args)
+      options = if args.last.is_a? Hash then args.pop else Hash.new end
+      CSV.open(*args << options.reverse_merge(col_sep: "\t", quote_char:  "\0"))
+    end
+  end
+end

data/lib/cascade/columns_matching.rb

@@ -0,0 +1,41 @@
+require "yaml"
+require "cascade/exceptions"
+require "cascade/helpers/configuration"
+
+module Cascade
+  class ColumnsMatching
+    extend Forwardable
+    extend Configuration
+
+    define_setting :mapping_file
+
+    def_delegator :supported_keys, :index
+
+    def initialize(options = {})
+      @filepath = options[:filepath]
+      @content = options.fetch(:content) { parse_content_file }
+    end
+
+    # Defines set of possible keys that can be used for iterating through
+    # parsed line
+    #
+    # @return [Array] of supported keys
+    def supported_keys
+      @supported_keys ||= @content.keys
+    end
+
+    # Presenter for passed key
+    #
+    # @return [Symbol] with curresponding value
+    def column_type(key)
+      @content[key].to_sym
+    end
+
+    private
+
+    def parse_content_file
+      content = YAML.load_file(@filepath || self.class.mapping_file)
+      (content && content["mapping"]) || raise(Cascade::WrongMappingFormat.new)
+    end
+  end
+end

data/lib/cascade/complex_fields.rb

@@ -0,0 +1,3 @@
+require "cascade/complex_fields/country_iso"
+require "cascade/complex_fields/currency"
+require "cascade/complex_fields/boolean"

data/lib/cascade/complex_fields/boolean.rb

@@ -0,0 +1,11 @@
+module Cascade
+  module ComplexFields
+    class Boolean
+      TRUE_VALUES = ["True", "true", "x", "+", true]
+
+      def call(value)
+        TRUE_VALUES.include?(value)
+      end
+    end
+  end
+end

data/lib/cascade/complex_fields/country_iso.rb

@@ -0,0 +1,12 @@
+require "iso_country_codes"
+
+module Cascade
+  module ComplexFields
+    class CountryIso
+      def call(country)
+        return unless country
+        IsoCountryCodes.search_by_name(country).first.alpha2
+      end
+    end
+  end
+end

data/lib/cascade/complex_fields/currency.rb

@@ -0,0 +1,23 @@
+require "bigdecimal"
+require "bigdecimal/util"
+
+module Cascade
+  module ComplexFields
+    class Currency
+      def call(value)
+        value = normalized_value(value)
+        value.to_d if valid?(value)
+      end
+
+      private
+
+      def normalized_value(value)
+        String(value).tr(",", ".").tr(" ", "")
+      end
+
+      def valid?(value)
+        true if Float(value) rescue false
+      end
+    end
+  end
+end

data/lib/cascade/concerns/statistics_collectible.rb

@@ -0,0 +1,17 @@
+require "cascade/statistics"
+
+module Cascade
+  module StatisticsCollectible
+    module InstanceMethods
+      def statistics
+        @statistics ||= Statistics.instance
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend Forwardable
+      receiver.send :include, InstanceMethods
+      receiver.def_delegator :statistics, :register_action
+    end
+  end
+end

data/lib/cascade/data_parser.rb

@@ -0,0 +1,28 @@
+require "cascade/columns_matching"
+require "cascade/row_processor"
+require "cascade/error_handler"
+require "cascade/helpers/hash"
+
+module Cascade
+  class DataParser
+    def initialize(filename, options = {})
+      @filename = filename
+      @data_provider    = options.fetch(:data_provider)    { CascadeCsv }
+      @row_processor    = options.fetch(:row_processor)    { RowProcessor.new }
+      @error_handler    = options.fetch(:error_handler)    { ErrorHandler.new }
+      @data_saver       = options.fetch(:data_saver)
+    end
+
+    # Starts parsing processing with opening file and iterating through each
+    # line with parsing and then saves result of each line parsing with
+    # DataSaver
+    #
+    def call
+      @data_provider.open(@filename).each do |row|
+        @error_handler.with_errors_handling(row) do
+          @data_saver.call @row_processor.call(row)
+        end
+      end
+    end
+  end
+end

data/lib/cascade/error_handler.rb

@@ -0,0 +1,23 @@
+module Cascade
+  class ErrorHandler
+    HANDLING_EXCEPTIONS = [IsoCountryCodes::UnknownCodeError, IndexError]
+    DEFAULT_ERROR_STORE = ->(row, reason) do
+      @errors ||= []
+      @errors << [row, reason]
+    end
+
+    def initialize(options = {})
+      @error_store = options.fetch(:error_store) { DEFAULT_ERROR_STORE }
+    end
+
+    # Runs passed block with catching throwing errors and storing in ErrorStore
+    #
+    # @param row [Hash] the object retrieved from CSV to store it in case of
+    # problems with processing
+    def with_errors_handling(row)
+      yield
+    rescue *HANDLING_EXCEPTIONS => exception
+      @error_store.call(row, exception.to_s)
+    end
+  end
+end

data/lib/cascade/exceptions.rb

@@ -0,0 +1,2 @@
+require "cascade/exceptions/wrong_mapping_format"
+require "cascade/exceptions/unknown_presenter_type"

data/lib/cascade/exceptions/unknown_presenter_type.rb

@@ -0,0 +1,3 @@
+module Cascade
+  class UnknownPresenterType < ::StandardError; end
+end

data/lib/cascade/exceptions/wrong_mapping_format.rb

@@ -0,0 +1,3 @@
+module Cascade
+  class WrongMappingFormat < ::StandardError; end
+end

data/lib/cascade/helpers/configuration.rb

@@ -0,0 +1,32 @@
+module Configuration
+  def configuration
+    yield self
+  end
+
+  def define_setting(name, default = nil)
+    class_variable_set("@@#{name}", default)
+
+    define_cattr_reader(name)
+    define_cattr_writer(name)
+  end
+
+  private
+
+  def define_cattr_reader(name)
+    define_class_method name do
+      class_variable_get("@@#{name}")
+    end
+  end
+
+  def define_cattr_writer(name)
+    define_class_method "#{name}=" do |value|
+      class_variable_set("@@#{name}", value)
+    end
+  end
+
+  def define_class_method(name, &block)
+    (class << self; self; end).instance_eval do
+      define_method name, &block
+    end
+  end
+end

data/lib/cascade/helpers/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def reverse_merge(other_hash)
+    other_hash.merge(self)
+  end
+end

data/lib/cascade/row_processor.rb

@@ -0,0 +1,51 @@
+require "cascade/complex_fields"
+require "cascade/exceptions"
+require "cascade/helpers/configuration"
+
+module Cascade
+  class RowProcessor
+    extend Configuration
+
+    DEFAULT_PROCESSOR = ->(value) { value }
+
+    define_setting :use_default_presenter, false
+    define_setting :deafult_presenter, -> { DEFAULT_PROCESSOR }
+
+    def initialize(options = {})
+      @columns_matching = options[:columns_matching] || ColumnsMatching.new
+      @presenters       = options.reverse_merge(defined_presenters)
+    end
+
+    # Iterates through object using columns values supported keys as keys for
+    # iterating, then parse it by curresponding parser.
+    #
+    # @param row [Hash] the object retrieved from CSV
+    # @return [Hash] the object with parsed columns
+    def call(row)
+      @columns_matching.supported_keys.inject({}) do |result, key|
+        raw_value = row.fetch(@columns_matching.index(key))
+        value     = receive_presenter(key).call(raw_value)
+        result.merge(key => value)
+      end
+    end
+
+    private
+
+    def receive_presenter(column_name)
+      presenter = @presenters[@columns_matching.column_type(column_name)]
+      if presenter.nil? && !self.class.use_default_presenter
+        raise Cascade::UnknownPresenterType.new
+      end
+      presenter || self.class.deafult_presenter
+    end
+
+    def defined_presenters
+      {
+        string:      DEFAULT_PROCESSOR,
+        currency:    ComplexFields::Currency.new,
+        country_iso: ComplexFields::CountryIso.new,
+        boolean:     ComplexFields::Boolean.new,
+      }
+    end
+  end
+end

data/lib/cascade/statistics.rb

@@ -0,0 +1,58 @@
+require "singleton"
+require "cascade/statistics_stores"
+
+module Cascade
+  class Statistics
+    include Singleton
+
+    STORES = {
+      counter: StatisticsStores::CounterStore,
+      array: StatisticsStores::ArrayStore
+    }.freeze
+
+    def initialize
+      @store_repository = {}
+    end
+
+    # Register statistics action with passed store
+    #
+    # @param action [Symbol] action name that will be used to access it
+    # @param store [Symbol] type of using store
+    # @param default_value [Object] value that will be used as default for store
+    # @return [Object] instance of passed store
+    def register_action(action, store, default_value = nil)
+      @store_repository[action] = defined_stores.fetch(store.to_sym) do
+        default_store
+      end.new(default_value)
+    end
+
+    # Updates store action with passed value
+    #
+    # @param action [Symbol] action name that will be used to access it
+    # @param value [Object] for updating store
+    def update(action, value = nil)
+      @store_repository[action].update(value)
+    end
+
+    # Returns statistics from store for passed action
+    #
+    # @param action [Symbol] action name that will be used to access it
+    def for(action)
+      @store_repository[action].store
+    end
+
+    protected
+
+    attr_reader :store_repository
+
+    private
+
+    def defined_stores
+      STORES
+    end
+
+    def default_store
+      StatisticsStores::AbstractStore
+    end
+  end
+end

data/lib/cascade/statistics_stores.rb

@@ -0,0 +1,3 @@
+require "cascade/statistics_stores/abstract_store"
+require "cascade/statistics_stores/counter_store"
+require "cascade/statistics_stores/array_store"