evt-transform 0.1.3.0 → 0.2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dfc383c07eccd30d0da3059af8ace4292e879e967506b496b877df82a150c16
-  data.tar.gz: 931175ac1c40ccc04218f928a01fd915913c7d32a365173f592a0a9a2d923168
+  metadata.gz: 7260f7bfa8857baec7819abfc066e1ca82351426370080050a79eff83045b0ca
+  data.tar.gz: d93f0bf14cfdea3e7bfb1b067bc42280680ba08ac51713f4d849aa1d0dca414e
 SHA512:
-  metadata.gz: b3ab2ded9cb2d24e4127510e14d37bcd057eb74162a4aa39dd02b501fbe8093837d861ada503bdd6057065b53fd7223d62df27bc85b9be402c14c4a936218230
-  data.tar.gz: 39b6cfc738ce60cf2679669ed8b56f505235645abcb1af10ab29f367a42d71142c79857482fba02c43b2b5fc179993f539902ff74c965d9007bb5f5ade334240
+  metadata.gz: 61fd991c0d43026f027a7326fa229168eeb3ac9bedb83239bffb965a9606ab99002b2fa1350f9038d1f22eaa909bddbcdf9df1e7d9140b5de105030aff13b495
+  data.tar.gz: e1147a06fd830aac80c7860fdfd6e0e7d8d97fd05537d205df579c43d6ee939816eaa85e364dd59fb5988d8bd39fcca05c9a41c24b1d138a4ad5228c1d725b44

data/lib/transform.rb

@@ -1,4 +1,5 @@
 require 'log'
+require 'reflect'
 
 require 'transform/log'
 require 'transform/transform'

data/lib/transform/controls.rb

@@ -6,5 +6,3 @@ require 'transform/controls/subject/transform'
 require 'transform/controls/subject/transformer'
 require 'transform/controls/no_transformer'
 require 'transform/controls/no_transform_methods'
-require 'transform/controls/no_format'
-require 'transform/controls/no_format_methods'

data/lib/transform/controls/no_transform_methods.rb

@@ -2,7 +2,20 @@ module Transform
   module Controls
     module NoTransformMethods
       class Example
-        module Transformer
+        module Transform
+          def self.some_format
+            SomeFormat
+          end
+
+          module SomeFormat
+            def self.write(raw_data)
+              Controls::Text.example
+            end
+
+            def self.read(text)
+              Controls::RawData.example
+            end
+          end
         end
       end
 

data/lib/transform/controls/subject.rb

@@ -1,49 +1,13 @@
 module Transform
   module Controls
     module Subject
-      def self.example
-        instance = example_class.new
-        instance.some_attribute = Controls::RawData.example
-        instance
-      end
-
-      def self.example_class
-        Example
-      end
-
-      class Example
-        attr_accessor :some_attribute
-
-        def ==(other)
-          other.some_attribute == self.some_attribute
-        end
-
-        module Transformer
-          def self.some_format
-            SomeFormat
-          end
-
-          def self.instance(raw_data)
-            instance = Example.new
-            instance.some_attribute = raw_data
-            instance
-          end
-
-          def self.raw_data(instance)
-            instance.some_attribute
-          end
-
-          module SomeFormat
-            def self.write(raw_data)
-              Controls::Text.example
-            end
-
-            def self.read(text)
-              Controls::RawData.example
-            end
-          end
-        end
-      end
+      Transformer = Subject
     end
   end
 end
+module Transform
+  module Controls
+    Subject = Transform::Controls::Subject::Transformer
+  end
+end
+

data/lib/transform/controls/subject/transformer.rb

@@ -1,7 +1,51 @@
 module Transform
   module Controls
     module Subject
