sms_validation 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d771ba3b06bfaf38dd03b4422c54ca14904d0d0f
+  data.tar.gz: f81fa7011d95d86d6b2ea2a60d91a871b4461cea
+SHA512:
+  metadata.gz: 55ef04ab2258fe6af54ace53155e4fc207617e4092a14995152cc72b8303beae6d6c920443917a7c383dd87991e743b8100ed948362060b2c5c273ae548a342b
+  data.tar.gz: 8fcd241178d77fbcc4af945307ff897a11f33313e4100e3f81137d71c9bc1a9ba59695d472965618edf91a546d0c2b1e6e3aa26e28e8ac0fa8391394560c3786

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sms_validation.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Isaac Betesh
+
+MIT License
+
+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,87 @@
+# SmsValidation
+
+This gem does not send SMS messages.  It just makes sure the arguments are valid.
+
+## What are valid arguments for an SMS message?
+
+- Phone number: 10 digits, does not begin with 0 or 1
+- Message: Not longer than 160 characters.
+
+## What if my message is longer than 160 characters?
+
+You have 3 choices:
+- Truncate the message to the first 160 characters
+- Split it into multiple messages
+- Raise a SmsValidation::Sms::MessageTooLongError error
+
+You can configure at any time using:
+
+    SmsValidation.configuration.on_message_too_long = :truncate # or :split or :raise_error
+
+It defaults to :raise_error
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sms_validation'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sms_validation
+
+## Usage
+
+### Configuration
+
+    SmsValidation.configure do |config|
+      config.on_message_too_long = :truncate # or :split or :raise_error
+      config.logger = ::Logger.new(STDOUT) # Defaults to ::Rails.logger if ::Rails.logger is defined
+
+      # This DOES NOT change the log_level of the logger--use `config.logger.level = :debug` for that
+      # This DOES determine the log level at which messages should be logged.
+      # This provides a convenient way to toggle whether this gem should log without interfering with the log level of others processes sharing the logger.
+      # For instance, if you're using Rails, you probably don't want to set the log_level to DEBUG, because then ActiveRecord will log every query.
+      # But you may still want SmsValidation to log everything it does.
+      config.log_at :info
+
+      # OR you may want SmsValidation to log only when you're logging all other DEBUG messages.
+      config.log_at :debug
+    end
+
+### Validation
+
+    sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps over the lazy dog")
+    puts sms.phone # => 8889999999
+    puts sms.message # => "The quick brown fox jumps over the lazy dog"
+
+    sms = SmsValidation::Sms.new(889999999, "The quick brown fox jumps over the lazy dog")
+    # => SmsValidation::Sms::InvalidPhoneNumberError: "Phone number must be ten digits"
+
+    SmsValidation.configuration.on_message_too_long = :split
+    sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps over the lazy dog" * 4)
+    puts sms.phone # => 8889999999
+    puts sms.messages # => ["(MSG 1/2): The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy dogThe quick brown ", "(MSG 2/2): fox jumps over the lazy dog"]
+
+    SmsValidation.configuration.on_message_too_long = :truncate
+    sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps over the lazy dog" * 4)
+    puts sms.phone # => 8889999999
+    puts sms.message # => ["The quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy dogThe quick brown fox jumps over "]
+
+    SmsValidation.configuration.on_message_too_long = :raise_error
+    sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps over the lazy dog" * 4)
+    # => SmsValidation::Sms::MessageTooLongError, "Message cannot be longer than 160 characters"
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/sms_validation/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/sms_validation.rb

@@ -0,0 +1,5 @@
+require "sms_validation/version"
+require "sms_validation/sms"
+
+module SmsValidation
+end

data/lib/sms_validation/configuration.rb

