iab_consent_string 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 603e1f8a6c7839dd0206dac21322c64bf3199f8b
+  data.tar.gz: 28349c00d6545617eadd88b4cab1b3f815649129
+SHA512:
+  metadata.gz: 60525c45d3349de4d745ff1f70427d6fc5e83fc641b0d752d08e8af43410126eba278446769dcc8178bdca906657f54ade477da19c0c42e4d591600ec7283b30
+  data.tar.gz: 1aa2736692465a5b053d876be1e7751713a3206111d3a3f96f7c1d49835b3bfefe83eb18d81950ae30354666521f7b25661833e528f0ac4cdfdeb27c3ca890b3

data/lib/iab_consent_string.rb

@@ -0,0 +1,14 @@
+require 'iab_consent_string/consent/vendor_consent'
+require 'iab_consent_string/consent/vendor_consent_encoder'
+require 'iab_consent_string/consent/vendor_consent_decoder'
+require 'iab_consent_string/consent/implementation/v1/byte_buffer_backed_vendor_consent'
+require 'iab_consent_string/consent/implementation/v1/vendor_consent_builder'
+require 'iab_consent_string/consent/range/range_entry.rb'
+require 'iab_consent_string/consent/range/start_end_range_entry.rb'
+require 'iab_consent_string/consent/range/single_range_entry.rb'
+require 'iab_consent_string/gdpr_constants'
+require 'iab_consent_string/purpose'
+require 'iab_consent_string/util/utils'
+
+module IABConsentString
+end

data/lib/iab_consent_string/bits.rb

@@ -0,0 +1,207 @@
+require 'iab_consent_string/error/vendor_consent_create_error'
+require 'iab_consent_string/error/vendor_consent_parse_error'
+
+# @author Fidzup Coding Stars Team
+module IABConsentString
+  class Bits
+    # big endian
+    BYTE_POWS = [ -128, 64, 32, 16, 8, 4, 2, 1 ]
+
+    def initialize(b)
+      @bytes = b
+    end
+
+    # Get the value of the specified index bit, under a boolean format (1 = true, 0 = false)
+    # @param index [Integer] the nth number bit to get from the bit string
+    # @return [Boolean], true if the bit is switched to 1, false otherwise
+    def getBit(index)
+      byteIndex = index / 8
+      bitExact = index % 8
+      b = @bytes[byteIndex]
+      return (b & BYTE_POWS[bitExact]) != 0
+    end
+
+    # Set the value of the specified index bit to 1
+    # @param index [Integer] set the nth number bit from the bit string
+    def setBit(index)
+      byteIndex = index / 8
+      shift = (byteIndex + 1) * 8 - index - 1
+      @bytes[byteIndex] |= 1 << shift
+    end
+
+    # Set the value of the specified index bit to 1
+    # @param index [Integer] set the nth number bit from the bit string
+    def unsetBit(index)
+      byteIndex = index / 8
+      shift = (byteIndex + 1) * 8 - index - 1
+      @bytes[byteIndex] &= ~(1 << shift)
+    end
+
+    # Interprets n number of bits as a big endiant int
+    # @param startInclusive [Integer] the nth to begin interpreting from
+    # @param size [Integer] the number of bits to interpret
+    # @return [void]
+    # @raise [VendorConsentParseError] when the bits cannot fit in an int sized field
+    def getInt(startInclusive, size)
+      # Integer Size limited to 32 bits
+      if (size > 32)
+        raise IABConsentString::Error::VendorConsentParseError, "can't fit bit range in int " + size, caller
+      end
+      val = 0
+      sigMask = 1
+      sigIndex = size - 1
+
+      for i in (0...size) do
+        if getBit(startInclusive + i)
+          val += (sigMask << sigIndex)
+        end 
+        sigIndex -= 1
+      end
+      val
+    end
+
+    # Writes an integer value into a bit array of given size
+    # @param startInclusive [Integer] the nth to begin writing to
+    # @param size [Integer] the number of bits available to write
+    # @param to [Integer] the integer to write out
+    # @return [void]
+    # @raise [VendorConsentCreateError] when the bits cannot fit into the provided size
+    def setInt(startInclusive, size, to)
+      # Integer Size limited to 32 bits
+      if (size > 32 || to > maxOfSize(size) || to < 0)
+        raise IABConsentString::Error::VendorConsentCreateError, "can't fit integer into bit range of size" + size , caller
+      end
+
+      setNumber(startInclusive, size, to);
+    end
+
+    # Interprets n bits as a big endian long
+    # @param startInclusive [Integer] the nth to begin interpreting from
+    # @param size [Integer] the number of bits to interpret
+    # @return [Long] the long value create by interpretation of provided bits
+    # @raise [VendorConsentParseError] when the bits cannot fit in a long sized field
+    def getLong(startInclusive, size)
+      # Long Size limited to 64 bits
+      if (size > 64)
+        raise IABConsentString::Error::VendorConsentParseError, "can't fit bit range in long: " + size , caller
+      end
+      val = 0
+      sigMask = 1
+      sigIndex = size - 1
+
+      for i in (0...size) do
+        if (getBit(startInclusive + i))
+          val += (sigMask << sigIndex)
+        end
+        sigIndex -= 1
+      end
+      val
+    end
+
+    # Writes a long value into a bit array of given size
+    # @param startInclusive [Integer] the nth to begin writing to
+    # @param size [Integer] the number of bits available to write
+    # @param to [Integer] the long number to write out
+    # @return [void]
+    # @raise [VendorConsentCreateError] when the bits cannot fit into the provided size
+    def setLong(startInclusive, size, to)
+      # Long Size limited to 64 bits
+      if (size > 64 || to > maxOfSize(size) || to < 0)
+        raise IABConsentString::Error::VendorConsentCreateError, "can't fit long into bit range of size " + size , caller
+      end
+
+      setNumber(startInclusive, size, to)
+    end
+
+    # returns a time derived from interpreting the given interval on the bit string as long representing
+    #   the number of demiseconds from the unix epoch
+    # @param startInclusive [Integer] the bit from which to begin interpreting
+    # @param size [Integer] the number of bits to interpret
+    # @return [void]
+    # @raise [VendorConsentParseError] when the number of bits requested cannot fit in a long
+    def getDateTimeFromEpochDeciseconds(startInclusive,size)
+      epochDemi = getLong(startInclusive, size)
+      epochDemi * 100
+    end
+
+    def setDateTimeToEpochDeciseconds(startInclusive, size, dateTime)
+      setLong(startInclusive, size, dateTime / 100)
+    end
+
+    # @return [Integer] the number of bits in the bit string
+    def length
+      @bytes.length * 8
+    end
+
+    # Interprets the given interval in the bit string as a series of six bit characters, where 0=A and 26=Z
+    # @param startInclusive [Integer]  the nth bit in the bitstring from which to start the interpretation
+    # @param size [Integer]  the number of bits to include in the string
+    # @return [String] the string given by the above interpretation
+    # @raise [VendorConsentParseError] when the requested interval is not a multiple of six
+    def getSixBitString(startInclusive, size)
+      if (size % 6 != 0)
+        raise IABConsentString::Error::VendorConsentParseError , "string bit length must be multiple of six: " + size, caller
+      end
+      charNum = size / 6
+      val = String.new()
+      for i in (0...charNum) do
+        charCode = getInt(startInclusive + (i * 6), 6) + 65
+        val << charCode.chr
+      end
+      val.upcase
+    end
+
+    # Interprets characters, as 0=A and 26=Z and writes to the given interval in the bit string as a series of six bits
+    # @param startInclusive [Integer] the nth bit in the bitstring from which to start writing
+    # @param size [Integer] the size of the bitstring
+    # @param to [Integer] the string given by the above interpretation
+    # @raise [VendorConsentCreateError] when the requested interval is not a multiple of six
+    def setSixBitString(startInclusive, size, to)
+      if (size % 6 != 0 || size / 6 != to.length())
+        raise IABConsentString::Error::VendorConsentCreateError , "bit array size must be multiple of six and equal to 6 times the size of string", caller
+      end
+      values = to.chars
+      for i in (0...values.length) do
+        charCode = values[i].ord - 65
+        setInt(startInclusive + (i * 6), 6, charCode)
+      end
+   end 
+
+    # @return [String] a string representation of the byte array passed in the constructor. for example, a bit array of [4]
+    #   yields a String of "0100"
+    def getBinaryString
+      s = String.new()
+      size = length()
+      for i in (0...size) do
+        if (getBit(i))
+          s << "1"
+        else
+          s << "0"
+        end
+      end
+      s
+    end
+
+    def toByteArray
+      @bytes
+    end
+
+    def setNumber(startInclusive,size,to)
+      (size - 1).downto(0) do |i|
+        index = startInclusive + i
+        byteIndex = index / 8
+        shift = (byteIndex + 1) * 8 - index - 1
+        @bytes[byteIndex] |= (to % 2) << shift
+        to /= 2
+      end
+    end
+
+    def maxOfSize(size)
+      max = 0
+      for i in (0...size) do
+        max += 2**i
+      end
+      max
+    end
+  end
+end

