salesforce_id 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 30c6400e6562285b005c9d9322e4e3784520e0b0
-  data.tar.gz: ec6108b0f8b16c825870497b17ec4d0271836e85
+  metadata.gz: 67c48be6bea0334c903a43a16d85a6a16864723a
+  data.tar.gz: d4c4bd69092a3d7de1b166f42d8b4a101fa001e1
 SHA512:
-  metadata.gz: a2ab32683c1bd72c0b65ec6346b17c5e884064e4966ff62aaaf1177f79811153966c6bc45f52c937d4cd012c15268a71e9fedf69bbba00bf5b7a07deb024c282
-  data.tar.gz: 01446cd19d32f632a1a8a99662cab6bee39280a5661f5bf87a427e95ef6f7cd50448d2c04799e9c4a14da130ffc78f7b05acd1b640362d9239752d842f3b1e6e
+  metadata.gz: 3008208bc7f80cc57e232be5756a46832240c8ebe91fd8e1a7e577cd5ae113971c3d65886455790b1b5e8a20109178506642b5e80c618f3e586815beeb6ac429
+  data.tar.gz: cb40b329f1cf4a559c24d292759deca85eab9cb54b6f1ae093fbe801bf87cee2705fa05d95e749b1746a6db858a189fbf42a20bcd21dc6810281c1c69f8cc3ed

data/.codeclimate.yml

@@ -0,0 +1,9 @@
+---
+engines:
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- spec/**/*

data/README.md

