datashift 0.16.0 → 0.40.0

data/spec/datashift/configuration.rb

@@ -0,0 +1,66 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2011
+# License::   MIT
+#
+# Details::   Specs for base class Loader
+#
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DataShift
+
+  describe Configuration do
+
+    let(:defaults) do
+      { project:
+          { value_as_string: 'Default Project Value',
+            category: 'reference:category_002',
+            value_as_datetime: Time.now.to_s(:db)
+          }
+      }
+    end
+
+    before do
+    end
+
+    let(:call) { DataShift::Exporters::Configuration.call }
+
+    context "with" do
+
+      it 'defaults to basic attribute data' do
+        expect(call.op_types_in_scope).to eq [:assignment, :enum]
+      end
+
+      it 'returns complete list of op types when [:all] specified' do
+        DataShift::Exporters::Configuration.configure do |config|
+          config.with = [:all]
+        end
+        expect(call.op_types_in_scope).to eq ModelMethod.supported_types_enum
+      end
+
+      it 'returns complete list of op types when :all specified' do
+        DataShift::Exporters::Configuration.configure do |config|
+          config.with = :all
+        end
+        expect(call.op_types_in_scope).to eq ModelMethod.supported_types_enum
+      end
+
+      it 'can be configuresd  complete list of op types when :all specified' do
+        DataShift::Exporters::Configuration.configure do |config|
+          config.with = :all
+        end
+        expect(call.op_types_in_scope).to eq ModelMethod.supported_types_enum
+      end
+
+      it 'can be configured  with custom list of op types to process' do
+        DataShift::Exporters::Configuration.configure do |config|
+          config.with = [:assignment, :enum, :belongs_to]
+        end
+        expect(call.op_types_in_scope).to eq [:assignment, :enum, :belongs_to]
+      end
+
+
+    end
+  end
+
+end

data/spec/datashift/context_factory_spec.rb

@@ -0,0 +1,63 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# License::   MIT
+#
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DataShift
+
+  describe 'Context Factory' do
+
+    include_context 'ClearThenManageProject'
+
+    # got burnt by other tests failing if run after this, we are caching stuff in this class
+    # that perissts across tests - so ContextFactory design probably a code smell
+    after(:all) do
+      ContextFactory.clear_populators
+    end
+
+    let(:model_method) { project_collection.search('value_as_string') }
+
+    let(:method_binding) { MethodBinding.new('column_for_value_as_string', 0, model_method) }
+
+    let(:another_populator) do
+      class AnotherPopulator
+      end
+
+      AnotherPopulator
+    end
+
+    context 'configuring' do
+      it 'can be configured to provide a specific Populator per operator' do
+        expect {
+          ContextFactory.set_populator(method_binding, another_populator)
+        }.to change(ContextFactory.populators, :size).by(1)
+      end
+    end
+
+    context 'providing populators' do
+      before(:each) do
+        ContextFactory.clear_populators
+
+        ContextFactory.set_populator(method_binding, another_populator)
+      end
+
+      it 'should provide a default Populator when none specifically defined' do
+
+        mb = MethodBinding.new('value_as_boolean', 0, project_collection.search('value_as_boolean'))
+
+        populator = ContextFactory.get_populator(mb)
+
+        expect(populator).to be
+        expect(populator).to be_a Populator
+      end
+
+      it 'should provide a specific Populator when one defined' do
+        populator = ContextFactory.get_populator(method_binding)
+
+        expect(populator).to_not be_nil
+        expect(populator).to be_a AnotherPopulator
+      end
+    end
+  end
+end