data/lib/iab_consent_string/consent/implementation/v1/byte_buffer_backed_vendor_consent.rb

@@ -0,0 +1,162 @@
+require 'set'
+require 'date'
+require 'iab_consent_string/bits'
+require 'iab_consent_string/gdpr_constants'
+require 'iab_consent_string/consent/vendor_consent'
+
+module IABConsentString
+  module Consent
+    module Implementation
+      module V1
+        class ByteBufferBackedVendorConsent < IABConsentString::Consent::VendorConsent
+          def initialize(bits)
+            @bits = bits
+          end
+
+          def getVersion
+            @bits.getInt(IABConsentString::GDPRConstants::VERSION_BIT_OFFSET,IABConsentString::GDPRConstants::VERSION_BIT_SIZE)
+          end
+
+          def getConsentRecordCreated
+            @bits.getDateTimeFromEpochDeciseconds(IABConsentString::GDPRConstants::CREATED_BIT_OFFSET, IABConsentString::GDPRConstants::CREATED_BIT_SIZE)
+          end
+
+          def getConsentRecordLastUpdated
+            @bits.getDateTimeFromEpochDeciseconds(IABConsentString::GDPRConstants::UPDATED_BIT_OFFSET,IABConsentString::GDPRConstants::UPDATED_BIT_SIZE)
+          end
+
+          def getCmpId
+            @bits.getInt(IABConsentString::GDPRConstants::CMP_ID_OFFSET,IABConsentString::GDPRConstants::CMP_ID_SIZE)
+          end
+
+          def getCmpVersion
+            @bits.getInt(IABConsentString::GDPRConstants::CMP_VERSION_OFFSET,IABConsentString::GDPRConstants::CMP_VERSION_SIZE)
+          end
+
+          def getConsentScreen
+            @bits.getInt(IABConsentString::GDPRConstants::CONSENT_SCREEN_SIZE_OFFSET,IABConsentString::GDPRConstants::CONSENT_SCREEN_SIZE)
+          end
+
+          def getConsentLanguage
+            @bits.getSixBitString(IABConsentString::GDPRConstants::CONSENT_LANGUAGE_OFFSET,IABConsentString::GDPRConstants::CONSENT_LANGUAGE_SIZE)
+          end
+
+          def getVendorListVersion
+            @bits.getInt(IABConsentString::GDPRConstants::VENDOR_LIST_VERSION_OFFSET,IABConsentString::GDPRConstants::VENDOR_LIST_VERSION_SIZE)
+          end
+
+          def getAllowedPurposeIds
+            allowedPurposes = Set[]
+            for i in (IABConsentString::GDPRConstants::PURPOSES_OFFSET...(IABConsentString::GDPRConstants::PURPOSES_OFFSET + IABConsentString::GDPRConstants::PURPOSES_SIZE)) do
+              if (@bits.getBit(i))
+                allowedPurposes.add(i - IABConsentString::GDPRConstants::PURPOSES_OFFSET + 1)
+              end
+            end
+            allowedPurposes
+          end
+
+          def getAllowedPurposes
+            allowedPurposes = getAllowedPurposeIds().map! {|id| IABConsentString::Purpose.new(id)}
+            allowedPurposes.to_a.uniq{|o| [o.getId]}.to_set
+          end
+
+          def getAllowedPurposesBits
+            @bits.getInt(IABConsentString::GDPRConstants::PURPOSES_OFFSET,IABConsentString::GDPRConstants::PURPOSES_SIZE)
+          end
+
+          def getMaxVendorId
+            @bits.getInt(IABConsentString::GDPRConstants::MAX_VENDOR_ID_OFFSET,IABConsentString::GDPRConstants::MAX_VENDOR_ID_SIZE)
+          end
+
+          def isPurposeIdAllowed(purposeId)
+            if ((purposeId < 1) || (purposeId > IABConsentString::GDPRConstants::PURPOSES_SIZE))
+              return false
+            end
+            @bits.getBit(IABConsentString::GDPRConstants::PURPOSES_OFFSET + purposeId - 1);
+          end
+
+          def isPurposeAllowed(purpose)
+            isPurposeIdAllowed(purpose.getId())
+          end
+
+          def isVendorAllowed(vendorId)
+            if ((vendorId < 1) || (vendorId > getMaxVendorId()))
+              return false
+            end
+            if (encodingType() == IABConsentString::GDPRConstants::VENDOR_ENCODING_RANGE)
+              defaultConsent = @bits.getBit(IABConsentString::GDPRConstants::DEFAULT_CONSENT_OFFSET)
+              present = isVendorPresentInRange(vendorId)
+              return (present != defaultConsent)
+            else
+              return @bits.getBit(IABConsentString::GDPRConstants::VENDOR_BITFIELD_OFFSET + vendorId - 1)
+            end
+          end
+
+          def toByteArray
+            @bits.toByteArray()
+          end
+
+          def hashCode
+            @bit.toByteArray().toString().hash
+          end
+
+          def toString
+            "ByteBufferVendorConsent{" +
+                "Version=" + getVersion().to_s +
+                ",Created=" + getConsentRecordCreated().to_s +
+                ",LastUpdated=" + getConsentRecordLastUpdated().to_s +
+                ",CmpId=" + getCmpId().to_s +
+                ",CmpVersion=" + getCmpVersion().to_s +
+                ",ConsentScreen=" + getConsentScreen().to_s +
+                ",ConsentLanguage=" + getConsentLanguage() +
+                ",VendorListVersion=" + getVendorListVersion().to_s +
+                ",PurposesAllowed=" + getAllowedPurposeIds().to_s +
+                ",MaxVendorId=" + getMaxVendorId().to_s +
+                ",EncodingType=" + encodingType().to_s +
+                "}"
+          end
+
+          private
+          def encodingType
+            @bits.getInt(IABConsentString::GDPRConstants::ENCODING_TYPE_OFFSET, IABConsentString::GDPRConstants::ENCODING_TYPE_SIZE)
+          end
+
+          def isVendorPresentInRange(vendorId)
+            numEntries = @bits.getInt(IABConsentString::GDPRConstants::NUM_ENTRIES_OFFSET, IABConsentString::GDPRConstants::NUM_ENTRIES_SIZE)
+            maxVendorId = getMaxVendorId()
+            currentOffset = IABConsentString::GDPRConstants::RANGE_ENTRY_OFFSET
+            for i in (0...numEntries) do
+              range = @bits.getBit(currentOffset)
+              currentOffset += 1
+              if range
+                startVendorId = @bits.getInt(currentOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE)
+                currentOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+                endVendorId = @bits.getInt(currentOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE)
+                currentOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+
+                if ((startVendorId > endVendorId) || (endVendorId > maxVendorId))
+                  raise IABConsentString::Error::VendorConsentParseError.new("Start VendorId must not be greater than End VendorId and End VendorId must not be greater than Max Vendor Id")
+                end
+                if ((vendorId >= startVendorId) && (vendorId <= endVendorId))
+                  return true
+                end
+              else
+                singleVendorId = @bits.getInt(currentOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE)
+                currentOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+
+                if (singleVendorId > maxVendorId)
+                  raise IABConsentString::Error::VendorConsentParseError.new("VendorId in the range entries must not be greater than Max VendorId")
+                end
+                if (singleVendorId == vendorId)
+                  return true
+                end
+              end
+            end
+
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/implementation/v1/vendor_consent_builder.rb