-      Transformer = Subject
+      module Transformer
+        def self.example
+          instance = example_class.new
+          instance.some_attribute = Controls::RawData.example
+          instance
+        end
+
+        def self.example_class
+          Example
+        end
+
+        class Example
+          attr_accessor :some_attribute
+
+          def ==(other)
+            other.some_attribute == self.some_attribute
+          end
+
+          module Transformer
+            def self.some_format
+              SomeFormat
+            end
+
+            def self.instance(raw_data)
+              instance = Example.new
+              instance.some_attribute = raw_data
+              instance
+            end
+
+            def self.raw_data(instance)
+              instance.some_attribute
+            end
+
+            module SomeFormat
+              def self.write(raw_data)
+                Controls::Text.example
+              end
+
+              def self.read(text)
+                Controls::RawData.example
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/transform/read.rb

@@ -2,41 +2,44 @@ module Transform
   module Read
     extend Transform
 
-    def self.mode
-      :read
-    end
-
-    def self.intermediate
-      :instance
-    end
-
-    def self.call(raw_data, format_name, cls)
-      if format_name.instance_of?(Class) && cls.instance_of?(Symbol)
-        cls, format_name = format_name, cls
-      end
-
+    def self.call(input, format_name, cls)
       logger.trace { "Reading (Format Name: #{format_name.inspect})" }
-      logger.trace(tags: [:data, :raw_data]) { raw_data.pretty_inspect }
+      logger.trace(tags: [:data, :input]) { input.pretty_inspect }
 
-      format = format(cls, format_name)
+      transformer_reflection = transformer_reflection(cls)
 
-      assure_mode(format, mode)
-      raw_data = format.read raw_data
+      format_reflection = transformer_reflection.get(format_name)
 
-      transformed = instance(raw_data, cls)
+      raw_data = format_reflection.(:read, input)
+
+      instance = instance(raw_data, cls, transformer_reflection)
 
       logger.info { "Read (Format Name: #{format_name.inspect})" }
-      logger.debug(tags: [:data, :transformed]) { transformed.pretty_inspect }
+      logger.debug(tags: [:data, :output]) { instance.pretty_inspect }
 
-      transformed
+      instance
     end
 
-    def self.instance(raw_data, cls)
+    def self.instance(raw_data, cls, transformer_reflection=nil)
       logger.trace { "Transforming raw data to instance" }
       logger.trace(tags: [:data, :raw_data]) { raw_data.pretty_inspect }
 
-      transformer = transformer(cls)
-      assure_mode(transformer, intermediate)
+      if transformer_reflection.nil?
+        transformer_reflection = transformer_reflection(cls)
+      end
+
+      transformer = transformer_reflection.constant
+
+      instance = get_instance(transformer, raw_data, cls)
+
+      logger.debug { "Transformed raw data to instance" }
+      logger.debug(tags: [:data, :instance]) { instance.pretty_inspect }
+
+      instance
+    end
+
+    def self.get_instance(transformer, raw_data, cls)
+      assure_instance_method(transformer)
 
       method = transformer.method(:instance)
 
@@ -48,12 +51,15 @@ module Transform
         instance = transformer.instance(raw_data, cls)
       end
 
-      logger.debug { "Transformed raw data to instance" }
-      logger.debug(tags: [:data, :instance]) { instance.pretty_inspect }
-
       instance
     end
 
+    def self.assure_instance_method(transformer)
+      unless transformer.respond_to?(:instance)
+        raise Error, "#{transformer.name} does not implement `instance'"
+      end
+    end
+
     def self.logger
       @logger ||= Log.get(self)
     end

data/lib/transform/retry_test.rb

@@ -0,0 +1,5 @@
+test retry
+
+need to raise expected version error
+
+expected version raises when version number is mismatched

data/lib/transform/transform.rb

@@ -1,113 +1,40 @@
 module Transform
   extend self
 
-  class Error < RuntimeError; end
+  Error = Class.new(RuntimeError)
 
-  def format(subject, format_name)
-    transformer = transformer(subject)
+  def transformer_reflection(subject)
+    subject_constant = Reflect.subject_constant(subject)
 