@@ -0,0 +1,48 @@
+module SmsValidation
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+  end
+
+  class Configuration
+    ON_MESSAGE_TOO_LONG_OPTIONS = [:truncate, :raise_error, :split]
+    LOG_LEVEL_OPTIONS = [:fatal, :error, :warn, :info, :debug]
+
+    attr_reader :logger, :log_level, :on_message_too_long
+    def initialize
+      @logger = Rails.logger if defined?(::Rails.logger)
+      @log_level = :debug
+      @on_message_too_long = :raise_error
+    end
+
+    def on_message_too_long=(action)
+      raise ArgumentError, "SmsValidation.configuration.on_message_too_long must be included in: #{options_string(ON_MESSAGE_TOO_LONG_OPTIONS)}.  It cannot be \"#{action}\"" unless ON_MESSAGE_TOO_LONG_OPTIONS.include?(action)
+      @on_message_too_long = action
+    end
+
+    def log_at(level)
+      validate_logger(@logger, level)
+      @log_level = level
+    end
+
+    def logger=(_logger)
+      validate_logger(_logger, @log_level)
+      @logger = _logger
+    end
+
+    private
+      def validate_logger(_logger, level)
+        raise ArgumentError, "SmsValidation.configuration.log_at argument must be included in: #{options_string(LOG_LEVEL_OPTIONS)}.  It cannot be \"#{level}\"" unless LOG_LEVEL_OPTIONS.include?(level)
+        raise ArgumentError, "SmsValidation.configuration.logger must respond to \"#{level}\"" if _logger && !_logger.respond_to?(level)
+      end
+
+      def options_string(array)
+        "[:#{array.join(", :")}]"
+      end
+  end
+end

data/lib/sms_validation/log.rb

@@ -0,0 +1,9 @@
+require "sms_validation/configuration"
+
+module SmsValidation
+  class << self
+    def log(*args, &block)
+      configuration.logger.__send__(configuration.log_level, *args, &block) if configuration.logger
+    end
+  end
+end

data/lib/sms_validation/sms.rb

@@ -0,0 +1,61 @@
+require "sms_validation/log"
+
+module SmsValidation
+  class Sms
+    class InvalidPhoneNumberError < ::ArgumentError; end
+    class InvalidMessageError < ::ArgumentError; end
+    class MessageTooLongError < ::ArgumentError; end
+
+    MAX_LENGTH = 160
+    MAX_SECTION_LENGTH = MAX_LENGTH - "(MSG XXX/XXX): ".size
+    MESSAGE_WHEN_SPLIT_MESSAGE = "This message was split because it is too long to fit into a single SMS.  Instead of #message, use #messages or change SmsValidation.configuration.on_message_too_long to something other than :split"
+
+    attr_reader :phone, :messages
+
+    def initialize(phone, message)
+      phone = phone.to_s
+      raise InvalidPhoneNumberError, "Phone number must be ten digits" unless /\A[0-9]{10}\z/.match(phone)
+      raise InvalidPhoneNumberError, "Phone number cannot begin with a \"#{phone[0]}\"" if ['0','1'].include?(phone[0].to_s)
+      raise InvalidMessageError, "Message cannot be blank" if message.empty?
+      SmsValidation.configuration.logger.warn { "WARNING: Some characters may be lost because the message must be broken into at least 1000 sections" } if message.size > (999 * MAX_SECTION_LENGTH)
+      @messages = (message.size > MAX_LENGTH) ? SmsValidation::Sms.__send__(SmsValidation.configuration.on_message_too_long, message) : [message.dup]
+      @phone = "1#{phone}"
+    end
+
+    def message
+      @message ||= begin
+        raise StandardError, MESSAGE_WHEN_SPLIT_MESSAGE unless 1 == messages.size
+        messages.first
+      end
+    end
+
+    class << self
+      def raise_error(message)
+        raise MessageTooLongError, "Message cannot be longer than #{MAX_LENGTH} characters"
+      end
+
+      def truncate(message)
+        truncated_message = message[0,MAX_LENGTH]
+        SmsValidation.log { "Truncating message due to length.  Message was: \"#{message}\" but will now be \"#{truncated_message}\"" }
+        [truncated_message]
+      end
+
+      def section_counter(size)
+        size / MAX_SECTION_LENGTH + ((size % MAX_SECTION_LENGTH).zero? ? 0 : 1)
+      end
+
+      def split(message)
+        sections = section_counter(message.size)
+        SmsValidation.log { "Splitting message into #{sections} messages due to length." }
+        split_message = (sections - 1).times.collect do |i|
+          first_char = i * MAX_SECTION_LENGTH
+          SmsValidation.log { "Section ##{i + 1} of ##{sections} contains characters #{first_char + 1} thru #{first_char + MAX_SECTION_LENGTH} of #{message.size}" }
+          "(MSG #{i+1}/#{sections}): #{message[first_char, MAX_SECTION_LENGTH]}"
+        end
+        first_char = (sections-1)*MAX_SECTION_LENGTH
+        SmsValidation.log { "Section ##{sections} of ##{sections} contains characters #{first_char + 1} thru #{message.size} of #{message.size}" }
+        split_message << "(MSG #{sections}/#{sections}): #{message[first_char..-1]}"
+      end
+    end
+  end
+end

