scatter_swapper 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce8d2cc8324748134de851ff2700b17d1d9bc88b
+  data.tar.gz: 35096e12bfde8a594d2a2dfabcffd4db480636f3
+SHA512:
+  metadata.gz: a6cc2d11257893757f3c17a515514ac377fb7f0f731c6550f24ecf494af03329738ce995255258263b361ad2618d8bf83116730dcbbd0b928429ab67252a0945
+  data.tar.gz: 1ef6a2cc17ca82c27d0ea8b0882229ac94d3bebdc940082797ebd2901e377c186457a4c76c6fae11b2c3a8b984ff6a30aa3d8572ce640aa6c9a4c602326bda29

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nathan and David Amick
+
+Copyright 2016 Patrice Lebel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# ScatterSwapper
+
+### Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'scatter_swapper'
+```
+
+Now, everytime an URL has a parameter with a name like `id` or `any_name_id`, it will be automatically converted to the decoded id.
+So, no need to change your controller code when accessing resources.
+
+Although, **URL generation isn't modified**... yet (still not sure if overriding `to_param` is the best solution), so you will need to pass the encoded id which is available through your model by the method `encoded_id`.
+
+### [Scatter Swap](https://github.com/altabyte/scatter_swap)
+
+Since `scatter_swap` isn't maintained anymore, the code has been brought back into this gem.
+
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,30 @@
+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    = 'ScatterSwapper'
+  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'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/ext/rails/action_controller/obfuscator.rb

@@ -0,0 +1,18 @@
+module ActionController
+  module Obfuscator
+    extend ActiveSupport::Concern
+
+    def params
+      return super if ScatterSwapper.config.skip_controller_params || self.class.try(:skip_obfuscator)
+
+      @_params ||= begin
+        super.each do |key, value|
+          if key =~ /(?:^|_)id$/
+            super[key] = ScatterSwap.reverse_hash(value, 0, 9).try(:to_i) # use 9, so standard 32-bit Int won't overflow
+          end
+        end
+        super
+      end
+    end
+  end
+end

data/lib/ext/rails/active_record/obfuscator.rb

@@ -0,0 +1,9 @@
+module ActiveRecord
+  module Obfuscator
+    extend ActiveSupport::Concern
+
+    def encoded_id
+      ScatterSwap.hash(id, 0, 9).try(:to_i) # use 9, so standard 32-bit Int won't overflow
+    end
+  end
+end

data/lib/scatter_swap.rb

@@ -0,0 +1,30 @@
+require 'scatter_swap/version'
+require 'scatter_swap/hasher'
+
+module ScatterSwap
+
+  # Hash the given +plain_integer+ into its obfuscated +String+ form.
+  #
+  # @note To obtain the corresponding hashed *integer* value call {ScatterSwap.hash}(plain_integer).to_i
+  # @param [Fixnum] plain_integer the numeric value to be hashed.
+  # @param [Fixnum] spin the seed value for the hashing algorithm.
+  # @param [Fixnum] length the number of digits in the returned hash.
+  # @return [String] a '0' padded string of +length+ digits containing the hashed numeric value.
+  #
+  def self.hash(plain_integer, spin = 0, length = 10)
+    Hasher.new(plain_integer, spin, length).hash
+  end
+
+
+  # Reverse +hashed_integer+ from its obfuscated form to its serial value.
+  #
+  # @note To obtain the corresponding reverse-hashed *integer* value call {ScatterSwap.reverse_hash}(hashed_integer).to_i
+  # @param [Fixnum] hashed_integer the numeric value to be hashed.
+  # @param [Fixnum] spin the seed value for the hashing algorithm.
+  # @param [Fixnum] length the number of digits in the returned hash.
+  # @return [String] a '0' padded string of +length+ digits containing the reverse-hashed numeric value.
+  #
+  def self.reverse_hash(hashed_integer, spin = 0, length = 10)
+    Hasher.new(hashed_integer, spin, length).reverse_hash
+  end
+end

data/lib/scatter_swap/hasher.rb

@@ -0,0 +1,98 @@
+module ScatterSwap
+  class Hasher
+
+    # @return [Array[Fixnum]]
+    attr_reader :working_array
+
+    # @return [Fixnum] the number of digits in the computed hashes.
+    attr_reader :length
+
+    # @return [Fixnum] A seed value to add some spice, so that different apps can have differently mapped hashes.
+    attr_reader :spin
+
+    # Construct a new +Hasher+.
+    # @param [Fixnum] integer the numeric value to be hashed/reversed.
+    # @param [Fixnum] spin a seed value.
+    # @param [Fixnum] length the number of digits in the computed hashes.
+    #
+    def initialize(integer, spin = 0, length = 10)
+      @original_integer = integer.freeze
+      @spin = (spin || 0).freeze
+      @length = length.freeze
+      zero_pad = integer.to_s.rjust(length, '0')
+      @working_array = zero_pad.split('').collect { |d| d.to_i }
+    end
+
+    # Obfuscate the original integer value to a zero-padded String of {#length} digits.
+    # @return [String] the obfuscated hash.
+    #
+    def hash
+      swap
+      scatter
+      completed_string
+    end
+
+    # De-obfuscate the original integer value to a zero-padded String of {#length} digits.
+    # @return [String] the de-obfuscated hash.
+    #
+    def reverse_hash
+      unscatter
+      unswap
+      completed_string
+    end
+
+
+    #-------------------------------------------------------------------------
+    private
+
+    def completed_string
+      @working_array.join
+    end
+
+    # We want a unique map for each place in the original number
+    def swapper_map(index)
+      array = (0..9).to_a
+      10.times.collect.with_index do |i|
+        array.rotate!(index + i ^ spin).pop
+      end
+    end
+
+    # Using a unique map for each of the ten places,
+    # we swap out one number for another
+    def swap
+      @working_array = @working_array.collect.with_index do |digit, index|
+        swapper_map(index)[digit]
+      end
+    end
+
+    # Reverse swap
+    def unswap
+      @working_array = @working_array.collect.with_index do |digit, index|
+        swapper_map(index).rindex(digit)
+      end
+    end
+
+    # Rearrange the order of each digit in a reversible way by using the
+    # sum of the digits (which doesn't change regardless of order)
+    # as a key to record how they were scattered
+    def scatter
+      sum_of_digits = @working_array.inject(:+).to_i
+      @working_array = length.times.collect do
+        @working_array.rotate!(spin ^ sum_of_digits).pop
+      end
+    end
+
+    # Reverse the scatter
+    def unscatter
+      scattered_array = @working_array
+      sum_of_digits = scattered_array.inject(:+).to_i
+      @working_array = []
+      @working_array.tap do |unscatter| 
+        length.times do
+          unscatter.push scattered_array.pop
+          unscatter.rotate! (sum_of_digits ^ spin) * -1
+        end
+      end
+    end
+  end
+end

data/lib/scatter_swap/run.rb

@@ -0,0 +1,93 @@
+require 'scatter_swap'
+
+# This file is spike code and is not part of the library
+# 
+# While developing this, I used this file to visualize what was going on with the numbers
+#
+# You can uncomment various methods at the bottom and then run it like this:
+#
+# watch -n1 ruby run_scatter_swap.rb
+# 
+# tweak the code a bit and see instant visual changes in the generated numbers
+
+def visualize_scatter_and_unscatter
+  # change this number to experiment with different values
+  rotations = 99
+
+  original = ScatterSwap.arrayify(123456789)
+  scattered = []
+  unscattered = []
+  puts original.join
+  puts "rotate!(#{rotations})"
+  10.times do
+    puts original.rotate!(rotations).join + "->" + scattered.push(original.pop).join
+  end
+  puts "scattered"
+  puts scattered.join
+  10.times do
+    puts unscattered.push(scattered.pop).join + "->" + unscattered.rotate!(rotations * -1).join
+  end
+
+  puts unscattered.join
+end
+
+
+def visualize_swapper_map
+  puts "swapper map"
+  10.times do |index|
+    key = 1
+    puts ScatterSwap.swapper_map(index).join.to_s
+  end
+end
+
+def visualize_hash
+  puts "hash"
+  40.times do |integer|
+    output = "|"
+    3.times do |index|
+      output += " #{(integer + (123456789 * index)).to_s.rjust(5, ' ')}"
+      output += " => #{hashed = ScatterSwap.hash(integer + (123456789 * index) ) }"
+      output += " => #{ScatterSwap.reverse_hash(hashed) } |"
+    end
+    puts output
+  end
+end
+
+
+def visualize_scatter
+  puts "original      scattered     unscattered"
+  20.times do |integer|
+    output = ""
+    2.times do |index|
+      original = ScatterSwap.arrayify(integer + (123456789 * index))
+      scattered = ScatterSwap.scatter(original.clone)
+      unscattered = ScatterSwap.unscatter(scattered.clone)
+      output += "#{original.join}" 
+      output += " => #{scattered.join}"
+      output += " => #{unscattered.join}    |    "
+    end
+    puts output
+  end
+end
+
+
+# find hash for lots of spins
+def visualize_spin
+  2000.times do |original|
+    hashed_values = []
+    9000000000.times do |spin|
+      hashed =  ScatterSwap.hash(original, spin)
+      if hashed_values.include? hashed
+        puts "collision: #{original} - #{spin} - #{hashed}"
+        break
+      end
+      hashed_values.push hashed
+    end
+  end
+end
+
+#visualize_spin
+#visualize_hash
+#visualize_scatter_and_unscatter
+#visualize_scatter
+#visualize_swapper_map

data/lib/scatter_swap/version.rb

@@ -0,0 +1,3 @@
+module ScatterSwap
+  VERSION = '0.1.0'
+end

data/lib/scatter_swapper.rb

@@ -0,0 +1,8 @@
+require 'scatter_swap'
+require "scatter_swapper/engine"
+require "ext/rails/active_record/obfuscator"
+require "ext/rails/action_controller/obfuscator"
+
+module ScatterSwapper
+  # Your code goes here...
+end

data/lib/scatter_swapper/configuration.rb

@@ -0,0 +1,21 @@
+module ScatterSwapper
+  @@config = nil
+
+  def self.configure
+    @@config ||= Configuration.new
+
+    if block_given?
+      yield config
+    end
+
+    config
+  end
+
+  def self.config
+    @@config || configure
+  end
+
+  class Configuration
+    attr_accessor :skip_controller_params
+  end
+end

data/lib/scatter_swapper/engine.rb

@@ -0,0 +1,23 @@
+require 'scatter_swapper/configuration'
+
+module ScatterSwapper
+  class Engine < ::Rails::Engine
+    initializer "scatter_swapper.configure" do
+      ActiveSupport.on_load :active_record do
+        ::ActiveRecord::Base.class_eval do
+          include ActiveRecord::Obfuscator
+        end
+      end
+
+      ActiveSupport.on_load :action_controller do
+        ::ActionController::Base.class_eval do
+          include ActionController::Obfuscator
+        end
+
+        ::ActionController::API.class_eval do
+          include ActionController::Obfuscator
+        end
+      end
+    end
+  end
+end

data/lib/scatter_swapper/version.rb

@@ -0,0 +1,3 @@
+module ScatterSwapper
+  VERSION = '0.3.0'
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative 'config/application'
+
+Rails.application.load_tasks

data/spec/dummy/app/assets/config/manifest.js

@@ -0,0 +1,4 @@
+
+//= link_tree ../images
+//= link_directory ../javascripts .js
+//= link_directory ../stylesheets .css

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/spec/dummy/app/assets/javascripts/cable.js

@@ -0,0 +1,13 @@
+// Action Cable provides the framework to deal with WebSockets in Rails.
+// You can generate new channels where WebSocket features live using the rails generate channel command.
+//
+//= require action_cable
+//= require_self
+//= require_tree ./channels
+
+(function() {
+  this.App || (this.App = {});
+
+  App.cable = ActionCable.createConsumer();
+
+}).call(this);