traitorous 0.3.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1dcf2e9d0afef212d428c6140582dd2d14b66e6a
-  data.tar.gz: 129a2a34983b5ed2b65908f227a2f81ef0ec1d95
+  metadata.gz: ce24a9926d5a1a1473d4ecce829f5ae67753747e
+  data.tar.gz: 935ffb3bb8ace183357d11db17ed1b9a45a07cd8
 SHA512:
-  metadata.gz: 84c658572a8ae35cc9e38e7bb8732e15eb8e2c55cf3d2cafc996896324fa67de78d5cbb87048c795967edd569fd3d04bdbe831b042ace881e9c580b3bb4a18c8
-  data.tar.gz: 460429463388d6aaa6a2e88f8622da871451baa62cccd1fb29318e37d9eeb3048ff3bfabe30f77973fa80fc30a73c118f0e40aa447b6fa053c7c1bd1d7ef25a1
+  metadata.gz: e4d983bdef166b6f527e01ab327d8e1ecdade88fec74f372bb0d534a31833ddbdf1921a23457cfe2b9fb16136f1547fe32dd1b92cf623c0853b6cd82906d5705
+  data.tar.gz: 5df97df341451212529e99b632aa18267c4a74648aa4f074e6be9ee2184617b8a830c5d71b40b76151907ff18014e600a7aea30873aa8ba5c06e0839b2a73a38

data/.gitignore

@@ -6,5 +6,90 @@
 /doc/
 /pkg/
 /spec/reports/
+### Ruby template
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+
 /tmp/
 .env

data/README.md

@@ -39,51 +39,52 @@ Or install it yourself as:
 
 ```ruby
 
-# see spec/
-require 'traitorous'
-
-class Ruin
-  include Traitorous
-  include Traitorous::Equality
-  trait :name
-  trait :danger
-end
-
-r = Ruin.new(name: 'Skull Mountain', danger: 'The Devil of')
-#
-puts r.name
-# Skull Mountain
-
-puts r.danger
-# The Devil of
-
-puts r.export
-# {'name' => 'Skull Mountain, 'danger' => 'The Devil of'}
-
-puts Ruin.new(r.export) == r
-# true
-
-class Area
-  include Traitorous
-  include Traitorous::Equality
-  trait :name
-  trait :size, Converter::DefaultValueStatic.new('sub-continent')
-  trait :ruins, Converter::UniformArray.new(Ruin)
-end
-
-area = Area.new(
-  name: 'Western Marches',
-  size: 'Region',
-  ruins: [{name: 'Skull Mountain', danger: 'The Devil of'},
-          {name: 'Dire Swamp', danger: 'The Devil of'}
-          ]
- )
-puts area.ruins.length
-# 2
-puts area.export
-#  {:name=>"Western Slope", :size=>"region", :ruins=>[{:name=>"Dire Swamp", :danger=>"The Creature of"}, {:name=>"Skull Mountain", :danger=>"The Devil of"}]}
-puts Area.new(area.export) == area
-# true
+    # see spec/
+    require 'traitorous'
+    
+    class Ruin
+      include Traitorous
+      include Traitorous::Equality
+      trait :name
+      trait :danger
+    end
+    
+    r = Ruin.new(name: 'Skull Mountain', danger: 'The Devil of')
+    #
+    puts r.name
+    # Skull Mountain
+    
+    puts r.danger
+    # The Devil of
+    
+    puts r.export
+    # {"name"=>"Skull Mountain", "danger"=>"The Devil of"}
+    
+    puts Ruin.new(r.export) == r
+    # true
+    
+    class Area
+      include Traitorous
+      include Traitorous::Equality
+      trait :name
+      trait :size, Converter::DefaultValueStatic.new('sub-continent')
+      trait :ruins, Converter::UniformArray.new(Ruin)
+    end
+    
+    area = Area.new(
+      name: 'Western Marches',
+      ruins: [{name: 'Skull Mountain', danger: 'The Devil of'},
+              {name: 'Dire Swamp', danger: 'The Devil of'}
+              ]
+     )
+    puts area.size
+    # 'sub-continent'
+    puts area.ruins.length
+    # 2
+    puts area.export
+    #  {:name=>"Western Slope", :size=> "sub-continent", :ruins=>[{:name=>"Dire Swamp", :danger=>"The Creature of"}, {:name=>"Skull Mountain", :danger=>"The Devil of"}]}
+    puts Area.new(area.export) == area
+    # true
 ```
 
 ## Converters