-    assure_format(format_name, transformer)
-    get_format(format_name, transformer)
-  end
-
-  def get_format(format_name, transformer)
-    transformer.send(format_name)
-  end
-
-  def transformer(subject)
-    subject_const = subject_const(subject)
-
-    assure_transformer(subject_const)
-    get_transformer(subject_const)
-  end
-
-  def get_transformer(subject_const)
-    if transformer_const?(subject_const)
-      return subject_const.const_get(:Transformer)
-    elsif transform_const?(subject_const)
-      return subject_const.const_get(:Transform)
-    end
-  end
-
-  def subject_const(subject)
-    [Module, Class].include?(subject.class) ? subject : subject.class
-  end
-
-  def assure_transformer(subject_const)
-    return if transform_const?(subject_const) || transformer_const?(subject_const)
-
-    raise Error, "#{subject_const.name} doesn't have a `Transformer' or 'Transform' namespace"
-  end
-
-  def transformer?(subject)
-    subject_const = subject_const(subject)
-    transformer_const?(subject_const)
-  end
-
-  def transformer_const?(subject_const)
-    subject_const.constants.any?{ |c| c.to_sym == :Transformer }
-  end
+    transformer_name = transformer_name(subject_constant)
 
-  def transform_const?(subject_const)
-    subject_const.constants.any?{ |c| c.to_sym == :Transform }
-  end
-
-  def assure_format(format_name, transformer)
-    unless format_accessor?(format_name, transformer)
-      raise Error, "#{transformer.name} does not implement `#{format_name}'"
+    if transformer_name.nil?
+      raise Error, "#{subject_constant.name} doesn't have a Transformer or Transform namespace"
     end
-  end
-
-  def format_accessor?(format_name, transformer)
-    transformer.respond_to?(format_name)
-  end
 
-  def format?(format_name, transformer)
-    format = get_format(format_name, transformer)
-    !!format
+    Reflect.(subject, transformer_name, strict: true)
   end
 
-  def assure_mode(format, mode)
-    unless mode?(format, mode)
-      raise Error, "#{format.name} does not implement `#{mode}'"
+  def transformer_name(subject_constant)
+    if transform_const?(subject_constant)
+      return :Transform
+    elsif transformer_const?(subject_constant)
+      return :Transformer
+    else
+      return nil
     end
   end
 
-  def mode?(format, mode)
-    format.respond_to?(mode)
+  def transform_const?(subject_constant)
+    Reflect.constant?(subject_constant, :Transform)
   end
 
-  def intermediate?(transformer, intermediate_name)
-    transformer.respond_to?(intermediate_name)
+  def transformer_const?(subject_constant)
+    Reflect.constant?(subject_constant, :Transformer)
   end
 
-  def implemented?(subject, format_name)
-    subject_const = subject_const(subject)
-
-    unless transformer_const?(subject_const)
-      return false
-    end
-
-    transformer = get_transformer(subject_const)
-
-    unless intermediate?(transformer, intermediate)
-      return false
-    end
-
-    unless format_accessor?(format_name, transformer)
-      return false
-    end
-
-    unless format?(format_name, transformer)
-      return false
-    end
-
-    format = get_format(format_name, transformer)
-
-    unless mode?(format, mode)
-      return false
-    end
-
-    true
+  def transformer?(subject)
+    subject_constant = Reflect.subject_constant(subject)
+    transform_const?(subject_constant) || transformer_const?(subject_constant)
   end
 end

data/lib/transform/write.rb

@@ -2,40 +2,41 @@ module Transform
   module Write
     extend Transform
 
-    def self.mode
-      :write
-    end
-
-    def self.intermediate
-      :raw_data
-    end
-
-    def self.call(instance, format_name)
+    def self.call(input, format_name)
       logger.trace { "Writing (Format Name: #{format_name.inspect})" }
-      logger.trace(tags: [:data, :instance]) { instance.pretty_inspect }
+      logger.trace(tags: [:data, :input]) { input.pretty_inspect }
 
-      format = format(instance, format_name)
+      transformer_reflection = transformer_reflection(input)
 
-      raw_data = raw_data(instance)
+      format_reflection = transformer_reflection.get(format_name)
 
-      assure_mode(format, mode)
+      raw_data = raw_data(input, transformer_reflection)
 