@@ -0,0 +1,246 @@
+require 'iab_consent_string/gdpr_constants'
+require 'iab_consent_string/error/vendor_consent_create_error'
+require 'iab_consent_string/consent/implementation/v1/byte_buffer_backed_vendor_consent'
+
+module IABConsentString
+  module Consent
+    module Implementation
+      module V1
+        #  Builder for version 1 of vendor consent
+        class VendorConsentBuilder
+          VERSION = 1
+
+          # With creation date
+          # @param consentRecordCreated [DateTime] Epoch deciseconds when record was created
+          # @return [VendorConsentBuilder] self
+          def withConsentRecordCreatedOn(consentRecordCreated)
+            @consentRecordCreated = consentRecordCreated
+            self
+          end
+
+          # With update date
+          # @param consentRecordLastUpdated [DateTime] Epoch deciseconds when consent string was last updated
+          # @return [VendorConsentBuilder] self
+          def withConsentRecordLastUpdatedOn(consentRecordLastUpdated)
+            @consentRecordLastUpdated = consentRecordLastUpdated;
+            self
+          end
+
+          # With CMP version
+          # @param cmpVersion [Integer] Consent Manager Provider version
+          # @return [VendorConsentBuilder] self
+          def withCmpVersion(cmpVersion)
+            @cmpVersion = cmpVersion
+            self
+          end
+
+          # With CMP Id
+          # @param cmpId [Integer] Consent Manager Provider Id
+          # @return [VendorConsentBuilder] self
+          def withCmpId(cmpId)
+            @cmpId = cmpId
+            self
+          end
+
+          # With Consent Screen Id
+          # @param consentScreenId [Integer] Consent Screen Id
+          # @return [VendorConsentBuilder] self
+          def withConsentScreenId(consentScreenId)
+            @consentScreenId = consentScreenId
+            self
+          end
+
+          # With consent language
+          # @param consentLanguage [Char(2)] Two-letter ISO639-1 language code that CMP asked for consent in
+          # @return [VendorConsentBuilder] self
+          def withConsentLanguage(consentLanguage)
+            @consentLanguage = consentLanguage
+            self
+          end
+
+          # With vendor list version
+          # @param vendorListVersion [Integer] Version of vendor list used in most recent consent string update
+          # @return [VendorConsentBuilder] self
+          def withVendorListVersion(vendorListVersion)
+            @vendorListVersion = vendorListVersion
+            self
+          end
+
+          # With allowed purpose IDs
+          # @param allowedPurposeIds [Set<Integer>] set of allowed purposes
+          # @return [VendorConsentBuilder] self
+          def withAllowedPurposeIds(allowedPurposeIds)
+            if allowedPurposeIds.nil?
+              raise "Argument allowedPurposeIds is null"
+            end
+            allowedPurposeIds.each do |purposeId|
+              if purposeId < 0 || purposeId > IABConsentString::GDPRConstants::PURPOSES_SIZE
+                raise "Invalid purpose ID found"
+              end
+            end
+            @allowedPurposes = allowedPurposeIds;
+            self
+          end
+
+          # With allowed purposes
+          # @param allowedPurposes [Set<Purpose>] set of allowed purposes
+          # @return [VendorConsentBuilder] self
+          def withAllowedPurposes(allowedPurposes)
+            if allowedPurposes.nil?
+              raise "Argument allowedPurposes is null"
+            end
+            @allowedPurposes = allowedPurposes.map! {|purpose| purpose.getId }
+            self
+          end
+
+          # With max vendor ID
+          # @param maxVendorId [Integer] The maximum VendorId for which consent values are given.
+          # @return [VendorConsentBuilder] self
+          def withMaxVendorId(maxVendorId)
+            @maxVendorId = maxVendorId
+            self
+          end
+
+          # With vendor encoding type
+          # @param vendorEncodingType [Integer] 0=BitField 1=Range
+          # @return [VendorConsentBuilder] self
+          def withVendorEncodingType(vendorEncodingType)
+            if (vendorEncodingType < 0 || vendorEncodingType > 1)
+              raise "Illegal value for argument vendorEncodingType:" + vendorEncodingType.to_s
+            end
+            @vendorEncodingType = vendorEncodingType
+            self
+          end
+
+          # With bit field entries
+          # @param bitFieldEntries [Set<Integer>] set of VendorIds for which the vendors have consent
+          # @return [VendorConsentBuilder] self
+          def withBitField(bitFieldEntries)
+            @vendorsBitField = bitFieldEntries
+            self
+          end
+
+          # With range entries
+          # @param rangeEntries [Set<RangeEntry>] List of VendorIds or a range of VendorIds for which the vendors have consent
+          # @return [VendorConsentBuilder] self
+          def withRangeEntries(rangeEntries)
+            @rangeEntries = rangeEntries
+            self
+          end
+
+          # With default consent
+          # @param defaultConsent [Boolean] Default consent for VendorIds not covered by a RangeEntry. 0=No Consent 1=Consent
+          # @return [VendorConsentBuilder] self
+          def withDefaultConsent(defaultConsent)
+            @defaultConsent = defaultConsent
+            self
+          end
+
+          # Validate supplied values and build VendorConsent object
+          # @return [IABConsentString::Consent::VendorConsent] vendor consent object
+          def build
+            if @consentRecordCreated.nil?
+              raise IABConsentString::Error::VendorConsentCreateError, "consentRecordCreated must be set", caller
+            end
+            if @consentRecordLastUpdated.nil?
+              raise IABConsentString::Error::VendorConsentCreateError, "consentRecordLastUpdated must be set", caller
+            end
+            if @consentLanguage.nil?
+              raise IABConsentString::Error::VendorConsentCreateError, "consentLanguage must be set", caller
+            end
+
+            if @vendorListVersion.nil? || @vendorListVersion <=0
+              raise IABConsentString::Error::VendorConsentCreateError, "Invalid value for vendorListVersion:" + @vendorListVersion.to_s, caller
+            end
+
+            if @maxVendorId.nil? || @maxVendorId<=0
+              raise IABConsentString::Error::VendorConsentCreateError, "Invalid value for maxVendorId:" + @maxVendorId.to_s, caller
+            end
+
+            # For range encoding, check if each range entry is valid
+            if @vendorEncodingType == IABConsentString::GDPRConstants::VENDOR_ENCODING_RANGE
+              if @rangeEntries.nil?
+                raise IABConsentString::Error::VendorConsentCreateError, "Range entries  must be set", caller
+              end
+              @rangeEntries.each do |rangeEntry|
+                if !rangeEntry.valid(@maxVendorId)
+                  raise IABConsentString::Error::VendorConsentCreateError, "Invalid range entries found", caller
+                end
+              end
+            end
+
+            # Calculate size of bit buffer in bits
+            bitBufferSizeInBits = 0
+            if (@vendorEncodingType == IABConsentString::GDPRConstants::VENDOR_ENCODING_RANGE)
+              rangeEntrySectionSize = 0
+              @rangeEntries.each do |rangeEntry|
+                rangeEntrySectionSize += rangeEntry.size
+              end
+              bitBufferSizeInBits = IABConsentString::GDPRConstants::RANGE_ENTRY_OFFSET + rangeEntrySectionSize
+            else
+              bitBufferSizeInBits = IABConsentString::GDPRConstants::VENDOR_BITFIELD_OFFSET + @maxVendorId
+            end
+
+            # Create new bit buffer
+            bitsFit = (bitBufferSizeInBits % 8) == 0
+            str = ""
+            for i in (0...(bitBufferSizeInBits / 8 + (bitsFit ? 0 : 1))) do
+              str << 0b00000000
+            end
+            bits = IABConsentString::Bits.new(str.bytes.to_a)
+
+            # Set fields in bit buffer
+            bits.setInt(IABConsentString::GDPRConstants::VERSION_BIT_OFFSET, IABConsentString::GDPRConstants::VERSION_BIT_SIZE, VERSION)
+            bits.setDateTimeToEpochDeciseconds(IABConsentString::GDPRConstants::CREATED_BIT_OFFSET, IABConsentString::GDPRConstants::CREATED_BIT_SIZE, @consentRecordCreated)
+            bits.setDateTimeToEpochDeciseconds(IABConsentString::GDPRConstants::UPDATED_BIT_OFFSET, IABConsentString::GDPRConstants::UPDATED_BIT_SIZE, @consentRecordLastUpdated)
+            bits.setInt(IABConsentString::GDPRConstants::CMP_ID_OFFSET, IABConsentString::GDPRConstants::CMP_ID_SIZE, @cmpId)
+            bits.setInt(IABConsentString::GDPRConstants::CMP_VERSION_OFFSET, IABConsentString::GDPRConstants::CMP_VERSION_SIZE, @cmpVersion)
+            bits.setInt(IABConsentString::GDPRConstants::CONSENT_SCREEN_SIZE_OFFSET, IABConsentString::GDPRConstants::CONSENT_SCREEN_SIZE, @consentScreenId)
+            bits.setSixBitString(IABConsentString::GDPRConstants::CONSENT_LANGUAGE_OFFSET, IABConsentString::GDPRConstants::CONSENT_LANGUAGE_SIZE, @consentLanguage)
+            bits.setInt(IABConsentString::GDPRConstants::VENDOR_LIST_VERSION_OFFSET, IABConsentString::GDPRConstants::VENDOR_LIST_VERSION_SIZE, @vendorListVersion)
+
+            # Set purposes bits
+            for i in (0...IABConsentString::GDPRConstants::PURPOSES_SIZE) do
+              if (@allowedPurposes.include?(i+1))
+                bits.setBit(IABConsentString::GDPRConstants::PURPOSES_OFFSET + i)
+              else
+                bits.unsetBit(IABConsentString::GDPRConstants::PURPOSES_OFFSET + i)
+              end
+            end
+
+            bits.setInt(IABConsentString::GDPRConstants::MAX_VENDOR_ID_OFFSET, IABConsentString::GDPRConstants::MAX_VENDOR_ID_SIZE, @maxVendorId)
+            bits.setInt(IABConsentString::GDPRConstants::ENCODING_TYPE_OFFSET, IABConsentString::GDPRConstants::ENCODING_TYPE_SIZE, @vendorEncodingType)
+
+            # Set the bit field or range sections
+            if (@vendorEncodingType == IABConsentString::GDPRConstants::VENDOR_ENCODING_RANGE)
+              # Range encoding
+              if (@defaultConsent)
+                bits.setBit(IABConsentString::GDPRConstants::DEFAULT_CONSENT_OFFSET)
+              else
+                bits.unsetBit(IABConsentString::GDPRConstants::DEFAULT_CONSENT_OFFSET)
+              end
+              bits.setInt(IABConsentString::GDPRConstants::NUM_ENTRIES_OFFSET, IABConsentString::GDPRConstants::NUM_ENTRIES_SIZE, @rangeEntries.size)
+
+              currentOffset = IABConsentString::GDPRConstants::RANGE_ENTRY_OFFSET
+
+              @rangeEntries.each do |rangeEntry|
+                currentOffset = rangeEntry.appendTo(bits, currentOffset)
+              end
+            else
+              # Bit field encoding
+              for i in (0...@maxVendorId) do
+                if @vendorsBitField.include?(i+1)
+                  bits.setBit(IABConsentString::GDPRConstants::VENDOR_BITFIELD_OFFSET+i)
+                else
+                  bits.unsetBit(IABConsentString::GDPRConstants::VENDOR_BITFIELD_OFFSET+i)
+                end
+              end
+            end
+
+            IABConsentString::Consent::Implementation::V1::ByteBufferBackedVendorConsent.new(bits)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/range/range_entry.rb

