webmat-mini_facet 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Mathieu Martin
+
+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.markdown

@@ -0,0 +1,26 @@
+MiniFacet
+=========
+
+This is a small library to add a few basic niceties to Ruby. It's not meant to 
+be all-encompassing and include tons of things like Ruby Facets, however.
+
+
+Example
+=======
+
+    require 'mini_facet'
+    # Will include everything
+    # Including piece by piece is coming, but is not yet done
+    
+    Right now, mini_facet only adds the following:
+    Hash#extract([])        #=> Hash
+    Hash#extract(&block)    #=> Hash
+    Hash#extract(proc)      #=> Hash
+    Hash#split(&block)      #=> Hash(block true), Hash(block false)
+    Hash#split(proc)        #=> Hash(proc true), Hash(proc false)
+    Array#count_distinct    #=> Hash with the count of each element, e.g. [:a, :a] => {:a => 2}
+    Array#includes_all?([]) #=> true/false
+    Array#include_all?      #Just replicating Ruby's typos ;-)
+
+
+Copyright (c) 2008 Mathieu Martin, released under the MIT license

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+
+require 'rake'
+
+HERE = File.dirname(__FILE__)
+windows = (RUBY_PLATFORM =~ /win32|cygwin/) rescue nil
+SUDO = windows ? "" : "sudo"
+
+require "#{HERE}/lib/mini_facet"
+Dir['tasks/**/*.rake'].each { |rake| load rake }
+
+desc 'Default: run all tests.'
+task :default => :test
+

data/lib/mini_facet.rb

@@ -0,0 +1,7 @@
+module MiniFacet
+  LIB_DIR = File.expand_path(File.dirname(__FILE__))
+end
+
+Dir["#{ MiniFacet::LIB_DIR }/mini_facet/*.rb"].each do |file|
+  require file
+end

data/lib/mini_facet/array.rb

@@ -0,0 +1,3 @@
+Dir["#{ File.dirname(__FILE__) }/array/*.rb"].each do |file|
+  require file
+end

data/lib/mini_facet/array/count_distinct.rb

@@ -0,0 +1,14 @@
+# Can be included in any class that responds to #each. 
+# Such as Array.
+module MiniFacet::CountDistinct
+  def count_distinct(purge_smaller_than=0)
+    h={}
+    self.each {|e|
+      h[e] ? h[e] += 1 : h[e] = 1
+    }
+    h.extract{|k,v| v >= purge_smaller_than}
+  end
+end
+
+Array.send :include, MiniFacet::CountDistinct
+

data/lib/mini_facet/array/includes_all.rb

@@ -0,0 +1,17 @@
+module MiniFacet::IncludesAll
+  def includes_all?(ary)
+    our_count   = self.count_distinct
+    their_count = ary.count_distinct
+    
+    their_count.each_pair do |k,v|
+      our_v = our_count[k]
+      return false if our_v.nil? || our_v < v
+    end
+    return true
+  end
+  
+  alias :include_all? :includes_all? #Replicating Ruby's typos
+end
+
+
+Array.send :include, MiniFacet::IncludesAll

data/lib/mini_facet/hash.rb

@@ -0,0 +1,3 @@
+Dir["#{ File.dirname(__FILE__) }/hash/*.rb"].each do |file|
+  require file
+end

data/lib/mini_facet/hash/extract.rb

