date_as_string 0.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f8bde9b4c771dda4f6270bb5270de295af06337e4352a55f425e4aaaa277ac21
+  data.tar.gz: '087b9878efd66ca01a9e60a5aa74fd7d6dc057edb680c570f70eaefcf6508878'
+SHA512:
+  metadata.gz: 44c6573aee04ef19c850c36daabf1093ce2684fd266e48850fd51bab1f055acb214721960071c5b6932eb38467f8f7f42f4a692276254f0b094cd2a8eaafa13c
+  data.tar.gz: b029b37c736ef35ecad4e3ffe4cf1ef67c12f7e37b21a025831198cbb7be137ab3281620f8651b645ab69a2fa601d99d4a71297ee12feb3309843ff13dd12b2f

data/.gitignore

@@ -0,0 +1,8 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+.DS_Store
+*.log
+*.sqlite

data/.rspec

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

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in date_as_string.gemspec
+gemspec
+
+
+group :test do
+  gem 'activesupport'
+  gem 'byebug'
+end

data/Rakefile

@@ -0,0 +1,28 @@
+require 'bundler/gem_tasks'
+
+#Override bundler to prevent releasing to RubyGems
+module Bundler
+  class GemHelper
+    def release_gem
+      guard_clean
+      guard_already_tagged
+      built_gem_path = build_gem
+      tag_version {
+        git_push
+      }
+    end
+  end
+end
+
+#http://asciicasts.com/episodes/245-new-gem-with-bundler
+#$ rake -T
+#rake build    # Build mesav-#.#.#.gem into the pkg directory
+#rake install  # Build and install mesav-#.#.#.gem into system gems
+#rake release  # Create tag v#.#.#, build, and push
+
+#RSPEC
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/date_as_string.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "date_as_string/version"
+
+Gem::Specification.new do |s|
+  s.name        = "date_as_string"
+  s.version     = DateAsString::VERSION::STRING
+  s.authors     = ["Eric Sullivan"]
+  s.email       = ["eric.sullivan@annkissam.com"]
+  s.homepage    = "http://annkissam.com"
+  s.summary     = %q{Convert from Date to String and vice versa by attaching _string suffix to an ActiveRecord field}
+  s.description = %q{Treat an ActiveRecord Date column as a String}
+
+  s.rubyforge_project = "date_as_string"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+end

data/lib/date_as_string.rb

