words_counted 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 07c1e76ee27525e7aa28de6a61dedde8ba6eae39
-  data.tar.gz: e8062169aaf99c19947a246ff33385e1fca928a7
+  metadata.gz: 0992a863d31573f13f2994d914701c22573edb2e
+  data.tar.gz: 83b5b5ca60aa6663321be5a24a791f829f9a0c23
 SHA512:
-  metadata.gz: 680cc6c8048a809941f4e23c53c99a2ee7fed5e3d0fe7943d9842b29967c7d19f8430143d56ed510042a493e166c99c4ae70c9b82e4b21fb4aeb3dbe9280f52e
-  data.tar.gz: ec317b1d90f3f14ba399996c8061835393d4aac6dd55f8ebc342b95a315c710bd62d3c9981e37cff6397863b8b5e10744748b1cede99e610dbf5cdd59aafcb90
+  metadata.gz: a1363df462e354e03a825db08fb2eebb877fd656a817061ea1eb3777fc95710a8276fb6dd109f720e8826b2f64acbe1bd855190cab5961914a7f59aed534e7f5
+  data.tar.gz: 8f238c41e476c485721da16e207cdc739ccdefb44c8fdb26693976eece3fcafceefd0ffcd11af744383248d4266009d08754e92af93d40866bd267f7ef40d52d

data/README.md

@@ -1,10 +1,14 @@
-# Words Counted
+# WordsCounted
 
-Words Counted is a highly customisable Ruby string analyser. It includes many handy utility methods that go beyond word counting. You can use this gem to get word density, words and the number of times they occur, the highest occurring words, and few more things.
+WordsCounted is a highly customisable Ruby string analyser. It includes many handy utility methods that go beyond word counting. You can use this gem to get word density, words and the number of times they occur, the highest occurring words, and few more things.
 
 I use *word* loosely since you can pass the program any string you want: words, numbers, characters, etc...
 