data/lib/sms_validation/version.rb

@@ -0,0 +1,3 @@
+module SmsValidation
+  VERSION = "0.0.1"
+end

data/sms_validation.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sms_validation/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sms_validation"
+  spec.version       = SmsValidation::VERSION
+  spec.authors       = ["Isaac Betesh"]
+  spec.email         = ["iybetesh@gmail.com"]
+  spec.description   = "Validate the phone number and content of an SMS Message.  This gem does not send SMS messages.  It just makes sure the arguments are valid."
+  spec.summary       = `cat README.md`
+  spec.homepage      = "https://github.com/betesh/sms_validation/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,114 @@
+require "sms_validation/configuration"
+require "sms_validation/log"
+require "logger"
+
+describe SmsValidation::Configuration do
+  before(:each) do
+    SmsValidation.instance_variable_set("@configuration", nil)
+  end
+
+  describe "logger" do
+    let(:logger) { ::Logger.new('/dev/null') }
+
+    def it_should_not_log
+      text = "Some info"
+      described_class::LOG_LEVEL_OPTIONS.each do |log_level|
+        expect(logger).not_to receive(log_level)
+      end
+      expect{SmsValidation.log { text } }.to_not raise_error
+    end
+
+    def it_should_log_at(log_level)
+      text = "Some info"
+      expect(logger).to receive(log_level) do |&arg|
+        expect(arg.call).to eq(text)
+      end
+      expect{SmsValidation.log { text } }.to_not raise_error
+    end
+
+    def when_the_logger_is_configured
+      SmsValidation.configuration.logger = logger
+    end
+
+    [:fatal, :error, :warn, :info, :debug].each do |log_level|
+      describe "can log at #{log_level}" do
+        let(:log_level) { log_level }
+        it "should allow log level ':#{log_level}'" do
+          SmsValidation.configuration.log_at(log_level)
+          when_the_logger_is_configured
+          it_should_log_at(log_level)
+        end
+      end
+    end
+
+    it "should default to log level debug" do
+      when_the_logger_is_configured
+      it_should_log_at(:debug)
+    end
+
+    it "should default to Rails.logger when Rails.logger is defined" do
+      stub_const("Rails", double)
+      allow(Rails).to receive(:logger).and_return(logger)
+      it_should_log_at(:debug)
+    end
+
+    it "should not attempt to default to Rails.logger when Rails is defined but Rails.logger is defined" do
+      stub_const("Rails", double)
+      it_should_not_log
+    end
+
+    it "can be nil" do
+      SmsValidation.configuration.logger = nil
+      it_should_not_log
+    end
+
+    it "should not allow log level news and should remain in a valid state" do
+      expect{SmsValidation.configuration.log_at(:news)}.to raise_error(ArgumentError, "SmsValidation.configuration.log_at argument must be included in: [:fatal, :error, :warn, :info, :debug].  It cannot be \"news\"")
+      SmsValidation.configuration.logger = logger
+      it_should_log_at(:debug)
+    end
+
+    it "should not allow log level that the logger does not respond_to when the logger is created before log level is set and should remain in a valid state" do
+      SmsValidation.configuration.logger = logger
+      allow(logger).to receive(:respond_to?).with(:warn).and_return(false)
+      expect{SmsValidation.configuration.log_at(:warn)}.to raise_error(ArgumentError, "SmsValidation.configuration.logger must respond to \"warn\"")
+      it_should_log_at(:debug)
+    end
+
+    it "should not allow log level that the logger does not respond_to when the logger is created after log level is set and should remain in a valid state" do
+      allow(logger).to receive(:respond_to?).with(:warn).and_return(false)
+      SmsValidation.configuration.log_at(:warn)
+      expect{SmsValidation.configuration.logger = logger}.to raise_error(ArgumentError, "SmsValidation.configuration.logger must respond to \"warn\"")
+      it_should_not_log
+    end
+  end
+
+  describe "on_message_too_long" do
+    it "should default to :raise_error" do
+      expect(SmsValidation.configuration.on_message_too_long).to eq(:raise_error)
+    end
+
+    [:raise_error, :split, :truncate].each do |value|
+      describe value.to_s do
+        let(:value) { value }
+        it "should be an allowed value" do
+          expect{SmsValidation.configuration.on_message_too_long = value}.to_not raise_error
+          expect(SmsValidation.configuration.on_message_too_long).to eq(value)
+        end
+
+        it "should not allow other values and should remain in a valid state" do
+          SmsValidation.configuration.on_message_too_long = value
+          expect{SmsValidation.configuration.on_message_too_long = :do_nothing}.to raise_error(ArgumentError, "SmsValidation.configuration.on_message_too_long must be included in: [:truncate, :raise_error, :split].  It cannot be \"do_nothing\"")
+          expect(SmsValidation.configuration.on_message_too_long).to eq(value)
+        end
+      end
+    end
+  end
+
+  it "can yield" do
+    SmsValidation.configure do |config|
+      config.on_message_too_long = :split
+    end
+    expect(SmsValidation.configuration.on_message_too_long).to eq(:split)
+  end
+end