@@ -0,0 +1,22 @@
+module IABConsentString
+  module Consent
+    module Range
+      class RangeEntry
+        # Append this range entry to the bit buffer
+        # @param buffer [Bits] bit buffer
+        # @param currentOffset [Integer] current offset in the buffer
+        # @return [Integer] new offset
+        def appendTo(buffer, currentOffset)
+          raise NotImplementedError
+        end
+
+        # Check if range entry is valid for the specified max vendor id
+        # @param maxVendorId [Integer] max vendor id
+        # @return [Boolean] true if range entry is valid, false otherwise
+        def valid(maxVendorId)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/range/single_range_entry.rb

@@ -0,0 +1,33 @@
+require 'iab_consent_string/consent/range/range_entry'
+require 'iab_consent_string/gdpr_constants'
+
+module IABConsentString
+  module Consent
+    module Range
+      class SingleRangeEntry < RangeEntry
+
+        def initialize(singleVendorId)
+          @singleVendorId = singleVendorId
+        end
+
+        def size()
+          #  One bit for SingleOrRange flag, VENDOR_ID_SIZE for single vendor ID
+          1 + IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+        end
+
+        def appendTo(buffer, currentOffset)
+          newOffset = currentOffset
+          buffer.unsetBit(newOffset)
+          newOffset += 1
+          buffer.setInt(newOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE, @singleVendorId)
+          newOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+          newOffset
+        end
+
+        def valid(maxVendorId)
+          (@singleVendorId > 0) && (@singleVendorId <= maxVendorId)
+        end
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/range/start_end_range_entry.rb

