stockboy 0.5.0

data/lib/stockboy/translator.rb

@@ -0,0 +1,66 @@
+require 'stockboy/exceptions'
+require 'stockboy/source_record'
+
+module Stockboy
+
+  # This is an abstract class to help set up common named translations
+  #
+  # A Translator receives a source record and transforms selected attributes to
+  # another format or type. The entire record context is passed to the
+  # translator so that other fields can be compared, split, or recombined
+  # (instead of just getting the single attribute value without context)
+  #
+  # == Interface
+  #
+  # To implement a translator type, you must:
+  #
+  # * Initialize with the attribute name to which it applies.
+  # * Implement a +translate+ method that returns the value for the attribute
+  #   it is transforming.
+  # * Use +field_value(context, field_key)+ to access the input value in the
+  #   translate method.
+  #
+  # @abstract
+  #
+  class Translator
+
+    # Field from the record context to which the translation will apply
+    #
+    attr_reader :field_key
+
+    # Initialize a new translator for an attribute
+    #
+    # @param [Symbol] key Mapped attribute name to be translated
+    #
+    def initialize(key)
+      @field_key = key
+    end
+
+    # Perform translation on a record attribute
+    #
+    # @param [SourceRecord, MappedRecord, Hash] context
+    #   The record to which the translation will be applied
+    #
+    def call(context)
+      context = OpenStruct.new(context) if context.is_a? Hash
+      translate(context)
+    end
+
+    # String representation for a more helpful representation
+    #
+    def inspect
+      "#<#{self.class.name||'Stockboy::Translator'} (#{@field_key})>"
+    end
+
+    private
+
+    def field_value(context, field_key)
+      context.send field_key if context.respond_to? field_key
+    end
+
+    def translate(context)
+      raise NoMethodError, "def #{self.class}#translate needs implementation"
+    end
+
+  end
+end

data/lib/stockboy/version.rb

@@ -0,0 +1,3 @@
+module Stockboy
+  VERSION = "0.5.0"
+end

data/spec/fixtures/files/a_garbage.csv

@@ -0,0 +1 @@
+Garbage

data/spec/fixtures/files/test_data-20120101.csv

@@ -0,0 +1 @@
+2012-01-01

data/spec/fixtures/files/test_data-20120202.csv

@@ -0,0 +1 @@
+2012-02-02

data/spec/fixtures/files/z_garbage.csv

@@ -0,0 +1 @@
+Garbage

data/spec/fixtures/jobs/test_job.rb

@@ -0,0 +1 @@
+# file exists!

data/spec/fixtures/soap/get_list/fault.xml

@@ -0,0 +1,8 @@
+<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
+  <soap:Body>
+    <soap:Fault>
+      <faultcode>soap:Server</faultcode>
+      <faultstring>Fault occurred while processing.</faultstring>
+    </soap:Fault>
+  </soap:Body>
+</soap:Envelope>

data/spec/fixtures/soap/get_list/success.xml

@@ -0,0 +1,18 @@
+<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+  <soapenv:Body>
+    <MultiNamespacedEntryResponse xmlns="http://www.example.com/BusinessRulesEngine/xsd">
+      <history>
+        <ns10:case xmlns:ns10="http://www.example.com/Common/xsd">
+          <ns10:logTime>2010-09-21T18:22:01.558+10:00</ns10:logTime>
+          <ns10:logType>Notes Log</ns10:logType>
+          <ns10:logText>test</ns10:logText>
+        </ns10:case>
+        <ns11:case xmlns:ns11="http://www.example.com/Common/xsd">
+          <ns11:logTime>2010-09-21T18:22:07.038+10:00</ns11:logTime>
+          <ns11:logType>Notes Log</ns11:logType>
+          <ns11:logText>another test</ns11:logText>
+        </ns11:case>
+      </history>
+    </MultiNamespacedEntryResponse>
+  </soapenv:Body>
+</soapenv:Envelope>

data/spec/fixtures/xml/body.xml

