csv_model 0.1.0

data/lib/csv_model/row.rb

@@ -0,0 +1,128 @@
+using CSVModel::Extensions
+
+module CSVModel
+  class Row
+    include Utilities::Options
+
+    attr_reader :data, :header, :marked_as_duplicate
+
+    def initialize(header, data, options = {})
+      @header = header
+      @data = data
+      @options = options
+    end
+
+    def index(value)
+      index = column_index(value) || value
+      data[index] if index.is_a?(Fixnum) && index >= 0
+    end
+    alias_method :[], :index
+
+    def errors
+      errors = []
+      errors << duplicate_row_error if is_dry_run? && marked_as_duplicate?
+      errors << model_instance.errors if !model_instance.valid?
+      errors.flatten
+    end
+
+    def key
+      cols = primary_key_columns
+      if cols.one?
+        index(cols.first.key)
+      elsif cols.any?
+        cols.collect { |x| index(x.key) }
+      else
+        data
+      end
+    end
+
+    def marked_as_duplicate?
+      !!marked_as_duplicate
+    end
+
+    def mark_as_duplicate
+      @marked_as_duplicate = true
+    end
+
+    def status
+      model_instance.status
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    [:errors, :status, :valid?].each do |method_name|
+      method = instance_method(method_name)
+      define_method(method_name) do |*args, &block|
+        process_row
+        method.bind(self).(*args, &block)
+      end
+    end
+
+    private
+
+    def all_attributes
+      @all_attributes ||= column_attributes_with_values(columns)
+    end
+
+    def columns
+      header.columns
+    end
+
+    def column_attributes_with_values(cols)
+      Hash[cols.collect { |col| [col.model_attribute, index(col.key)] }]
+    end
+
+    def column_index(key)
+      header.column_index(key)
+    end
+
+    def duplicate_row_error
+      names = primary_key_columns.collect { |x| x.name }
+      names.any? ? "Duplicate #{names.join(', ')}" : "Duplicate row"
+    end
+
+    def is_dry_run?
+      option(:dry_run, false)
+    end
+
+    def model
+      option(:model)
+    end
+
+    def model_instance
+      @model_instance ||= begin
+        x = inherit_or_delegate(:find_row_model, key_attributes) 
+        x ||= inherit_or_delegate(:new_row_model, key_attributes)
+        x = CSVModel::ObjectWithStatusSnapshot.new(x)
+      end
+    end
+
+    def key_attributes
+      cols = primary_key_columns.any? ? primary_key_columns : columns
+      @key_attributes ||= column_attributes_with_values(cols)
+    end
+
+
+    def primary_key_columns
+      header.primary_key_columns
+    end
+
+    def process_row
+      return if @processed
+      @processed = true
+
+      model_instance.assign_attributes(all_attributes)
+      model_instance.mark_as_duplicate if marked_as_duplicate?
+      model_instance.save(dry_run: is_dry_run?)
+    end
+
+    private
+
+    def inherit_or_delegate(method, *args)
+      try(method, *args) || model.try(method, *args)
+    end
+
+  end
+end

data/lib/csv_model/utilities.rb

@@ -0,0 +1,15 @@
+using CSVModel::Extensions
+
+module CSVModel
+  module Utilities
+    module Options
+
+      attr_reader :options
+
+      def option(key, default = nil)
+        options.try(:[], key) || options.try(key) || default
+      end
+
+    end
+  end
+end

data/lib/csv_model/version.rb

@@ -0,0 +1,3 @@
+module CSVModel
+  VERSION = "0.1.0"
+end

data/lib/csv_model.rb

@@ -0,0 +1,17 @@
+require 'csv'
+require 'delegate'
+
+require 'csv_model/errors'
+require 'csv_model/extensions'
+require 'csv_model/record_status'
+require 'csv_model/utilities'
+
+require 'csv_model/column'
+require 'csv_model/row'
+require 'csv_model/header_row'
+require 'csv_model/model'
+require 'csv_model/object_with_status_snapshot'
+require 'csv_model/version'
+
+module CSVModel
+end

