snake-eyes 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9528a2e50402eff13ab812c8909b0bb251c301a3
-  data.tar.gz: 20fefd48f80e6175bfc7f46727c089ad5803fbdc
+  metadata.gz: e5d87558dd242a686cdeb61d193ff4785f0dca88
+  data.tar.gz: 3342dc90f6aa0cb230758f303d9ba7694135369a
 SHA512:
-  metadata.gz: f30b1a86afb2ee7cbdad47cc54cc042693190e6bac57783b001acad97d3f8ee27d4ee8fec90c521f7a78e6af49144356c2429914c3a4116a5aada6f4924d71d1
-  data.tar.gz: 7f62c295eda2b33f42456f2cac333d002b3c1e080809a27c3a0a1c9908f1fa67c8c3b23cc86781aa6f68be1ce339c67cf8254db4d2cbcd76bbf9debac4d6ea7f
+  metadata.gz: 2b52f46eb4f20de9c95d6b00e8ba465c98c40fcae292d06508c3ec6a35b856d25b4f06f41b78cad1364d301c82c0f4ad375ba501f94ee16c63bf89f8db980140
+  data.tar.gz: accbf453ddafdf9b49b598a1e89cc01de69285e204a7417fb157de84918224adfd372b1c8860f76940dab4dbccf721119b2c32d0a6dfbe7d88d34b359b2cfc94