@@ -0,0 +1,222 @@
+require "date_as_string/version"
+
+require "date_as_string/formats"
+
+module DateAsString
+  def self.guess_century(year, cutoff=20)
+    century = get_century_from_year_range(year, cutoff)
+
+    century.present? ? century : raise_century_error
+  end
+
+  def self.included(base)
+    base.send(:extend, DateAsString::ClassMethods)
+  end
+
+  def self.parse_date(date)
+    date.respond_to?(:strftime) ? date.strftime('%m/%d/%Y') : nil
+  end
+
+  def self.parse_string(date_string)
+    begin
+      case
+      when t_regex.match(date_string)
+        date_for_t_match(date_string)
+      when mmddyy_regex.match(date_string)
+        date_for_mmddyy_match(date_string)
+      when mmddyy_regex(with_slashes: true).match(date_string)
+        date_for_mmddyy_match(date_string, with_slashes: true)
+      when mmddyyyy_regex.match(date_string)
+        date_for_mmddyyyy_match(date_string)
+      when mmddyyyy_regex(with_slashes: true).match(date_string)
+        date_for_mmddyyyy_match(date_string, with_slashes: true)
+      else
+        nil
+      end
+    rescue
+      nil
+    end
+  end
+
+  module ClassMethods
+    def date_as_string(*args)
+      defaults = {:input_formats => [:mm_dd_yyyy, :mm_dd_yyyy, :mmddyyyy, :mmddyy, :t_pmd],
+                  :default_display_format => :mm_dd_yyyy,
+                  :century_cutoff => 20,
+                  :default => nil}
+      options = args.last.is_a?(Hash) ? defaults.merge(args.pop) : defaults
+
+      #We're current not doing anything with the options...
+      #We should support default formats, default value, and allowable formats...
+
+      unless self.respond_to?(:date_as_string_options)
+        cattr_accessor :date_as_string_options
+        self.date_as_string_options = {}
+      end
+
+      args.each do |attribute_name|
+        self.date_as_string_options[attribute_name] = options
+
+        validate :"#{attribute_name}_format"
+
+        define_method "#{attribute_name}_string" do |*display_format|
+          if instance_variable_get("@#{attribute_name}_string")
+            instance_variable_get("@#{attribute_name}_string")
+          else
+            if self.send("#{attribute_name}").nil?
+              if options[:default] && options[:default].is_a?(String)
+                eval(options[:default])
+              elsif options[:default] && options[:default].is_a?(Proc)
+                options[:default].call
+              else
+                nil
+              end
+            else
+              #self.send("#{attribute_name}").strftime('%m/%d/%Y')
+              unless display_format.empty?
+                DateAsString::Formats.find_format(display_format[0]).strftime(self.send("#{attribute_name}"))
+              else
+                DateAsString::Formats.find_format(options[:default_display_format]).strftime(self.send("#{attribute_name}"))
+              end
+            end
+          end
+        end
+
+        define_method "#{attribute_name}_string=" do |str|
+          instance_variable_set("@#{attribute_name}_string", str)
+          self.send("#{attribute_name}=", DateAsString.parse_string(str))
+        end
+
+        define_method "#{attribute_name}_format" do
+          re = /^(([tT]([\-\+]\d+)?)|(\d{6})|(\d{8})|([0-1]?\d\/[0-3]?\d\/\d\d)|([0-1]?\d\/[0-3]?\d\/(19|20)\d\d))$/
+
+          attribute_string = instance_variable_get("@#{attribute_name}_string")
+
+          #No string was entered - this clears the date
+          return if attribute_string.blank?
+
+          #the entered string did not match a regex...
+          if (attribute_string =~ re).nil?
+            errors.add("#{attribute_name}_string", "must be in the format of MM/DD/YY, MM/DD/YYYY, MMDDYY, MMDDYYYY or t, t+#, t-#")
+            return
+          end
+
+          #The mapping did not work for some reason...
+          if self.send("#{attribute_name}").nil?
+            errors.add("#{attribute_name}_string", :invalid)
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def self.year_range(cutoff)
+    current_year = Time&.zone&.today&.year || Date.today.year
+
+    range_start = current_year - (99 - cutoff)
+    range_end = current_year + cutoff
+
+    range_start..range_end
+  end
+
+  def self.get_century_from_year_range(year, cutoff=20)
+    year_range(cutoff).detect { |temp_year| temp_year % 100 == year }
+  end
+
+  def self.raise_century_error
+    raise RangeError.new('Error converting year...')
+  end
+
+  def self.t_regex
+    /^[tT]((?<operator>[\-\+])(?<days_count>\d+))?$/
+  end
+
+  #Allow MMDDYY or MM/DD/YY
+  def self.mmddyy_regex(options={})
+    with_slashes = options.fetch(:with_slashes, false)
+
+    slash_str = with_slashes ? '/' : nil
+    month_str = '(?<month>[0-1]?\d)'
+    day_str = '(?<day>[0-3]?\d)'
+    year_str =  '(?<year>\d{2})'
+
+    date_tup = [month_str, day_str, year_str]
+    slashes = [slash_str]*2
+
+    inner_regex = date_tup.zip(slashes)
+                          .flatten
+                          .compact
+                          .join
+
+    /^#{inner_regex}$/
+  end
+
+  #Allow MMDDYYYY or MM/DD/YYYY
+  def self.mmddyyyy_regex(options={})
+    with_slashes = options.fetch(:with_slashes, false)
+
+    slash_str = with_slashes ? '/' : nil
+    month_str = '(?<month>[0-1]?\d)'
+    day_str = '(?<day>[0-3]?\d)'
+    year_str =  '(?<year>\d{4})'
+
+    date_tup = [month_str, day_str, year_str]
+    slashes = [slash_str]*2
+
+    inner_regex = date_tup.zip(slashes)
+                          .flatten
+                          .compact
+                          .join
+
+    /^#{inner_regex}$/
+  end
+
+  # matches:
+  #   e.g.)
+  #     t   => Date.today
+  #     t+7 => Date.today + 1.week
+  #     t-1 => Date.today - 1.day
+  def self.date_for_t_match(date_string)
+    today = Time&.zone&.today || Date.today
+
+    t_regex.match(date_string) do |match_data|
+      operator, days_count = *[match_data[:operator], match_data[:days_count]]
+
+      operator ? today.send(operator, days_count.to_i) : today
+    end
+  end
+
+  def self.date_for_mmddyy_match(date_string, options={})
+    slashy_regex = options.fetch(:with_slashes, false)
+    month, day, year = nil, nil, nil
+
+    mmddyy_regex(with_slashes: slashy_regex).match(date_string) do |match_data|
+      month = match_data[:month] ? match_data[:month] : date_string[0..1]
+      day = match_data[:day] ? match_data[:day] : date_string[2..3]
+      year = match_data[:year] ? match_data[:year] : date_string[4..5]
+
+      century = DateAsString.guess_century(year.to_i)
+
+      Date.civil(century, month.to_i, day.to_i)
+    end
+  end
+
+  def self.date_for_mmddyyyy_match(date_string, options={})
+    slashy_regex = options.fetch(:with_slashes, false)
+    month, day, year = nil, nil, nil
+
+    mmddyyyy_regex(with_slashes: slashy_regex).match(date_string) do |match_data|
+      month = match_data[:month] ? match_data[:month] : date_string[0..1]
+      day = match_data[:day] ? match_data[:day] : date_string[2..3]
+      year = match_data[:year] ? match_data[:year] : date_string[4..5]
+
+      Date.civil(year.to_i, month.to_i, day.to_i)
+    end
+  end
+end
+
+if Object.const_defined?("ActiveRecord")
+  ActiveRecord::Base.send(:include, DateAsString)
+end