data/spec/csv_model/column_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe CSVModel::Column do
+
+  let(:column_name) { "Column One" }
+  let(:subject) { described_class.new(column_name) }
+
+  describe "#is_primary_key?" do
+    it "defaults to false" do
+      expect(subject.is_primary_key?).to eq(false)
+    end
+
+    it "returns false if options indicate column is a primary key" do
+      subject = described_class.new(column_name, primary_key: true)
+      expect(subject.is_primary_key?).to eq(true)
+    end
+  end
+
+  describe "#key" do
+    it "returns the column key" do
+      expect(subject.key).to eq("column one")
+    end
+  end
+
+  describe "#model_attribute" do
+    it "returns a symbolized version of the column key" do
+      expect(subject.model_attribute).to eq(:column_one)
+    end
+  end
+
+end

data/spec/csv_model/header_row_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+describe CSVModel::HeaderRow do
+
+  let(:data) { ["Column One"] }
+  let(:subject) { described_class.new(data) }
+
+  # TODO: should detect invalid opbions
+  #  e.g. when primar_key is not a subset of columns
+  #   raise ArgumentError, 'Message'
+
+  describe "#columns" do
+    it "returns an empty array when no columns exist" do
+      subject = described_class.new([])
+      expect(subject.columns).to eq([])
+    end
+
+    it "returns a column object that describes each column" do
+      columns = subject.columns
+      expect(columns).to be_an(Array)
+      expect(columns.size).to eq(1)
+
+      column = columns.first
+      expect(column.name).to eq(data.first)
+    end
+  end
+
+  describe "#column_index" do
+    it "returns nil when a column does not exist" do
+      expect(subject.column_index("Non-existent Column")).to eq(nil)
+    end
+
+    it "finds the index of a column given its value" do
+      expect(subject.column_index("Column One")).to eq(0)
+    end
+
+    it "finds the index of a column regardless of capitalization" do
+      expect(subject.column_index("column ONE")).to eq(0)
+    end
+
+    it "finds the index of a column regardless of leading whitespace" do
+      expect(subject.column_index(" Column One")).to eq(0)
+    end
+
+    it "finds the index of a column regardless of trailing whitespace" do
+      expect(subject.column_index("Column One\t")).to eq(0)
+    end
+
+    it "finds the index of a column given its symbolic representation" do
+      expect(subject.column_index("Column One".to_sym)).to eq(0)
+    end
+  end
+
+  describe "#column_count" do
+    it "returns 0 when no columns" do
+      subject = described_class.new([])
+      expect(subject.column_count).to eq(0)
+    end
+
+    it "returns the number of columns" do
+      expect(subject.column_count).to eq(1)
+    end
+  end
+
+  describe "#errors" do
+    it "returns an empty array when header is valid" do
+      expect(subject.errors).to eq([])
+    end
+
+    it "returns duplicate column message when header has duplicate columns" do
+      subject = described_class.new(data + data)
+      expect(subject.errors).to eq(["Multiple columns found for Column One, column headings must be unique"])
+    end
+
+    it "returns illegal column message when header contains illegal columns" do
+      subject = described_class.new(data, legal_columns: ["Column Two"])
+      expect(subject.errors).to eq(["Unknown column Column One"])
+    end
+
+    it "returns returns required column message when header is missing required columns" do
+      subject = described_class.new(data, required_columns: ["Column Two"])
+      expect(subject.errors).to eq(["Missing column Column Two"])
+    end
+  end
+
+  describe "#has_column?" do
+    it "returns false when a column does not exist" do
+      expect(subject.has_column?("Non-existent Column")).to eq(false)
+    end
+
+    it "returns true when a column does exist" do
+      expect(subject.has_column?("Column One")).to eq(true)
+    end
+  end
+
+  describe "#primary_key_columns" do
+    it "returns emptry array when no primary key columns specified" do
+      expect(subject.primary_key_columns).to eq([])
+    end
+
+    context "when the row has a single primary key column" do
+      let(:subject) { described_class.new(data, OpenStruct.new(primary_key: ["Column One"])) }
+
+      it "has a single key column" do
+        expect(subject.primary_key_columns.count).to eq(1)
+      end
+
+      it "returns the key column" do
+        column = subject.primary_key_columns.first
+        expect(column.name).to eq("Column One")
+      end
+
+      context "even if the column capitalization does not match" do
+        let(:subject) { described_class.new(data, OpenStruct.new(primary_key: ["column one"])) }
+
+        it "returns the key column" do
+          column = subject.primary_key_columns.first
+          expect(column.name).to eq("Column One")
+        end
+      end
+    end
+
+    context "when the row has multiple primary key columns" do
+      let(:data) { ["Column One", "Column Two"] }
+      let(:subject) { described_class.new(data, primary_key: data) }
+
+      it "returns the key columns" do
+        expect(subject.primary_key_columns.collect { |x| x.name }).to eq(["Column One", "Column Two"])
+      end
+    end
+  end
+
+  describe "#valid?" do
+    it "returns true when header is valid" do
+      expect(subject.valid?).to eq(true)
+    end
+
+    it "returns false when header has duplicate columns" do
+      subject = described_class.new(data + data)
+      expect(subject.valid?).to eq(false)
+    end
+
+    it "returns false when header contains illegal columns" do
+      subject = described_class.new(data, legal_columns: ["Column Two"])
+      expect(subject.valid?).to eq(false)
+    end
+
+    it "returns false when header is missing required columns" do
+      subject = described_class.new(data, required_columns: ["Column Two"])
+      expect(subject.valid?).to eq(false)
+    end
+  end
+
+  describe "internals" do
+    describe "#duplicate_column_names" do
+      it "doesn't respond to duplicate_column_names" do
+        expect(subject.respond_to?(:duplicate_column_names)).to eq(false)
+      end
+
+      it "returns an empty array when no duplicate columns exist" do
+        expect(subject.send(:duplicate_column_names)).to eq([])
+      end
+
+      it "returns the duplicate column names when duplicate columns exist" do
+        data << data.first
+        expect(subject.send(:duplicate_column_names)).to eq(["Column One"])
+      end
+    end
+
+    describe "#has_duplicate_columns?" do
+      it "doesn't respond to has_duplicate_columns?" do
+        expect(subject.respond_to?(:has_duplicate_columns?)).to eq(false)
+      end
+
+      it "returns false when no duplicate columns exist" do
+        expect(subject.send(:has_duplicate_columns?)).to eq(false)
+      end
+
+      it "returns true when duplicate columns exist" do
+        data << data.first
+        expect(subject.send(:has_duplicate_columns?)).to eq(true)
+      end
+    end
+
+    describe "#has_illegal_columns?" do
+      it "doesn't respond to has_illegal_columns?" do
+        expect(subject.respond_to?(:has_illegal_columns?)).to eq(false)
+      end
+
+      it "returns false when no legal columns specified" do
+        expect(subject.send(:has_illegal_columns?)).to eq(false)
+      end
+
+      context "with legal columns specified" do
+        let(:subject) { described_class.new(data, legal_columns: ["Column One"]) }
+
+        it "returns false when no illegal columns are present" do
+          expect(subject.send(:has_illegal_columns?)).to eq(false)
+        end
+
+        it "returns true when an illegal column is present" do
+          data[0] = "Column Two"
+          expect(subject.send(:has_illegal_columns?)).to eq(true)
+        end
+      end
+    end
+
+    describe "#has_required_columns?" do
+      it "doesn't respond to has_required_columns?" do
+        expect(subject.respond_to?(:has_required_columns?)).to eq(false)
+      end
+
+      it "returns true when no required columns specified" do
+        expect(subject.send(:has_required_columns?)).to eq(true)
+      end
+
+      context "with required columns specified" do
+        let(:subject) { described_class.new(data, required_columns: ["Column One"]) }
+
+        it "returns true when all required columns are present" do
+          expect(subject.send(:has_required_columns?)).to eq(true)
+        end
+
+        it "returns false when a required columns is missing" do
+          data[0] = "Column Two"
+          expect(subject.send(:has_required_columns?)).to eq(false)
+        end
+      end
+    end
+
+    describe "illegal_column_names" do
+      it "doesn't respond to illegal_colum_names" do
+        expect(subject.respond_to?(:illegal_colum_names)).to eq(false)
+      end
+
+      it "returns emptry array when no legal columns specified" do
+        expect(subject.send(:illegal_column_names)).to eq([])
+      end
+
+      context "with legal columns specified" do
+        let(:subject) { described_class.new(data, OpenStruct.new(legal_columns: ["Column One"])) }
+
+        it "returns empty array when no illegal columns are present" do
+          expect(subject.send(:illegal_column_names)).to eq([])
+        end
+
+        it "returns array of illegal column names when a illegal column is present" do
+          data[0] = "Column Two"
+          expect(subject.send(:illegal_column_names)).to eq(["Column Two"])
+        end
+      end
+    end
+
+    describe "#missing_column_names" do
+      it "doesn't respond to missing_column_names" do
+        expect(subject.respond_to?(:missing_column_names)).to eq(false)
+      end
+
+      it "returns emptry array when no required columns specified" do
+        expect(subject.send(:missing_column_names)).to eq([])
+      end
+
+      context "with required columns specified" do
+        let(:subject) { described_class.new(data, OpenStruct.new(required_columns: ["Column One"])) }
+
+        it "returns empty array when all required columns are present" do
+          expect(subject.send(:missing_column_names)).to eq([])
+        end
+
+        it "returns array of missing column names when a required column is missing" do
+          data[0] = "Column Two"
+          expect(subject.send(:missing_column_names)).to eq(["Column One"])
+        end
+      end
+    end
+  end
+
+end

