store_hours 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWJjOWYzNjliZWE5YWM1MjY3ZWM3MWI0NDE0NDljZDA3NzY1MWExZg==
+  data.tar.gz: !binary |-
+    ODc4YTE1YjVmZGQ2Y2Q0NDIyZGVlZGQ4NjQ5MzA5MTkzNDNmYzQ1MA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZTA3MTg3MDhiMDg1MjJkZDRiMDY5NTYzNWFiNGQ2ZmE0NmQ3YjRiOThkYjNm
+    YjliZTI1MDgxYTYyYTIxOGUwMTk2ZjczNThkNWUyOWI5ZGQ5M2JlYjUwNTBl
+    NDc4YjI2OGIxOTIwYjRjNTFlNjBlMTQ5YTI2MjZkZmZkYWRkZDM=
+  data.tar.gz: !binary |-
+    YmY4M2RkNDg0ZWQ1ZmFkODc4NzlmMTc0MTEwMzdlMDM4ZjRjM2VmNjY1NGMx
+    N2I4MGEwOTNmNjg4NmUzM2Y1YWY3ZjA3ZWRmZjQ1Y2E0MWUyNDdhNzllMmM2
+    Mjg2YTgxM2NlYTdhY2U3NjkwMmVhNTY2NzEwODc5NGUyZDcyYzM=

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in store_hours.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rake', '~> 0.9.2.2'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Yanhao Zhu
+
+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,94 @@
+# StoreHours
+
+A very simple parser to parse text like
+
+    Mon-Fri:  9AM-5PM
+    Sat:      10AM-7PM
+    Sun:      closed
+
+and build an internal data structure to enable possible formatting and queries.
+
+This class is designed for situations where (1) you like to use a single text field in database to store open hours, and (2) you would like to be able to check whether the store opens for a certain time, or to make sure inputs are valid, or to display the hours in a format different from user input (for example, format the input in html to display on website).
+
+Here is an example about how to use this class in rails. Suppose you have a model
+called "Store" with a text filed named normal_business_hours, you can add this validation
+method:
+
+    validate :normal_business_hours_must_be_in_valid_format
+    def normal_business_hours_must_be_in_valid_format
+        hours_parser = ::StoreHours::StoreHours.new
+        #check whether input is valid?
+        success, error_message  = hours_parser.from_text(self.normal_business_hours)
+        if !success
+            #input is not valid
+            errors.add(:normal_business_hours, error_message)
+        end
+    end
+
+Examples of valid input:
+
+    Mon: 8AM-12PM 2PM-6PM
+    Tue: 8:30AM-5:30PM
+    Wed-Fri: 9:00AM - 4:50PM 6:00PM-10:30PM
+    Sat: 10AM-1PM 1:30PM - 6PM
+    Sun: closed
+    mon: 10:00am - 5:00PM           #case insensitive
+    mon: 8:00am-12:00pm, 1pm-5pm    #time periods can be separated by comma(,) or space
+    mon: 8:00am-12:00pm 1pm-5pm
+    mon-fri : 10am-5pm
+    sat - sun: closed
+    sun : closed
+    
+Examples of invalid entries:
+
+    mon  10am - 5pm           # colon(:) after week day(s) is required
+    mon fri: 10am - 5pm       # dash(-) between two days is required
+    mon-fri: 10:am - 5pm      # minute component for time is required when the colon(:) is present
+    mon-fri: 10 am - 5 pm     # no space is allowed between time digits and am/pm
+    mon : 10am - 17           # standard time format (with am or pm) is required
+    sat-sun: 10am-1pm closed  # closed can only be used with other time periods
+
+## Usage
+
+```
+#!ruby
+1.9.3-p194 :001 > require 'store_hours'
+ => true 
+1.9.3-p194 :002 > hours_parser = ::StoreHours::StoreHours.new
+ => #<StoreHours::StoreHours:0x007fb5dc1bead8 @hours=[]> 
+1.9.3-p194 :003 > hours_parser.from_text('mon:10:40am-5pm tue:8am-')
+ => [false, "syntax error: input is not in correct format"] 
+1.9.3-p194 :004 > hours_parser.from_text('mon:10:40am-5pm tue:8am-6pm')
+ => [true, ""] 
+1.9.3-p194 :006 > puts hours_parser.to_text
+Mon: 10:40AM - 5:00PM
+Tue: 8:00AM - 6:00PM
+1.9.3-p194 :007 > hours_parser
+ => #<StoreHours::StoreHours:0x007fb5dc1bead8 @hours=[{1..1=>[640..1020]}, {2..2=>[480..1080]}]> 
+```
+
+## Limitations
+
+Time periods can only be within 0AM-11:59PM.  In other words, time periods like 11:30PM-6:00AM are not supported.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'store_hours'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install store_hours
+
+## Contributing
+
+1. Fork it
+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,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/lib/store_hours.rb