data/lib/date_as_string/formats.rb

@@ -0,0 +1,55 @@
+module DateAsString
+  module Formats
+    def self.find_format(format_string)
+      case format_string
+      when :mm_dd_yyyy
+        Format1
+      when :mm_dd_yy
+        Format2
+      when :mmddyyyy
+        Format3
+      when :mmddyy
+        Format4
+      when :t_pmd
+        Format5
+      else
+        raise TypeError.new("Format does not exist: #{format_string}")
+      end
+    end
+    
+    #mm_dd_yyyy
+    class Format1
+      def self.strftime(value)
+        value.strftime('%m/%d/%Y')
+      end
+    end
+    
+    #mm_dd_yy
+    class Format2
+      def self.strftime(value)
+        value.strftime('%m/%d/%y')
+      end
+    end
+    
+    #mmddyyyy
+    class Format3
+      def self.strftime(value)
+        value.strftime('%m%d%Y')
+      end
+    end
+    
+    #mmddyy
+    class Format4
+      def self.strftime(value)
+        value.strftime('%m%d%y')
+      end
+    end
+    
+    #t_pmd
+    class Format5
+      def self.strftime(value)
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/date_as_string/version.rb

@@ -0,0 +1,12 @@
+module DateAsString
+  module VERSION
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 6
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+
+    SUMMARY = "date_as_string #{STRING}"
+  end
+end

data/spec/date_as_string_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe 'DateAsString' do
+  let(:today) { Date.today }
+  let(:tomorrow) { today + 1.day }
+  let(:yesterday) { today - 1.day }
+  let(:new_years_day_1990) { Date.new(1990, 1, 1) }
+
+  describe '.parse_date(date)' do
+    subject { DateAsString.parse_date date_arg }
+
+    context 'when provided with a Date' do
+      let(:date_arg) { new_years_day_1990 }
+
+      it { is_expected.to eq "01/01/1990" }
+    end
+
+    describe 'handling invalid arguments' do
+      context "argument is a String" do
+        let(:date_arg) { 'abc' }
+
+        it { is_expected.to eq nil }
+      end
+    end
+  end
+
+  describe ".parse_string(string)" do
+    subject { DateAsString.parse_string date_string_arg }
+
+    context "format -> 't+#'" do
+      let(:date_string_arg) { "t+1" }
+
+      it { is_expected.to eq tomorrow }
+    end
+
+    context "format -> 't-#'" do
+      let(:date_string_arg) { "t-1" }
+
+      it { is_expected.to eq yesterday }
+    end
+
+    context "format -> 't'" do
+      let(:date_string_arg) { "t" }
+
+      it { is_expected.to eq today }
+    end
+
+    context "format -> '######'" do
+      let(:date_string_arg) { "010190" }
+
+      it { is_expected.to eq new_years_day_1990 }
+    end
+
+    context "format -> '########'" do
+      let(:date_string_arg) { "01011990" }
+
+      it { is_expected.to eq new_years_day_1990 }
+    end
+
+    context "format -> '##/##/##'" do
+      let(:date_string_arg) { "01/01/90" }
+
+      it { is_expected.to eq new_years_day_1990 }
+    end
+
+    context "format -> '##/##/####'" do
+      let(:date_string_arg) { "01/01/1990" }
+
+      it { is_expected.to eq new_years_day_1990 }
+    end
+
+    describe 'handling invalid arguments' do
+      context "argument is a String" do
+        let(:date_string_arg) { 'abc' }
+
+        it { is_expected.to eq nil }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "date_as_string/version"
+require "date_as_string/formats"
+
+require 'active_support/all'
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'date_as_string'
+
+require 'byebug'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: date_as_string
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+platform: ruby
+authors:
+- Eric Sullivan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-06 00:00:00.000000000 Z
+dependencies:
+- !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: Treat an ActiveRecord Date column as a String
+email:
+- eric.sullivan@annkissam.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Rakefile
+- date_as_string.gemspec
+- lib/date_as_string.rb
+- lib/date_as_string/formats.rb
+- lib/date_as_string/version.rb
+- spec/date_as_string_spec.rb
+- spec/spec_helper.rb
+homepage: http://annkissam.com
+licenses: []
+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: date_as_string
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Convert from Date to String and vice versa by attaching _string suffix to
+  an ActiveRecord field
+test_files: []