@@ -0,0 +1,14 @@
+<MultiNamespacedEntryResponse xmlns="http://www.example.com/BusinessRulesEngine/xsd">
+  <history>
+    <ns10:case xmlns:ns10="http://www.example.com/Common/xsd">
+      <ns10:logTime>2010-09-21T18:22:01.558+10:00</ns10:logTime>
+      <ns10:logType>Notes Log</ns10:logType>
+      <ns10:logText>test</ns10:logText>
+    </ns10:case>
+    <ns11:case xmlns:ns11="http://www.example.com/Common/xsd">
+      <ns11:logTime>2010-09-21T18:22:07.038+10:00</ns11:logTime>
+      <ns11:logType>Notes Log</ns11:logType>
+      <ns11:logText>another test</ns11:logText>
+    </ns11:case>
+  </history>
+</MultiNamespacedEntryResponse>

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'pry'
+require 'pry-debugger'
+require 'ostruct'
+require 'savon'
+require 'savon/mock/spec_helper'
+# require 'vcr'
+
+$:.unshift File.expand_path('../lib/stockboy/lib', __FILE__)
+
+RSpec.configure do |config|
+  config.include Savon::SpecHelper
+  config.mock_with :rspec
+  spec_fixtures = File.expand_path("fixtures", File.dirname(__FILE__))
+  config.add_setting :fixture_path, default: Pathname(spec_fixtures)
+
+  config.before :suite do
+    require 'stockboy/configuration'
+    Stockboy.configure do |c|
+      c.logger = Logger.new(StringIO.new)
+    end
+  end
+
+end
+
+# VCR.configure do |c|
+#   c.cassette_library_dir = 'fixtures/vcr_cassettes'
+#   # c.hook_into :fakeweb # or :fakeweb
+# end

data/spec/stockboy/attribute_map_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'stockboy/attribute_map'
+
+module Stockboy
+  describe AttributeMap do
+
+    subject do
+      AttributeMap.new do
+        email
+        updated_at from: 'statusDate', as: [proc{ |v| Date.parse(v) }]
+      end
+    end
+
+    describe ".new" do
+      it "initializes from hash attribute" do
+        row = Attribute.new(:email, "email", [])
+        map = AttributeMap.new(:email => row)
+        map[:email].should == row
+      end
+    end
+
+    it "captures same destination as default" do
+      subject[:email].should == Attribute.new(:email, "email", [])
+    end
+
+    it "sets source from string to string" do
+      map = AttributeMap.new { updated_at from: "statusDate" }
+      map[:updated_at].from.should == "statusDate"
+    end
+
+    it "sets source from symbol to string" do
+      map = AttributeMap.new { updated_at from: :statusDate }
+      map[:updated_at].from.should == "statusDate"
+    end
+
+    it "sets source from number to number" do
+      map = AttributeMap.new { email from: 12 }
+      map[:email].from.should == 12
+    end
+
+    it "sets callable translators" do
+      subject[:updated_at].translators.first.call("2012-01-01").should == Date.new(2012,1,1)
+    end
+
+    it "has attr accessors" do
+      subject.email.should be_a Attribute
+    end
+
+    it "raises error for undefined attrs" do
+      expect {subject.foobar}.to raise_error(NoMethodError)
+    end
+
+    it "is enumerable" do
+      subject.map(&:from).should == ["email", "statusDate"]
+      subject.map(&:to).should == [:email, :updated_at]
+    end
+
+  end
+end