@@ -0,0 +1,141 @@
+require 'parslet'
+
+require "store_hours/version"
+require "store_hours/text_input_parser"
+require "store_hours/tree_transformer"
+require "store_hours/semantic_error"
+require "store_hours/common_methods"
+
+require "json"
+
+module StoreHours
+  # A very simple parser to parse text like
+  #       Mon-Fri:  9AM-5PM
+  #       Sat:      10AM-7PM
+  #       Sun:      closed
+  # and build an internal data structure to enable possible formatting and queries.
+  #
+  # This class is designed to use when (1) you like to use a single text field in
+  # database to store open hours, and (2) you would like to be able to check whether
+  # the store opens for a certain time, or to make sure inputs are valid, or to
+  # display the hours in a format different from user input (for example, take plain
+  # text from users, but to format the input in html to display).
+  #
+  # Here is an example about how to use this class in rails. Suppose you have a model
+  # called "Store" with a text filed named normal_business_hours, you can add this validation
+  # method:
+  # 
+  #   validate :normal_business_hours_must_be_in_valid_format
+  #   def normal_business_hours_must_be_in_valid_format
+  #     hours_parser = ::StoreHours::StoreHours.new
+  #     #check whether input is valid?
+  #     success, error_message  = hours_parser.from_text(self.normal_business_hours)
+  #     if !success
+  #       #input is not valid
+  #       errors.add(:normal_business_hours, error_message)
+  #     end
+  #   end
+  #
+  # Please refer to text_input_parser.rb and tree_transformer.rb to get some idea
+  # of what kinds of inputs are valid.
+  #
+  class StoreHours
+    def initialize
+      @hours = []
+    end
+
+    # Try to parse the input text.
+    # @param text [String] store hours text input, case-insensitive
+    # @return [Boolean, String] returns [true, ''] if the text is valid, otherwise,
+    # the return value will be [false, "error message"]
+    #
+    # This method will build the internal data structure for valid text argument.
+    #
+    # Please don't ignore the return value from this method as it is the only way to
+    # know whether input is valid.
+    #
+    def from_text(text)
+      text = '' if text == nil
+      result = true
+      error_message = ''
+
+      begin
+        # parse the text into an intermediary tree
+        # this call may raise Parslet::ParseFailed exception
+        tree = TextInputParser.new.parse(text.strip.downcase)
+
+        # convert the tree into internal data structure
+        # please refer to tree_transformer.rb for the details of this structure
+        # this call may raise StoreHours::SemanticError exception
+        @hours = TreeTransformer.new.apply(tree)
+
+        result = true
+      rescue Parslet::ParseFailed => e
+        puts e.cause.ascii_tree
+        puts e.cause.message
+        puts text[0..e.cause.source.chars_left]
+
+        result = false
+        error_message = "syntax error: input is not in correct format"
+      rescue ::StoreHours::SemanticError => e
+        puts e.message
+
+        result = false
+        error_message = e.message
+      end
+
+      return [result, error_message]
+    end
+
+    # This is the method you can use to display store hours.
+    def to_text
+      text = ''
+      @hours.each do |days_table|
+        days = days_table.keys.first  #days is the day range, for example, (1..5)
+        if block_given?
+          text += yield NUM_TO_WEEKDAY[days.first], NUM_TO_WEEKDAY[days.last], days_table[days]
+        else
+          text += NUM_TO_WEEKDAY[days.first].to_s
+          text += "-" + NUM_TO_WEEKDAY[days.last].to_s if days.first != days.last
+          text += ": "
+
+          days_table[days].each_with_index do |minutes, index|
+            text += ', ' if index > 0
+            if minutes.first == -1  #closed days
+              text += "closed"
+            elsif
+              text += ::StoreHours::from_minutes_to_time_str(minutes.first) + " - " + ::StoreHours::from_minutes_to_time_str(minutes.last)
+            end
+          end
+          text += "\n"
+        end
+      end
+
+      text.strip
+    end
+
+    def is_open?(t)
+      @hours.each do |days_table|
+        # days_table in the format of range(wday..wday) => [range(minutes..minutes),...]
+        # only one key in the hash table
+        days = days_table.keys.first
+        if days.include?(t.wday == 0 ? 7 : t.wday)
+          days_table[days].each do |min_range|
+            minutes = t.hour * 60 + t.min
+
+            if min_range.include?(minutes)
+              return true
+            end
+          end
+        end
+      end
+
+      return false
+    end
+
+
+  end
+
+
+
+end