-      transformed = format.write(raw_data)
+      output = format_reflection.(:write, raw_data)
 
       logger.info { "Wrote (Format Name: #{format_name.inspect})" }
-      logger.debug(tags: [:data, :transformed]) { transformed.pretty_inspect }
+      logger.debug(tags: [:data, :output]) { output.pretty_inspect }
 
-      transformed
+      output
     end
 
-    def self.raw_data(instance)
+    def self.raw_data(instance, transformer_reflection=nil)
       logger.trace { "Transforming instance to raw data" }
       logger.trace(tags: [:data, :instance]) { instance.pretty_inspect }
 
-      transformer = transformer(instance)
-      assure_mode(transformer, intermediate)
+      if transformer_reflection.nil?
+        subject_constant = Reflect.subject_constant(instance)
+        transformer_name = transformer_name(subject_constant)
+
+        if transformer_name.nil?
+          raise Error, "#{subject_constant.name} doesn't have a `Transformer' or 'Transform' namespace"
+        end
 
-      raw_data = transformer.raw_data(instance)
+        transformer_reflection = Reflect.(instance, transformer_name, strict: true)
+      end
+
+      transformer = transformer_reflection.constant
+      raw_data = get_raw_data(transformer, instance)
 
       logger.debug { "Transformed to raw data" }
       logger.debug(tags: [:data, :raw_data]) { raw_data.pretty_inspect }
@@ -43,6 +44,19 @@ module Transform
       raw_data
     end
 
+    # This is not strictly necessary since Reflection does this
+    # but it provides symmetry with Read, which cannot use Reflection
+    def self.get_raw_data(transformer, instance)
+      assure_raw_data_method(transformer)
+      transformer.raw_data(instance)
+    end
+
+    def self.assure_raw_data_method(transformer)
+      unless transformer.respond_to?(:raw_data)
+        raise Error, "#{transformer.name} does not implement `raw_data'"
+      end
+    end
+
     def self.logger
       @logger ||= Log.get(self)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt-transform
 version: !ruby/object:Gem::Version
-  version: 0.1.3.0
+  version: 0.2.0.0
 platform: ruby
 authors:
 - The Eventide Project
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-25 00:00:00.000000000 Z
+date: 2018-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-log
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: evt-reflect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: test_bench
   requirement: !ruby/object:Gem::Requirement
@@ -46,8 +60,6 @@ extra_rdoc_files: []
 files:
 - lib/transform.rb
 - lib/transform/controls.rb
-- lib/transform/controls/no_format.rb
-- lib/transform/controls/no_format_methods.rb
 - lib/transform/controls/no_transform_methods.rb
 - lib/transform/controls/no_transformer.rb
 - lib/transform/controls/raw_data.rb
@@ -59,6 +71,7 @@ files:
 - lib/transform/copy.rb
 - lib/transform/log.rb
 - lib/transform/read.rb
+- lib/transform/retry_test.rb
 - lib/transform/transform.rb
 - lib/transform/write.rb
 homepage: https://github.com/eventide-project/transform

data/lib/transform/controls/no_format.rb

@@ -1,26 +0,0 @@
-module Transform
-  module Controls
-    module NoFormat
-      class Example
-        module Transformer
-          def self.some_format
-          end
-
-          def self.instance(raw_data)
-          end
-
-          def self.raw_data(instance)
-          end
-        end
-      end
-
-      def self.example
-        Example.new
-      end
-
-      def self.example_class
-        Example
-      end
-    end
-  end
-end

data/lib/transform/controls/no_format_methods.rb

@@ -1,30 +0,0 @@
-module Transform
-  module Controls
-    module NoFormatMethods
-      class Example
-        module Transformer
-          def self.some_format
-            SomeFormat
-          end
-
-          def self.instance(raw_data)
-          end
-
-          def self.raw_data(instance)
-          end
-
-          module SomeFormat
-          end
-        end
-      end
-
-      def self.example
-        Example.new
-      end
-
-      def self.example_class
-        Example
-      end
-    end
-  end
-end