data/spec/csv_model/model_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe CSVModel::Model do
+
+  let(:header_row) { ["Column One", "Column Two"] }
+  let(:data_row) { ["Value One", "Value Two"] }
+  let(:data) { [header_row.join("\t"), data_row.join("\t")].join($/) }
+  let(:subject) { described_class.new(data) }
+
+  describe "header" do
+    context "with options" do
+      let(:options) { { dry_run: true } }
+      let(:subject) { described_class.new(data, options) }
+
+      it "instantiates header with options" do
+        expect(subject.header.options).to eq(options)
+      end
+    end
+  end
+
+  describe "rows" do
+    it "has a row for each data row" do
+      expect(subject.rows.count).to eq(1)
+    end
+
+    context "with options" do
+      let(:options) { { dry_run: true } }
+      let(:subject) { described_class.new(data, options) }
+
+      it "instantiates rows with options" do
+        expect(subject.rows.first.options).to eq(options)
+      end
+    end
+  end
+
+  describe "#row_count" do
+    it "returns 0 when no data" do
+      expect(described_class.new("").row_count).to eq(0)
+    end
+
+    it "returns the number of rows" do
+      expect(subject.row_count).to eq(1)
+    end
+  end
+
+  describe "#structure_errors" do
+    it "returns an empty array when CSV data has integrity" do
+      expect(subject.structure_errors).to eq([])
+    end
+
+    it "returns a parser specific error when CSV data is maleformed" do
+      expect(CSV).to receive(:parse).and_raise(CSV::MalformedCSVError.new("foo"))
+      expect(subject.structure_errors).to eq(["The data could not be parsed. Please check for formatting errors: foo"])
+    end
+
+    it "returns a parser specific error when CSV data is inconsistent" do
+      data_row.shift
+      expect(subject.structure_errors).to eq(["Each row should have exactly 2 columns. Error on row 2."])
+    end
+
+    it "returns a generic error when CSV data is invalid" do
+      expect(CSV).to receive(:parse).and_raise(Exception.new("foo"))
+      expect(subject.structure_errors).to eq(["An unexpected error occurred. Please try again or contact support if the issue persists: foo"])
+    end
+
+    it "returns header errors when header is invalid" do
+      header_row.pop
+      header_row << header_row.first
+      expect(subject.structure_errors).to eq(["Multiple columns found for Column One, column headings must be unique"])
+    end
+
+    context "with required columns" do
+      let(:options) { OpenStruct.new(required_columns: ["Column Two", "Column Three", "Column Four"]) }
+      let(:subject) { described_class.new(data, options) }
+
+      it "returns errors for each missing required column" do
+        expect(subject.structure_errors).to eq(["Missing column Column Three", "Missing column Column Four"])
+      end
+    end
+  end
+
+  describe "#structure_valid?" do
+    it "returns true when CSV data has integrity" do
+      expect(subject.structure_valid?).to eq(true)
+    end
+
+    it "returns false when CSV data is maleformed" do
+      expect(CSV).to receive(:parse).and_raise(CSV::MalformedCSVError.new("foo"))
+      expect(subject.structure_valid?).to eq(false)
+    end
+
+    it "returns false when CSV data is invalid" do
+      expect(CSV).to receive(:parse).and_raise(Exception.new("foo"))
+      expect(subject.structure_valid?).to eq(false)
+    end
+
+    it "returns false when header is invalid" do
+      header_row.shift
+      header_row << header_row.first
+      expect(subject.structure_valid?).to eq(false)
+    end
+  end
+
+  describe "internals" do
+    describe "#parse_data" do
+      context "with a custom header row class" do
+        class TestHeaderRow < CSVModel::HeaderRow; end
+
+        let(:subject) { described_class.new(data, header_class: TestHeaderRow) }
+
+        before do
+          subject.send(:parse_data)
+        end
+
+        it "uses the custom class in parsing" do
+          expect(subject.header.class).to eq(TestHeaderRow)
+        end
+      end
+
+      context "With a custom row class" do
+        class TestRow < CSVModel::Row; end
+
+        let(:subject) { described_class.new(data, row_class: TestRow) }
+
+        before do
+          subject.send(:parse_data)
+        end
+
+        it "uses the custom class in parsing" do
+          expect(subject.rows.count).to eq(1)
+          expect(subject.rows.first.class).to eq(TestRow)
+        end
+      end
+
+      context "with duplicate rows" do
+        let(:data) { [header_row.join("\t"), data_row.join("\t"), data_row.join("\t"), data_row.join("\t")].join($/) }
+
+        before do
+          subject.send(:parse_data)
+        end
+
+        context "with a single column primary key" do
+          let(:subject) { described_class.new(data, primary_key: [header_row.first]) }
+
+          context "when primary key values are present" do
+            it "does not mark the first row as a duplicate" do
+              puts subject.structure_errors
+              expect(subject.rows.first.marked_as_duplicate?).to eq(false)
+            end
+
+            it "marks subsequent instances as a duplicates" do
+              rows = subject.rows
+              rows.shift
+              rows.each { |row| expect(row.marked_as_duplicate?).to eq(true) }
+            end
+          end
+
+          context "when no primary key values are present" do
+            let(:data_row) { ["", ""] }
+
+            it "does not mark any row as a duplicate" do
+              subject.rows.each { |row| expect(row.marked_as_duplicate?).to eq(false) }
+            end
+          end
+        end
+
+        context "with a compount primary key" do
+          context "when primary key values are present" do
+            it "does not mark the first row as a duplicate" do
+              expect(subject.rows.first.marked_as_duplicate?).to eq(false)
+            end
+
+            it "marks subsequent instances as a duplicates" do
+              rows = subject.rows
+              rows.shift
+              rows.each { |row| expect(row.marked_as_duplicate?).to eq(true) }
+            end
+          end
+
+          context "when no primary key values are present" do
+            let(:data_row) { ["", ""] }
+
+            it "does not mark any row as a duplicate" do
+              subject.rows.each { |row| expect(row.marked_as_duplicate?).to eq(false) }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end