data/lib/store_hours/common_methods.rb

@@ -0,0 +1,33 @@
+module StoreHours
+
+  # Convert a time point in a day to the number of minutes passed since midnight.
+  # @param hour [Fixnum] the hour component of time (not in military format)
+  # @param minutes [Fixnum] the minutes component of time
+  # @param am_or_pm [Symbol, :am or :pm]  morning or afternoon
+  # @return [Fixnum] the number of minutes passed since midnight
+  #
+  def self.convert_time_input_to_minutes(hour, minutes, am_or_pm)
+    hour += 12 if am_or_pm == :pm and hour < 12
+    hour = 0 if am_or_pm == :am and hour == 12
+
+    hour * 60 + minutes
+  end
+
+  # This is the reverse function of convert_time_input_to_minutes(hour, minutes,
+  # am_or_pm).
+  #
+  # This function coverts the number of minutes passed since midnight to a
+  # standard time string like 10:00AM.
+  # @param t [Fixnum] the number of minutes passed since midnight
+  # @return [String] the standard time string
+  #
+  def self.from_minutes_to_time_str(t)
+    hour_part = t / 60
+    minute_part = t % 60
+
+    am_or_pm = (hour_part >= 12 ? 'PM' : 'AM')
+    hour_part = hour_part - 12 if hour_part >= 13
+
+    "#{ hour_part }:#{ format('%02d', minute_part) }#{ am_or_pm }"
+  end
+end

data/lib/store_hours/constants.rb

@@ -0,0 +1,6 @@
+module StoreHours
+
+  WEEKDAY_TO_NUM = { :mon => 1, :tue => 2, :wed => 3, :thu => 4, :fri => 5, :sat => 6, :sun => 7}
+
+  NUM_TO_WEEKDAY = { 1=> :Mon, 2 => :Tue, 3 => :Wed, 4 => :Thu, 5 => :Fri, 6 => :Sat, 7 => :Sun }
+end

data/lib/store_hours/semantic_error.rb

@@ -0,0 +1,12 @@
+module StoreHours
+  # When parslet apply the TreeTransformer to the intermediary tree generated by parser,
+  # it may raise this exception if the input is valid syntax-wise but contains errors.
+  #
+  # Possible scenarios to cause this exception are defined in tree_transformer.rb.
+  #
+  class SemanticError < StandardError
+    def initialize(message)
+      super(message)
+    end
+  end
+end

data/lib/store_hours/text_input_parser.rb

