datashift 0.16.0 → 0.40.0

data/lib/datashift/guards.rb

@@ -23,9 +23,8 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-
 # Details::   Active Record Loader
-# 
+#
 # To pull DataShift commands into your main application :
 #
 #     require 'datashift'
@@ -33,14 +32,15 @@
 #     DataShift::load_commands
 #
 require 'rbconfig'
-  
+
 module DataShift
 
   module Guards
 
     def self.jruby?
-      return RUBY_PLATFORM == "java"
+      RUBY_PLATFORM == 'java'
     end
+
     def self.mac?
       RbConfig::CONFIG['target_os'] =~ /darwin/i
     end
@@ -54,4 +54,4 @@ module DataShift
     end
 
   end
-end
+end

data/lib/datashift/header.rb

@@ -0,0 +1,25 @@
+# Copyright:: (c) Autotelik Media Ltd 2016
+# Author ::   Tom Statter
+# Date ::     Feb 2016
+# License::   MIT
+#
+# Details::   A column header
+#
+module DataShift
+
+  class Header
+
+    attr_accessor :source, :presentation
+
+    def initialize(source:)
+      @source = source
+      @presentation = source
+    end
+
+    def to_s
+      presentation
+    end
+
+  end
+
+end

data/lib/datashift/headers.rb

@@ -0,0 +1,94 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# License::   MIT
+#
+# Details::   Holds the current headers and any pre-processing
+#             mapping done on them
+#
+require 'forwardable'
+
+module DataShift
+
+  # Acts as an array
+
+  class Headers
+
+    attr_accessor :source
+
+    # Row Index
+    attr_reader :idx
+
+    extend Forwardable
+
+    def_delegators :@headers, *Array.delegated_methods_for_fwdable
+
+    def initialize(source, idx = 0, headers = [])
+      @source = source
+      @idx = idx
+      @headers = headers
+    end
+
+    # Factory for dealing with Active Record models and collections
+    # Catalogs the supplied Klass and builds set of expected/valid Headers for Klass
+    #
+    def self.klass_to_headers(klass)
+
+      headers = Headers.new(klass)
+
+      headers.class_source_to_headers
+
+      DataShift::Transformation::Remove.new.unwanted_headers(headers)
+
+      headers
+    end
+
+    # Helpers for dealing with source = class, usually an Active Record model
+    # Catalogs the supplied Klass and builds set of expected/valid Headers for Klass
+    #
+    def class_source_to_headers
+
+      raise SourceIsNotAClass, 'Cannot parse source for headers - source must be a Class' unless source.is_a?(Class)
+
+      # TODO: This collection can now be sorted
+      collection = ModelMethods::Manager.catalog_class(source)
+
+      configuration = DataShift::Configuration.call
+
+      collection.each do |mm|
+        next if(DataShift::Transformation::Remove.new.association?(mm))
+
+        if(mm.association_type?)
+          association_to_headers(mm)
+        else
+          add mm.operator
+        end if(configuration.op_type_in_scope?(mm))
+      end if collection
+    end
+
+    def association_to_headers( model_method )
+
+      configuration = DataShift::Configuration.call
+
+      if(configuration.expand_associations)
+        model_method.association_columns.each do |c|
+          add "#{model_method.operator}::#{c.name}"
+        end
+      else
+        add model_method.operator
+      end
+    end
+
+    def add(source)
+      @headers << Header.new(source: source)
+    end
+
+    def sources
+      @headers.collect(&:source)
+    end
+
+    def row_index
+      idx
+    end
+
+  end
+end

data/lib/datashift/inbound_data/column.rb

@@ -0,0 +1,44 @@
+# Copyright:: (c) Autotelik Media Ltd 2016
+# Author ::   Tom Statter
+# License::   MIT
+#
+# Details::   The basic raw Header info from a client - column heading, column indexx
+#             Column contains additional data such as lookup fields, defaults etc
+#
+
+module DataShift
+
+  module InboundData
+
+    class Column
+
+      attr_accessor :header, :index, :lookup_list, :data
+
+      def initialize(source, index = -1)
+
+        @header = DataShift::Header.new(source: source)
+
+        @index = index
+        @lookup_list = []
+        @data = []
+      end
+
+      delegate :source, to: :header
+
+      alias lookups lookup_list
+
+      def add_lookup( klass, field, where_value )
+        @lookup_list.unshift( LookupSupport.new(klass, field, where_value) )
+      end
+
+      def find_by_operator
+        lookup_list.first ? lookup_list.first.field : ''
+      end
+
+      def find_by_value
+        lookup_list.first ? lookup_list.first.value : ''
+      end
+
+    end
+  end
+end

