datashift 0.16.0 → 0.40.0

data/lib/datashift/model_methods/collection.rb

@@ -0,0 +1,140 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# License::   MIT
+#
+# Details::   Stores complete collection of ModelMethod instances per mapped class.
+#
+#             Mapped to association types as defined by ModelMethod::supported_types_enum
+
+#             Provides high level find facilities to find a ModelMethod and to list out
+#             operators per type (has_one, has_many, belongs_to, instance_method etc)
+#             and all possible operators,
+#
+module DataShift
+
+  module ModelMethods
+
+    class Collection
+
+      include DataShift::Logging
+      extend DataShift::Logging
+
+      include Enumerable
+
+      attr_reader :managed_class
+
+      # Hash of all available methods by type
+      #    [:assignment] => [:id, :name], [:belongs_to] => [:user, :address]
+      #
+      attr_accessor :by_optype
+
+      attr_accessor :model_method_list
+
+      extend Forwardable
+
+      def_delegators :@model_method_list, [], :sort, :sort!, :first, :last
+
+      def initialize( klass )
+        @managed_class = klass
+        @model_method_list = []
+        @by_optype = {}
+      end
+
+      def managed_class_name
+        @managed_class.name
+      end
+
+      alias klass managed_class_name
+
+      def insert(operator, type)
+        mm = ModelMethod.new(managed_class, operator, type)
+        add( mm )
+        mm
+      end
+
+      def add(model_method)
+        model_method_list << model_method
+
+        maintain_by_optype_helper model_method
+      end
+
+      def maintain_by_optype_helper( model_method )
+        # Helper list of all available by type  [:belongs_to]
+        by_optype[model_method.operator_type.to_sym] ||= []
+        by_optype[model_method.operator_type.to_sym] << model_method
+        by_optype[model_method.operator_type.to_sym].uniq!
+      end
+
+      def <<(model_method)
+        add(model_method)
+      end
+
+      def push(model_method)
+        add(model_method)
+      end
+
+      def unshift(model_method)
+        model_method_list.unshift model_method
+        maintain_by_optype_helper model_method
+      end
+
+      def each
+        model_method_list.each { |mm| yield(mm) }
+      end
+
+      # Search for  matching ModelMethod for given name across all types in supported_types_enum order
+      def search(name)
+        ModelMethod.supported_types_enum.each do |type|
+          model_method = find_by_name_and_type(name, type)
+          return model_method if model_method
+        end
+
+        nil
+      end
+
+      # Return matching ModelMethod for given name and specific type
+      def find_by_name_and_type(name, type)
+        by_optype = model_method_list.find_all { |mm| mm.operator_type? type }
+
+        by_optype.find { |mm| mm.operator? name }
+      end
+
+      # Search for  matching ModelMethod for given name across Association types
+      def find_association(name)
+        ModelMethod.association_types_enum.each do |type|
+          model_method = find_by_name_and_type(name, type)
+          return model_method if model_method
+        end
+
+        nil
+      end
+
+      # Returns all ModelMethod(s) for supplied type e.g :belongs_to
+      # type is expected to be one of ModelMethod::supported_types_enum
+      def for_type( type )
+        model_method_list.find_all { |mm| mm.operator_type? type }
+      end
+
+      # Get list of Rails model operators
+      def get_operators(type)
+        for_type(type).collect(&:operator)
+      end
+
+      def available_operators
+        model_method_list.collect(&:operator)
+      end
+
+      # A reverse map  showing all operators with their associated 'type'
+      def available_operators_with_type
+        h = {}
+        by_optype.each { |t, mms| mms.each { |v| h[v.operator] = t } }
+
+        # this is meant to be more efficient that Hash[h.sort]
+        sh = {}
+        h.keys.sort.each { |k| sh[k] = h[k] }
+        sh
+      end
+    end
+
+  end
+end

data/lib/datashift/model_methods/model_method.rb