data/spec/stockboy/attribute_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'stockboy/attribute'
+
+module Stockboy
+  describe Attribute do
+    it "describes its attrs" do
+      attr = Attribute.new :outfield, "infield", [:one, :two]
+      attr.inspect.should == %{#<Stockboy::Attribute to=:outfield, from="infield", translators=[:one, :two]>}
+    end
+  end
+end

data/spec/stockboy/candidate_record_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'stockboy/candidate_record'
+
+module Stockboy
+  describe CandidateRecord do
+
+    let(:hash_attrs) do
+      {'id' => '1',
+       'full_name' => 'Arthur Dent',
+       'email' => 'adent@example.com',
+       'birthday' => '1980-01-01'}
+    end
+
+    describe "initialize" do
+      let(:map) { AttributeMap.new { id; email } }
+
+      it "takes a hash and attributes map" do
+        record = CandidateRecord.new(hash_attrs, map)
+      end
+    end
+
+    describe "#to_hash" do
+      it "remaps attributes" do
+        map = AttributeMap.new { name from: 'full_name' }
+        subject = CandidateRecord.new(hash_attrs, map).to_hash
+        subject.should == { :name => 'Arthur Dent' }
+      end
+
+      it "converts String subclasses to clean strings" do
+        stub_const 'Nori::StringWithAttributes', Class.new(String)
+        map = AttributeMap.new { full_name }
+        hash_attrs['full_name'] = Nori::StringWithAttributes.new('Arthur')
+        subject = CandidateRecord.new(hash_attrs, map).to_hash
+        subject[:full_name].class.should == String
+      end
+    end
+
+    describe "#raw_hash" do
+      it "remaps attributes" do
+        map = AttributeMap.new { name from: 'full_name' }
+        subject = CandidateRecord.new(hash_attrs, map).raw_hash
+        subject.should == { :name => 'Arthur Dent' }
+      end
+
+      it "does not translate attributes" do
+        map = AttributeMap.new { birthday as: ->(r) { Date.parse(r.birthday) } }
+        subject = CandidateRecord.new(hash_attrs, map).raw_hash
+        subject.should == { :birthday => "1980-01-01" }
+      end
+    end
+
+    describe "attribute translation" do
+      subject(:hash) { CandidateRecord.new(hash_attrs, map).to_hash }
+
+      context "from lambda" do
+        let(:map) { AttributeMap.new{ birthday as: ->(r){ Date.parse(r.birthday) } } }
+        it { should == {birthday: Date.new(1980,1,1)} }
+      end
+
+      context "from symbol lookup" do
+        before    { Stockboy::Translations.register :date, ->(r){ Date.parse(r.birthday) } }
+        let(:map) { AttributeMap.new{ birthday :as => :date } }
+        it { should == {birthday: Date.new(1980,1,1)} }
+      end
+
+      context "chaining" do
+        let(:map) { AttributeMap.new{ id as: [->(r){r.id.next}, ->(r){r.id.next}] } }
+        it { should == {id: '3'} }
+      end
+
+      context "with exception" do
+        let(:map) { AttributeMap.new{ id as: [->(r){r.id.to_i}, ->(r){r.id / 0}] } }
+        it { should == {id: nil} }
+      end
+
+      context "dynamic without an input field" do
+        let(:map) { AttributeMap.new{ generated as: [->(r){ "from lambda" }] } }
+        it { should == {generated: "from lambda"} }
+      end
+    end
+
+    describe "#to_model" do
+      it "should instantiate a new model" do
+        model = Class.new(OpenStruct)
+        model.should_receive(:new).with({id: '1', name: 'Arthur Dent'})
+        map = AttributeMap.new { id; name from: 'full_name' }
+        subject = CandidateRecord.new(hash_attrs, map)
+
+        subject.to_model(model)
+      end
+    end
+
+    describe "#input" do
+      describe "[]" do
+        it "fetches raw values for raw input keys" do
+          map = AttributeMap.new { name from: 'full_name' }
+          subject = CandidateRecord.new(hash_attrs, map)
+          subject.input['full_name'].should == 'Arthur Dent'
+        end
+      end
+
+      it "accesses fields by mapped name before translation" do
+        map = AttributeMap.new { name from: 'full_name', as: ->(r){ r.name.upcase } }
+        subject = CandidateRecord.new(hash_attrs, map)
+        subject.input.name.should == 'Arthur Dent'
+      end
+    end
+
+    describe "#output" do
+      describe "[]" do
+        it "fetches translated values for raw input keys" do
+          map = AttributeMap.new { name from: 'full_name' }
+          subject = CandidateRecord.new(hash_attrs, map)
+          subject.output.name.should == 'Arthur Dent'
+        end
+      end
+    end
+
+    describe "#partition" do
+      subject do
+        CandidateRecord.new({'name' =>'Arthur'}, AttributeMap.new { name })
+      end
+
+      it "returns first matched filter key" do
+        key = subject.partition(zeta:  proc{ |raw| raw.name =~ /Z/ },
+                                alpha: proc{ |raw| raw.name =~ /A/ })
+        key.should == :alpha
+      end
+
+      it "returns a match for translated block argument" do
+        map = AttributeMap.new { name as: ->(r){ r.name.downcase } }
+        subject = CandidateRecord.new({'name' =>'Arthur'}, map)
+
+        key = subject.partition(down: proc{ |raw,out| out.name[0] == "a" })
+        key.should == :down
+      end
+
+      it "returns nil when raw field is unmatched" do
+        key = subject.partition({beta: proc{ |raw| raw.name =~ /B/ }})
+        key.should be_nil
+      end
+
+      it "returns nil when translated field is unmatched" do
+        key = subject.partition({beta: proc{ |raw,out| out.name =~ /B/ }})
+        key.should be_nil
+      end
+    end
+
+  end
+end

data/spec/stockboy/configuration_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'stockboy/configuration'
+
+module Stockboy
+  describe Configuration do
+
+    subject(:config) { Stockboy::Configuration.new }
+
+    it "yields a config block" do
+      Stockboy::Configuration.new do |c|
+        c.should be_a Stockboy::Configuration
+      end
+    end
+
+    it "is accessible from top namespace" do
+      Stockboy.configuration.should be_a Stockboy::Configuration
+    end
+
+    specify "#template_load_paths" do
+      config.template_load_paths.clear
+      config.template_load_paths << "/some_path"
+      config.template_load_paths.should == ["/some_path"]
+      config.template_load_paths = ["/other_path"]
+      config.template_load_paths.should == ["/other_path"]
+    end
+
+  end
+end

data/spec/stockboy/configurator_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+require 'stockboy/configurator'
+
+module Stockboy
+  describe Configurator do
+
+    let(:provider_class) { OpenStruct }
+    let(:reader_class)   { OpenStruct }
+
+    describe "#initialize" do
+      it "evaluates string config" do
+        expect_any_instance_of(Configurator).to receive(:provider).with(:ftp)
+        Configurator.new("provider :ftp")
+      end
+
+      it "evaluates block config" do
+        expect_any_instance_of(Configurator).to receive(:provider).with(:ftp)
+        Configurator.new do
+          provider :ftp
+        end
+      end
+    end
+
+    describe "#provider" do
+      before do
+        Providers.register(:ftp, provider_class)
+      end
+
+      it "registers with a symbol" do
+        subject.provider :ftp
+        subject.config[:provider].should be_a(provider_class)
+      end
+
+      it "registers with a class" do
+        subject.provider provider_class
+        subject.config[:provider].should be_a(provider_class)
+      end
+
+      it "initializes arguments" do
+        provider_class.should_receive(:new).with(password:'foo')
+        subject.provider :ftp, password: 'foo'
+      end
+    end
+
+    describe "#reader" do
+      before do
+        Readers.register(:csv, reader_class)
+      end
+
+      it "registers with a symbol" do
+        subject.reader :csv
+        subject.config[:reader].should be_a(reader_class)
+      end
+
+      it "registers with a class" do
+        subject.reader reader_class
+        subject.config[:reader].should be_a(reader_class)
+      end
+
+      it "initializes arguments" do
+        reader_stub = double(:reader)
+        reader_class.should_receive(:new).with(col_sep: '|').and_return(reader_stub)
+        subject.reader reader_class, col_sep: '|'
+        subject.config[:reader].should == reader_stub
+      end
+    end
+
+    describe "#attributes" do
+      it "initializes a block" do
+        attribute_map = double
+        AttributeMap.should_receive(:new).and_return(attribute_map)
+        subject.attributes &proc{}
+        subject.config[:attributes].should be attribute_map
+      end
+    end
+
+    describe "#on" do
+
+      let(:job) { double(:job, reset: true, process: true) }
+
+      it "initializes a block" do
+        subject.on :reprocess do |job, *args|
+          job.reset
+          job.process
+        end
+
+        subject.config[:triggers][:reprocess][0].should be_a Proc
+      end
+
+    end
+
+    describe "#filter" do
+      it "initializes a callable" do
+        filter_stub = double(call: true)
+        subject.filter :pass, filter_stub
+        subject.config[:filters][:pass].should == filter_stub
+      end
+
+      it "initializes a block" do
+        subject.filter :pass do |r|
+          true if r == 42
+        end
+        subject.config[:filters][:pass].call(42).should == true
+      end
+    end
+
+    describe "#to_job" do
+      before do
+        Providers.register :test_prov, provider_class
+        Readers.register :test_read, reader_class
+      end
+
+      it "returns a Job instance" do
+        subject.provider :test_prov
+        subject.reader :test_read
+        subject.attributes &proc{}
+
+        job = subject.to_job
+        job.should be_a(Job)
+        job.provider.should be_a(provider_class)
+        job.reader.should be_a(reader_class)
+        job.attributes.should be_a(AttributeMap)
+      end
+    end
+
+  end
+end