@@ -95,30 +96,114 @@ in a simple form ready to save.
 This system should be flexible enough to account for an large variety of data
 structures that can be read in and out of storage easily and in 1 tree.
 
-#### Traitorous::Converter::Identity
-This converter is meant as a pass through converter that doesn't alter the
-incoming value on either do_import or do_export.  
+The 5 that are in the system should cover a lot of ground, anything trickier 
+should just be implemented as it's own Converter, ensuring that it responds to
+`#do_import(data)` and `#do_export(data)`.  
 
-#### Traitorous::Converter::DefaultValueStatic
-THis converter is similar to the Traitorous::Converter::Identity except that
-when doing do_import it will return a default value if the opts are nil or 
-false.
+Most of the converters wil have a pair of optional arguments: import_method 
+(defaults to :new) and export_method (defaults to :export). Export is simple, 
+it's the method called on the object, objects created using Traitorous 
+automatically respond_to export.  set export_method to :to_s in order to convert
+your Pathname object into a string.  Set import_method to :parse, to create your
+object with URI.parse. This should provide a tremendous amount of versatility.
 
-#### Traitorous::Converter::Model
-This converter takes a model_klass argument and on do_import, will instantiate 
-a new object of that class passing in the opts as params.  do_export calls 
-.export on the object and returns the result.
+```ruby
+# Example of using the defaults for IMport_method and export_method
+# import_method defaults to :new
+# export_method defaults to :export
+batman_data = {name: 'Batman', secret_identity: 'Bruce Wayne'}
+converter = Model.new(Superhero)
+superhero = converter.do_import(batman_data)
+# does this
+Superhero.send(import_method, data)
+# and is the same result as
+Superhero.new(batman_data)
+# exports by
+converter.do_export(superhero)
+# does this
+superhero.send(export_method)
+# and is the same result as
+superhero.export
+
+# Example of using a custom import_method and export_method
+batman_data_uri = '/batman/current'
+converter = Model.new(Superhero, import_method: :parse, export_method: :to_s)
+superhero = converter.do_import(batman_data)
+# does this
+uri = URI.send(import_method, batman_data)
+# and is the same result as
+URI.parse(batman_data)
+# exports by
+converter.do_export(uri)
+# does this
+uri.send(export_method)
+# and is the same result as
+uri.to_s
+```
 