@@ -0,0 +1,36 @@
+require 'iab_consent_string/consent/range/range_entry'
+require 'iab_consent_string/gdpr_constants'
+
+module IABConsentString
+  module Consent
+    module Range
+      class StartEndRangeEntry < RangeEntry
+
+        def initialize(startVendorId,endVendorId)
+          @startVendorId = startVendorId
+          @endVendorId = endVendorId
+        end
+
+        def size()
+          #  One bit for SingleOrRange flag, 2 * VENDOR_ID_SIZE for 2 vendor IDs
+          1 + ( IABConsentString::GDPRConstants::VENDOR_ID_SIZE * 2 )
+        end
+
+        def appendTo(buffer, currentOffset)
+          newOffset = currentOffset
+          buffer.setBit(newOffset)
+          newOffset += 1
+          buffer.setInt(newOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE, @startVendorId)
+          newOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+          buffer.setInt(newOffset, IABConsentString::GDPRConstants::VENDOR_ID_SIZE, @endVendorId)
+          newOffset += IABConsentString::GDPRConstants::VENDOR_ID_SIZE
+          newOffset
+        end
+
+        def valid(maxVendorId)
+          (@startVendorId > 0) && (@endVendorId > 0) && (@startVendorId < @endVendorId) && (@endVendorId <= maxVendorId)
+        end
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/vendor_consent.rb