data/lib/datashift/inbound_data/lookup_support.rb

@@ -0,0 +1,33 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Jan 2015
+# License::   MIT
+#
+# Details::  Store details of the inbound data from Excel,CSV files etc
+
+module DataShift
+
+  module InboundData
+
+    # Store data supplied from client to find an instance of an object (e.g find Associations)
+
+    # Klass.where( @field => @where_value)
+
+    class LookupSupport
+
+      attr_reader :klass, :field, :where_value
+
+      def initialize(klass, in_name, where_value)
+        @klass = klass
+        @field = in_name
+        @where_value = where_value
+      end
+
+      def find
+        klass.where( field => where_value )
+      end
+
+    end
+
+  end
+end

data/lib/datashift/inbound_data/method_binding.rb

@@ -0,0 +1,139 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Jan 2015
+# License::   MIT
+#
+# Details::   Bind incoming data to it's associated domain model
+#             Link headers to the details of individual population methods
+#
+#             Enables 'loaders' to iterate over the incoming data set, and assign
+#             values to domain object, without knowing anything about that receiving object.
+#
+require 'set'
+
+module DataShift
+
+  class MethodBinding
+
+    include DataShift::Logging
+
+    attr_reader :model_method
+
+    attr_reader :inbound_column
+
+    delegate :source, to: :inbound_column, allow_nil: true
+
+    # Is this method detail a valid mapping, aids identifying unmapped/unmappable columns
+    attr_accessor :valid
+
+    # Store the raw (client supplied) name against the active record  klass(model).
+    # Operator is the associated method call on klass,
+    # i.e client supplies name 'Price' in a spreadsheet,
+    # but true operator to call on klass is price
+    #
+    # type determines the style of operator call; simple assignment, an association or a method call
+    #
+    # col_types can typically be derived from klass.columns - set of ActiveRecord::ConnectionAdapters::Column
+
+    def initialize(name, idx, model_method)
+      @inbound_column = InboundData::Column.new(name, idx)
+
+      @model_method = model_method
+
+      @valid = (name && model_method) ? true : false
+    end
+
+    # TODO: - use delegators
+    def operator
+      model_method ? model_method.operator : ''
+    end
+
+    def operator?(name, case_sensitive = false)
+      model_method ? model_method.operator?(name, case_sensitive) : false
+    end
+
+    def klass
+      model_method.klass
+    end
+
+    def class_name
+      model_method.klass.name
+    end
+
+    def inbound_name
+      inbound_column.source
+    end
+
+    def inbound_index
+      inbound_column.index
+    end
+
+    def add_column_data(data)
+      inbound_column.data << data
+    end
+
+    # Example :
+    # Project:name:My Best Project
+    #   User (klass) has_one project  lookup where name(field) == 'My Best Project' (value)
+    #   User.project.where( :name => 'My Best Project')
+
+    def add_lookup( model_method, field, value)
+
+      # check the finder method name is a valid field on the actual association class
+      klass = model_method.klass
+
+      association = klass.reflect_on_association(model_method.operator)
+
+      # TODO: - this is instance methods .. what about class methods ?
+      if association && association.klass.new.respond_to?(field)
+        inbound_column.add_lookup(association.klass, field, value)
+        logger.info("Complex Lookup specified for [#{model_method.operator}] : on field [#{field}] (optional value [#{value}])")
+      else
+        logger.error("Check MethodBinding [#{inbound_name}](#{inbound_index}) - Association field names are case sensitive")
+        raise NoSuchOperator.new("Field [#{field}] Not Found on Association [#{model_method.operator}] within Class #{klass.name}")
+      end
+    end
+
+    def valid?
+      (@valid == true)
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def pp
+      "Binding: Column [#{inbound_index}] : Header [#{inbound_name}] : Operator [#{model_method.operator}]"
+    end
+
+    def spp
+      "Column [#{inbound_index}] : Header [#{inbound_name}]"
+    end
+
+  end
+
+  class NoMethodBinding < MethodBinding
+
+    attr_accessor :reason
+
+    def initialize(client_name = '', client_idx = -1, options = {})
+      super(client_name, client_idx, nil)
+
+      @reason = options[:reason] || ''
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    def valid?
+      false
+    end
+
+    def pp
+      "No Binding Found : Row [#{inbound_index}] : Header [#{inbound_name}]"
+    end
+
+  end
+
+end

data/lib/datashift/load_object.rb

@@ -1,25 +1,50 @@
 # Copyright:: (c) Autotelik Media Ltd 2015
 # Author ::   Tom Statter
 # Date ::     March 2015
-# License::   MIT
+# License::   MI
 #
 # Details::   Manage the current loader object
 #
-require 'to_b'
-require 'logging'
-
+#
 module DataShift
 
-  class LoadObject
-    
-    include DataShift::Logging
+  class LoadObject < SimpleDelegator
+
+    attr_accessor :instance
+
+    def initialize(current_object)
+      super
+      @instance = current_object
+    end
+
+   # delegate :errors, to: :instance
 
-    attr_accessor :load_object
+    # This method usually called during processing to avoid errors with associations like
+    #   <ActiveRecord::RecordNotSaved: You cannot call create unless the parent is saved>
+    # If the object is still invalid at this point probably indicates compulsory
+    # columns on model have not been processed before associations on that model
+    #
+    def save_if_new
+      return false unless instance && instance.new_record?
 
-    def initialize( current_object = nil)
-      @load_object = current_object
+      return instance.save if instance.valid?
+
+      raise SaveError, "Cannot Save #{instance.class} : #{instance.errors.full_messages.inspect}"
+    end
+
+    private
+
+=begin
+    def method_missing(method, *args, &block)
+      raise "Cannot call [#{method}] on : #{instance.class.name}"
+      if instance.respond_to? method
+        instance.send(method, *args, &block)
+      else
+        raise "Cannot call [#{method}] on : #{instance.class.name}"
+      end
     end
-    
+=end
+
   end
-  
+
 end

data/lib/datashift/logging.rb

@@ -1,4 +1,4 @@
-# Copyright:: (c) Autotelik Media Ltd 2012
+# Copyright:: (c) Autotelik Media Ltd 2015
 # Author ::   Tom Statter
 # Date ::     Aug 2012
 # License::   Free, Open Source. MIT.
@@ -6,53 +6,80 @@
 # Details::   Logging facilities for datashift.
 #
 require 'fileutils'
-  
+require 'singleton'
+
 module DataShift
 
   module Logging
-    
+
     class MultiIO
-           
-      def initialize(*targets)
+
+      include Singleton
+
+      attr_reader :targets
+
+      def initialize
         @targets = []
-        targets.each {|t| @targets << Logger.new(t) }
+        @names = []
       end
 
-      def add(target)
-        @targets << Logger.new(target)
-      end
-      
-      
-      def method_missing(method, *args, &block)
-        @targets.each {|t| t.send(method, *args, &block) }
+      def add_file(target)
+        unless @names.include?(target)
+          puts "Logging going to target [#{target}]"
+          add( File.open(target, 'a') )
+          @names << target
+        end
       end
-    
+
       def verbose
         add(STDOUT)
       end
-    
+
+      def method_missing(method, *args, &block)
+        @targets.each { |t| t.send(method, *args, &block) }
+      end
+
+      private
+
+      def add(target)
+        @targets << Logger.new(target)
+      end
+
     end
-    
+
     require 'logger'
-     
+
+    def logdir=(x)
+      @logdir = x
+    end
+
     def logdir
       @logdir ||= 'log'
       @logdir
     end
-  
+
     def logger
-      @logger ||= open
-      @logger
+      @mutli_logger ||= open
+      @mutli_logger
+    end
+
+    def verbose
+      @verbose_logger ||= logger.add(STDOUT)
     end
-    
+
     private
-    
+
     def open( log = 'datashift.log')
-      return ActiveRecord::Base.logger if(defined?(ActiveRecord) && ActiveRecord::Base.logger)
-      FileUtils::mkdir(logdir) unless File.directory?(logdir)
-      log_file = File.open( File.join(logdir(), 'datashift.log'), "a")
-      MultiIO.new(log_file)
+      FileUtils.mkdir(logdir) unless File.directory?(logdir)
+
+      MultiIO.instance.add_file(File.join(logdir, log))
+
+      ActiveRecord::Base.logger = MultiIO.instance if defined?(ActiveRecord) && ActiveRecord::Base.logger
+
+      verbose if(DataShift::Configuration.call.verbose)
+
+      MultiIO.instance
     end
   end
-  
+
 end