data/spec/datashift/data_flow_schema_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DataShift
+
+  RSpec.describe DataFlowSchema, type: :model do
+
+    let(:data_flow_schema) { subject }
+
+    let(:yaml_text) {
+      x=<<-EOS
+      data_flow_schema:
+        Project:
+          nodes:
+            - project_title:
+                heading:
+                  source: "title"
+                operator: title
+            - value_as_string:
+                heading:
+                  source: "Value:"
+                operator: value_as_string
+            - project_owner_budget:
+                heading:
+                  source: "Budget"
+                operator: owner.budget
+            - value_as_integer:
+                heading:
+                  source: "This Column goes to value_as_string"
+      EOS
+      x
+    }
+
+    context "DataFlowSchema" do
+
+      context("YAML (LOCALE) DSL") do
+
+        before(:each) do
+          @collection = data_flow_schema.prepare_from_string(yaml_text)
+        end
+
+        it "build node collection from a locale based DSL" do
+          expect(@collection).to be_instance_of NodeCollection
+          expect(@collection.size).to eq operators_in_config.size
+        end
+
+        it "each section is an instance of Node" do
+          @collection = data_flow_schema.prepare_from_string(yaml_text)
+          expect(@collection.first).to be_instance_of DataShift::NodeContext
+        end
+
+        let(:operators_in_config) { ['title', 'value_as_string', 'owner.budget', ''] }
+
+
+        it "should preserve order of the nodes and cope with nil" do
+          @collection.each_with_index {|n, i| expect(n.operator).to eq operators_in_config[i] }
+
+          operators = @collection.collect(&:operator)
+
+          expect(operators).to eq operators_in_config
+        end
+=begin
+      it "each row contains columns required to build view" do
+        review_data_column = review_data_sections.first.rows.first
+
+        expect(review_data_column).to be_instance_of Struct::ReviewDataRow
+
+        expect(review_data_column.title).to be_instance_of String
+        expect(review_data_column.link_state).to be_instance_of String
+      end
+
+      context("Specific YAML") do
+        include_examples "clear_and_after_reload_yaml"
+
+        it "can access methods directly on the model" do
+          I18n.backend.store_translations(:en, YAML.load(simple_review_farming_yaml))
+
+          expect(I18n.exists?("enrollment_review")).to eq true
+
+          review_data_list = enrollment_review.prepare_from_locale(enrollment)
+
+          expect(review_data_list.size).to eq 1
+
+          review_data_section = review_data_list.first
+
+          expect(review_data_section.heading).to eq "Farming data"
+          expect(review_data_section.rows.size).to eq 2
+
+          row = review_data_section.rows.first
+
+          expect(row).to be_instance_of Struct::ReviewDataRow
+          expect(row.data).to eq enrollment.on_a_farm?
+        end
+
+        it "can access methods on an association of the model", fail: true do
+          I18n.backend.store_translations(:en, YAML.load(direct_and_association_review_yaml))
+
+          expect(I18n.exists?("enrollment_review")).to eq true
+
+          review_data_list = enrollment_review.prepare_review_data_list
+
+          expect(review_data_list.size).to eq 2 # 2 sections
+          review_data_section = review_data_list.last
+
+          expect(review_data_section.heading).to eq "Waste Exemption Codes"
+          expect(review_data_section.rows.size).to eq enrollment.exemptions.count
+
+          row = review_data_section.rows.first
+
+          expect(row).to be_instance_of Struct::ReviewDataRow
+
+          expect(row.data).to eq enrollment.exemptions.first.code
+          expect(row.link_state).to eq "bad_link"
+
+          expect(row.target(enrollment)).to include "/reviews/"
+          expect(row.target(enrollment)).to include "/bad_link/"
+          expect(row.target(enrollment)).to include enrollment.id.to_s
+        end
+
+        context("association and method chaining") do
+          before(:each) do
+            I18n.backend.store_translations(:en, YAML.load(chained_review_yaml))
+          end
+
+          let(:review_data_list) { enrollment_review.prepare_review_data_list }
+
+          it "can access associated object down the whole association chain on model" do
+            expect(review_data_list.size).to eq 2
+            organisation_address_section = review_data_list.first
+
+            row = organisation_address_section.rows.first
+
+            expect(row.data).to eq enrollment.organisation.contact.email_address
+          end
+
+          it "can access methods down the whole association chain on model" do
+            expect(review_data_list.size).to eq 2
+            applicant_contact_section = review_data_list.last
+
+            row = applicant_contact_section.rows.first
+
+            expect(row.data).to eq enrollment.applicant_contact.business_number.tel_number
+          end
+        end
+      end
+    end
+=end
+      end
+    end
+  end
+end

data/spec/datashift/datashift_spec.rb

@@ -0,0 +1,52 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Oct 2011
+# License::   MIT
+#
+# Details::   Specs for high level apsects of DataShift library
+#
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'datashift/version'
+
+describe 'DataShift' do
+  before(:each) do
+  end
+
+  it 'should provide gem version' do
+    expect(DataShift::VERSION).to be_a String
+  end
+
+  it 'should provide gem name' do
+    expect(DataShift.gem_name).to eq 'datashift'
+  end
+
+  it 'should provide root_path' do
+    expect(DataShift.root_path).to_not be_empty
+  end
+
+  it 'should provide a log' do
+    class Blah
+      include DataShift::Logging
+
+      def try_me
+        logger.info 'hello datashift spec'
+      end
+    end
+
+    b = Blah.new
+
+    b.logger.info 'try me'
+
+    b.try_me
+  end
+
+  it 'should provide quick way to create exception class' do
+    DataShift::DataShiftException.generate( 'BadRspecError')
+
+    e = DataShift::BadRspecError.new('my new exception  class')
+
+    expect(e).to be
+    expect(e.message).to eq 'my new exception  class'
+  end
+end