@@ -0,0 +1,91 @@
+module IABConsentString
+  module Consent
+    class VendorConsent
+      # @return [Integer] the version of consent string format
+      def getVersion
+        raise NotImplementedError
+      end
+
+      # @return [Timestamp] the time (milli since epoch) at which the consent string was created
+      def getConsentRecordCreated
+        raise NotImplementedError
+      end
+
+      # @return [Timestamp] the time (milli since epoch) at which the consent string was last updated
+      def getConsentRecordLastUpdated
+        raise NotImplementedError
+      end
+
+      # @return [Integer] the Consent Manager Provider ID that last updated the consent string
+      def getCmpId
+        raise NotImplementedError
+      end
+
+      # @return [Integer] the Consent Manager Provider version
+      def getCmpVersion
+        raise NotImplementedError
+      end
+
+      # @return [Integer] the screen number in the CMP where consent was given
+      def getConsentScreen
+        raise NotImplementedError
+      end
+
+      # @return [Char(2)] the two-letter ISO639-1 language code that CMP asked for consent in
+      def getConsentLanguage
+        raise NotImplementedError
+      end
+
+      # @return [Integer] version of vendor list used in most recent consent string update.
+      def getVendorListVersion
+        raise NotImplementedError
+      end
+
+      # @return [Set<Integer>] the set of purpose id's which are permitted according to this consent string
+      def getAllowedPurposesIds
+        raise NotImplementedError
+      end
+
+      # @return [Set<Purpose>] the set of allowed purposes which are permitted according to this consent string
+      def getAllowedPurposes
+        raise NotImplementedError
+      end
+
+      # @return [Integer] an integer equivalent of allowed purpose id bits according to this consent string
+      def getAllowedPurposesBits
+        raise NotImplementedError
+      end
+
+      # @return [Integer] the maximum VendorId for which consent values are given.
+      def getMaxVendorId
+        raise NotImplementedError
+      end
+
+      # Check wether purpose with specified ID is allowed
+      # @param purposeId [Integer] purpose ID
+      # @return [Boolean] true if purpose is allowed in this consent, false otherwise
+      def isPurposeIdAllowed(purposeId)
+        raise NotImplementedError
+      end
+
+      # Check wether specified purpose is allowed
+      # @param purpose [Purpose] purpose to check
+      # @return [Boolean] true if purpose is allowed in this consent, false otherwise
+      def isPurposeAllowed(purpose)
+        raise NotImplementedError
+      end
+
+      # Check wether vendor with specified ID is allowed
+      # @param vendorId [Integer] vendor ID
+      # @return [Boolean] true if vendor is allowed in this consent, false otherwise
+      def isVendorAllowed(vendorId)
+        raise NotImplementedError
+      end
+
+      # @return [Array<Byte>] the value of this consent as byte array
+      def toByteArray
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/vendor_consent_decoder.rb