@@ -0,0 +1,162 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Feb 2015
+# License::   MIT
+#
+# Details::   This class holds info on a single Method callable on a domain Model
+#             By holding information on the Type inbound data can be manipulated
+#             into the right format for the style of operator; simple assignment,
+#             appending to an association collection or a method call
+#
+require_relative 'operator'
+
+module DataShift
+
+  class ModelMethod < Operator
+
+    include DataShift::Logging
+
+    def self.association_types_enum
+      @assoc_type_enum ||= [:belongs_to, :has_one, :has_many]
+      @assoc_type_enum
+    end
+
+    def self.association_type?( type )
+      association_types_enum.member?( type )
+    end
+
+    # Klass is the class of the 'parent' object i.e with the associations,
+    # For example Product which may have operator orders
+    attr_accessor :klass
+
+    # The real column data from the DB - via ActiveRecord::ConnectionAdapters::Column when available
+
+    attr_reader :connection_adapter_column
+
+    # Operator is a population type method call on klass
+    #
+    # Type determines the style of operator call; simple assignment, an association or a method call
+    #
+    def initialize(klass, operator, type, connection_adapter_column = nil)
+
+      super(operator, type)
+
+      @klass = klass
+
+      # Note : Not all assignments will currently have a column type, for example
+      # those that are derived from a delegate_belongs_to
+      @connection_adapter_column = klass.columns.find { |col| col.name == operator } if connection_adapter_column.nil?
+
+      @connection_adapter_column = DataShift::ModelMethods::Catalogue.column_type_for(klass, operator) if connection_adapter_column.nil?
+    end
+
+    # Return the operator's expected class name, if can be derived, else nil
+    def operator_class_name
+      @operator_class_name ||=
+        if operator_for(:has_many) || operator_for(:belongs_to) || operator_for(:has_one)
+
+          determine_operator_class.name
+
+        elsif connection_adapter_column
+          connection_adapter_column.type.to_s.classify
+        else
+          ''
+        end
+
+      @operator_class_name
+    end
+
+    # Return the operator's expected class, if can be derived, else nil
+    def operator_class
+      @operator_class ||= determine_operator_class
+    end
+
+    # Returns true of MM is an association (rather than plain attribute or, enum or method)
+    def association_type?
+      ModelMethod.association_type?( operator_type )
+    end
+
+    def association_columns
+      klass.reflect_on_association(operator).klass.columns
+    end
+
+    def ==(other)
+      other.class == self.class && other.state == state
+    end
+
+    include Comparable
+
+    def <=>(other)
+      state <=> other.state
+    end
+
+    alias eql? ==
+
+    def hash
+      state.hash
+    end
+
+    def pp
+      x = <<-EOS
+      Class         [#{klass.name}]
+      Operator Type [#{operator_type}]
+      Operator      [#{operator}]
+      EOS
+
+      if connection_adapter_column.respond_to?(:cast_type)
+        x += <<-EOS
+      Col/SqlType   [#{connection_adapter_column.class} - #{connection_adapter_column.cast_type.class.name}]
+        EOS
+      end
+      x
+    end
+
+    protected
+
+    # Defines the precedence order.
+    # For example in import, generally you want to process attributes first so that by
+    # the time you get to associations you have a valid model instance with an ID
+    # hence operator_type before operator
+    #
+    def state
+      [klass.name, ModelMethod.supported_types_enum.index(operator_type), operator]
+    end
+
+    private
+
+    # Return the operator's expected class, if can be derived, else nil
+    def determine_operator_class
+
+      if operator_for(:has_many) || operator_for(:belongs_to) || operator_for(:has_one)
+
+        result = klass.reflect_on_association(operator)
+
+        return result.klass if result
+
+        result = MapperUtils.class_from_string(operator.classify)
+
+        if result.nil?
+          begin
+
+            first = klass.to_s.split('::').first
+            logger.debug "Trying to find operator class with Parent Namespace #{first}"
+
+            result = MapperUtils.const_get_from_string("#{first}::#{operator.classify}")
+          rescue => e
+            logger.error("Failed to derive Class for #{operator} (#{@operator_type} - #{e.inspect}")
+          end
+        end
+
+        result
+
+      elsif connection_adapter_column
+        begin
+          Kernel.const_get(connection_adapter_column.type.to_s.classify)
+        rescue
+          nil
+        end
+      end
+    end
+
+  end
+end

data/lib/datashift/model_methods/model_methods_manager.rb

@@ -0,0 +1,76 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Feb 2015
+# License::   MIT
+#
+# Details::   Just a high level helper to build Collections of model methods
+#             and enable quick access via Map of Class => Collection
+#
+module DataShift
+
+  module ModelMethods
+
+    class Manager
+
+      def self.collections
+        @collections ||= {}
+      end
+
+      def self.for(klass)
+        collections[klass]
+      end
+
+      def self.for?(klass)
+        (collections[klass] != nil)
+      end
+
+      # Build a thorough and usable picture of the operators which can be
+      # used to import/export data to objects of type 'klass'
+      #  Stored as a dictionary of ModelMethods objects
+      #
+      # Subsequent calls with same class will return existing mapping
+      # To over ride this behaviour, supply :reload
+      #
+      # Options:   TODO - find we are passing through options to other calls alot - good pattern for this ?
+
+      #   :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.catalog_class( klass, options = {} )
+
+        return collections[klass] if collections[klass] && !options[:reload]
+
+        ModelMethods::Catalogue.populate(klass, options) unless ModelMethods::Catalogue.catalogued?(klass)
+
+        collection = ModelMethods::Collection.new( klass )
+
+        DataShift::ModelMethods::Catalogue.assignments_for(klass).each do |n|
+          collection << ModelMethod.new(klass, n, :assignment)
+        end
+
+        DataShift::ModelMethods::Catalogue.has_one_for(klass).each do |n|
+          collection << ModelMethod.new(klass, n, :has_one)
+        end
+
+        DataShift::ModelMethods::Catalogue.has_many_for(klass).each do |n|
+          collection << ModelMethod.new(klass, n, :has_many)
+        end
+
+        DataShift::ModelMethods::Catalogue.belongs_to_for(klass).each do |n|
+          collection << ModelMethod.new(klass, n, :belongs_to)
+        end
+
+        collections[klass] = collection
+
+        collection
+
+      end
+
+      def self.clear
+        collections.clear
+      end
+
+    end
+
+  end
+end

data/lib/datashift/model_methods/operator.rb

@@ -0,0 +1,62 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Feb 2015
+# License::   MIT
+#
+# Details::   This class holds info on a single Method callable on a domain Model
+#             By holding information on the Type inbound data can be manipulated
+#             into the right format for the style of operator; simple assignment,
+#             appending to an association collection or a method call
+#
+module DataShift
+
+  class Operator
+
+    include DataShift::Logging
+
+    # List of supported operator types e.g :assignment, :belongs_to, :has_one, :has_many etc
+    # N.B these are in priority order ie. often prefer to process assignments first, then associations
+    #
+    def self.supported_types_enum
+      @type_enum ||= [:assignment, :enum, :belongs_to, :has_one, :has_many, :method]
+      @type_enum
+    end
+
+    # The :operator that can be called to assign  e.g orders or Products.new.orders << Order.new
+    attr_reader :operator
+
+    # The type of operator e.g normal method or Rails :assignment, :belongs_to, :has_one, :has_many etc
+    attr_reader :operator_type
+
+    # Operator is a population type method call
+    # Type determines the style of operator call; simple assignment, an association or a method call
+    #
+    def initialize(operator, type = :method)
+
+      if ModelMethod.supported_types_enum.include?(type.to_sym)
+        @operator_type = type.to_sym
+      else
+        raise BadOperatorType, "No such operator Type [#{type}] cannot instantiate ModelMethod for #{operator}"
+      end
+
+      @operator = operator
+    end
+
+    # Return the actual operator's name for supplied method type
+    # where type one of :assignment, :has_one, :belongs_to, :has_many etc
+    def operator_for( type )
+      return operator if @operator_type == type.to_sym
+      nil
+    end
+
+    def operator?(name, case_sensitive = false)
+      return false if(name.nil?)
+      case_sensitive ? operator == name : operator.casecmp(name.downcase).zero?
+    end
+
+    def operator_type?(type)
+      @operator_type == type.to_sym
+    end
+
+  end
+end

data/lib/datashift/node_collection.rb

@@ -0,0 +1,26 @@
+# Copyright:: (c) Autotelik Media Ltd 2016
+# Author ::   Tom Statter
+# License::   MIT
+#
+# Details::   A collection of DataFlowNodes
+
+require 'forwardable'
+
+module DataShift
+
+  # Acts as an array of Node
+
+  class NodeCollection
+
+    extend Forwardable
+
+    attr_accessor :doc_context
+
+    def_delegators :@nodes, *Array.delegated_methods_for_fwdable
+
+    def initialize
+      @nodes = []
+    end
+
+  end
+end