data/spec/datashift/excel_base_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module DataShift
+
+  module ExcelBase
+
+    describe 'ExcelBase' do
+      before(:each) do
+        include DataShift::ExcelBase
+        extend DataShift::ExcelBase
+      end
+
+      let(:file_name) { ifixture_file('ProjectsSingleCategories.xls') }
+
+      it 'should provide fast access to an Excel instance' do
+        expect( start_excel(Project) ).to be_a DataShift::Excel
+      end
+
+      it 'should provide fast access to open an existing Excel file' do
+        expect( open_excel(file_name) ).to be_a DataShift::Excel
+      end
+
+      let(:sheet_name) { 'RspecTester' }
+
+      it 'should enable us to add a named worksheet' do
+        start_excel(Project, sheet_name: sheet_name)
+        expect( excel ).to be_a DataShift::Excel
+
+        expect( sheet ).to be_a Spreadsheet::Worksheet
+        expect( sheet.name ).to eq sheet_name
+      end
+
+      it 'should enable us to add a named worksheet to existing Excel file' do
+        open_excel(file_name, sheet_name: sheet_name)
+        expect( excel ).to be_a DataShift::Excel
+
+        expect( sheet ).to be_a Spreadsheet::Worksheet
+        expect( sheet.name ).to eq sheet_name
+      end
+
+      context 'Once opened' do
+
+        before(:each) do
+          open_excel(file_name, sheet_number: 0)
+        end
+
+        it 'should provide fast access to current sheet' do
+          expect( sheet ).to be_a Spreadsheet::Worksheet
+        end
+
+        it 'should parse headers' do
+          parse_headers( sheet )
+        end
+      end
+    end
+  end
+end

data/spec/datashift/excel_spec.rb