@@ -0,0 +1,41 @@
+require 'base64'
+require 'iab_consent_string/bits'
+require 'iab_consent_string/gdpr_constants'
+require 'iab_consent_string/consent/implementation/v1/byte_buffer_backed_vendor_consent'
+
+module IABConsentString
+  module Consent
+    # IABConsentString::Consent::VendorConsent decoder from Base64 string. Right now only version 1 is know, but eventually
+    # this can be extended to support new versions
+    class VendorConsentDecoder
+      # Build a IABConsentString::Consent::VendorConsent object from a base64 string
+      # @params consentString [String] a url safe base64 encoded consent string
+      # @return [IABConsentString::Consent::VendorConsent] a VendorConsent object
+      # @raise an error when there's a problem with the consentString passed
+      def self.fromBase64String(consentString)
+        if consentString.nil?
+          raise "Null or empty consent string passed as an argument"
+        end
+        fromByteArray(Base64.urlsafe_decode64(consentString).bytes.to_a)
+      end
+
+      def self.fromByteArray(bytes)
+        if ( bytes.nil?  || bytes.length == 0)
+          raise "Null or empty consent string passed as an argument"
+        end
+        bits = Bits.new(bytes)
+        version = getVersion(bits)
+        case version
+        when 1
+          IABConsentString::Consent::Implementation::V1::ByteBufferBackedVendorConsent.new(bits)
+        else
+          raise "Unsupported version: " + version.to_s
+        end
+      end
+
+      def self.getVersion(bits)
+        bits.getInt(IABConsentString::GDPRConstants::VERSION_BIT_OFFSET, IABConsentString::GDPRConstants::VERSION_BIT_SIZE)
+      end
+    end
+  end
+end

data/lib/iab_consent_string/consent/vendor_consent_encoder.rb

@@ -0,0 +1,15 @@
+require 'base64'
+
+module IABConsentString
+  module Consent
+    class VendorConsentEncoder
+      # Encode vendor consent to Base64 string
+      # @param vendorConsent [VendorConsent] vendor consent
+      # @return [String] Base64 encoded string
+      def self.toBase64String(vendorConsent)
+        # Encode Without Padding to respect IAB Consent String Spec
+        Base64.urlsafe_encode64(vendorConsent.toByteArray().pack("C*") , padding: false)
+      end
+    end
+  end
+end

data/lib/iab_consent_string/error/vendor_consent_create_error.rb

@@ -0,0 +1,8 @@
+require 'iab_consent_string/error/vendor_consent_error'
+
+module IABConsentString
+  module Error
+    class VendorConsentCreateError < IABConsentString::Error::VendorConsentError
+    end
+  end
+end

data/lib/iab_consent_string/error/vendor_consent_error.rb

@@ -0,0 +1,6 @@
+module IABConsentString
+  module Error
+    class VendorConsentError < StandardError
+    end
+  end
+end

data/lib/iab_consent_string/error/vendor_consent_parse_error.rb

@@ -0,0 +1,8 @@
+require 'iab_consent_string/error/vendor_consent_error'
+
+module IABConsentString
+  module Error
+    class VendorConsentParseError < IABConsentString::Error::VendorConsentError
+    end
+  end
+end

data/lib/iab_consent_string/gdpr_constants.rb

@@ -0,0 +1,33 @@
+module IABConsentString
+  class GDPRConstants
+    VENDOR_ENCODING_RANGE = 1
+    VERSION_BIT_OFFSET = 0
+    VERSION_BIT_SIZE = 6
+    CREATED_BIT_OFFSET = 6
+    CREATED_BIT_SIZE = 36
+    UPDATED_BIT_OFFSET = 42
+    UPDATED_BIT_SIZE = 36
+    CMP_ID_OFFSET = 78
+    CMP_ID_SIZE = 12
+    CMP_VERSION_OFFSET = 90
+    CMP_VERSION_SIZE = 12
+    CONSENT_SCREEN_SIZE_OFFSET = 102
+    CONSENT_SCREEN_SIZE = 6
+    CONSENT_LANGUAGE_OFFSET = 108
+    CONSENT_LANGUAGE_SIZE = 12
+    VENDOR_LIST_VERSION_OFFSET = 120
+    VENDOR_LIST_VERSION_SIZE = 12
+    PURPOSES_OFFSET = 132
+    PURPOSES_SIZE = 24
+    MAX_VENDOR_ID_OFFSET = 156
+    MAX_VENDOR_ID_SIZE = 16
+    ENCODING_TYPE_OFFSET = 172
+    ENCODING_TYPE_SIZE = 1
+    VENDOR_BITFIELD_OFFSET = 173
+    DEFAULT_CONSENT_OFFSET = 173
+    NUM_ENTRIES_OFFSET = 174
+    NUM_ENTRIES_SIZE = 12
+    RANGE_ENTRY_OFFSET = 186
+    VENDOR_ID_SIZE = 16
+  end
+end

data/lib/iab_consent_string/purpose.rb