@@ -0,0 +1,54 @@
+require 'parslet'
+
+module StoreHours
+  # Parser definition for store hours.
+  #
+  # A valid input includes one or more entries of durations separated by one or more white spaces.
+  #
+  # This parser will only takes lower cases.  However,
+  #
+  # Each entry has two parts: (1)week day or week days, and (2) one or more time periods when the
+  # store is open, or closed for the days the store closes.
+  #
+  # Examples of valid entries:
+  #   mon: 10:00am - 5:00pm
+  #   mon: 8:00am-12:00pm, 1pm-5pm   #time periods can be separated by comma(,) or space
+  #   mon: 8:00am-12:00pm 1pm-5pm
+  #   mon-fri : 10am-5pm
+  #   sat - sun: closed
+  #   sun : closed
+  #
+  # Examples of invalid entries:
+  #   mon  10am - 5pm           # colon(:) after week day(s) is required
+  #   mon fri: 10am - 5pm       # dash(-) between two days is required
+  #   mon-fri: 10:am - 5pm      # minute component for time is required when the colon(:) is present
+  #   mon-fri: 10 am - 5 pm     # no space is allowed between time digits and am/pm
+  #   mon : 10am - 17           # standard time format (with am or pm) is required
+  #   sat-sun: 10am-1pm closed  # closed can only be used with other time periods
+  #
+  class TextInputParser < Parslet::Parser
+    rule(:space)    { match('\s').repeat }
+    rule(:sep)      { str('-') }
+    rule(:colon)    { str(':') }
+    rule(:comma)    { str(',') }
+    rule(:ampm)     { str('am') | str('pm') }
+    rule(:closed)   { str('closed') }
+
+    rule(:day)      { (str('mon') | str('tue') | str('wed') | str('thu') | str('fri') | str('sat') | str('sun')).as(:day) }
+
+    rule(:range)    { day.as(:day_from) >> space >> sep >> space >> day.as(:day_to) }
+
+    rule(:left)     { range.as(:day_range) | day.as(:day_single) }
+
+    rule(:minutes)  { colon >> match('[0-9]').repeat(1,2).as(:minute) }
+    rule(:time)     { match('[0-9]').repeat(1,2).as(:hour) >> minutes.maybe >> ampm.as(:ampm) }
+    rule(:trange)   { time.as(:time_from) >> space >> sep >> space >> time.as(:time_to) >> space >> comma.maybe >> space }
+    rule(:right)    { trange.repeat(1).as(:time_range) | (closed.as(:closed) >> space) }
+
+    rule(:line)     { left.as(:line_left) >> space >> colon >> space >> right.as(:line_right) }
+
+    rule(:lines)    { line.repeat(1).as(:lines) }
+
+    root(:lines)
+  end
+end

data/lib/store_hours/tree_transformer.rb