@@ -90,6 +90,71 @@ id.to_insensitive # => "003G000001SUbc4IAD"
 SalesforceId("003G000001SUbc4") == SalesforceId.id("003G000001SUbc4") # => true
 ```
 
+### Test utilities
+
+#### SalesforceId::Random
+
+A useful utility class to generate random salesforce IDs
+
+```ruby
+# Generate a valid case-sensitive salesforce id
+SalesforceId::Random.sensitive # => 003G000001SUbc4
+
+# Generate a valid case-insensitive salesforce id
+SalesforceId::Random.insensitive # => 003G000001SUbc4IAD
+
+# Generate an **invalid** case-sensitive salesforce id
+SalesforceId::Random.invalid_sensitive # => 003G0-0001SUbc4
+
+# Generate a **invalid** case-insensitive salesforce id where the first 15
+# characters are invalid, not the checksum part
+SalesforceId::Random.insensitive # => 003-000001SUbc4IAD
+
+# Generate a **invalid** case-insensitive salesforce id where only the checksum
+# part (last 3 characters) is invalid
+SalesforceId::Random.insensitive # => 003G000001SUbc4I9D
+
+# Generate a valid SalesforceId::Safe salesforce id
+SalesforceId::Random.safe # => #<SalesforceId::Safe:0x007f86f2294c50 @value="003G000001SUbc4IAD">
+
+# Shorter version to perform `SalesforceId::Random.safe`
+SalesforceId.random # => #<SalesforceId::Safe:0x007f86f2294c50 @value="003G000001SUbc4IAD">
+```
+
+#### RSpec matchers
+
+Include `SalesforceId::RSpec` in your tests to get a bunch of salesforce id
+matchers
+
+```ruby
+RSpec.describe SalesforceId("003G000001SUbc4") do
+  include ::SalesforceId::RSpec
+  
+  it "is a sensitive salesforce id" do
+    expect(subject.to_sensitive).to be_sensitive_salesforce_id # => true
+  end
+  
+  it "is an insensitive salesforce id" do
+    expect(subject.to_insensitive).to be_insensitive_salesforce_id # => true
+  end
+
+  it "is a salesforce id" do
+    is_expected.to be_salesforce_id # => true
+  end
+
+  it "is a salesforce id in safe format (case-sensitive + checksum)" do
+    is_expected.to be_safe_salesforce_id # => true
+  end
+
+end
+```
+
+These tests will pass. Matchers will work with any object that can be converted
+into a string with `to_s`, including `SalesforceId::Safe`.
+
+One note on `be_safe_salesforce_id` matcher, it will consider safe **even
+strings** if they are of the correct format (case sensitive + checksum)
+
 ## Documentation
 
 Methods are documented in [salesforce_id_ext.h](https://github.com/Fire-Dragon-DoL/salesforce_id/blob/master/ext/salesforce_id/salesforce_id_ext.h), this file is

data/ext/salesforce_id/salesforce_id_ext.c

@@ -9,6 +9,8 @@
 
 VALUE rb_mSalesforceId;
 
+static VALUE VALID_CHARACTERS_to_rb();
+
 void Init_salesforce_id()
 {
   // Module
@@ -25,6 +27,11 @@ void Init_salesforce_id()
     "INSENSITIVE_SIZE",
     INT2FIX(SALESFORCE_ID_INSENSITIVE_LENGTH)
   );
+  rb_define_const(
+    rb_mSalesforceId,
+    "VALID_CHARACTERS",
+    VALID_CHARACTERS_to_rb()
+  );
 
   // Methods
   rb_define_method(
@@ -149,3 +156,25 @@ VALUE salesforce_id_is_insensitive(VALUE self, VALUE rb_sId)
 
   return Qfalse;
 }
+
+VALUE VALID_CHARACTERS_to_rb()
+{
+  VALUE rb_Chars = Qnil;
+
+  rb_Chars = rb_ary_new2(VALID_CHARMAP_SIZE);
+
+  for (long index = 0; index < VALID_CHARMAP_SIZE; ++index)
+  {
+    char  str_Char[2];
+    VALUE rb_Char;
+
+    memset(&str_Char[1], 0, sizeof(str_Char[1]));
+    memset(str_Char, VALID_CHARMAP[index], sizeof(str_Char[0]));
+
+    rb_Char = rb_str_new2(str_Char);
+
+    rb_ary_store(rb_Chars, index, rb_obj_freeze(rb_Char));
+  }
+
+  return rb_ary_freeze(rb_Chars);
+}

data/ext/salesforce_id/salesforce_id_ext.h

@@ -16,18 +16,20 @@ extern VALUE rb_mSalesforceId;
 void Init_salesforce_id();
 
 /*
- * Converts any valid salesforce ID to case-sensitive version. Raises
- * ArgumentError if ID contains invalid characters or it's not correct length
+ * Converts any valid salesforce ID to case-sensitive version
  * @param rb_sId [String] valid salesforce id
  * @return [String] salesforce id in case-sensitive version
+ * @raise [ArgumentError] If ID contains invalid characters or it's not correct
+ *   length
  */
 VALUE salesforce_id_to_sensitive(VALUE self, VALUE rb_sId);
 
 /*
- * Converts any valid salesforce ID to case-insensitive version. Raises
- * ArgumentError if ID contains invalid characters or it's not correct length
+ * Converts any valid salesforce ID to case-insensitive version
  * @param rb_sId [String] valid salesforce id
  * @return [String] salesforce id in case-insensitive version
+ * @raise [ArgumentError] If ID contains invalid characters or it's not correct
+ *   length
  */
 VALUE salesforce_id_to_insensitive(VALUE self, VALUE rb_sId);
 
@@ -47,6 +49,8 @@ VALUE salesforce_id_is_valid(VALUE self, VALUE rb_sId);
  * @return [String] case-insensitive salesforce id with casing fixed, which
  *   means you can strip the last 3 characters to obtain the case-sensitive
  *   format
+ * @raise [ArgumentError] If ID contains invalid characters or it's not correct
+ *   length
  */
 VALUE salesforce_insensitive_repair_casing(VALUE self, VALUE rb_sId);
 

data/ext/salesforce_id/validate_id.c

@@ -6,13 +6,66 @@
 #include "salesforce_id_ext.h"
 #include "charmap.h"
 
+const char VALID_CHARMAP[VALID_CHARMAP_SIZE] = {
+  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p',
+  'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
+  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
+};
+
+static bool is_valid_insensitive_id(char* cId);
+static bool is_valid_sensitive_id(char* cId);
+static bool is_valid_char_for_id(char idChar);
+
 // rb_sId MUST be a string
 bool is_id_valid(VALUE rb_sId)
 {
-  VALUE id = rb_sId;
+  unsigned long  id_size = 0;
+           VALUE id      = rb_sId;
+           char* cId     = NULL;
+
+  id_size = RSTRING_LEN(id);
+
+  if (id_size != SALESFORCE_ID_SENSITIVE_LENGTH &&
+      id_size != SALESFORCE_ID_INSENSITIVE_LENGTH) return false;
+
+  // XXX: Careful, cId is NOT NULL TERMINATED!
+  //   Useful because it saves various allocations
+  cId = StringValuePtr(rb_sId);
+
+  if (!is_valid_sensitive_id(cId)) return false;
+  if (id_size == SALESFORCE_ID_INSENSITIVE_LENGTH &&
+      !is_valid_insensitive_id(cId)) return false;
+
+  return true;
+}
+
+bool is_valid_insensitive_id(char* cId)
+{
+  const unsigned long insensitive_size = SALESFORCE_ID_INSENSITIVE_LENGTH;
+        unsigned long index            = 0;
+
+  for (index = SALESFORCE_ID_SENSITIVE_LENGTH; index < insensitive_size; ++index)
+    if (charmap_index(cId[index]) < 0) return false;
+
+  return true;
+}
+
+bool is_valid_sensitive_id(char* cId)
+{
+  for (unsigned long index = 0; index < SALESFORCE_ID_SENSITIVE_LENGTH; ++index)
+    if (!is_valid_char_for_id(cId[index])) return false;
 
-  if (RSTRING_LEN(id) == SALESFORCE_ID_SENSITIVE_LENGTH)   return true;
-  if (RSTRING_LEN(id) == SALESFORCE_ID_INSENSITIVE_LENGTH) return true;
+  return true;
+}
+
+bool is_valid_char_for_id(char idChar)
+{
+  for (int index = 0; index < VALID_CHARMAP_SIZE; ++index)
+    if (VALID_CHARMAP[index] == idChar) return true;
 
   return false;
 }

data/ext/salesforce_id/validate_id.h

@@ -4,6 +4,10 @@
 #include "ruby.h"
 #include <stdbool.h>
 
+#define VALID_CHARMAP_SIZE 62
+
+extern const char VALID_CHARMAP[VALID_CHARMAP_SIZE];
+
 bool is_id_valid(VALUE rb_sId);
 
 #endif /* VALIDATE_SALESFORCE_ID_H */

data/lib/salesforce_id/random.rb

@@ -0,0 +1,75 @@
+require 'salesforce_id'
+
+module ::SalesforceId
+
+  # Factory for random generation of salesforce ids
+  module Random
+    extend self
+
+    # Creates a random salesforce id in case-sensitive format
+    # @return [String]
+    def sensitive
+      id = ""
+
+      # Fetch samples in this way to allow repetition of values
+      ::SalesforceId::SENSITIVE_SIZE.times do
+        id << ::SalesforceId::VALID_CHARACTERS.sample
+      end
+
+      id
+    end
+
+    # Creates a random salesforce id in case-insensitive format
+    # @return [String]
+    def insensitive
+      safe.to_insensitive
+    end
+
+    # Create a random salesforce id in case-sensitive format with
+    # one invalid character, making it invalid
+    # @return [String]
+    def invalid_sensitive
+      id = sensitive
+
+      id[rand(id.size)] = '-'
+
+      id
+    end
+
+    # Create a random salesforce id in case-insensitive format with
+    # one **invalid character in the case-sensitive part** (first 15
+    # characters), making it invalid
+    # @return [String]
+    def invalid_insensitive
+      id = insensitive
+
+      id[rand(::SalesforceId::SENSITIVE_SIZE)] = '-'
+
+      id
+    end
+
+    # Create a random salesforce id in case-insensitive format with
+    # one **invalid character in the case-insensitive part** (last 3 characters   # from 15 to 18), making it invalid
+    # @return [String]
+    def invalid_insensitive_checksum
+      id             = insensitive
+      checksum_size  = ::SalesforceId::INSENSITIVE_SIZE
+      checksum_size -= ::SalesforceId::SENSITIVE_SIZE
+
+      # Gets a random number between -1 and -3 and set that char to a valid
+      # case-sensitive character which is however invalid for case-insensitive
+      # id
+      id[(-checksum_size) + rand(checksum_size)] = '9'
+
+      id
+    end
+
+    # Creates a random salesforce id enclosed in {SalesforceId::Safe} object
+    # @return [SalesforceId::Safe]
+    def safe
+      SalesforceId(sensitive)
+    end
+
+  end
+
+end

data/lib/salesforce_id/rspec/be_insensitive_salesforce_id_matcher.rb

@@ -0,0 +1,16 @@
+require 'salesforce_id'
+require 'salesforce_id/rspec'
+require 'rspec/expectations'
+
+module ::SalesforceId::RSpec
+
+  module BeInsensitiveSalesforceIdMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :be_insensitive_salesforce_id do
+      match { |id| SalesforceId.insensitive?(id) }
+    end
+
+  end
+
+end

data/lib/salesforce_id/rspec/be_safe_salesforce_id_matcher.rb

@@ -0,0 +1,18 @@
+require 'salesforce_id'
+require 'salesforce_id/rspec'
+require 'rspec/expectations'
+
+module ::SalesforceId::RSpec
+
+  module BeSafeSalesforceIdMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :be_safe_salesforce_id do
+      match do |id|
+        SalesforceId.valid?(id) && SalesforceId(id).to_s == id.to_s
+      end
+    end
+
+  end
+
+end

data/lib/salesforce_id/rspec/be_salesforce_id_matcher.rb

@@ -0,0 +1,16 @@
+require 'salesforce_id'
+require 'salesforce_id/rspec'
+require 'rspec/expectations'
+
+module ::SalesforceId::RSpec
+
+  module BeSalesforceIdMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :be_salesforce_id do
+      match { |id| SalesforceId.valid?(id) }
+    end
+
+  end
+
+end

data/lib/salesforce_id/rspec/be_sensitive_salesforce_id_matcher.rb

@@ -0,0 +1,16 @@
+require 'salesforce_id'
+require 'salesforce_id/rspec'
+require 'rspec/expectations'
+
+module ::SalesforceId::RSpec
+
+  module BeSensitiveSalesforceIdMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :be_sensitive_salesforce_id do
+      match { |id| SalesforceId.sensitive?(id) }
+    end
+
+  end
+
+end

data/lib/salesforce_id/rspec.rb

@@ -0,0 +1,16 @@
+require 'salesforce_id'
+require 'salesforce_id/rspec/be_sensitive_salesforce_id_matcher'
+require 'salesforce_id/rspec/be_insensitive_salesforce_id_matcher'
+require 'salesforce_id/rspec/be_salesforce_id_matcher'
+require 'salesforce_id/rspec/be_safe_salesforce_id_matcher'
+
+module SalesforceId
+
+  module RSpec
+    include ::SalesforceId::RSpec::BeSensitiveSalesforceIdMatcher
+    include ::SalesforceId::RSpec::BeInsensitiveSalesforceIdMatcher
+    include ::SalesforceId::RSpec::BeSalesforceIdMatcher
+    include ::SalesforceId::RSpec::BeSafeSalesforceIdMatcher
+  end
+
+end

data/lib/salesforce_id/safe.rb

@@ -26,12 +26,12 @@ module SalesforceId
       value
     end
 
-    def as_json(*args)
+    def as_json(*)
       to_s
     end
 
     # In JSON format, it's a plain string
-    def to_json(*args)
+    def to_json(*)
       as_json
     end
 
@@ -40,7 +40,7 @@ module SalesforceId
     # format
     # @param other [SalesforceId::Safe]
     def <=>(other)
-      return nil unless other.kind_of?(self.class)
+      return nil unless other.is_a?(self.class)
 
       to_s <=> other.to_s
     end

data/lib/salesforce_id/version.rb

@@ -1,3 +1,3 @@
 module SalesforceId
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/salesforce_id.rb

@@ -1,18 +1,61 @@
 require 'salesforce_id/version'
 require 'salesforce_id/salesforce_id'
 require 'salesforce_id/safe'
+require 'salesforce_id/random'
 
 module SalesforceId
   extend self
 
+  # [FixNum] SENSITIVE_SIZE
+  # [FixNum] INSENSITIVE_SIZE
+  # [Array<String>] VALID_CHARACTERS array of valid characters
+  #   for salesforce id
+
+  # to_sensitive
+  # @param id [String]
+  # @return [String]
+
+  # to_insensitive
+  # @param id [String]
+  # @return [String]
+
+  # valid?
+  # @param id [String]
+  # @return [Boolean]
+
+  # repair_casing
+  # @param id [String]
+  # @return [String]
+
+  # sensitive?
+  # @param id [String]
+  # @return [Boolean]
+
+  # insensitive?
+  # @param id [String]
+  # @return [Boolean]
+
+  # Creates a salesforce id based on string
+  # @param salesforce_id [#to_s] An object that converts to a valid salesforce
+  #   id in string format
+  # @return [SalesforceId::Safe] the original object if it's already a
+  #   {SalesforceId::Safe}, otherwise a generated salesforce id
+  # @raise [ArgumentError] if passed id is not valid
   def id(salesforce_id)
     return salesforce_id if salesforce_id.kind_of?(::SalesforceId::Safe)
 
     ::SalesforceId::Safe.new(salesforce_id)
   end
 
+  # Provides a randomly generated salesforce id using {Salesforce::Random}
+  # @return [SalesforceId::Safe]
+  def random
+    ::SalesforceId::Random.safe
+  end
+
 end
 
+# Shortcut for {SalesforceId#id}
 def SalesforceId(salesforce_id)
   SalesforceId.id(salesforce_id)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: salesforce_id
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Fire-Dragon-DoL
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-26 00:00:00.000000000 Z
+date: 2015-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -117,6 +117,7 @@ extensions:
 - ext/salesforce_id/extconf.rb
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
@@ -150,6 +151,12 @@ files:
 - ext/salesforce_id/validate_id.c
 - ext/salesforce_id/validate_id.h
 - lib/salesforce_id.rb
+- lib/salesforce_id/random.rb
+- lib/salesforce_id/rspec.rb
+- lib/salesforce_id/rspec/be_insensitive_salesforce_id_matcher.rb
+- lib/salesforce_id/rspec/be_safe_salesforce_id_matcher.rb
+- lib/salesforce_id/rspec/be_salesforce_id_matcher.rb
+- lib/salesforce_id/rspec/be_sensitive_salesforce_id_matcher.rb
 - lib/salesforce_id/safe.rb
 - lib/salesforce_id/version.rb
 - salesforce_id.gemspec