@@ -0,0 +1,69 @@
+# Enumeration of currently defined purposes by IAB
+# @see <a href="https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework">https://github.com/InteractiveAdvertisingBureau/GDPR-Transparency-and-Consent-Framework</a>
+module IABConsentString
+  class Purpose
+    # The storage of information, or access to information that is already stored, on user device such as accessing advertising identifiers
+    # and/or other device identifiers, and/or using cookies or similar technologies.
+    STORAGE_AND_ACCESS = 1
+    # The collection and processing of information about user of a site to subsequently personalize advertising for them in other contexts,
+    #  i.e. on other sites or apps, over time. Typically, the content of the site or app is used to make inferences about user interests, which inform future selections.
+    PERSONALIZATION = 2 
+    # The collection of information and combination with previously collected information, to select and deliver advertisements and to measure the delivery
+    # and effectiveness of such advertisements. This includes using previously collected information about user interests to select ads, processing data about
+    # what advertisements were shown, how often they were shown, when and where they were shown, and whether they took any action related to the advertisement,
+    # including for example clicking an ad or making a purchase.
+    AD_SELECTION = 3
+    # The collection of information, and combination with previously collected information, to select and deliver content and to measure the delivery and
+    # effectiveness of such content. This includes using previously collected information about user interests to select content, processing data about
+    # what content was shown, how often or how long it was shown, when and where it was shown, and whether they took any action related to the content,
+    # including for example clicking on content.
+    CONTENT_DELIVERY = 4
+    # The collection of information about user use of content, and combination with previously collected information, used to measure, understand,
+    # and report on user usage of content.
+    MEASUREMENT = 5
+    # Ads targeted on geolocalization
+    GEOLOCALIZED_ADS = 6
+    # Purpose ID that is currently not defined
+    UNDEFINED = -1
+
+    def initialize(id)
+      case id
+      when STORAGE_AND_ACCESS, PERSONALIZATION, AD_SELECTION, CONTENT_DELIVERY, MEASUREMENT, GEOLOCALIZED_ADS
+        @id = id
+      else
+        @id = -1
+      end
+    end
+
+    def getId
+      @id
+    end
+
+    def eql?(other)
+      @id == other.getId
+    end
+
+    def ==(other)
+      @id == other.getId
+    end
+
+    def valueOf()
+      case @id
+      when STORAGE_AND_ACCESS
+        return "STORAGE_AND_ACCESS"
+      when PERSONALIZATION
+        return "PERSONALIZATION"
+      when AD_SELECTION
+        return "AD_SELECTION"
+      when CONTENT_DELIVERY
+        return "CONTENT_DELIVERY"
+      when MEASUREMENT
+        return "MEASUREMENT"
+      when GEOLOCALIZED_ADS
+        return "GEOLOCALIZED_ADS"
+      else
+        return "UNDEFINED"
+      end
+    end
+  end
+end

data/lib/iab_consent_string/util/utils.rb

@@ -0,0 +1,28 @@
+require 'iab_consent_string/bits'
+
+module IABConsentString
+  module Util
+    class Utils
+      # Create bit buffer from string representation
+      # @param binaryString [String] binary string
+      # @return [Bits] bit buffer
+      def self.fromBinaryString(binaryString)
+        length = binaryString.length
+        bitsFit = (length % 8) == 0
+        str = ""
+        for i in (0...length / 8 + (bitsFit ? 0 : 1)) do
+          str << 0b00000000
+        end
+        bits = IABConsentString::Bits.new(str.bytes.to_a)
+        for i in (0...length) do
+          if binaryString[i] == '1'
+            bits.setBit(i)
+          else
+            bits.unsetBit(i)
+          end
+        end
+        bits
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: iab_consent_string
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Fidzup Coding Star Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-10-23 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  This library is a Ruby reference implementation for dealing with consent strings in the IAB EU's GDPR Transparency and Consent Framework.
+  It should be used by anyone who receives or sends consent information like vendors that receive consent data from a partner, or consent management platforms that need to encode/decode the global cookie.
+
+  The IAB specification for the consent string format is available on the IAB Github (section 'Vendor Consent Cookie Format').
+
+  This library supports the version v1.1 of the specification. It can encode and decode consent strings with version bit 1.
+email: coding.stars@fidzup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/iab_consent_string.rb
+- lib/iab_consent_string/bits.rb
+- lib/iab_consent_string/consent/implementation/v1/byte_buffer_backed_vendor_consent.rb
+- lib/iab_consent_string/consent/implementation/v1/vendor_consent_builder.rb
+- lib/iab_consent_string/consent/range/range_entry.rb
+- lib/iab_consent_string/consent/range/single_range_entry.rb
+- lib/iab_consent_string/consent/range/start_end_range_entry.rb
+- lib/iab_consent_string/consent/vendor_consent.rb
+- lib/iab_consent_string/consent/vendor_consent_decoder.rb
+- lib/iab_consent_string/consent/vendor_consent_encoder.rb
+- lib/iab_consent_string/error/vendor_consent_create_error.rb
+- lib/iab_consent_string/error/vendor_consent_error.rb
+- lib/iab_consent_string/error/vendor_consent_parse_error.rb
+- lib/iab_consent_string/gdpr_constants.rb
+- lib/iab_consent_string/purpose.rb
+- lib/iab_consent_string/util/utils.rb
+homepage: https://rubygems.org/gems/iab_consent_string
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Fidzup/Consent-String-SDK-Ruby
+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.5.2.3
+signing_key: 
+specification_version: 4
+summary: Encode and decode web-safe base64 consent information with the IAB EU's GDPR
+  Transparency and Consent Framework.
+test_files: []