-#### Traitorous::Converter::UniformArray
-This converter takes a uniform_klass argument.  It expects an array as input for
-.do_import and will instantiate an uniform_klass object for each element of the
-array and return the resulting array.
+##### export
+My current design kind of places a lot of the responsibilities for the export
+sequence of the objects themselves.  And I'm both satisied with this design and 
+not at all sure that it's the right design.  The importers gets the combination
+of the klass and the import_method which makes for a near perfect amount of
+coverage, they cover everything from URI.parse to File.read to Animal.new to
+YAML.load_file.  But the exporters are expected to get with just the 
+export_method setting to be called on the object itself.  
+
+THe concepts of the converters could easily be isolated into a single type of
+converter, and assigning both an import and export converter.  But think the
+concept has 3 points against it, and they take the day over the advantages.
+1.  Maintaining the import and export parts of the converter in a single object
+provides a semantic and symbolic relationship between the import and export 
+functions for a single trait.  This should be encouraged to maintain a focus
+upon synchronicity between import and export that is central to Traitorous.
+2.  having to define both an import converter and an export converter makes the
+trait api less attractive.
+3.  It is really easy to write a custom converter in which you can implement
+whatever logic you need to meet your needs.
+4.  The domain knowledge on how to export belongs in the class or object of the 
+model.
+
+#### Traitorous::Converter::Value
+The Value converter leaves an existing value alone, but may insert a default
+value if no value exists.  The ability to maintain nil vs false values is
+unimportant to me and thus unaddressed.  I highly recommend a small custom class
+instead.  Or submit a PR.
+
+#### MISSING - Traitorous::Converter::Proc
+The Proc converter would take a block in the initialize `that thes a value gets applied to
 
-#### Traitorous::Converter::MethodKeyedUniformHash
-This converter takes key_method and uniform_class arguments.  It expects an 
-array as input for .do_import and will instantiate an uniform_klass object for 
-each element of the array, then call key_method on that object and add them
-to a hash as a key instance pair.
+
+#### Traitorous::Converter::Model
+This converter calls an import_method on a klass and passes the data as 
+attributes.  Villain.send(:new, data), URI.send(:parse, data).  This is meant to
+provide class instantiation, complex conversion behavior, and service object 
+handling.  On export the export_method is called om the data. data.send(:export),
+data.send(:to_s).
+
+#### Traitorous::Converter::Array
+This converter imports an array of data and then uses klass and import_method as
+with the Converter::Model.  On export, the each element has the export_method
+called on it and returns the transformed array. 
+`data_arr.map{|e| e.send(export_method)}`
+
+#### Traitorous::Converter::ArrayToHash
+This converter takes a key_method in addition to klass, import_method, and export
+methods.  It takes an array of data, imports them as the Array converter does.
+But the sends the key_method to the imported object for use in a key/value pair.
+
+### MISSING - Traitorous::Converter::Hash
+A converter that takes a hash to import, and export.  The tricky thing is how
+the keys of the incoming hash are treated, and how the keys for the exported
+hash are created.  One way would be to discard the keys of the incoming hash, and
+treat the array of values as the ArrayToHash converter does.  A second way would
+be to maintain the incoming keys as the outgoing keys.  A third way would be to
+expect to pass both the key and the value around as a pair making the import
+look like klass.send(import_method, key, value), and expecting (k,v) as output
+for export.  
+
+I haven't come up with a use case that has compelled me to solve this problem 
+yet, my needs are provided for by the ArrayToHash converter.
 
 ### More Converters
 
@@ -128,6 +213,9 @@ usage.  This especially would be important if you wanted to import a list of
 object that represents different klasses that are given with a sub_type or 
 sub_class attributes that are part of the do_import data.  
 
+Maybe also set traits to accept both import and export settings?  Not sure if 
+this is necessary yet.
+
 ## Roadmap
 
 1.  Add better documentation
@@ -136,10 +224,9 @@ sub_class attributes that are part of the do_import data.
     a. DefaultValueDynamic that stores code to run upon input or output
     b. VariableArray that uses a sub-type in the opts to location the correct
        class to instantiate instead of always using a uniform class
-    c. Validations?
-    d. translations?
-    e. class specific (Date, CreditCard)
-
+4. Validations?
+5. translations?
+6.  HashWithIndifferentAccess
 ## Development
 
 I use Guard to automate testing.  It won't affect anything execpt the disk space

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.6.1

data/lib/traitorous/convert.rb

@@ -0,0 +1,106 @@
+module Traitorous
+  # Convert provides a selection of helpers that will build converters for
+  #   common situations.
+  module Convert
+    class << self
+      # .skip provides the simplest converter. It does nothing to the value
+      #   except pass it through unchanged on both import and export
+      # @return [Traitorous::Converter]
+      def skip
+        Converter.new(
+            StandardProcs.noop,
+            StandardProcs.noop
+        )
+      end
+
+      # .default(default_value = nil) creates a StandardProc.default importer
+      #   and a StandardProcs.noop exporter
+      # TODO add :export_with for consistency
+      # @param default_value [Object] value to set in cases that data is falsey
+      # @return [Traitorous::Converter]
+      def default(default_value = nil)
+        Converter.new(
+            StandardProcs.default(default_value),
+            StandardProcs.noop
+        )
+      end
+
+
+      # .call_on creates a StandardProc.call_on proc for the importer, and a
+      #   StandardProc.call_on_self proc for the exporter.
+      # @param method_name [Symbol, String] method to send data
+      # @param with: [Symbol, String] method to send klass with data as params
+      # @param export_with: [Symbol, String] method to send klass with data as params
+      # @return [Traitorous::Converter]
+      def call_on(klass, with: :new, export_with: :export)
+        Converter.new(
+            StandardProcs.call_on(klass, with_method: with),
+            StandardProcs.call_on_self(export_with)
+        )
+      end
+
+      # .call_on_self creates a StandardProc.call_on_self proc for the importer
+      #   with the with_method param, and a StandardProc.call_on_self with the
+      #   export_with param
+      # @param with_method [Symbol, String] method to send data on import
+      # @param export_with [Symbol, String] method to send data on export
+      # @return [Traitorous::Converter]
+      def call_on_self(with_method, export_with: :export)
+        Converter.new(
+            StandardProcs.call_on_self(with_method),
+            StandardProcs.call_on_self(export_with)
+        )
+      end
+
+
+      # Creates an importer that runs the converter importer or exporter for
+      #   each element of an array, return the resulting array
+      # @param converter [Traitorous::Converter] the converter to use for both
+      #   import and export.
+      # @return [Traitorous::Converter]
+      def array(converter)
+        Converter.new(
+            proc { |data| Array(data).map { |entry| converter.importer.call(entry) } },
+            proc { |data| Array(data).map { |entry| converter.exporter.call(entry) } }
+        )
+      end
+
+      # TODO better to extract the inject proc into it's own StandardProc?
+      # @param value_converter [Traitorous::Converter] the converter to use for both
+      #   import and export.
+      # @return [Traitorous::Converter]
+      def hash(value_converter)
+        Converter.new(
+            proc { |data| data.inject({}) { |h, (k, v)| h[k] = value_converter.importer.call(v); h } },
+            proc { |data| data.inject({}) { |h, (k, v)| h[k] = value_converter.exporter.call(v); h } },
+        )
+      end
+
+      # TODO better expecting key, value pairs as the output of the converter?
+      # Expects an incoming array, uses the param value_converter for each
+      #   element, then uses the key_converter on the resulting value and stores
+      #   the key, value pair in the resulting hash.
+      # @note.  The value_converter is used before the key_converter, and the
+      #   key_converter receives the output of the value_converter as it's data
+      #   param.
+      # @param key_converter [Traitorous::Converter] the converter to use for to
+      #   generate the hash key for a given value.
+      # @param value_converter [Traitorous::Converter] the converter to use for
+      #   converting the value.
+      # @return [Traitorous::Converter]
+      def array_to_hash(key_converter, value_converter)
+        Converter.new(
+            proc do |data_arr|
+              data_arr.inject({}) do |h, d|
+                v    = value_converter.importer.call(d)
+                k    = key_converter.importer.call(v)
+                h[k] = v
+                h
+              end
+            end,
+            proc { |data_hsh| data_hsh.values.map { |value| value_converter.exporter.call(value) } }
+        )
+      end
+    end
+  end
+end

data/lib/traitorous/converter.rb

@@ -0,0 +1,30 @@
+module Traitorous
+  # The purpose of the converters are to facilitate the importation of simple
+  #   JSON or YAML, CSV data,  and import that data into an arbitrarily nested
+  #   tree of objects.  And then to take those object and be able to export
+  #   that data in a simple form ready to save, that is functionally identical to
+  #
+  #   opts = {some: 'deep', data: ['structures']}
+  #    r = Mission.new(opts)
+  #    Mission.new(r.export) == r
+  class Converter
+    # if no other converter is declared, use the identity converter which
+    # merely pass through the data passed to it.
+    # DEFAULT_PROC is a default pass through proc
+
+    attr_accessor :converters, :importer, :exporter
+
+    def initialize(importer, exporter = StandardProcs.noop)
+      @importer = importer
+      @exporter = exporter
+    end
+
+    def import(data)
+      importer.call(data)
+    end
+
+    def export(data)
+      exporter.call(data)
+    end
+  end
+end

data/lib/traitorous/standard_procs.rb

@@ -0,0 +1,35 @@
+module Traitorous
+  module StandardProcs
+    class << self
+      NOOP = proc { |data| data }
+
+      # a proc that simply passes through it's input as output
+      def noop
+        NOOP
+      end
+
+      # a proc that simply passes through it's input if the input is truthy,
+      #   otherwise it returns it's default value
+      # @param default_value [Object] the default value to use with data is
+      #   falsey
+      # @return [Object] returns data || default_value
+      def default(default_value)
+        proc { |data| data || default_value }
+      end
+
+      # This proc calls method_name on data.
+      # @param method_name [Symbol, String] method to send data
+      # @return [Object] result of calling method_name on data
+      def call_on_self(method_name)
+        proc { |data| data.send(method_name) }
+      end
+
+      # This proc calls klass with :with and passes data as params
+      # @param klass [Class, Module, Object] obj to call
+      # @param with_method: [Symbol, String] method to send klass with data as params
+      def call_on(klass, with_method: :new)
+        proc {|data| klass.send(with_method, data)}
+      end
+    end
+  end
+end

data/lib/traitorous.rb

@@ -1,5 +1,14 @@
 require 'active_support/core_ext/hash/indifferent_access'
 
+# Traitorous is a model trait library whose primary goal is to be able to
+#   import from a hash and have it initialize an object graph.  It also exports
+#   back to a similar hash.
+# The exported hash will be almost identical to the import hash with the sole
+#   exception being that any trait values that are left out of the initial hash
+#   will end up being in the export hash with a nil value.
+# Similar libraries include https://github.com/solnic/virtus,
+#   https://github.com/cgriego/active_attr, and https://github.com/jetrockets/attrio
+
 module Traitorous
 
   # Use the HashWithIndifferentAccess from the activesupport gem.
@@ -13,57 +22,56 @@ module Traitorous
   # values to be defined, and 2 methods: :do_import and :do_export.
   # do_import is meant to take the data, and use the initial data to combine to
   # build objects or other data structures.
-  module Converter
-    # The purpose of the converters are to facilitate the importation of simple
-    #   JSON or YAML data and import that data into an arbitrarily nested tree
-    #   of objects.  And then to take those object and be able to export that data
-    #   in a simple form ready to save.
-    #   opts = {some: 'deep', data: ['structures']}
-    #    r = Mission.new(opts)
-    #    Mission.new(r.export) == r
-    require 'traitorous/converter/identity'
-    require 'traitorous/converter/default_value_static'
-    require 'traitorous/converter/model'
-    require 'traitorous/converter/uniform_array'
-    require 'traitorous/converter/method_keyed_uniform_hash'
-    # if no other converter is declared, use the identity converter which
-    # merely pass through the data passed to it.
-    DEFAULT_CONVERTER = Converter::Identity.new
-  end
+  require 'traitorous/standard_procs'
+  require 'traitorous/converter'
 
+  # The convert module provides simple front ends to the Converter object
+  #   constructor
+  require 'traitorous/convert'
   require 'traitorous/equality'
 
   module ClassMethods
+    # @!attribute [rw] traits
+    #   @return [HashWithIndifferntAccess]
+    #   There's no reason you can't manually alter the .traits hash, but be
+    #   aware of the potential consequences upon your data when doing so.
     attr_accessor :traits
 
-    def trait(attr_name, converter = Traitorous::Converter::DEFAULT_CONVERTER)
+    # @param attr_name [Symbol,String] name of the attribute, follows normal
+    #   method name rules
+    # @param converter [Traitorous::Converter,#do_import,#do_export] the converter
+    #   this trait will use during import and export operations.  A converter
+    #   must implement #do_import(data) and #do_export(data) but can otherwise
+    #   be any object or module.
+    #
+    #   defaults to Traitorous::Converter::DEFAULT
+    def trait(attr_name, converter = Convert.skip)
       self.traits            ||= HASH.new
-      # sub hash used here, {} chosen for expansion possibility, but only
-      #   :converter is in use
-      self.traits[attr_name] = {converter: converter}
+      self.traits[attr_name.intern] = converter
       attr_accessor attr_name
     end
   end
 
+  # :nodoc:
   def self.included(base)
     base.extend(ClassMethods)
   end
 
-  def initialize(opts = {})
+  # use the key/value pairs of
+  def initialize(data = {})
     raise "No traits have been defined for #{self.class}" unless self.class.traits
-    @opts = HASH.new(opts)
-    traits.each_pair do |new_trait, trait_opts|
-      converter = trait_opts[:converter]
-      val = converter.do_import(@opts.fetch(new_trait, nil))
+    @data = HASH.new(data)
+    traits.each_pair do |new_trait, converter|
+      val = converter.import(@data.fetch(new_trait, nil))
       self.send("#{new_trait}=".intern, val)
     end
   end
 
   def export
-    exported = HASH.new
-    traits.each_pair do |trait_name, trait_opts|
+    exported = {}
+    traits.each_pair do |trait_name, converter|
       attr_value = self.public_send(trait_name.intern)
-      exported[trait_name] = trait_opts[:converter].do_export(attr_value)
+      exported[trait_name] = converter.export(attr_value)
     end
     exported
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: traitorous
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.1
 platform: ruby
 authors:
 - scott m parrish
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-20 00:00:00.000000000 Z
+date: 2015-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -102,12 +102,10 @@ files:
 - bin/console
 - bin/setup
 - lib/traitorous.rb
-- lib/traitorous/converter/default_value_static.rb
-- lib/traitorous/converter/identity.rb
-- lib/traitorous/converter/method_keyed_uniform_hash.rb
-- lib/traitorous/converter/model.rb
-- lib/traitorous/converter/uniform_array.rb
+- lib/traitorous/convert.rb
+- lib/traitorous/converter.rb
 - lib/traitorous/equality.rb
+- lib/traitorous/standard_procs.rb
 - traitorius.gemspec
 homepage: https://github.com/anithri/traitorous
 licenses:
@@ -130,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A simple attribute, import, export system for PORO,

data/lib/traitorous/converter/default_value_static.rb

@@ -1,15 +0,0 @@
-module Traitorous
-  module Converter
-    class DefaultValueStatic
-      def initialize(default_value)
-        @default_value = default_value
-      end
-      def do_import(opts)
-        opts || @default_value
-      end
-      def do_export(data)
-        data
-      end
-    end
-  end
-end

data/lib/traitorous/converter/identity.rb

@@ -1,35 +0,0 @@
-module Traitorous
-  module Converter
-    # The Identity converter is used as a simple default which performs the
-    # jobs of a Converter without changing the inputs at all.
-    #
-    # This converter can be used when you have simple data (strings, dates,
-    #   numbers, hashes and arrays of the same) that doesn't need to be inflated
-    #   into an object and needs no changes to be safely stored as the same.
-    class Identity
-      # do_export is called in order to take an existing piece of data and
-      #   prepare it to be written to a simpler data structure.
-      #
-      # The Identity converter exports the same data it is passed without
-      #   changing them at all.
-      #
-      # @params data [Object] the data object passed in to be exported
-      # @return [Object] exports data to a form simple enough to save as JSON
-      def do_export(data)
-        data
-      end
-
-      # do_import is called in order to take some opts and to turn them into
-      #   instantiated objects, arrays, or other types of transformation
-      #
-      # The Identity converter imports the same opts it is passed without
-      #   changing them at all.
-      #
-      # @params opts [Object] the options to be imported
-      # @return [Object] opts
-      def do_import(opts)
-        opts
-      end
-    end
-  end
-end

data/lib/traitorous/converter/method_keyed_uniform_hash.rb

@@ -1,43 +0,0 @@
-module Traitorous
-  module Converter
-    # MethodKeyedUniformedHash is meant to take an array of a simple data
-    #   structures and convert each into a uniform class, and then will call a
-    #   key_method on that class and use it as the key in the returned hash.
-    #
-    # Exported data will be converted into an array calling do_export on each
-    #   element
-    class MethodKeyedUniformHash
-      attr_accessor :key_method, :uniform_klass
-      # @param key_method [Symbol] the method to call on the uniform_klass instance
-      #   to generate the key in the returned hash
-      # @param uniform_klass [Class, #new] the class to instantiate with each
-      #   element of the do_import array
-      def initialize(key_method, uniform_klass)
-        @key_method = key_method
-        @uniform_klass = uniform_klass
-      end
-
-      # The import instantiates each element of the array as an instance of
-      #   the uniform_klass, the key is determined by calling key_method on the
-      #   instance and then they are joined to the result hash as a key,
-      #   instance pair.
-      # @param arr_data [Array] the array of data to instantiate
-      # @return [Hash] hash containing key, instance pairs
-      def do_import(arr_data)
-        out = {}
-        Array(arr_data).each do |elem_data|
-          obj = uniform_klass.new(elem_data)
-          out[obj.send(key_method)] = obj
-        end
-        out
-      end
-
-      # @param hsh_data [Hash<obj,#export>] keys are ignored
-      # @return Array each element of the values of hsh_data has #export called
-      #   on it.
-      def do_export(hsh_data)
-        hsh_data.values.map{|instance| instance.export }
-      end
-    end
-  end
-end

data/lib/traitorous/converter/model.rb

@@ -1,39 +0,0 @@
-module Traitorous
-  module Converter
-    # The Model converter is used a a simple way to instantiate an object from
-    #   the model_class using the imported opts, and which will call .export on
-    #   the data.
-    #
-    # This converter can be used when you have a set of opts that you can pass
-    #   to a classes .new command in order to instantiate an object.
-    class Model
-      # @param model_klass [Class,#new] class to instantiate when importing
-      def initialize(model_klass)
-        @model_klass = model_klass
-      end
-
-      # do_export is called in order to take an existing piece of data and
-      #   prepare it to be written to a simpler data structure.
-      #
-      # The model converter exports the data by calling .export on it
-      #
-      # @params data [Object] the data object passed in to be exported
-      # @return [Object] result of data.export
-      def do_export(data)
-        data.export
-      end
-
-      # do_import is called in order to take some opts and to turn them into
-      #   instantiated objects, arrays, or other types of transformation
-      #
-      # The model converter imports the opts by instantiating a model_class
-      #   object with it.
-      #
-      # @params opts [Object] the options to be exported
-      # @return [Object] result of model_klass.new(opts)
-      def do_import(opts)
-        @model_klass.new(opts)
-      end
-    end
-  end
-end

data/lib/traitorous/converter/uniform_array.rb

@@ -1,17 +0,0 @@
-module Traitorous
-  module Converter
-    class UniformArray
-      def initialize(uniform_klass)
-        @uniform_klass ||= uniform_klass
-      end
-      def do_export(data_arr)
-        Array(data_arr).map(&:export)
-      end
-
-      def do_import(opts_arr)
-        Array(opts_arr).map{|d| @uniform_klass.new(d)}
-      end
-
-    end
-  end
-end