Transformer

I want to transform objects.

should transform hash 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """
      var hash = {
          name: 'value'
      }

      // name -> name2
      var transformer = new Transformer({
          name2: 'name'
      });


      var result = transformer(hash);

      var expected = {
          name2: 'value'
      };

  """
`result` should deep equal `expected`          

should transform array 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """
      var _array = [
          {
              name: 'value'
          }
      ];

      var transformer = new Transformer({
          name2: 'name'
      });


      var result = transformer(_array);

      var expected = [
          {
              name2: 'value'
          }
      ];
  """
`result` should deep equal `expected`          

should allow to define defaults 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """

      var hash = {
          name: 'value'
      }

      var transformer = new Transformer({
          name2: ['name-not-exist', Transformer.Default(null)],
          name3: ['name', Transformer.Default(null)]
      });


      var result = transformer(hash);

      var expected = {
          name2: null,
          name3: 'value'
      };

  """
`result` should deep equal `expected`          

should allow to transform simple nested hash 

require `src/Transformer.js` as `Transformer`    
code:                                            
  """
      var hash = {
          user: {
              name: 'value'
          }
      }

      var transformer = new Transformer({
          name2: 'user.name'
      });


      var result = transformer(hash);

      var expected = {
          name2: 'value'
      };
  """
`result` should deep equal `expected`             

should allow to transform complex nested hash 

require `src/Transformer.js` as `Transformer`     
code:                                             
  """
      var hash = {
          users: [
              {
                  name: 'value'
              }
          ]
      }

      var userTransformer = new Transformer({
          name2: 'name'
      });

      var transformer = new Transformer({
          users2: ['users', userTransformer]
      });


      var result = transformer(hash);

      var expected = {
          users2: [
              {
                  name2: 'value'
              }
          ]
      };

  """
`result` should deep equal `expected`              

should ignore non-object 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """
      var transformer = new Transformer({
          name1: 'name0'
      });

      var nonObject = 'my non object value';
      var result = transformer(nonObject);
  """
`result` should equal `nonObject`              
code:                                         
  """
      var nonObject = 100500;
      var result = transformer(nonObject);
  """
`result` should equal `nonObject`              

should ignore Error object 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """
      var transformer = new Transformer({
          name1: 'name0'
      });

      var error = new Error('my error');
      var result = transformer(error);
  """
`result` should equal `error`                  

should merge changes through transformer 

require `src/Transformer.js` as `Transformer` 
code:                                         
  """

      // name2 -> name1
      var transformer = new Transformer({
          name1: 'name2'
      });


      var myHash = {
          name1: 'name1',
          name2: 'name2'
      }

      var myData = {
          name2: 'name1-updated'
      }

      var result = transformer.merge(myHash, myData);

      var expected = {
          name1: 'name1-updated',
          name2: 'name2'
      };
  """
`result` should deep equal `expected`          

8 scenarios (8 passed) 26 steps (26 passed)