data/spec/sms_spec.rb

@@ -0,0 +1,174 @@
+require "sms_validation/sms"
+require "sms_validation/log"
+require "logger"
+
+describe SmsValidation::Sms do
+  let(:phone_number_length) { 10 }
+  let(:phone_number) { "8" * phone_number_length }
+  let(:message) { "TEXT MESSAGE FROM ME TO YOU" }
+  let(:on_message_too_long) { :raise_error }
+
+  before(:each) do
+    SmsValidation.instance_variable_set("@configuration", nil)
+    SmsValidation.configure do |config|
+      config.log_at(:info)
+      config.logger = logger
+      config.on_message_too_long = on_message_too_long
+    end
+  end
+
+  def it_should_not_log
+    described_class::LOG_LEVEL_OPTIONS.each do |log_level|
+      expect(logger).not_to receive(log_level)
+    end
+  end
+
+  def it_should_log(text, options={})
+    expect(logger).to receive(options[:at] || :info) do |&arg|
+      expect(arg.call).to eq(text)
+    end
+  end
+
+  subject { described_class.new(phone_number, message) }
+
+  shared_examples_for :all_specs do
+  describe "phone number" do
+    describe "when 9 digits" do
+      let(:phone_number_length) { 9 }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(described_class::InvalidPhoneNumberError, "Phone number must be ten digits")
+      end
+    end
+
+    describe "when 11 digits" do
+      let(:phone_number_length) { 11 }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(described_class::InvalidPhoneNumberError, "Phone number must be ten digits")
+      end
+    end
+
+    describe "when it starts with a 0" do
+      let(:phone_number) { "0" + "8" * (phone_number_length - 1) }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(described_class::InvalidPhoneNumberError, "Phone number cannot begin with a \"0\"")
+      end
+    end
+
+    describe "when it starts with a 1" do
+      let(:phone_number) { "1" + "8" * (phone_number_length - 1) }
+
+      it "should raise an error" do
+        expect{subject}.to raise_error(described_class::InvalidPhoneNumberError, "Phone number cannot begin with a \"1\"")
+      end
+    end
+
+    it "should prepend a '1' and be safe from changes" do
+      expected_phone_number = "1#{phone_number}"
+      subject
+      phone_number[1..3] = ''
+      expect(subject.phone).to eq(expected_phone_number)
+    end
+  end
+
+  describe "message" do
+    describe "when blank" do
+      let(:message) { "" }
+
+      it "raises an error" do
+        expect{subject}.to raise_error(described_class::InvalidMessageError, "Message cannot be blank")
+      end
+    end
+
+    describe "when longer than 160 characters" do
+      describe "when on_message_too_long = :truncate" do
+        let(:on_message_too_long) { :truncate }
+        let(:message) { "A"+"ABCDEFGHIJ"*16 }
+
+        it "is truncated to the first 160 characters" do
+          expect(subject.message).to eq(message[0,160])
+          expect(subject.messages).to eq([message[0,160]])
+        end
+
+        it "should be safe from changing" do
+          expected_message = "#{message[0,160]}"
+          subject
+          message[1..3] = ''
+          expect(subject.message).to eq(expected_message)
+          expect(subject.messages).to eq([expected_message])
+        end
+      end
+
+      describe "when on_message_too_long = :raise_error" do
+        let(:on_message_too_long) { :raise_error }
+        let(:message) { "A"*161 }
+
+        it "raises an error" do
+          expect{subject}.to raise_error(described_class::MessageTooLongError, "Message cannot be longer than 160 characters")
+        end
+      end
+
+      describe "when on_message_too_long = :split" do
+        let(:on_message_too_long) { :split }
+
+        describe "when it's an even split" do
+          let(:message) { "ABCDEFGHIJ"*58 }
+
+          it "should be split into multiple messages" do
+            expect(subject.messages).to eq(["(MSG 1/4): #{message[0,145]}", "(MSG 2/4): #{message[145,145]}", "(MSG 3/4): #{message[290,145]}", "(MSG 4/4): #{message[435,145]}"])
+            expect{subject.message}.to raise_error(StandardError, "This message was split because it is too long to fit into a single SMS.  Instead of #message, use #messages or change SmsValidation.configuration.on_message_too_long to something other than :split")
+          end
+        end
+
+        describe "when it's not an even split" do
+          let(:message) { "ABCDEFGHIJ"*32 }
+
+          it "should be split into multiple messages" do
+            expect(subject.messages).to eq(["(MSG 1/3): #{message[0,145]}", "(MSG 2/3): #{message[145,145]}", "(MSG 3/3): #{message[290..-1]}"])
+            expect{subject.message}.to raise_error(StandardError, "This message was split because it is too long to fit into a single SMS.  Instead of #message, use #messages or change SmsValidation.configuration.on_message_too_long to something other than :split")
+          end
+
+          it "should be safe from changing" do
+            expected_messages = ["(MSG 1/3): #{message[0,145]}", "(MSG 2/3): #{message[145,145]}", "(MSG 3/3): #{message[290..-1]}"]
+            subject
+            message[1..3] = ''
+            expect(subject.messages).to eq(expected_messages)
+          end
+        end
+      end
+    end
+
+    [:raise_error, :split, :truncate].each do |value|
+      describe "when on_message_too_long = :#{value}" do
+        let(:on_message_too_long) { value }
+
+        it "should be safe from changing the message" do
+          expected_message = "#{message}"
+          subject
+          message[1..3] = ''
+          expect(subject.message).to eq(expected_message)
+        end
+
+        describe "when the initial message is 160 characters" do
+          let(:message) { "A"*160 }
+
+          it "does not change" do
+            expect(subject.message).to eq(message)
+            expect(subject.messages).to eq([message])
+          end
+        end
+      end
+    end
+  end
+  end
+
+  it_behaves_like :all_specs do
+    let(:logger) { ::Logger.new('/dev/null') }
+  end
+
+  it_behaves_like :all_specs do
+    let(:logger) { nil }
+  end
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: sms_validation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Isaac Betesh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Validate the phone number and content of an SMS Message.  This gem does
+  not send SMS messages.  It just makes sure the arguments are valid.
+email:
+- iybetesh@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sms_validation.rb
+- lib/sms_validation/configuration.rb
+- lib/sms_validation/log.rb
+- lib/sms_validation/sms.rb
+- lib/sms_validation/version.rb
+- sms_validation.gemspec
+- spec/configuration_spec.rb
+- spec/sms_spec.rb
+homepage: https://github.com/betesh/sms_validation/
+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.3
+signing_key: 
+specification_version: 4
+summary: '# SmsValidation  This gem does not send SMS messages.  It just makes sure
+  the arguments are valid.  ## What are valid arguments for an SMS message?  - Phone
+  number: 10 digits, does not begin with 0 or 1 - Message: Not longer than 160 characters.  ##
+  What if my message is longer than 160 characters?  You have 3 choices: - Truncate
+  the message to the first 160 characters - Split it into multiple messages - Raise
+  a SmsValidation::Sms::MessageTooLongError error  You can configure at any time using:  SmsValidation.configuration.on_message_too_long
+  = :truncate # or :split or :raise_error  It defaults to :raise_error  ## Installation  Add
+  this line to your application''s Gemfile:  ```ruby gem ''sms_validation'' ```  And
+  then execute:  $ bundle  Or install it yourself as:  $ gem install sms_validation  ##
+  Usage  ### Configuration  SmsValidation.configure do |config| config.on_message_too_long
+  = :truncate # or :split or :raise_error config.logger = ::Logger.new(STDOUT) # Defaults
+  to ::Rails.logger if ::Rails.logger is defined  # This DOES NOT change the log_level
+  of the logger--use `config.logger.level = :debug` for that # This DOES determine
+  the log level at which messages should be logged. # This provides a convenient way
+  to toggle whether this gem should log without interfering with the log level of
+  others processes sharing the logger. # For instance, if you''re using Rails, you
+  probably don''t want to set the log_level to DEBUG, because then ActiveRecord will
+  log every query. # But you may still want SmsValidation to log everything it does.
+  config.log_at :info  # OR you may want SmsValidation to log only when you''re logging
+  all other DEBUG messages. config.log_at :debug end  ### Validation  sms = SmsValidation::Sms.new(8889999999,
+  "The quick brown fox jumps over the lazy dog") puts sms.phone # => 8889999999 puts
+  sms.message # => "The quick brown fox jumps over the lazy dog"  sms = SmsValidation::Sms.new(889999999,
+  "The quick brown fox jumps over the lazy dog") # => SmsValidation::Sms::InvalidPhoneNumberError:
+  "Phone number must be ten digits"  SmsValidation.configuration.on_message_too_long
+  = :split sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps over
+  the lazy dog" * 4) puts sms.phone # => 8889999999 puts sms.messages # => ["(MSG
+  1/2): The quick brown fox jumps over the lazy dogThe quick brown fox jumps over
+  the lazy dogThe quick brown fox jumps over the lazy dogThe quick brown ", "(MSG
+  2/2): fox jumps over the lazy dog"]  SmsValidation.configuration.on_message_too_long
+  = :truncate sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps
+  over the lazy dog" * 4) puts sms.phone # => 8889999999 puts sms.message # => ["The
+  quick brown fox jumps over the lazy dogThe quick brown fox jumps over the lazy dogThe
+  quick brown fox jumps over the lazy dogThe quick brown fox jumps over "]  SmsValidation.configuration.on_message_too_long
+  = :raise_error sms = SmsValidation::Sms.new(8889999999, "The quick brown fox jumps
+  over the lazy dog" * 4) # => SmsValidation::Sms::MessageTooLongError, "Message cannot
+  be longer than 160 characters"  ## Contributing  1. Fork it ( https://github.com/[my-github-username]/sms_validation/fork
+  ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your
+  changes (`git commit -am ''Add some feature''`) 4. Push to the branch (`git push
+  origin my-new-feature`) 5. Create a new Pull Request'
+test_files:
+- spec/configuration_spec.rb
+- spec/sms_spec.rb