@@ -0,0 +1,51 @@
+module MiniFacet::Extract
+  # Hash#extract([keys]) => Hash
+  # Hash#extract{|k,v| predicate } => Hash
+  # Hash#extract(proc) => Hash
+  # 
+  # Returns a new Hash that contains only the k,v pairs where the k was
+  # specified in the keys array.
+  # If any k in keys is not present in the original Hash, it's simply
+  # not the resulting Hash.
+  # 
+  # This is very useful to check that a Hash contains at least some desired keys
+  # or to get a sanitized Hash out of the one we currently have.
+  # 
+  # Examples:
+  #  h = {:bob=>'Marley',:mom=>'Barley'}
+  #  h.extract([:bob])            #=> {:bob=>'Marley'}
+  #  h.extract([:bob, :mom])      #=> {:bob=>'Marley',:mom=>'Barley'}
+  #  h.extract([:sos])            #=> {}
+  #
+  #  h.extract{|k,v| v =~ /Mar/}  #=>{:bob=>'Marley}
+  
+  def extract(*args, &block)
+    # Despide the *args, extract doesn't accept a splatted array.
+    # It's really either an array or some form of block/proc.
+    if block_given?
+      extract_block(&block)
+    elsif args[0].is_a? Proc
+      extract_block(&args[0])
+    elsif args[0].is_a? Array
+      extract_keys(args[0])
+    else
+      raise ArgumentError, "extract requires either an array of keys, a block or a proc"
+    end
+  end
+  
+  private
+    def extract_keys(keys)
+      extracted = self.class.new #Can therefore be included in any hash-like container
+      keys.each { |k| extracted[k] = self[k] if self.include?(k) }
+      extracted
+    end
+    
+    def extract_block(&block)
+      extracted = self.class.new
+      each_pair{ |k,v| extracted[k] = v if yield(k,v) }
+      extracted
+    end
+end
+
+
+Hash.send :include, MiniFacet::Extract

data/lib/mini_facet/hash/split.rb

@@ -0,0 +1,19 @@
+module MiniFacet::Split
+  # Returns two hashes. The first contains all pairs for which the block evaluated to true,
+  # the second contains all the others.
+  def split(&block)
+    trues, falses = self.class.new, self.class.new
+    each_pair do |k,v| 
+      if yield(k,v) 
+        trues[k] = v
+      else
+        falses[k] = v
+      end
+    end
+    #each_pair{ |k,v| (yield(k,v) ? trues : falses)[k] = v }
+    return trues, falses
+  end
+end
+
+
+Hash.send :include, MiniFacet::Split

data/lib/mini_facet/version.rb

@@ -0,0 +1,12 @@
+module MiniFacet
+  module VERSION
+    MAJOR    = 0
+    MINOR    = 0
+    TINY     = 1
+    
+    STRING   = [MAJOR, MINOR, TINY].join('.').freeze
+  end
+  
+  NAME          = 'mini_facet'.freeze
+  COMPLETE_NAME = "#{NAME} #{VERSION::STRING}".freeze  
+end

data/tasks/gem.rake

@@ -0,0 +1,67 @@
+require 'yaml'
+
+require 'rake/gempackagetask'
+
+task :clean => :clobber_package
+
+spec = Gem::Specification.new do |s|
+  s.name                  = MiniFacet::NAME
+  s.version               = MiniFacet::VERSION::STRING
+  s.summary               = "Adding a few basic, useful things to Ruby."
+  s.description           = "Adding a few basic, useful things to Ruby."
+
+  s.authors               = ['Mathieu Martin']
+  s.email                 = "webmat@gmail.com"
+  s.homepage              = "http://github.com/webmat/mini_facet"
+  s.rubyforge_project     = 'mini_facet'
+
+  s.has_rdoc              = true
+  
+  s.test_files            = Dir['test/**/*'].reject{|f| f =~ /test\/my_test_helper.rb/}
+  s.files                 = Dir['**/*'].reject{|f| f =~ /\Apkg|\Acoverage|\.gemspec\Z|test\/my_test_helper.rb/}
+  
+  s.require_path          = "lib"
+end
+
+#Creates clobber_package, gem, package and repackage tasks
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+TAG_COMMAND = "git tag -m 'Tagging version #{MiniFacet::VERSION::STRING}' -a v#{MiniFacet::VERSION::STRING}"
+task :tag_warn do
+  puts  "*" * 40,
+        "Don't forget to tag the release:",
+        '',
+        "  " + TAG_COMMAND,
+        '',
+        "or run rake tag",
+        "*" * 40
+end
+task :tag do
+  sh TAG_COMMAND
+end
+task :gem => :tag_warn
+
+namespace :gem do
+  desc "Update the gemspec for GitHub's gem server"
+  task :github do
+    File.open("#{MiniFacet::NAME}.gemspec", 'w'){|f| f.puts YAML::dump(spec) }
+    puts "gemspec generated here: #{MiniFacet::NAME}.gemspec"
+  end
+  
+  desc 'Upload gem to rubyforge.org'
+  task :rubyforge => :gem do
+    sh 'rubyforge login'
+    sh "rubyforge add_release mini_facet mini_facet '#{MiniFacet::VERSION::STRING}' pkg/#{spec.full_name}.gem"
+    sh "rubyforge add_file mini_facet mini_facet #{MiniFacet::VERSION::STRING} pkg/#{spec.full_name}.gem"
+  end
+end
+
+task :install => [:clean, :gem] do
+  sh "#{SUDO} gem install pkg/#{spec.full_name}.gem"
+end
+
+task :uninstall do
+  sh "#{SUDO} gem uninstall -v #{MiniFacet::VERSION::STRING} -x #{MiniFacet::NAME}"
+end

