date_interval 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 813d0b8efd859f424896abe5f481d49f4b8c6f52
+  data.tar.gz: b7e075815608d25339f44a5e7e85415081cfecee
+SHA512:
+  metadata.gz: 778f7247a5b7a65096b959aa518bad9b176810732dbfaf7e84029b04c57ddff6c416cef3b10bd1618ee70f71790e4eafdee49e464720b14b4e8d9da3ef67da03
+  data.tar.gz: 5983f419c51d80b2769b3e9369811b2c7e898b49cb1a86a0ba7d4bcb436bdb2a0b803c7a26f8d8f77e203773f7337e09b9d68889f27adc54446189080f767d65

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.0
+  - 2.0.0
+  - 1.9.3

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nando Vieira
+
+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,51 @@
+# DateInterval
+
+Parse date intervals from strings.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'date_interval'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install date_interval
+
+## Usage
+
+You must always define at least one range at the beginning of the expression. The snippet below will return three dates objects.
+
+```ruby
+expr = "2014-01-01 - 2014-01-03"
+dates = DateInterval.parse(expr)
+```
+
+You can provide as many intervals as you want. The following expression returns six date objects.
+
+```ruby
+expr = "2014-01-01 - 2014-01-03, 2014-02-01 - 2014-02-03"
+dates = DateInterval.parse(expr)
+```
+
+You can also define filters. Filters are applied in sequence, from left to right. The following filters are available:
+
+- `none`: return no dates. Useful for applying specific filters afterwards.
+- `[+-]weekends`: filter weekend dates
+- `[+-]weekdays`: filter weekdays ()
+- `[+-]sundays`: filter sundays. You can use any weekday name (sundays-saturdays)
+- `[+-]yyy-mm-dd`: add/remove the given date.
+
+Beware that duplicated dates are removed from the final result. They're also sorted.
+
+## Contributing
+
+1. Fork it ( http://github.com/[my-github-username]/date_interval/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 new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/date_interval.gemspec

@@ -0,0 +1,22 @@
+require "./lib/date_interval/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "date_interval"
+  spec.version       = DateInterval::VERSION
+  spec.authors       = ["Nando Vieira"]
+  spec.email         = ["fnando.vieira@gmail.com"]
+  spec.summary       = "Parse date intervals from strings"
+  spec.homepage      = "http://github.com/fnando/date_interval"
+  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_dependency "parslet"
+  spec.add_development_dependency "bundler", ">= 0"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry-meta"
+end

data/lib/date_interval.rb

@@ -0,0 +1,32 @@
+require "date"
+require "parslet"
+require "forwardable"
+
+require "date_interval/date"
+require "date_interval/filter"
+require "date_interval/filter/operator"
+require "date_interval/filter/date"
+require "date_interval/filter/none"
+require "date_interval/filter/weekday"
+require "date_interval/filter/weekdays"
+require "date_interval/filter/weekend"
+require "date_interval/parser"
+require "date_interval/transformer"
+require "date_interval/version"
+
+module DateInterval
+  InvalidRuleError = Class.new(StandardError)
+
+  def self.parse(expression)
+    parser = Parser.new
+    transformer = Transformer.new
+
+    tree = parser.parse(expression)
+    ast = transformer.apply(tree)
+
+    Filter.filter(
+      ast[:intervals].flatten.uniq,
+      ast[:filters].kind_of?(Array) ? ast[:filters] : []
+    )
+  end
+end

data/lib/date_interval/date.rb

@@ -0,0 +1,37 @@
+module DateInterval
+  class Date
+    attr_reader :date
+
+    extend Forwardable
+    def_delegator :date, :wday
+
+    def initialize(date)
+      @date = date
+      @add = true
+    end
+
+    def add?
+      @add
+    end
+
+    def add!
+      @add = true
+    end
+
+    def remove!
+      @add = false
+    end
+
+    def weekend?
+      [0, 6].include?(date.wday)
+    end
+
+    def weekday?
+      !weekend?
+    end
+
+    def to_date
+      date
+    end
+  end
+end

data/lib/date_interval/filter.rb

@@ -0,0 +1,15 @@
+module DateInterval
+  module Filter
+    def self.filter(dates, filters)
+      filters.each do |filter|
+        filter.apply(dates)
+      end
+
+      dates
+        .select(&:add?)
+        .map(&:to_date)
+        .uniq
+        .sort
+    end
+  end
+end

data/lib/date_interval/filter/date.rb

@@ -0,0 +1,22 @@
+module DateInterval
+  module Filter
+    class Date < Operator
+      attr_reader :date, :operator
+
+      def initialize(date, operator)
+        @date = date
+        @operator = operator
+      end
+
+      def positive(dates)
+        dates << DateInterval::Date.new(date)
+      end
+
+      def negative(dates)
+        dates
+          .select {|d| d.to_date == date }
+          .each(&:remove!)
+      end
+    end
+  end
+end

data/lib/date_interval/filter/none.rb

@@ -0,0 +1,9 @@
+module DateInterval
+  module Filter
+    class None
+      def apply(dates)
+        dates.each(&:remove!)
+      end
+    end
+  end
+end

data/lib/date_interval/filter/operator.rb

@@ -0,0 +1,17 @@
+module DateInterval
+  module Filter
+    class Operator
+      def apply(dates)
+        operator == "-" ? negative(dates) : positive(dates)
+      end
+
+      def negative(dates)
+        filter(dates).each(&:remove!)
+      end
+
+      def positive(dates)
+        filter(dates).each(&:add!)
+      end
+    end
+  end
+end

data/lib/date_interval/filter/weekday.rb

@@ -0,0 +1,19 @@
+module DateInterval
+  module Filter
+    class Weekday < Operator
+      attr_reader :day, :operator, :wday
+
+      WEEKDAYS = %w[sunday monday tuesday wednesday thursday friday saturday]
+
+      def initialize(day, operator)
+        @day = day
+        @wday = WEEKDAYS.index(day)
+        @operator = operator
+      end
+
+      def filter(dates)
+        dates.select {|date| date.wday == wday }
+      end
+    end
+  end
+end

data/lib/date_interval/filter/weekdays.rb

@@ -0,0 +1,15 @@
+module DateInterval
+  module Filter
+    class Weekdays < Operator
+      attr_reader :operator
+
+      def initialize(operator)
+        @operator = operator
+      end
+
+      def filter(dates)
+        dates.select(&:weekday?)
+      end
+    end
+  end
+end

data/lib/date_interval/filter/weekend.rb

@@ -0,0 +1,15 @@
+module DateInterval
+  module Filter
+    class Weekend < Operator
+      attr_reader :operator
+
+      def initialize(operator)
+        @operator = operator
+      end
+
+      def filter(dates)
+        dates.select(&:weekend?)
+      end
+    end
+  end
+end

data/lib/date_interval/parser.rb

@@ -0,0 +1,90 @@
+module DateInterval
+  class Parser < Parslet::Parser
+    rule(:date)  { year >> hyphen >> month >> hyphen >> day }
+
+    rule(:year)  {
+      match("[12]") >> match("[0-9]").repeat(3)
+    }
+
+    rule(:month) {
+      str("0") >> match("[1-9]") |
+      str("1") >> match("[0-2]")
+    }
+
+    rule(:day)   {
+      str("0") >> match("[1-9]")      |
+      match("[12]") >> match("[0-9]") |
+      str("3") >> match("[01]")
+    }
+
+    rule(:comma)              { str(",") >> space? }
+    rule(:hyphen)             { str("-") }
+    rule(:hyphen_with_space)  { space? >> hyphen >> space? }
+
+    rule(:space)  { match(" ").repeat(1) }
+    rule(:space?) { space.maybe }
+
+    rule(:interval)  {
+      (date.as(:starting) >> hyphen_with_space >> date.as(:ending)).as(:interval)
+    }
+
+    rule(:intervals) {
+      interval >>
+      ((comma >> interval).repeat).maybe
+    }
+
+    rule(:filters)  { (comma >> filter).repeat }
+    rule(:filters?) { filters.maybe }
+    rule(:filter)   {
+      filter_weekday.as(:weekday)   |
+      filter_weekdays.as(:weekdays) |
+      filter_weekend.as(:weekend)   |
+      filter_none.as(:none)         |
+      filter_date.as(:date)
+    }
+
+    rule(:s?) { str("s").maybe }
+
+    rule(:filter_weekend)   {
+      operator? >>
+      str("weekend") >> s?
+    }
+
+    rule(:filter_weekdays)   {
+      operator? >>
+      str("weekday") >> s?
+    }
+
+    rule(:filter_weekday)   {
+      operator? >>
+      (
+        str("sunday")     |
+        str("monday")     |
+        str("tuesday")    |
+        str("wednesday")  |
+        str("thursday")   |
+        str("friday")     |
+        str("saturday")
+      ).as(:day) >> s?
+    }
+
+    rule(:filter_none)  {
+      str("none")
+    }
+
+    rule(:filter_date) {
+      operator? >>
+      date.as(:date)
+    }
+
+    rule(:operator)   { match("[+-]").as(:operator) }
+    rule(:operator?)  { operator.maybe }
+
+    rule(:expression) {
+      intervals.as(:intervals) >>
+      filters?.as(:filters)
+    }
+
+    root :expression
+  end
+end

data/lib/date_interval/transformer.rb

@@ -0,0 +1,27 @@
+module DateInterval
+  class Transformer < Parslet::Transform
+    rule(interval: {starting: simple(:starting), ending: simple(:ending)}) {
+      (::Date.parse(starting)..::Date.parse(ending)).map {|date| Date.new(date) }
+    }
+
+    rule(weekday: {operator: simple(:operator), day: simple(:day)}) {
+      Filter::Weekday.new(day.to_s, operator.to_s)
+    }
+
+    rule(date: {operator: simple(:operator), date: simple(:date)}) {
+      Filter::Date.new(::Date.parse(date), operator.to_s)
+    }
+
+    rule(weekend: {operator: simple(:operator)}) {
+      Filter::Weekend.new(operator.to_s)
+    }
+
+    rule(weekdays: {operator: simple(:operator)}) {
+      Filter::Weekdays.new(operator.to_s)
+    }
+
+    rule(none: simple(:name)) {
+      Filter::None.new
+    }
+  end
+end

data/lib/date_interval/version.rb

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

data/spec/date_interval_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+describe DateInterval do
+  it "parses the interval" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05")
+    expected_interval = (Date.parse("2014-01-01")..Date.parse("2014-01-05")).to_a
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "filters all out" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none")
+    expect(interval).to eql([])
+  end
+
+  it "includes weekends" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +weekends")
+    expected_interval = date_range("2014-01-04", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes weekends" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, -weekends")
+    expected_interval = date_range("2014-01-01", "2014-01-03")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes weekdays" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +weekdays")
+    expected_interval = date_range("2014-01-01", "2014-01-03")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes weekdays" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, -weekdays")
+    expected_interval = date_range("2014-01-04", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes date" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, +2014-01-06")
+    expected_interval = date_range("2014-01-01", "2014-01-06")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes date" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, -2014-01-05")
+    expected_interval = date_range("2014-01-01", "2014-01-04")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes sunday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +sunday")
+    expected_interval = [to_date("2014-01-05")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes sunday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, -sunday")
+    expected_interval = date_range("2014-01-01", "2014-01-04")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes monday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-06, none, +monday")
+    expected_interval = [to_date("2014-01-06")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes monday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-06, -monday")
+    expected_interval = date_range("2014-01-01", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes tuesday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-07, none, +tuesday")
+    expected_interval = [to_date("2014-01-07")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes tuesday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-07, -tuesday")
+    expected_interval = date_range("2014-01-01", "2014-01-06")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes wednesday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +wednesday")
+    expected_interval = [to_date("2014-01-01")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes wednesday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, -wednesday")
+    expected_interval = date_range("2014-01-02", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes thursday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +thursday")
+    expected_interval = [to_date("2014-01-02")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes thursday" do
+    interval = DateInterval.parse("2014-01-02 - 2014-01-05, -thursday")
+    expected_interval = date_range("2014-01-03", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes friday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-05, none, +friday")
+    expected_interval = [to_date("2014-01-03")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes friday" do
+    interval = DateInterval.parse("2014-01-03 - 2014-01-05, -friday")
+    expected_interval = date_range("2014-01-04", "2014-01-05")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "includes saturday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-04, none, +saturday")
+    expected_interval = [to_date("2014-01-04")]
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "excludes saturday" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-04, -saturday")
+    expected_interval = date_range("2014-01-01", "2014-01-03")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "returns unique dates" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-02, +2014-01-02")
+    expected_interval = date_range("2014-01-01", "2014-01-02")
+
+    expect(interval).to eql(expected_interval)
+  end
+
+  it "returns sorted dates" do
+    interval = DateInterval.parse("2014-01-01 - 2014-01-02, +2013-12-31")
+    expected_interval = date_range("2013-12-31", "2014-01-02")
+
+    expect(interval).to eql(expected_interval)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require "bundler/setup"
+require "date_interval"
+
+module SpecHelper
+  def date_range(starting, ending)
+    (to_date(starting)..to_date(ending)).to_a
+  end
+
+  def to_date(literal)
+    Date.parse(literal)
+  end
+end
+
+RSpec.configure do |config|
+  config.include SpecHelper
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: date_interval
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nando Vieira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: pry-meta
+  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: 
+email:
+- fnando.vieira@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- date_interval.gemspec
+- lib/date_interval.rb
+- lib/date_interval/date.rb
+- lib/date_interval/filter.rb
+- lib/date_interval/filter/date.rb
+- lib/date_interval/filter/none.rb
+- lib/date_interval/filter/operator.rb
+- lib/date_interval/filter/weekday.rb
+- lib/date_interval/filter/weekdays.rb
+- lib/date_interval/filter/weekend.rb
+- lib/date_interval/parser.rb
+- lib/date_interval/transformer.rb
+- lib/date_interval/version.rb
+- spec/date_interval_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/fnando/date_interval
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Parse date intervals from strings
+test_files:
+- spec/date_interval_spec.rb
+- spec/spec_helper.rb