voltron-encrypt 0.1.2

data/lib/generators/templates/db/migrate/create_voltron_ids.rb

@@ -0,0 +1,9 @@
+class CreateVoltronIds < ActiveRecord::Migration
+  def change
+    create_table :voltron_ids, id: false do |t|
+      t.integer :id, limit: 8, primary_key: true
+      t.integer :resource_id, limit: 8
+      t.string :resource_type
+    end
+  end
+end

data/lib/generators/voltron/encrypt/install_generator.rb

@@ -0,0 +1,91 @@
+module Voltron
+  class Encrypt
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+
+        source_root File.expand_path("../../../templates", __FILE__)
+
+        desc "Add Voltron Encrypt initializer"
+
+        def inject_initializer
+
+          voltron_initialzer_path = Rails.root.join("config", "initializers", "voltron.rb")
+
+          unless File.exist? voltron_initialzer_path
+            unless system("cd #{Rails.root.to_s} && rails generate voltron:install")
+              puts "Voltron initializer does not exist. Please ensure you have the 'voltron' gem installed and run `rails g voltron:install` to create it"
+              return false
+            end
+          end
+
+          current_initiailzer = File.read voltron_initialzer_path
+
+          unless current_initiailzer.match(Regexp.new(/^# === Voltron Encrypt Configuration ===/))
+            inject_into_file(voltron_initialzer_path, after: "Voltron.setup do |config|\n") do
+<<-CONTENT
+
+  # === Voltron Encrypt Configuration ===
+
+  # The offset used in generating base64 encoded ids. A higher number means larger ids (i.e. - "7feIds" instead of "6f"),
+  # but can potentially produce large base64 encoded ids
+  # DON'T change this number once records whose id's are being encoded exist in the database
+  # as all decoded ids will be incorrect
+  # config.encrypt.offset = 262144
+
+  # The location of the blacklist, words that should NOT be permitted in the form of generated ids
+  # Each word should be on it's own line, and only contain [A-Z], no spaces, dashes, underscores, or numbers
+  # Each word is automatically matched against it's literal, case-insensitive, and l33t spellings, with dashes
+  # and underscores optionally preceding/following each character.
+  # i.e. - the blacklist word "toke" will match [toke, tOKE, 7oke, t0k3, t-o-k-e, -t0--k3--, etc...]
+  # config.encrypt.blacklist = Rails.root.join("config", "locales", "blacklist.txt")
+
+  # The seed used to randomize base 64 characters. Once set, it should NOT EVER be changed.
+  # Doing so will result in incorrect decoded ids, followed by large crowds with pitchforks and torches
+  # Running `rake secret` is a good way to generate a random seed for this config value
+  # config.encrypt.seed = ""
+CONTENT
+            end
+          end
+        end
+
+        def copy_blacklist
+          unless File.exist? Rails.root.join("config", "locales", "blacklist.txt")
+            copy_file "config/locales/blacklist.txt", Rails.root.join("config", "locales", "blacklist.txt")
+          end
+        end
+
+        def copy_migrations
+          copy_migration "create_voltron_ids"
+        end
+
+        protected
+
+          def copy_migration(filename)
+            if migration_exists?(Rails.root.join("db", "migrate"), filename)
+              say_status("skipped", "Migration #{filename}.rb already exists")
+            else
+              copy_file "db/migrate/#{filename}.rb", Rails.root.join("db", "migrate", "#{migration_number}_#{filename}.rb")
+            end
+          end
+
+          def migration_exists?(dirname, filename)
+            Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{filename}.rb$/).first
+          end
+
+          def migration_id_exists?(dirname, id)
+            Dir.glob("#{dirname}/#{id}*").length > 0
+          end
+
+          def migration_number
+            @migration_number ||= Time.now.strftime("%Y%m%d%H%M%S").to_i
+
+            while migration_id_exists?(Rails.root.join("db", "migrate"), @migration_number) do
+              @migration_number += 1
+            end
+
+            @migration_number
+          end
+      end
+    end
+  end
+end

data/lib/voltron/config/encrypt.rb

@@ -0,0 +1,19 @@
+module Voltron
+  class Config
+
+    def encrypt
+      @encrypt ||= Encrypt.new
+    end
+
+    class Encrypt
+
+      attr_accessor :offset, :seed, :blacklist
+
+      def initialize
+        @offset ||= 262144
+        @seed ||= ""
+        @blacklist ||= Rails.root.join("config", "locales", "blacklist.txt")
+      end
+    end
+  end
+end

data/lib/voltron/encrypt/engine.rb

@@ -0,0 +1,19 @@
+module Voltron
+  class Encrypt
+    class Engine < Rails::Engine
+
+      isolate_namespace Voltron
+
+      initializer "voltron.encrypt.initialize" do
+        ::ActiveRecord::Base.send :extend, ::Voltron::Encryptable
+
+        # Corrects sidekiq resource lookup by forcing it to find_by_id rather than find with the model id
+        # We either want it to find with to_param value, or find_by_id with the actual id, this is the latter
+        ::GlobalID::Locator.use Rails.application.railtie_name.remove("_application").dasherize do |gid|
+          gid.model_class.find_by_id gid.model_id
+        end
+      end
+
+    end
+  end
+end

data/lib/voltron/encrypt/version.rb

@@ -0,0 +1,5 @@
+module Voltron
+  class Encrypt
+    VERSION = "0.1.2".freeze
+  end
+end

data/lib/voltron/encrypt.rb

@@ -0,0 +1,83 @@
+require "voltron"
+require "voltron/encrypt/version"
+require "voltron/config/encrypt"
+require "voltron/encryptable"
+
+module Voltron
+  class Encrypt
+
+    def encode(input)
+      radix = digits.length
+      i = input.to_i + Voltron.config.encrypt.offset.to_i # Increase the number just so we don't end up with id's like "E" or "d3" on low number ids
+
+      raise ArgumentError.new("Value #{val} cannot be less than zero") if i < 0
+
+      out = []
+      begin
+        rem = i % radix
+        i /= radix
+        out << digits[rem]
+      end until i == 0
+
+      out.reverse.join
+    end
+
+    def decode(input)
+      inp = input.to_s.split("")
+      out = 0
+
+      begin
+        chr = inp.shift
+        out += (digits.length**inp.length)*digits.index(chr)
+      end until inp.empty?
+
+      out - Voltron.config.encrypt.offset.to_i # Decrease the number by the same offset amount
+    end
+
+    def blacklisted?(input)
+      encoded = encode(input)
+
+      pattern = ["\\b([_\\-])*"]
+      encoded.split("").each do |c|
+        subs = translations[c.downcase] || []
+        c = "\\#{c}" if c == "-"
+        pattern << "[#{c}#{subs.join}]([_\\-])*"
+      end
+      pattern << "\\b"
+
+      regex = Regexp.new(pattern.join, Regexp::IGNORECASE)
+      !blacklist(encoded.length).match(regex).nil?
+    end
+
+    private
+
+      def blacklist(len = 6)
+        if File.exist?(Voltron.config.encrypt.blacklist.to_s)
+          File.readlines(Voltron.config.encrypt.blacklist).map(&:strip).reject { |line| line.length > len }.join(" ")
+        else
+          ""
+        end
+      end
+
+      def translations
+        {
+          "a" => ["4"],
+          "e" => ["3"],
+          "i" => ["1", "l"],
+          "o" => ["0"],
+          "s" => ["5"],
+          "t" => ["7"],
+          "b" => ["8"],
+          "z" => ["2"],
+          "g" => ["9"]
+        }
+      end
+
+      def digits
+        rnd = Random.new(Voltron.config.encrypt.seed.to_s.to_i(24))
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_".split("").shuffle(random: rnd)
+      end
+  end
+end
+
+require "voltron/encrypt/engine" if defined?(Rails)

data/lib/voltron/encryptable.rb

@@ -0,0 +1,125 @@
+module Voltron
+  module Encryptable
+
+    def encrypted_id
+      extend ClassMethods
+      include InstanceMethods
+
+      has_one :encryptable, as: :resource, class_name: "Voltron::Id"
+
+      before_create do
+        self.build_encryptable id: find_id
+      end
+    end
+
+    module ClassMethods
+      def find(*args)
+        scope = args.slice!(0)
+        options = args.slice!(0) || {}
+
+        if !options[:bypass] && ![:first, :last, :all].include?(scope.try(:to_sym))
+          scope = decoded_ids(scope)
+        end
+        
+        super(scope)
+      end
+
+      def exists?(conditions = :none)
+        if conditions.is_a?(String)
+          # If conditions is a string, assume it's an encoded id
+          super(decoded_ids(conditions))
+        else
+          # Otherwise do what exists? normally does
+          super(conditions)
+        end
+      end
+
+      def destroy(id)
+        super(decoded_ids(id))
+      end
+
+      def delete(id)
+        super(decoded_ids(id))
+      end
+
+      private
+
+        def decoded_ids(*ids)
+          crypt = Voltron::Encrypt.new
+
+          ids.flatten!
+          ids.map! { |id| crypt.decode(id).to_i }
+          ids.reject! { |id| id > 9223372036854775807 } # Remove id if given decoded value is greater than max PostgreSQL value
+          ids = Voltron::Id.where(id: ids).pluck(:resource_id)
+          ids = ids.first if ids.length == 1
+          ids
+        end
+    end
+
+    module InstanceMethods
+      def to_param
+        return super if encryptable.nil?
+
+        crypt = Voltron::Encrypt.new
+        crypt.encode(encryptable.id)
+      end
+
+      def find_id
+        # Helps determine the min/max value. For example if amount is 1100, min will be 1024, if amount is 947, min will be 1
+        amount = Voltron::Id.count.to_f
+
+        # The range of ids from which we try to find an unused id, i.e. - (1..1024), (1025..2048), (2049..3073)
+        factor = 1024.to_f
+
+        # Get the min and max value of the range segment
+        min = (((amount/factor).floor*factor) + 1).to_i
+        max = (((amount+1)/factor).ceil*factor).to_i
+
+        # Get all ids in the determined range segment, these are the ids we cannot choose from
+        used = Voltron::Id.where(id: min..max).pluck(:id)
+        # Get the candidates, an array of values from min to max, subtracting the used values from above
+        candidates = ((min..max).to_a - used).shuffle
+        # Get the first candidate, the first value off the shuffled array
+        candidate = candidates.shift
+
+        # Check for blacklisted words given the candidate id
+        while crypt.blacklisted?(candidate) do
+          # If id chosen is a blacklisted word, insert it as a placeholder record and try again
+          Voltron::Id.create(id: candidate, resource_id: 0, resource_type: :blacklist)
+
+          # If no more candidates to choose from, re-run find_id, it will get a new set of candidates from the next segment
+          return find_id if candidates.empty?
+
+          # Pick the next candidate
+          candidate = candidates.shift
+        end
+
+        # The id chosen is good, not a blacklisted word. Use it
+        candidate
+      end
+
+      def reload(options = nil)
+        clear_aggregation_cache
+        clear_association_cache
+        self.class.connection.clear_query_cache
+
+        fresh_object =
+          if options && options[:lock]
+            self.class.unscoped { self.class.lock(options[:lock]).find_by(id: encryptable.resource_id) }
+          else
+            self.class.unscoped { self.class.find(encryptable.resource_id, bypass: true) }
+          end
+
+        @attributes = fresh_object.instance_variable_get("@attributes")
+        @new_record = false
+        self
+      end
+
+      private
+
+        def crypt
+          @crypt ||= Voltron::Encrypt.new
+        end
+    end
+  end
+end

data/voltron-encrypt.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'voltron/encrypt/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "voltron-encrypt"
+  spec.version       = Voltron::Encrypt::VERSION
+  spec.authors       = ["Eric Hainer"]
+  spec.email         = ["eric@commercekitchen.com"]
+
+  spec.summary       = %q{Enables base 64 encoded ids on rails models}
+  spec.homepage      = "https://github.com/ehainer/voltron-encrypt"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rails", ">= 4.2"
+  spec.add_dependency "voltron", ">= 0.1.0"
+
+  spec.add_development_dependency "bundler", ">= 1.12"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rspec", ">= 3.0"
+  spec.add_development_dependency "rspec-rails", ">= 3.4"
+  spec.add_development_dependency "sqlite3", ">= 1.2"
+  spec.add_development_dependency "simplecov", "0.11.0"
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: voltron-encrypt
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Eric Hainer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: voltron
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+description: 
+email:
+- eric@commercekitchen.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/models/voltron/id.rb
+- bin/console
+- bin/setup
+- lib/generators/templates/config/locales/blacklist.txt
+- lib/generators/templates/db/migrate/create_voltron_ids.rb
+- lib/generators/voltron/encrypt/install_generator.rb
+- lib/voltron/config/encrypt.rb
+- lib/voltron/encrypt.rb
+- lib/voltron/encrypt/engine.rb
+- lib/voltron/encrypt/version.rb
+- lib/voltron/encryptable.rb
+- voltron-encrypt.gemspec
+homepage: https://github.com/ehainer/voltron-encrypt
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Enables base 64 encoded ids on rails models
+test_files: []