@@ -0,0 +1,118 @@
+require 'parslet'
+
+require 'store_hours/constants'
+require 'store_hours/semantic_error'
+require 'store_hours/common_methods'
+
+module StoreHours
+  # Convert the intermediary tree resulted from parser to the internal data structure in the format of
+  #   [{d1..d2 => [(m1..m2), (m3..m4)]},{d3..d3 => [(m5..m6)]}]
+  # where
+  #   d is the integer value of week day (i.e, Mon = 1, Tue = 2, ..., Sun = 7),
+  #   m is the number of minutes passed from midnight (12AM).
+  #
+  # For example, "Mon-Fri: 1AM-2AM, 10AM-5PM Sat-Sun: closed" will be converted to
+  #   [{1..5 => [(60..120), (600..1020)]}, {6..7 => [(-1..-1)]}].
+  #
+  # Use the list of single entry hash tables instead of one hash table to preserve order of inputs.
+  #
+  class TreeTransformer < Parslet::Transform
+    rule(:hour => simple(:h), :ampm => simple(:ap)) { |dict|
+      ::StoreHours::convert_time_input_to_minutes(dict[:h].to_i, 0, dict[:ap].to_sym)
+    }
+    rule(:hour => simple(:h), :minute => simple(:m), :ampm => simple(:ap))  { |dict|
+      ::StoreHours::convert_time_input_to_minutes(dict[:h].to_i, dict[:m].to_i, dict[:ap].to_sym)
+    }
+    rule(:closed => simple(:x)) { x.to_sym }
+    rule(:time_from => simple(:f), :time_to => simple(:t)) { |dict| check_starting_time_not_later_than_ending_time(dict[:f], dict[:t]) }
+    rule(:time_range => sequence(:x)) { |dict| check_no_overlap_within_time_periods_for_single_day_range(dict[:x]) }
+    rule(:day => simple(:x)) { WEEKDAY_TO_NUM[x.to_sym]}
+    rule(:day_single => simple(:x)) { x..x }
+    rule(:day_range => {:day_from => simple(:f), :day_to => simple(:t)}) { |dict| check_starting_day_not_later_than_ending_day(dict[:f], dict[:t]) }
+    rule(:line_left => simple(:d), :line_right => sequence(:t))  { { d => t} }
+    rule(:line_left => simple(:d), :line_right => simple(:c)) { {d => [-1..-1]} }  #for "closed" days
+    rule(:lines => subtree(:x)) { |dict| check_no_overlap_within_day_ranges(dict[:x]) }
+
+    private
+    # Make sure the starting time is not later than the ending time.
+    # @param starting_time [Fixnum] starting time in minutes passed since midnight
+    # @param ending_time [Fixnum] ending time in minutes
+    # @return [Range, (starting_time..ending_time)] if it is valid
+    #
+    # Will raise SemanticError if it is invalid.
+    #
+    def self.check_starting_time_not_later_than_ending_time(starting_time, ending_time)
+      if starting_time > ending_time
+        raise ::StoreHours::SemanticError.new "incorrect time period specified: ending time has to be later"
+      end
+      starting_time..ending_time
+    end
+
+    # Check to make sure the day range is valid. The integer values of week days are defined in constants.rb.
+    # @param starting_day [Fixnum] starting day of the range, mon=1, ..., sun=7
+    # @param ending_day [Fixnum] ending day of the range
+    # @return [Range, (starting_day..ending_day)]
+    #
+    # Will raise SemanticError if starting_day is later than ending_day.
+    #
+    def self.check_starting_day_not_later_than_ending_day(starting_day, ending_day)
+      if starting_day > ending_day
+        raise ::StoreHours::SemanticError.new "incorrect day range specified: ending day has to be later"
+      end
+      starting_day..ending_day
+    end
+
+    # For a give day or day range, check to make sure there are no overlap within time periods
+    # @param periods [Array of Range] time periods for a single day range, i.e., [(60, 120), (540, 1020)]
+    # @return [Array of Range] the same as argument periods
+    #
+    # Will raise SemanticError if there is overlap.
+    #
+    def self.check_no_overlap_within_time_periods_for_single_day_range(periods)
+      if self.ranges_overlap?(periods)
+        raise ::StoreHours::SemanticError.new "incorrect time range specified: overlap for a single day range"
+      end
+
+      periods
+    end
+
+    # For the overall tree, check to make sure that a day integer can only appear once.
+    # @param tree [Array of Hashtable] the already transformed internal data presentation.
+    # @return [Array of Hashtable] the tree passed in will be untouched
+    #
+    # Will raise SemanticError if there is overlap
+    #
+    def self.check_no_overlap_within_day_ranges(tree)
+      # make an array of hashtable keys
+      ranges = []
+      tree.each do |table|
+        ranges << table.keys.first
+      end
+
+      if self.ranges_overlap?(ranges)
+        raise ::StoreHours::SemanticError.new "incorrect day range specified: at last one day appear more than once"
+      end
+
+      tree
+    end
+
+    # Check whether two or more ranges contain overlaps.
+    # @param periods [Array of Range] list of ranges to be checked against
+    # @return [Boolean] return true if ranges overlap
+    #
+    def self.ranges_overlap?(periods)
+      # sort the ranges by range's first item
+      sorted_periods = periods.sort {|x, y| x.first <=> y.first }
+
+      # starts from the second item
+      last_index = periods.length - 1
+      for i in 1..last_index
+        if sorted_periods[i].first <= sorted_periods[i-1].last
+          return true
+        end
+      end
+
+      return false
+    end
+  end
+end