data/tasks/rdoc.rake

@@ -0,0 +1,10 @@
+require 'rake/rdoctask'
+
+desc 'Generate documentation for mini_facet.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'MiniFacet'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.markdown')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/tasks/test.rake

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+
+desc "Run all tests"
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+namespace :test do
+  # desc "Run integration tests"
+  # Rake::TestTask.new(:integration) do |t|
+  #   t.pattern = 'test/integration/**/*_test.rb'
+  #   t.verbose = true
+  # end
+
+  desc "Run unit tests"
+  Rake::TestTask.new(:unit) do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$TEST_DIR = File.expand_path(File.dirname(__FILE__))
+
+require "#{$TEST_DIR}/my_test_helper" if File.exists?("#{$TEST_DIR}/my_test_helper.rb")

data/test/unit/array/count_distinct_test.rb

@@ -0,0 +1,21 @@
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+class ArrayCountDistinctTest < Test::Unit::TestCase
+  context "Array#count_distinct" do
+    should "work with empty arrays" do
+      assert_equal({}, [].count_distinct)
+    end
+    
+    should "calculate the sums correctly" do
+      assert_equal({:key => 2, 'key2' => 1}, [:key, 'key2', :key].count_distinct)
+    end
+    
+    should "support and count nil elements" do
+      assert_equal({:key => 2, nil => 3}, [nil, :key, nil, nil, :key].count_distinct)
+    end
+    
+    should "filter out elements with a low count based on purge_smaller_than" do
+      assert_equal({:key => 2}, [:key, 'key', nil, :key].count_distinct(2))
+    end
+  end
+end

data/test/unit/array/includes_all_test.rb

@@ -0,0 +1,31 @@
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+class ArrayIncludesAllTest < Test::Unit::TestCase
+  def self.test_includes_all(options)
+    context "#{ options[:array].inspect }.includes_all?(#{ options[:includes_all?].inspect })" do
+      should "return #{options[:returns]}" do
+        assert_equal options[:returns], options[:array].includes_all?(options[:includes_all?])
+      end
+    end
+  end
+  
+  test_includes_all :array => [],             :includes_all? => [],           :returns => true    # Same as Ruby's Set
+  test_includes_all :array => [],             :includes_all? => [:a],         :returns => false
+                                              
+  test_includes_all :array => [:a],           :includes_all? => [],           :returns => true    # Same as Ruby's Set
+  test_includes_all :array => [:a],           :includes_all? => [:a],         :returns => true
+  test_includes_all :array => [:a],           :includes_all? => [:a, :a],     :returns => false
+  test_includes_all :array => [:a, :a],       :includes_all? => [:a],         :returns => true
+  test_includes_all :array => [:a, :a],       :includes_all? => [:a, :a],     :returns => true
+  
+  test_includes_all :array => [:a, :b],       :includes_all? => [:a],         :returns => true
+  test_includes_all :array => [:a, :b],       :includes_all? => [:a, :b],     :returns => true
+  test_includes_all :array => [:a, :b],       :includes_all? => [:b, :a],     :returns => true
+  
+  test_includes_all :array => [[:a], [:b]],   :includes_all? => [[:a]],       :returns => true
+  test_includes_all :array => [[:a], [:b]],   :includes_all? => [[:a], [:b]], :returns => true
+  
+  test_includes_all :array => [[:a], [:b]],   :includes_all? => [:a, :b],     :returns => false
+  test_includes_all :array => [[:a, :b]],     :includes_all? => [:a, :b],     :returns => false
+  test_includes_all :array => [:a, :b],       :includes_all? => [[:a, :b]],   :returns => false
+end

data/test/unit/hash/extract_test.rb

@@ -0,0 +1,77 @@
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+class HashExtractTest < Test::Unit::TestCase
+  def setup
+    super
+    @h = {
+      :bob => 'Marley',
+      :mom => 'Barley',
+      :gods => 'Harley',
+      :chris => 'Farley'
+    }
+  end
+  
+  context "extract" do
+    context "with a block" do
+      
+      should "return all elements for which the block evaluates to a true value" do
+        assert_equal( {:bob => 'Marley', :mom => 'Barley'}, @h.extract{ |k, v| v =~ /\A[M|B]/ })
+      end
+      
+      should "ignore the args and go with the block" do
+        assert_equal( {:bob => 'Marley', :mom => 'Barley'}, @h.extract([:gods]){ |k, v| v =~ /\A[M|B]/ })
+      end
+    end
+    
+    should "accept a proc as a normal parameter" do
+      proc = Proc.new { |k, v| v =~ /\A[M|B]/ }
+      assert_equal( {:bob => 'Marley', :mom => 'Barley'}, @h.extract(proc))
+    end
+    
+    should "accept a lambda as a normal parameter" do
+      l = lambda { |k, v| v =~ /\A[M|B]/ }
+      assert_equal( {:bob => 'Marley', :mom => 'Barley'}, @h.extract(l))
+    end
+  end
+  
+  def test_normal
+    assert_equal( {:bob => 'Marley'}, @h.extract([:bob]) )
+    assert_equal( {:mom => 'Barley', :bob => 'Marley'}, @h.extract([:bob, :mom]) )
+    
+    all_keys = @h.extract [:bob, :mom, :gods, :chris]
+    assert_not_equal( all_keys.object_id, @h.object_id )
+  end
+  
+  def test_normal_alternative
+    assert_equal( {:bob => 'Marley'}, @h.extract([:bob]) )
+    assert_equal( {:mom => 'Barley', :bob => 'Marley'}, @h.extract([:bob, :mom]) )
+    
+    all_extracted = @h.extract([:bob, :mom, :gods, :chris])
+    assert_not_equal( all_extracted.object_id, @h.object_id )
+  end
+  
+  def test_edge_case
+    assert_equal( {}, @h.extract([]) )
+    assert_equal( @h, @h.extract([:bob, :mom, :gods, :chris]) )
+  end
+  
+  def test_unknown_key
+    assert_equal( {}, @h.extract([:ahem]) )
+    assert_equal( {:bob => 'Marley'}, @h.extract([:bob, :ahem]) )
+    assert_equal( {}, @h.extract(['some other type of key']) )
+  end
+  
+  def test_keep_nil_value_in_hash
+    #Yes, h2 as in Hummer :-)
+    h2 = {:price => 'expensive', :sex_appeal => nil}
+    assert_equal( h2, h2.extract([:sex_appeal, :price]) )
+  end
+  
+  class CustomTestHash < Hash; end
+  def test_something_else_than_hash_is_extractable
+    m=CustomTestHash.new.merge({:a=>:b,:c=>:d})
+    n=m.extract([:a])
+    assert_kind_of CustomTestHash, n
+    assert_equal( CustomTestHash.new.merge({:a=>:b}), n )
+  end
+end

data/test/unit/hash/split_test.rb