data/{LICENSE.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2016 Aleck Greenham
+Copyright 2018 Aleck Greenham
 
 MIT License
 

data/README.md

@@ -1,14 +1,10 @@
 # SnakeEyes
 
-Automatically convert between camel case APIs to snake case for your Rails code
-
-## Important
-
-🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧
-
-If you are using a version below `0.0.4`, please upgrade to avoid [potentially logging sensitive user information](https://github.com/greena13/snake-eyes/issues/1)
+[![Gem](https://img.shields.io/gem/dt/snake-eyes.svg)]()
+[![Build Status](https://travis-ci.org/greena13/snake-eyes.svg)](https://travis-ci.org/greena13/snake-eyes)
+[![GitHub license](https://img.shields.io/github/license/greena13/snake-eyes.svg)](https://github.com/greena13/snake-eyes/blob/master/LICENSE)
 
-🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧🚧
+Automatically convert between camel case APIs to snake case for your Rails code
 
 ## Installation
 
@@ -71,6 +67,8 @@ Once `snake_eyes_params` has been enabled for a controllor, `params` accepts an
   end
  ```
 
+#### Avoid _attributes suffix on parents: the _ prefix
+
 To specify nested objects that should not have the `_attributes` suffix (but contain attributes that should), you can prefix them with an underscore:
 
 
@@ -92,22 +90,108 @@ To specify nested objects that should not have the `_attributes` suffix (but con
   end
  ```
 
-## Limitations
+#### Reference any element of an array: the '*' wildcard
+
+To apply the `_attributes` suffix to all elements of an array, use the `'*'` wildcard in place of the array index:
+
+```ruby
+class WithSnakeEyesController < ApplicationController
+    snake_eyes_params
+
+    def show
+        # Given
+        params(nested_attributes: [ _array: { '*' => :string } ])
+
+        # If the params are:
+        #
+        # 'array' => [
+        #      { 'string' => 'string' },
+        #      { 'string' => 'string2' },
+        #  ]
+        #
+        # What will be returned:
+        #
+        # 'array' => [
+        #      { 'string_attributes' => 'string' },
+        #      { 'string_attributes' => 'string2' },
+        #  ]
+    end
+end
+```
+
+## Substitutions
 
-SnakeEyes does *not* currently handle the following aspects of converting a JSON API to a Rails-compatible one:
+If you want to substitute alternative values for the ones that the controller actually receives, you can do that using the `substitutions` option:
 
-**Converting arrays of objects to hashes, keyed by item indexes**
+```ruby
+class WithSnakeEyesController < ApplicationController
+    snake_eyes_params
 
-Fox example:
+    def show
+        # Given
+        params(substitutions: {
+            shallow_object: {
+                price: { replace: 'FREE', with: 0.00 }
+            }
+        })
+
+        # If params is:
+        #
+        # 'shallowObject' => {
+        #      'price' => 'FREE'
+        #  }
+        #
+        # What will be returned:
+        #
+        # 'shallow_object' => {
+        #     'price' => 0.00
+        # }
+    end
+end
+```
 
-```JSON
-{
-    "a": [
-        { "b": 1 },
-        { "b": 2 },
-        { "b": 3 }
-    ]
-}
+You can also provide multiple substitutions as an array. They are matched left-to-right, and the first matching substitution is the one that is used.
+
+```ruby
+class WithSnakeEyesController < ApplicationController
+    snake_eyes_params
+
+    def show
+        # Given
+        params(substitutions: {
+            shallow_object: {
+                price: [
+                    { replace: 'FREE', with: 0.00 } ,
+                    { replace: 'EXPENSIVE', with: 999.00 }
+                ]
+            }
+        })
+
+        # If params is:
+        #
+        # 'shallowObject' => {
+        #      'price' => 'FREE'
+        #  }
+        #
+        # What will be returned:
+        #
+        # 'shallow_object' => {
+        #     'price' => 0.00
+        # }
+
+        # If params is:
+        #
+        # 'shallowObject' => {
+        #      'price' => 'EXPENSIVE'
+        #  }
+        #
+        # What will be returned:
+        #
+        # 'shallow_object' => {
+        #     'price' => 999.00
+        # }
+    end
+end
 ```
 
 ## Configuration

data/Rakefile

@@ -1,2 +1,30 @@
-require "bundler/gem_tasks"
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
 
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SnakeEyes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+Bundler::GemHelper.install_tasks
+
+Dir[File.join(File.dirname(__FILE__), 'tasks/**/*.rake')].each {|f| load f }
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+desc "Run all specs in spec directory (excluding plugin specs)"
+RSpec::Core::RakeTask.new(:spec => 'app:db:test:prepare')
+
+task :default => :spec

data/lib/snake-eyes/engine.rb

@@ -0,0 +1,12 @@
+module SnakeEyes
+  class Engine < ::Rails::Engine
+
+    config.generators do |g|
+      g.test_framework :rspec, :fixture => false
+      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.assets false
+      g.helper false
+    end
+
+  end
+end

data/lib/snake-eyes/interface_changes.rb

@@ -1,81 +1,38 @@
 module SnakeEyes
   module InterfaceChanges
+    KEYS_ALWAYS_PRESENT = [
+        "controller",
+        "action"
+    ]
+
     def params(options = {})
       validate_options(options)
 
       original_params = super()
 
-      return original_params unless original_params.any?
-
-      # List of subtrees maintained to mark the depth-first traversal's position
-      # throughout the transformation of the original param's keys, whereby the
-      # last element is the traversal's current position and backtracking (going
-      # from child to parent) is achieved by popping off the last element.
-
-      original_params_sub_trees = [
-          original_params
-      ]
-
-      # Convert the relatively flat format used to specify the nested attributes
-      # (easier for specification) into a series of nested objects (easier for
-      # look-ups)
+      params_present = (original_params.keys | KEYS_ALWAYS_PRESENT).length > KEYS_ALWAYS_PRESENT.length
 
-      nested_schema = build_nested_schema(options[:nested_attributes] || {})
+      unless params_present
+        return original_params
+      end
 
       @previous_params ||= { }
 
-      return @previous_params[nested_schema] if @previous_params[nested_schema]
-
-      # Similar to original_params_sub_trees, a list of subtrees used to maintain
-      # the traversal position of nested_schema. This is kept in sync with the
-      # traversal of original_params, to ensure the correct leaf of
-      # nested_schema is checked at each point in the traversal of original_params
-
-      nested_schema_sub_trees = [
-        nested_schema
-      ]
-
-      transformed_params = original_params.deep_transform_keys do |original_key|
-        # Synchronise the original params sub-tree with the current key being
-        # transformed. We can detect that the sub-tree is stale because the key
-        # being transformed does not appear amongst its own. When the sub-tree is
-        # indeed stale, move the position to its parent for the original params
-        # sub-tree and the nested schema sub-tree and repeat the check.
-
-        while original_params_sub_trees.length > 1 && original_params_sub_trees.last[original_key].nil?
-          original_params_sub_trees.pop
-          nested_schema_sub_trees.pop
+      nested_schema = build_options_schema(options[:nested_attributes] || {}, '') do |target, parent_name|
+        if parent_name.empty? || parent_name.starts_with?('_')
+          target
+        else
+          target.merge({ _attributes_suffix: true })
         end
+      end
 
-        original_params_sub_tree = original_params_sub_trees.last[original_key]
-
-        # Append the '_attributes' suffix if the original params key has the
-        # same name and is nested in the same place as one mentioned in the
-        # nested_attributes option
+      options[:nested_attributes] = nested_schema
 
-        transformed_key_base = original_key.underscore
+      return @previous_params[options] if @previous_params[options]
 
-        transformed_key =
-            if nested_schema_sub_trees.last[transformed_key_base]
-              transformed_key_base + '_attributes'
-            else
-              transformed_key_base
-            end
+      transformed_params = deep_transform(original_params, options)
 
-        if original_params_sub_tree.kind_of?(Hash)
-          original_params_sub_trees.push(original_params_sub_tree)
-
-          nested_schema_sub_trees.push(
-              nested_schema_sub_trees.last[transformed_key_base] ||
-                  nested_schema_sub_trees.last['_' + transformed_key_base] ||
-                  {}
-          )
-        end
-
-        transformed_key
-      end
-
-      @previous_params[nested_schema] = @snake_eyes_params = ActionController::Parameters.new(transformed_params)
+      @previous_params[options] = @snake_eyes_params = ActionController::Parameters.new(transformed_params)
 
       log_snakized_params
 
@@ -86,7 +43,7 @@ module SnakeEyes
 
     def validate_options(options)
       options.keys.each do |key|
-        raise ArgumentError.new("SnakeEyes: params received unrecognised option '#{key}'") if key != :nested_attributes
+        raise ArgumentError.new("SnakeEyes: params received unrecognised option '#{key}'") if key != :nested_attributes && key != :substitutions
       end
     end
 
@@ -100,28 +57,117 @@ module SnakeEyes
       end
     end
 
-    def build_nested_schema(attributes_list = [])
+    def deep_transform(target, options = {})
 
-      if attributes_list.kind_of?(Array)
+      nested_attributes = options[:nested_attributes] || {}
+
+      substitutions =
+          if options[:substitutions].kind_of?(Array)
+            options[:substitutions].map(&:stringify_keys)
+          else
+            (options[:substitutions] || {}).stringify_keys
+          end
 
-        attributes_list.inject({}) do |memo, nested_attribute|
-          memo.merge(build_nested_schema(nested_attribute))
+      if target.kind_of?(Array)
+        target.map do |targetElement|
+          deep_transform(targetElement, {
+              nested_attributes: nested_attributes['*'],
+              substitutions: substitutions.kind_of?(Array) ? {} : substitutions['*']
+          })
         end
 
-      elsif attributes_list.kind_of?(Hash)
+      elsif target.kind_of?(Hash)
 
-        attributes_list.inject({}) do |memo, key_and_value|
+        target.inject({}) do |memo, key_and_value|
           key, value = key_and_value
-          memo[key.to_s] = build_nested_schema(value)
+
+          # Append the '_attributes' suffix if the original params key has the
+          # same name and is nested in the same place as one mentioned in the
+          # nested_attributes option
+
+          transformed_key_base = key.to_s.underscore
+
+          transformed_key =
+              if nested_attributes[transformed_key_base] && nested_attributes[transformed_key_base][:_attributes_suffix]
+                transformed_key_base + '_attributes'
+              else
+                transformed_key_base
+              end
+
+          transformed_value = deep_transform(value,
+            {
+                nested_attributes: nested_attributes[transformed_key_base] || nested_attributes['_' + transformed_key_base],
+                substitutions: substitutions.kind_of?(Array) ? {} : substitutions[transformed_key_base]
+            }
+          )
+
+          memo[transformed_key] = transformed_value
+
           memo
         end
 
       else
+        perform_substitution(target, substitutions)
+      end
 
-        { attributes_list.to_s.underscore => {} }
+    end
+
+    def perform_substitution(target, substitution)
+      if substitution.kind_of?(Array)
+        matching_substitution = substitution.find do |substitution_item|
+          has_substitution_keys?(substitution_item) && target === substitution_item["replace"]
+        end
+
+        if matching_substitution
+          matching_substitution["with"]
+        else
+          target
+        end
+
+      else
+        if has_substitution_keys?(substitution)
+          target === substitution["replace"] ? substitution["with"] : target
+        else
+          target
+        end
+      end
+    end
+
+    def has_substitution_keys?(substitution)
+      substitution.has_key?("replace") && substitution.has_key?("with")
+    end
+
+    def build_options_schema(attributes_list = [], parent_name = '', options = {}, &block)
+
+      if attributes_list.kind_of?(Array)
+        attributes_array = attributes_list.inject({}) do |memo, nested_attribute|
+          memo.merge(build_options_schema(nested_attribute, parent_name, options, &block))
+        end
+
+        yield(attributes_array, parent_name)
+
+      elsif attributes_list.kind_of?(Hash) && (!options[:internal_attributes] || (attributes_list.keys & options[:internal_attributes]).length > options[:internal_attributes].length)
+
+        attributes_hash = attributes_list.inject({}) do |memo, key_and_value|
+          key, value = key_and_value
+
+          memo[key.to_s] = yield(build_options_schema(value, '', options, &block), key.to_s)
+
+          memo
+        end
+
+        yield(attributes_hash, parent_name)
+      else
+
+        {
+            attributes_list.to_s.underscore => yield({}, attributes_list.to_s.underscore)
+        }
 
       end
 
     end
+
+
   end
+
 end

data/lib/snake-eyes/version.rb

@@ -1,3 +1,3 @@
 module SnakeEyes
-  VERSION = "0.0.8"
+  VERSION = "0.1.0"
 end