-Pass your own regular expression to customise the criteria for splitting strings. This makes Words Counted very flexible, whether you want to count words, numbers, or special characters.
+Pass your own regular expression to customise the criteria for splitting strings. This makes WordsCounted very flexible, whether you want to count words, numbers, or special characters.
+
+### Demo
+
+Visit [the gem's website][4] for a demo.
 
 ### Features
 
@@ -22,7 +26,7 @@ Pass your own regular expression to customise the criteria for splitting strings
 * Customisable criteria. Pass your own regexp rules to split strings if you prefer. The default regexp has two features:
   * Filters special characters but respects hyphens and apostrophes.
   * Plays nicely with diacritics (UTF and unicode characters): "São Paulo" is treated as `["São", "Paulo"]` and not `["S", "", "o", "Paulo"]`.
-* Pass in a file path or a url instead of a string. Words Counted opens and reads files.
+* Pass in a file path or a url instead of a string. WordsCounted opens and reads files.
 
 See usage instructions for details on each feature.
 
@@ -40,7 +44,7 @@ Or install it yourself as:
 
     $ gem install words_counted
 
-## Usage
+## Quick usage
 
 Pass in a string or a file path, and an optional filter and/or regexp.
 
@@ -53,7 +57,31 @@ counter = WordsCounted.count(
 counter = WordsCounted.from_file("path/or/url/to/my/file.txt")
 ```
 
-### API
+## API
+
+### Class methods
+
+#### `count(string, options = {})`
+
+Initializes an analyser object.
+
+```ruby
+counter = WordsCounted.count("Hello Beirut!")
+````
+
+Accepts two options: `exclude` and `regexp`. See [Excluding words from the analyser][5] and [Passing in a custom regexp][6] respectively.
+
+#### from_file(path, options = {})
+
+Initializes an analyser object from a file path.
+
+```ruby
+counter = WordsCounted.count("Hello Beirut!")
+````
+
+Accepts the same options as `count()`.
+
+### Instance methods
 
 #### `.word_count`
 
@@ -74,22 +102,14 @@ counter.word_occurrences
   "we"      => 1,
   "are"     => 2,
   "all"     => 1,
-  "in"      => 1,
-  "the"     => 2,
-  "gutter"  => 1,
-  "but"     => 1,
-  "some"    => 1,
-  "of"      => 1,
-  "us"      => 1,
-  "looking" => 1,
-  "at"      => 1,
+  # ...
   "stars"   => 1
 }
 ```
 
 #### `.sorted_word_occurrences`
 
-Returns a two dimentional array of words and their number of occurrences sorted in descending order. Uppercase and lowercase words are counted as the same word.
+Returns a two dimensional array of words and their number of occurrences sorted in descending order. Uppercase and lowercase words are counted as the same word.
 
 ```ruby
 counter.sorted_word_occurrences
@@ -124,22 +144,14 @@ counter.word_lengths
   "We"      => 2,
   "are"     => 3,
   "all"     => 3,
-  "in"      => 2,
-  "the"     => 3,
-  "gutter"  => 6,
-  "but"     => 3,
-  "some"    => 4,
-  "of"      => 2,
-  "us"      => 2,
-  "looking" => 7,
-  "at"      => 2,
+  # ...
   "stars"   => 5
 }
 ```
 
 #### `.sorted_word_lengths`
 
-Returns a two dimentional array of words and their lengths sorted in descending order.
+Returns a two dimensional array of words and their lengths sorted in descending order.
 
 ```ruby
 counter.sorted_word_lengths
@@ -174,7 +186,7 @@ counter.words
 
 #### `.word_density([ precision = 2 ])`
 
-Returns a two-dimentional array of words and their density to a precision of two. It accepts a precision argument which defaults to two.
+Returns a two-dimensional array of words and their density to a precision of two. It accepts a precision argument which defaults to two.
 
 ```ruby
 counter.word_density
@@ -183,15 +195,7 @@ counter.word_density
   ["are",     13.33],
   ["the",     13.33],
   ["but",     6.67 ],
-  ["us",      6.67 ],
-  ["of",      6.67 ],
-  ["some",    6.67 ],
-  ["looking", 6.67 ],
-  ["gutter",  6.67 ],
-  ["at",      6.67 ],
-  ["in",      6.67 ],
-  ["all",     6.67 ],
-  ["stars",   6.67 ],
+  # ...
   ["we",      6.67 ]
 ]
 ```
@@ -214,12 +218,20 @@ counter.average_chars_per_word  #=> 4
 
 #### `.unique_word_count`
 
-Returns the count of unique words in the string.
+Returns the count of unique words in the string. This is case insensitive.
 
 ```ruby
 counter.unique_word_count       #=> 13
 ```
 
+#### `.count(word)`
+
+Counts the occurrence of a word in the string.
+
+```ruby
+counter.count("are")            #=> 2
+```
+
 ## Excluding words from the analyser
 
 You can exclude anything you want from the string you want to analyse by passing in the `exclude` option. The exclude option accepts a variety of filters.
@@ -310,17 +322,21 @@ In this example `-you` and `you` are counted as separate words. Writers should u
 
 Another gotcha is that the default criteria does not include numbers in its analysis. Remember that you can pass your own regular expression if the default behaviour does not fit your needs.
 
+### A note on case sensitivity
+
+The program will downcase all incoming strings for consistency.
+
 ## Road Map
 
 1. Add ability to open URLs.
 2. Add paragraph, sentence, average words per sentence, and average sentence chars counters.
 
-#### Ability to open URLs
+#### Ability to read URLs
 
 Something like...
 
 ```ruby
-def self.count_from_url
+def self.from_url
   # open url and send string here after removing html
 end
 ```
@@ -335,7 +351,7 @@ end
 
 Originally I wrote this program for a code challenge on Treehouse. You can find the original implementation on [Code Review][1].
 
-## Contributers
+## Contributors
 
 Thanks to Dave Yarwood for helping me improve my code. Some of my code is based on his recommendations. You can find the original program implementation, as well as Dave's code review, on [Code Review][1].
 
@@ -353,3 +369,6 @@ Thanks to [Wayne Conrad][2] for providing [an excellent code review][3], and imp
   [1]: http://codereview.stackexchange.com/questions/46105/a-ruby-string-analyser
   [2]: https://github.com/wconrad
   [3]: http://codereview.stackexchange.com/a/49476/1563
+  [4]: http://rubywordcount.com
+  [5]: https://github.com/abitdodgy/words_counted#excluding-words-from-the-analyser
+  [6]: https://github.com/abitdodgy/words_counted#passing-in-a-custom-regexp

data/lib/words_counted/counter.rb

@@ -13,9 +13,9 @@ module WordsCounted
     def initialize(string, options = {})
       @options = options
       exclude = filter_proc(options[:exclude])
-      @words = string.scan(regexp).reject { |word| exclude.call(word) }
-      @char_count = @words.join.size
-      @word_occurrences = words.each_with_object(Hash.new(0)) { |word, hash| hash[word.downcase] += 1 }
+      @words = string.scan(regexp).map(&:downcase).reject { |word| exclude.call(word) }
+      @char_count = words.join.size
+      @word_occurrences = words.each_with_object(Hash.new(0)) { |word, hash| hash[word] += 1 }
       @word_lengths = words.each_with_object({}) { |word, hash| hash[word] ||= word.length }
     end
 
@@ -54,6 +54,10 @@ module WordsCounted
       sort_by_descending_value word_lengths
     end
 
+    def count(match)
+      words.select { |word| word == match.downcase }.size
+    end
+
   private
 
     def highest_ranking(entries)
@@ -77,14 +81,14 @@ module WordsCounted
       elsif filter.respond_to?(:to_str)
         exclusion_list = filter.split.collect(&:downcase)
         ->(word) {
-          exclusion_list.include?(word.downcase)
+          exclusion_list.include?(word)
         }
       elsif regexp_filter = Regexp.try_convert(filter)
         Proc.new { |word| word =~ regexp_filter }
       elsif filter.respond_to?(:to_proc)
         filter.to_proc
       else
-        raise ArgumentError, "Filter must String, Array, Lambda, or Regexp"
+        raise ArgumentError, "Filter must String, Array, Lambda, or a Regexp"
       end
     end
   end

data/lib/words_counted/version.rb

@@ -1,3 +1,3 @@
 module WordsCounted
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/spec/words_counted/counter_spec.rb

@@ -33,62 +33,62 @@ module WordsCounted
       end
 
       it "splits words" do
-        expect(counter.words).to eq(%w[We are all in the gutter but some of us are looking at the stars])
+        expect(counter.words).to eq(%w[we are all in the gutter but some of us are looking at the stars])
       end
 
       it "removes special characters" do
         counter = Counter.new("Hello! # $ % 12345 * & % How do you do?")
-        expect(counter.words).to eq(%w[Hello How do you do])
+        expect(counter.words).to eq(%w[hello how do you do])
       end
 
       it "counts hyphenated words as one" do
         counter = Counter.new("I am twenty-two.")
-        expect(counter.words).to eq(%w[I am twenty-two])
+        expect(counter.words).to eq(%w[i am twenty-two])
       end
 
       it "does not split words on apostrophe" do
         counter = Counter.new("Bust 'em! Them be Jim's bastards'.")
-        expect(counter.words).to eq(%w[Bust 'em Them be Jim's bastards'])
+        expect(counter.words).to eq(%w[bust 'em them be jim's bastards'])
       end
 
       it "does not split on unicode chars" do
         counter = Counter.new("São Paulo")
-        expect(counter.words).to eq(%w[São Paulo])
+        expect(counter.words).to eq(%w[são paulo])
       end
 
       it "it accepts a string filter" do
         counter = Counter.new("That was magnificent, Trevor.", exclude: "magnificent")
-        expect(counter.words).to eq(%w[That was Trevor])
+        expect(counter.words).to eq(%w[that was trevor])
       end
 
       it "it accepts a string filter with multiple words" do
         counter = Counter.new("That was magnificent, Trevor.", exclude: "was magnificent")
-        expect(counter.words).to eq(%w[That Trevor])
+        expect(counter.words).to eq(%w[that trevor])
       end
 
       it "filters words in uppercase when using a string filter" do
         counter = Counter.new("That was magnificent, Trevor.", exclude: "Magnificent")
-        expect(counter.words).to eq(%w[That was Trevor])
+        expect(counter.words).to eq(%w[that was trevor])
       end
 
       it "accepts a regexp filter" do
         counter = Counter.new("That was magnificent, Trevor.", exclude: /magnificent/i)
-        expect(counter.words).to eq(%w[That was Trevor])
+        expect(counter.words).to eq(%w[that was trevor])
       end
 
       it "accepts an array filter" do
         counter = Counter.new("That was magnificent, Trevor.", exclude: ['That', 'was'])
-        expect(counter.words).to eq(%w[magnificent Trevor])
+        expect(counter.words).to eq(%w[magnificent trevor])
       end
 
       it "accepts a lambda filter" do
-        counter = Counter.new("That was magnificent, Trevor.", exclude: ->(w) {w == 'That'})
-        expect(counter.words).to eq(%w[was magnificent Trevor])
+        counter = Counter.new("That was magnificent, Trevor.", exclude: ->(w) { w == 'that' })
+        expect(counter.words).to eq(%w[was magnificent trevor])
       end
 
       it "accepts a custom regexp" do
         counter = Counter.new("I am 007.", regexp: /[\p{Alnum}\-']+/)
-        expect(counter.words).to eq(["I", "am", "007"])
+        expect(counter.words).to eq(["i", "am", "007"])
       end
 
       it "char_count should be calculated after the filter is applied" do
@@ -143,7 +143,7 @@ module WordsCounted
 
       it "returns a hash of word lengths" do
         counter = Counter.new("One two three.")
-        expect(counter.word_lengths).to eq({ "One" => 3, "two" => 3, "three" => 5 })
+        expect(counter.word_lengths).to eq({ "one" => 3, "two" => 3, "three" => 5 })
       end
     end
 
@@ -154,7 +154,7 @@ module WordsCounted
 
       it "returns a two dimensional array sorted by descending word length" do
         counter = Counter.new("I am not certain of that")
-        expect(counter.sorted_word_lengths).to eq([ ["certain", 7], ["that", 4], ["not", 3], ["of", 2], ["am", 2], ["I", 1] ])
+        expect(counter.sorted_word_lengths).to eq([ ["certain", 7], ["that", 4], ["not", 3], ["of", 2], ["am", 2], ["i", 1] ])
       end
     end
 
@@ -165,7 +165,7 @@ module WordsCounted
 
       it "returns the longest words" do
         counter = Counter.new("Those whom the gods love grow young.")
-        expect(counter.longest_words).to eq([["Those", 5],["young", 5]])
+        expect(counter.longest_words).to eq([["those", 5],["young", 5]])
       end
     end
 
@@ -218,6 +218,18 @@ module WordsCounted
       it "returns the number of unique words" do
         expect(counter.unique_word_count).to eq(13)
       end
+
+      it "is case insensitive" do
+        counter = Counter.new("Up down. Down up.")
+        expect(counter.unique_word_count).to eq(2)
+      end
+    end
+  end
+
+  describe "count" do
+    it "returns count for a single word" do
+      counter = Counter.new("I am so clever that sometimes I don't understand a single word of what I am saying.")
+      expect(counter.count("i")).to eq(3)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: words_counted
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Mohamad El-Husseini
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-24 00:00:00.000000000 Z
+date: 2014-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler