datashift 0.16.0 → 0.40.0

data/lib/datashift/method_dictionary.rb

@@ -1,281 +0,0 @@
-# Copyright:: (c) Autotelik Media Ltd 2012
-# Author ::   Tom Statter
-# Date ::     Aug 2010
-# License::   MIT
-#
-# Details::   A cache type class that stores details of all possible associations on AR classes.
-#             
-module DataShift
-
-  class MethodDictionary
-
-    include DataShift::Logging
-    extend DataShift::Logging
-
-    # Return true if dictionary has  been populated for  klass
-    def self.for?(klass)
-      any = has_many[klass] || belongs_to[klass] || has_one[klass] || assignments[klass]
-      return any != nil
-    end
-    
-    # Create simple picture of all the operator names for assignment available on an AR model,
-    # grouped by type of association (includes belongs_to and has_many which provides both << and = )
-    # Options:
-    #   :reload => clear caches and re-perform  lookup
-    #   :instance_methods => if true include instance method type 'setters' as well as model's pure columns
-    #
-    def self.find_operators(klass, options = {} )
-      
-      raise "Cannot find operators supplied klass nil #{klass}" if(klass.nil?)
-
-      logger.debug("MethodDictionary - building operators information for #{klass}")
-
-      # Find the has_many associations which can be populated via <<
-      if( options[:reload] || has_many[klass].nil? )
-        has_many[klass] = klass.reflect_on_all_associations(:has_many).map { |i| i.name.to_s }
-        klass.reflect_on_all_associations(:has_and_belongs_to_many).inject(has_many[klass]) { |x,i| x << i.name.to_s }
-      end
-
-      # Find the belongs_to associations which can be populated via  Model.belongs_to_name = OtherArModelObject
-      if( options[:reload] || belongs_to[klass].nil? )
-        belongs_to[klass] = klass.reflect_on_all_associations(:belongs_to).map { |i| i.name.to_s }
-      end
-
-      # Find the has_one associations which can be populated via  Model.has_one_name = OtherArModelObject
-      if( options[:reload] || has_one[klass].nil? )
-        has_one[klass] = klass.reflect_on_all_associations(:has_one).map { |i| i.name.to_s }
-      end
-
-      # Find the model's column associations which can be populated via xxxxxx= value
-      # Note, not all reflections return method names in same style so we convert all to
-      # the raw form i.e without the '='  for consistency 
-      if( options[:reload] || assignments[klass].nil? )
- 
-        assignments[klass] = klass.column_names  
-         
-        # get into consistent format with other assignments names i.e remove the = for now
-        assignments[klass] += setters(klass).map{|i| i.gsub(/=/, '')} if(options[:instance_methods])
-           
-        # Now remove all the associations
-        assignments[klass] -= has_many[klass]   if(has_many[klass])
-        assignments[klass] -= belongs_to[klass] if(belongs_to[klass])
-        assignments[klass] -= has_one[klass]    if(has_one[klass])
-         
-        # TODO remove assignments with id
-        # assignments => tax_id  but already in belongs_to => tax
-        
-        assignments[klass].uniq!
-
-        assignments[klass].each do |assign|
-          column_types[klass] ||= {}
-          column_def = klass.columns.find{ |col| col.name == assign }
-          column_types[klass].merge!( assign => column_def) if column_def
-        end
-      end
-    end
-    
-    def self.setters( klass )
-          
-      # N.B In 1.8 these return strings, in 1.9 symbols.
-      # map everything to strings a
-      #setters = klass.accessible_attributes.sort.collect( &:to_s )
-      
-      # remove methodsa that start with '_'
-      @keep_only_pure_setters ||= Regexp.new(/^[a-zA-Z]\w+=/)
-      
-      setters = klass.instance_methods.grep(@keep_only_pure_setters).sort.collect( &:to_s )
-      setters.uniq
-    end
-
-    def self.add( klass, operator, type = :assignment)
-      method_details_mgr = get_method_details_mgr( klass )
-      md = MethodDetail.new(operator, klass, operator, type)
-      method_details_mgr <<  md
-      return md
-    end
-    
-    # Build a thorough and usable picture of the operators by building dictionary of our MethodDetail
-    # objects which can be used to import/export data to objects of type 'klass'
-    # Subsequent calls with same class will return existign mapping
-    # To over ride this behaviour, supply :force => true to force  regeneration
-
-    def self.build_method_details( klass, options = {} )
-
-      return method_details_mgrs[klass] if(method_details_mgrs[klass] && !options[:force])
-
-      method_details_mgr = MethodDetailsManager.new( klass )
-      
-      method_details_mgrs[klass] = method_details_mgr
-            
-      assignments_for(klass).each do |n|
-        method_details_mgr << MethodDetail.new(n, klass, n, :assignment, column_types[klass])
-      end
-        
-      has_one_for(klass).each do |n|
-        method_details_mgr << MethodDetail.new(n, klass, n, :has_one)
-      end
-        
-      has_many_for(klass).each do |n|
-        method_details_mgr << MethodDetail.new(n, klass, n, :has_many)
-      end
-        
-      belongs_to_for(klass).each do |n|
-        method_details_mgr << MethodDetail.new(n, klass, n, :belongs_to)
-      end
-      
-      method_details_mgr
-      
-    end
-    
-    # TODO - check out regexp to do this work better plus Inflections ??
-    # Want to be able to handle any of ["Count On hand", 'count_on_hand', "Count OnHand", "COUNT ONHand" etc]
-    def self.substitutions(external_name)
-      name = external_name.to_s
-      
-      [
-        name.downcase,
-        name.tableize,
-        name.gsub(' ', '_'),
-        name.gsub(' ', '_').downcase,
-        name.gsub(/(\s+)/, '_').downcase,
-        name.gsub(' ', ''),
-        name.gsub(' ', '').downcase,
-        name.gsub(' ', '_').underscore
-      ]
-    end
-
-
-    # Dump out all available operators
-    #
-    def self.dump( klass )
-      method_details_mgr = get_method_details_mgr( klass )
-      #TODO
-    end
-
-
-    # For a client supplied name/header - find the operator i.e appropriate call + column type
-    # 
-    # e.g Given users entry in spread sheet check for pluralization, missing underscores etc
-    #
-    # If not nil, returned method can be used directly in for example klass.new.send( call, .... )
-    #
-    def self.find_method_detail( klass, external_name, conditions = nil )
-
-      method_details_mgr = get_method_details_mgr( klass )
-   
-      # first try for an exact match across all association types
-      MethodDetail::supported_types_enum.each do |t|
-        method_detail = method_details_mgr.find(external_name, t)
-        return method_detail.clone if(method_detail)
-      end  
-              
-      # Now try various alternatives of the name
-      substitutions(external_name).each do |n|    
-        # Try each association type, returning first that contains matching operator with name n    
-        MethodDetail::supported_types_enum.each do |t|
-          method_detail = method_details_mgr.find(n, t)
-          return method_detail.clone if(method_detail)
-        end  
-      end
-
-      nil
-    end
-    
-    # Assignments can contain things like delegated methods, this returns a matching 
-    # method details only when a true database column   
-    def self.find_method_detail_if_column( klass, external_name )
-
-      method_details_mgr = get_method_details_mgr( klass )
-      
-      # first try for an exact match across all association types
-      MethodDetail::supported_types_enum.each do |t|
-        method_detail = method_details_mgr.find(external_name, t)
-        return method_detail.clone if(method_detail && method_detail.col_type) 
-      end  
-              
-      # Now try various alternatives
-      substitutions(external_name).each do |n|    
-        # Try each association type, returning first that contains matching operator with name n    
-        MethodDetail::supported_types_enum.each do |t|
-          method_detail = method_details_mgr.find(n, t)
-          return method_detail.clone if(method_detail && method_detail.col_type) 
-        end  
-      end
-
-      nil
-    end
-    
-    
-    def self.clear
-      belongs_to.clear
-      has_many.clear
-      assignments.clear
-      column_types.clear
-      has_one.clear
-      method_details_mgrs.clear
-    end
-
-    def self.column_key(klass, column)
-      "#{klass.name}:#{column}"
-    end
-    
-    def self.get_method_details_mgr( klass )
-      method_details_mgrs[klass] || MethodDetailsManager.new( klass )
-    end
-    
-    
-    # Store a Mgr per mapped klass
-    def self.method_details_mgrs
-      @method_details_mgrs ||= {}
-      @method_details_mgrs
-    end
-
-    def self.belongs_to
-      @belongs_to ||={}
-      @belongs_to
-    end
-
-    def self.has_many
-      @has_many ||= {}
-      @has_many
-    end
-
-    def self.has_one
-      @has_one ||= {}
-      @has_one
-    end
-
-    def self.assignments
-      @assignments ||= {}
-      @assignments
-    end
-    
-    def self.column_types
-      @column_types ||= {}
-      @column_types  
-    end
-
-
-    def self.belongs_to_for(klass)
-      belongs_to[klass] || []
-    end
-    
-    def self.has_many_for(klass)
-      has_many[klass] || []
-    end
-
-    def self.has_one_for(klass)
-      has_one[klass] || []
-    end
-
-    def self.assignments_for(klass)
-      assignments[klass] || []
-    end
-    
-    def self.column_type_for(klass, column)
-      column_types[klass] ?  column_types[klass][column] : []
-    end
-  
-  end
-
-end

data/lib/datashift/method_mapper.rb

@@ -1,174 +0,0 @@
-# Copyright:: (c) Autotelik Media Ltd 2011
-# Author ::   Tom Statter
-# Date ::     Aug 2010
-# License::   MIT
-#
-# Details::   A base class that stores details of all possible associations on AR classes and,
-#             given user supplied class and name, attempts to find correct attribute/association.
-#
-#             Derived classes define where the user supplied list of names originates from.
-#
-#             Example usage, load from a spreadsheet where the column names are only
-#             an approximation of the actual associations. Given a column heading of
-#             'Product Properties' on class Product,  find_method_detail() would search AR model,
-#             and return details of real has_many association 'product_properties'.
-#
-#             This real association can then be used to send spreadsheet row data to the AR object.
-#             
-module DataShift
-
-  class MethodMapper
-
-    include DataShift::Logging
-    
-    attr_accessor :method_details, :missing_methods
-  
-    def initialize
-      @method_details = []
-    end
-
-    # Build complete picture of the methods whose names listed in columns
-    # Handles method names as defined by a user, from spreadsheets or file headers where the names
-    # specified may not be exactly as required e.g handles capitalisation, white space, _ etc
-    # 
-    # The header can also contain the fields to use in lookups, separated with Delimiters ::column_delim
-    # For example specify that lookups on has_one association called 'product', be performed using name'
-    #   product:name
-    #
-    # The header can also contain a default value for the lookup field, again separated with Delimiters ::column_delim
-    #
-    # For example specify lookups on assoc called 'user', be performed using 'email' == 'test@blah.com'
-    #
-    #   user:email:test@blah.com
-    #
-    # Returns: Array of matching method_details, including nils for non matched items
-    # 
-    # N.B Columns that could not be mapped are left in the array as NIL
-    # 
-    # This is to support clients that need to map via the index on @method_details
-    # 
-    # Other callers can simply call compact on the results if the index not important.
-    # 
-    # The MethodDetails instance will contain a pointer to the column index from which it was mapped.
-    # 
-    # Options:
-    # 
-    #   [:force_inclusion]  : List of columns that do not map to any operator but should be included in processing.
-    #                     
-    #       This provides the opportunity for loaders to provide specific methods to handle these fields
-    #       when no direct operator is available on the model or it's associations
-    #       
-    #   [:include_all]      : Include all headers in processing - takes precedence of :force_inclusion
-    #
-    def map_inbound_headers_to_methods( klass, columns, options = {} )
-      
-      # If klass not in MethodDictionary yet, add to dictionary all possible operators on klass
-      # which can be used to map headers and populate an object of type klass
-      unless(MethodDictionary::for?(klass))
-        DataShift::MethodDictionary.find_operators(klass)
-        
-        DataShift::MethodDictionary.build_method_details(klass)
-      end 
-      
-      mgr = DataShift::MethodDictionary.method_details_mgrs[klass]
-       
-      forced = [*options[:force_inclusion]].compact.collect { |f| f.to_s.downcase }
-      
-      @method_details, @missing_methods = [], []
-    
-      columns.each_with_index do |col_data, col_index|
-
-        raw_col_data = col_data.to_s
-        
-        if(raw_col_data.nil? or raw_col_data.empty?)
-          logger.warn("Column list contains empty or null column at index #{col_index}") 
-          @method_details << nil
-          next
-        end
-        
-        raw_col_name, where_field, where_value, *data = raw_col_data.split(Delimiters::column_delim)
-         
-        md = MethodDictionary::find_method_detail(klass, raw_col_name)
-
-        if(md.nil?)
-          if(options[:include_all] || forced.include?(raw_col_name.downcase))
-            logger.debug("Operator #{raw_col_name} not found but forced inclusion operative")
-            md = MethodDictionary::add(klass, raw_col_name)
-          end
-        end
-        
-        if(md)
-
-          md.name = raw_col_name
-          md.column_index = col_index
-
-          # put data back as string for now - leave it to clients to decide what to do with it later
-          Populator::set_header_default_data(md.operator, data.join(Delimiters::column_delim))
-
-          if(where_field)
-            logger.info("Lookup query field [#{where_field}] - specified for association #{md.operator}")
-
-            md.find_by_value = where_value
-
-            # Example :
-            # Project:name:My Best Project
-            #   User (klass) has_one project (operator) lookup by name  (find_by_operator) == 'My Best Project' (find_by_value)
-            #   User.project.where( :name => 'My Best Project')
-
-            # check the finder method name is a valid field on the actual association class
-
-            if(klass.reflect_on_association(md.operator) &&
-               klass.reflect_on_association(md.operator).klass.new.respond_to?(where_field))
-              md.find_by_operator = where_field
-              logger.info("Complex Lookup specified for [#{md.operator}] : on field [#{md.find_by_operator}] (optional value [#{md.find_by_value}])")
-            else
-              logger.warn("Find by operator [#{where_field}] Not Found on association [#{md.operator}] on Class #{klass.name} (#{md.inspect})")
-              logger.warn("Check column (#{md.column_index}) heading - e.g association field names are case sensitive")
-              # TODO - maybe derived loaders etc want this data for another purpose - should we stash elsewhere ?
-            end
-          end
-        else
-          # TODO populate unmapped with a real MethodDetail that is 'null' and create is_nil
-          logger.warn("No operator or association found for Header #{raw_col_name}")
-          @missing_methods << raw_col_name
-        end
-
-        logger.debug("Column [#{col_data}] (#{col_index}) - mapped to :\n#{md.inspect}")
-
-        @method_details << md
-        
-      end
-     
-      @method_details
-    end
-
-    
-    # TODO populate unmapped with a real MethodDetail that is 'null' and create is_nil
-    # 
-    # The raw client supplied names
-    def method_names()
-      @method_details.compact.collect( &:name )
-    end
-
-    # The true operator names discovered from model
-    def operator_names()
-      @method_details.compact.collect( &:operator )
-    end
-
-    
-    # Returns true if discovered methods contain every operator in mandatory_list
-    def contains_mandatory?( mandatory_list )
-      a = [*mandatory_list].collect { |f| f.downcase }
-      puts a.inspect
-      b = operator_names.collect { |f| f.downcase }
-      puts b.inspect
-      (a - b).empty?
-    end
-
-    def missing_mandatory( mandatory_list )
-      [ [*mandatory_list] - operator_names].flatten
-    end
-
-  end
-
-end