data/lib/store_hours/version.rb

@@ -0,0 +1,3 @@
+module StoreHours
+  VERSION = "0.0.2"
+end

data/store_hours.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'store_hours/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "store_hours"
+  gem.version       = StoreHours::VERSION
+  gem.authors       = ["Yanhao Zhu"]
+  gem.email         = ["yanhaozhu@gmail.com"]
+  gem.description   = 'A small parser for store normal business hours'
+  gem.summary       = 'A small parser for store normal business hours'
+  gem.homepage      = "https://github.com/luanzhu/store_hours"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'parslet', '~> 1.5.0'
+end

data/test/store_hours_test.rb

@@ -0,0 +1,161 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'store_hours'
+
+
+describe StoreHours::StoreHours do
+  before { @h = StoreHours::StoreHours.new }
+
+  it "should return empty string for to_text() without loading from text" do
+    @h.to_text.must_equal ''
+  end
+
+  it "should parse store hours text and format text" do
+    text = "Mon     -    Thu  : 9:00AM    -        5:00PM, 6PM-9PM        Fri: 9AM - 10PM
+            Sun: closed"
+    r, msg = @h.from_text(text)
+
+    r.must_equal true
+    @h.to_text.must_equal "Mon-Thu: 9:00AM - 5:00PM, 6:00PM - 9:00PM\nFri: 9:00AM - 10:00PM\nSun: closed"
+  end
+
+  it "should return true for valid text" do
+    texts = ["mon: 10:00am - 5:00pm", "mon-fri : 10am-5pm sat - sun: closed", "sun : closed Sat: 10am - 3:30pm 5pm-11pm"]
+
+    texts.each do |t|
+      r, msg = @h.from_text(t)
+
+      r.must_equal true
+    end
+  end
+
+  it "should return false for invalid text" do
+    texts = ["M-T 9:00am-5pm", "mon  10am - 5pm", "mon-fri: 10:am - 5pm", "mon-fri: 10 am - 5 pm",  "mon : 10am - 17",
+             "sat-sun: 10am-1pm closed", "sat-sun:  closed  10am-1pm", "mon fri: 10am - 5pm"
+    ]
+
+    texts.each do |t|
+      @h.from_text(t)[0].must_equal false
+    end
+  end
+
+  it "should check whether the store is open for a time object" do
+    text = "Mon-Fri: 8AM - 12PM, 1pm-5pm\nSat-Sun: closed"
+
+    r, msg = @h.from_text(text)
+
+    r.must_equal true
+
+    t = Time.new(2013, 2, 24, 11, 0) #2013 Feb 24, 11:00AM, Sunday
+    @h.is_open?(t).must_equal false
+
+    t = Time.new(2013, 2, 23, 17, 0) #2013 Feb 23, 5:00PM, Saturday
+    @h.is_open?(t).must_equal false
+
+    t = Time.new(2013, 2, 21, 8, 0) #2013 Feb 21, 8:00AM Thursday
+    @h.is_open?(t).must_equal true
+
+    t = Time.new(2013, 2, 20, 16, 59) #2013 Feb 20, 4:59PM Wednesday
+    @h.is_open?(t).must_equal true
+
+    t = Time.new(2013, 2, 20, 17, 1) #2013 Feb 20, 5:01PM Wednesday
+    @h.is_open?(t).must_equal false
+
+    t = Time.new(2013, 2, 19, 7, 59) #2013 Feb 19, 7:59AM Tuesday
+    @h.is_open?(t).must_equal false
+
+    t = Time.new(2013, 2, 18, 12, 30) #2013 Feb 18, 12:30PM Monday
+    @h.is_open?(t).must_equal false
+  end
+
+  it "should work with stores what open after the midnight" do
+    text = "Mon-Sun: 12:30AM-10PM"
+
+    r, msg = @h.from_text(text)
+
+    r.must_equal true
+
+    t = Time.new(2013, 2, 24, 0, 0) #2013 Feb 24 12:00AM
+    @h.is_open?(t).must_equal false
+    t = Time.new(2013, 2, 24, 0, 15) # 2013 Feb 24, 12:15AM
+    @h.is_open?(t).must_equal false
+    t = Time.new(2013, 2, 24, 0, 30) #2013 Feb 24, 12:30AM
+    @h.is_open?(t).must_equal true
+    t = Time.new(2013, 2, 24, 22, 0) #2013 Feb 24, 10:00PM
+    @h.is_open?(t).must_equal true
+    t = Time.new(2013, 2, 24, 22, 1) #2013 Feb 24, 10:01PM
+    @h.is_open?(t).must_equal false
+  end
+
+  it "should return false for invalid time periods" do
+    texts = ["Mon-Fri: 9pm - 5am", "Sat: 5:30pm - 1:00pm"]
+
+    texts.each do |t|
+      r, msg = @h.from_text(t)
+
+      r.must_equal false
+    end
+  end
+
+  it "should return false for invalid day periods" do
+    texts = ["Fri-Mon: 10:00pm - 11pm", "sun-mon: 1am-3pm"]
+    texts.each do |t|
+      r, msg = @h.from_text(t)
+      r.must_equal false
+    end
+  end
+
+  it "should return false for overlap in time periods for a single day range" do
+    texts = ["mon-fri: 10am-5pm 4pm-10pm", "mon: 10am-5pm 5pm-9pm"]
+    texts.each do |t|
+      r, msg = @h.from_text(t)
+      r.must_equal false
+    end
+  end
+
+  it "should return false for overlap in the day ranges" do
+    texts = ["mon-fri: 10am-5pm, mon: 6pm-10pm", "mon-fri: 10am-5pm wed:6pm-10pm", "mon-fri: 9am-9pm fri:10pm-11pm"]
+
+    texts.each do |t|
+      r, msg = @h.from_text(t)
+
+      r.must_equal false
+    end
+  end
+
+  it "should take a block to customize to_text format" do
+    text = "mon-fri: 10am-6pm, 7pm-10pm sat: 1pm-5pm sun: closed"
+
+    r, msg = @h.from_text(text)
+    r.must_equal true
+
+    formatted_text = @h.to_text do |d1, d2, list_of_durations|
+      s = '<tr>'
+
+      s += "<td>#{d1.to_s}"
+      if d2 != d1
+        s += " - #{d2.to_s}"
+      end
+      s += ":"
+      s += "</td>"
+
+      s += "<td>"
+      list_of_durations.each_with_index do |r, index|
+        if index > 0
+          s += " "
+        end
+        s += StoreHours::from_minutes_to_time_str(r.first)
+        s += "-"
+        s += StoreHours::from_minutes_to_time_str(r.last)
+      end
+      s += "</td>"
+
+      s += "</tr>"
+    end
+
+    formatted_text.must_equal "<tr><td>Mon - Fri:</td><td>10:00AM-6:00PM 7:00PM-10:00PM</td></tr><tr><td>Sat:</td><td>1:00PM-5:00PM</td></tr><tr><td>Sun:</td><td>-1:59AM--1:59AM</td></tr>"
+
+  end
+
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: store_hours
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Yanhao Zhu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+description: A small parser for store normal business hours
+email:
+- yanhaozhu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/store_hours.rb
+- lib/store_hours/common_methods.rb
+- lib/store_hours/constants.rb
+- lib/store_hours/semantic_error.rb
+- lib/store_hours/text_input_parser.rb
+- lib/store_hours/tree_transformer.rb
+- lib/store_hours/version.rb
+- store_hours.gemspec
+- test/store_hours_test.rb
+homepage: https://github.com/luanzhu/store_hours
+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: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A small parser for store normal business hours
+test_files:
+- test/store_hours_test.rb