@@ -0,0 +1,188 @@
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+require 'excel'
+
+module DataShift
+
+  describe 'Excel Proxy' do
+    let(:excel) { Excel.new }
+
+    it 'should reject .xlsx until spreedsheet gem supports it' do
+      expect { excel.open( ifixture_file('ProjectsSingleCategories.xlsx') ) }.to raise_error Ole::Storage::FormatError
+    end
+
+    it 'can open an existing spreadsheet' do
+      sheet = excel.open( ifixture_file('ProjectsSingleCategories.xls') )
+
+      expect(sheet).to_not be_nil
+    end
+
+    it 'can create new un-named worksheet' do
+      sheet1 = excel.create_worksheet
+
+      expect( sheet1.name).to eq 'Worksheet1'
+    end
+
+    it 'can create multiple un-named worksheets' do
+      sheet1 = excel.create_worksheet
+      sheet2 = excel.create_worksheet
+      expect(sheet1.name).to eq 'Worksheet1'
+      expect(sheet2.name).to eq 'Worksheet2'
+    end
+
+    it 'can create new named worksheet' do
+      sheet = excel.create_worksheet( name: 'daft punk')
+      expect( sheet.name).to eq 'daft punk'
+
+      sheet2 = excel.create_worksheet( name: 'underworld')
+      expect( sheet2.name).to eq 'underworld'
+    end
+
+    it 'can sanitize worksheet names as per Excel spec' do
+      include DataShift::ExcelBase
+      extend DataShift::ExcelBase
+
+      #    name.gsub(/[\[\]:\*\/\\\?]/, '
+
+      expect(sanitize_sheet_name('aute?chre')).to eq 'autechre'
+      expect(sanitize_sheet_name('?autechre')).to eq 'autechre'
+      expect(sanitize_sheet_name('aute?chre?')).to eq 'autechre'
+
+      expect(sanitize_sheet_name('daft: ?punk')).to eq 'daft punk'
+      expect(sanitize_sheet_name('guy call[]ed *Gerald')).to eq 'guy called Gerald'
+
+      expect(sanitize_sheet_name('guy called */Gerald')).to eq 'guy called Gerald'
+    end
+
+    # Pending - inject create_worksheet method into Spreadsheet gem
+    if DataShift::Guards.jruby?
+      it 'ensures name of worksheet sanitized' do
+        sheet = excel.create_worksheet( name: 'daft: ?punk')
+        expect( sheet.name).to eq 'daft punk'
+
+        sheet = excel.create_worksheet( name: 'under[]world')
+        expect( sheet.name).to eq 'underworld'
+      end
+    end
+
+    it 'can create multiple named worksheets' do
+      excel.create_worksheet( name: 'underworld')
+      excel.create_worksheet( name: 'jeff mills')
+      excel.create_worksheet( name: 'autechre')
+      excel.create_worksheet( name: 'swarms')
+
+      expect(excel.worksheets.size).to eq 4
+    end
+
+    it 'can access a worksheet by index' do
+      excel.create_worksheet( name: 'underworld')
+      excel.create_worksheet( name: 'jeff mills')
+      excel.create_worksheet( name: 'autechre')
+
+      expect(excel.worksheets[0].name).to eq 'underworld'
+      expect(excel.worksheets[2].name).to eq 'autechre'
+    end
+
+    it 'can access a worksheet by ID' do
+      excel.create_worksheet( name: 'daft punk')
+      excel.create_worksheet( name: 'underworld')
+
+      expect(excel.worksheet(0).name).to eq 'daft punk'
+
+      expect(excel.worksheet(1).name).to eq 'underworld'
+    end
+
+    it 'can add data to a specific row and column' do
+      excel.create_worksheet( name: 'underworld')
+
+      excel[0, 1] = 'born slippy'
+      expect(excel[0, 1]).to eq 'born slippy'
+
+      excel[1, 23] = 23.0
+      expect(excel[1, 23]).to eq 23.0
+
+      excel[0, 5] = true
+      expect( excel[0, 5]).to eq true
+    end
+
+    it 'can ask a row what index it is' do
+      excel.create_worksheet( name: 'underworld')
+
+      excel[3, 0] = 'do i know who i am?'
+      excel[28, 0] = 'who am i?'
+
+      r1 = excel.row(3)
+      expect(r1[0]).to eq 'do i know who i am?'
+      expect(r1.idx).to eq 3    #  idx (0-based)
+
+      r2 = excel.row(28)
+      expect(r2[0]).to eq 'who am i?'
+      expect(r2.idx).to eq 28   #  idx (0-based)
+    end
+
+    it 'can iterate over the rows in a worksheet' do
+      sheet = excel.create_worksheet
+
+      excel[0, 1] = 12.30
+      excel[1, 1] = 25.30
+      excel[3, 1] = 4
+
+      sheet.each do |row|
+        row[0] = "A#{row.idx}"
+      end
+
+      expect(excel[0, 0]).to eq 'A0'
+      expect(excel[1, 0]).to eq 'A1'
+
+      # pending for JRuby ... spreadsheet iterates from 0 to max row, probably
+      # dynamically creating rows that have never been referenced ..
+      expect(excel[2, 0]).to eq 'A2' unless DataShift::Guards.jruby?
+
+      expect(excel[3, 0]).to eq 'A3'
+
+      expect(excel[0, 1]).to eq 12.30
+      expect(excel[1, 1]).to eq 25.30
+      expect(excel[2, 1]).to satisfy { |x| x == '' || x.nil? }
+      expect(excel[3, 1]).to eq 4
+    end
+
+    it 'can iterate over the cells in a row' do
+      sheet = excel.create_worksheet
+
+      values = ['hello world', 12.30, '', 4]
+
+      values.each_with_index do |v, i|
+        excel[0, i] = v
+      end
+
+      row = excel.row(0)
+
+      row.each { |col| expect(col).to eq values.shift }
+    end
+
+    # it "can support bools" do
+    #  pending "reading back value sometimes returns "" when cell was set to false"
+
+    # sheet = excel.create_worksheet
+
+    # end
+
+    it 'can write an Excel file' do
+      excel = Excel.new
+
+      sheet1 = excel.create_worksheet
+
+      excel.create_worksheet( name: 'underworld')
+
+      excel[0, 1] = 'born slippy'
+      expect(excel[0, 1]).to eq 'born slippy'
+
+      expected = result_file('it_can_save_an_excel_file.xls')
+
+      excel.write( expected )
+
+      expect(File.exist?(expected)).to eq true
+    end
+  end
+
+end