@@ -0,0 +1,31 @@
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+class HashSplitTest < Test::Unit::TestCase
+  def setup
+    super
+    @h = {
+      :bob => 'Marley',
+      :mom => 'Barley',
+      :gods => 'Harley',
+      :chris => 'Farley'
+    }
+  end
+  
+  context "split" do
+    should "return two hashes" do
+      assert_kind_of Hash, (@h.split{|k,v| false})[0]
+      assert_kind_of Hash, (@h.split{|k,v| false})[1]
+    end
+    context "splits the values" do
+      setup do
+        @first, @second = @h.split{|k,v| k.to_s.length == 3}
+      end
+      should "putting all pairs evaluating to true in the first one" do
+        assert_equal( {:bob => 'Marley', :mom => 'Barley'}, @first)
+      end
+      should "putting all pairs evaluating to false in the second one" do
+        assert_equal( {:gods => 'Harley', :chris => 'Farley'}, @second)
+      end
+    end
+  end
+end

data/test/unit/test_helper.rb

@@ -0,0 +1,3 @@
+require "#{ File.dirname(__FILE__) }/../test_helper"
+
+require "#{$TEST_DIR}/../lib/mini_facet"

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: webmat-mini_facet
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mathieu Martin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-07 21:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Adding a few basic, useful things to Ruby.
+email: webmat@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib
+- lib/mini_facet
+- lib/mini_facet/array
+- lib/mini_facet/array/count_distinct.rb
+- lib/mini_facet/array/includes_all.rb
+- lib/mini_facet/array.rb
+- lib/mini_facet/enumerable
+- lib/mini_facet/hash
+- lib/mini_facet/hash/extract.rb
+- lib/mini_facet/hash/split.rb
+- lib/mini_facet/hash.rb
+- lib/mini_facet/object
+- lib/mini_facet/version.rb
+- lib/mini_facet.rb
+- MIT-LICENSE
+- Rakefile
+- rdoc
+- rdoc/classes
+- rdoc/classes/MiniFacet
+- rdoc/classes/MiniFacet/CountDistinct.html
+- rdoc/classes/MiniFacet/Extract.html
+- rdoc/classes/MiniFacet/IncludesAll.html
+- rdoc/classes/MiniFacet/Split.html
+- rdoc/classes/MiniFacet/VERSION.html
+- rdoc/classes/MiniFacet.html
+- rdoc/created.rid
+- rdoc/files
+- rdoc/files/lib
+- rdoc/files/lib/mini_facet
+- rdoc/files/lib/mini_facet/array
+- rdoc/files/lib/mini_facet/array/count_distinct_rb.html
+- rdoc/files/lib/mini_facet/array/includes_all_rb.html
+- rdoc/files/lib/mini_facet/array_rb.html
+- rdoc/files/lib/mini_facet/hash
+- rdoc/files/lib/mini_facet/hash/extract_rb.html
+- rdoc/files/lib/mini_facet/hash/split_rb.html
+- rdoc/files/lib/mini_facet/hash_rb.html
+- rdoc/files/lib/mini_facet/version_rb.html
+- rdoc/files/lib/mini_facet_rb.html
+- rdoc/files/README_markdown.html
+- rdoc/fr_class_index.html
+- rdoc/fr_file_index.html
+- rdoc/fr_method_index.html
+- rdoc/index.html
+- rdoc/rdoc-style.css
+- README.markdown
+- tasks
+- tasks/gem.rake
+- tasks/rdoc.rake
+- tasks/test.rake
+- test
+- test/integration
+- test/test_helper.rb
+- test/unit
+- test/unit/array
+- test/unit/array/count_distinct_test.rb
+- test/unit/array/includes_all_test.rb
+- test/unit/hash
+- test/unit/hash/extract_test.rb
+- test/unit/hash/split_test.rb
+- test/unit/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/webmat/mini_facet
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: mini_facet
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Adding a few basic, useful things to Ruby.
+test_files: 
+- test/integration
+- test/test_helper.rb
+- test/unit
+- test/unit/array
+- test/unit/array/count_distinct_test.rb
+- test/unit/array/includes_all_test.rb
+- test/unit/hash
+- test/unit/hash/extract_test.rb
+- test/unit/hash/split_test.rb
+- test/unit/test_helper.rb