libraries 0.0.1 → 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -1,4 +1,7 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in libraries.gemspec
 gemspec
+
+group :test do
+  gem "rspec"
+end

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    libraries (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  libraries!
+  rspec

data/Rakefile

@@ -1,2 +1,12 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = %w(-fs --color)
+end

data/lib/libraries.rb

@@ -1,3 +1,7 @@
-module Libraries
+require "active_support"
 
-end
+require "libraries/enumerable"
+require "libraries/array"
+require "libraries/hash"
+require "libraries/string"
+require "libraries/object"

data/lib/libraries/active_record.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+
+  class Base
+    before_save(:_clean_whitespace)
+
+    def _clean_whitespace
+      self.attributes.each_pair do |key, value|
+        if value && value.respond_to?('strip')
+          self[key] = value.strip
+        end
+      end
+    end
+
+    def to_hash(*fields)
+      h = attributes.symbolize_keys
+      fields.present? ? h.slice(*fields.flatten) : h
+    end
+
+    class << self
+      def conditions(*args)
+        scoped :conditions => args
+      end
+
+      def date_range(options)
+        options.reverse_merge! :field => "created_at", :end => Time.now
+        scoped :conditions => { options[:field] => options[:range] || options[:start]..options[:end] }
+      end
+
+      def sort_scope(options)
+        scoped :order => "#{options[:attribute]} #{options[:direction]}"
+      end
+
+      def random(_limit=1)
+        scoped :order => "RAND()", :limit => _limit
+      end
+
+      def limit(_limit)
+        scoped :limit => _limit
+      end
+    end
+  end
+
+end

data/lib/libraries/array.rb

@@ -0,0 +1,17 @@
+class Array
+
+  def each_pair
+    self.in_groups_of(2).each { |g| yield g.first, g.last }
+  end
+
+  # delete all passed element and return the array after delete
+  def delete!(*args)
+    self.tap { |a| a.delete_if { |e| args.include? e } }
+  end
+
+  # same as delete! but does not alter self
+  def without(*args)
+    self.dup.tap { |dup| dup.delete!(*args) }
+  end
+
+end

data/lib/libraries/enumerable.rb

@@ -0,0 +1,15 @@
+module Enumerable
+
+  # Call the given block for each element, creating a new hash
+  # that uses the element as the key and the block's result as the value.
+  def map_into_hash &block
+    # The "reduce(:concat)" does a shallow flatten, so that blocks that
+    # return arrays will do the Right Thing.
+    Hash[*map {|x| [x, block.call(x)]}.inject([], &:concat)]
+  end
+
+  def map_keyvals_into_hash &block
+    Hash[*map(&block).inject([], &:concat)]
+  end
+
+end

data/lib/libraries/hash.rb

@@ -0,0 +1,73 @@
+class Hash
+
+  def recursive_symbolize_keys!
+    symbolize_keys!
+    # symbolize each hash in .values
+    values.each{|h| h.recursive_symbolize_keys! if h.is_a?(Hash) }
+    # symbolize each hash inside an array in .values
+    values.select{|v| v.is_a?(Array) }.flatten.each{|h| h.recursive_symbolize_keys! if h.is_a?(Hash) }
+    self
+  end
+
+  # deep lookup a nested hash without failing on non-existing keys
+  # in which case returns and empty hash
+  # This will only work on NESTED hashes, something like:
+  # h = {:a => {:b => {:c => 3}}}
+  # h.lookup(:a,:b,:c) => 3
+  # h.lookup(:a,:b) => {:c => 3}
+  # h.lookup(:a,:b,:X) => nil
+  # h.lookup(:a,:X,:Y) => nil
+  # h.lookup(:W,:T,:F) => nil
+  def nested_lookup(*keys)
+    keys.inject(self){ |h,k| (h || {}).fetch(k,nil) } rescue nil
+  end
+
+  # Takes a hash argument of old, new pairs
+  # Returns hash with keys renamed
+  def rename_keys!(keys_hash)
+    keys_hash.each do |old, new|
+      self[new] = self.delete(old)
+    end
+    self
+  end
+
+  def rename_keys(keys_hash)
+    self.dup.rename_keys!(keys_hash)
+  end
+
+  # map from a block
+  def map_into_hash(&block)
+    Hash[*map {|x| [x[0], block.call(x)]}.inject([], &:concat)]
+  end
+
+  def parent_to?(*args)
+    return self.slice(*args.first.keys) == args.first if args.size == 1 && args.first.is_a?(Hash)
+    args.each_pair do |key, value|
+      return false unless self[key].to_s == value.to_s
+    end
+    true
+  end
+
+  ############################################################
+  # The following methods take as an argument, a list of keys
+  # See the specs for examples
+
+  def all_keys?(*keys)
+    keys.all? {|k| has_key? k}
+  end
+
+  def any_key?(*keys)
+    keys.any? {|k| has_key? k}
+  end
+
+  def all_values?(*keys)
+    keys.all?{|k| self[k].present?}
+  end
+
+  def any_value?(*keys)
+    keys.any?{|k| self[k].present?}
+  end
+
+  ############################################################
+
+end

data/lib/libraries/object.rb

@@ -0,0 +1,9 @@
+class Object
+
+  def m regexp=nil
+    m = (self.methods - Object.methods).sort
+    return m.grep(/#{regexp}/) if regexp
+    m
+  end
+
+end

data/lib/libraries/string.rb

@@ -0,0 +1,32 @@
+class String
+
+  def strip_with_arg_support!(char=nil)
+    if char.present?
+      m = char.each_char.inject('') {|r,c| r+=(c =~ /[\*\.\[\]\^\$\?\\\|\=\+\:\/\(\)]/ ? "\\" : "") + c}
+      self.gsub!(/^[#{m}]*(.*?)[#{m}]*$/,'\1')
+    else
+      strip_without_arg_support!
+    end
+  end
+  alias_method_chain :strip!, :arg_support
+
+  def strip_with_arg_support(char=nil)
+    char.present? ? self.dup.strip!(char) : strip_without_arg_support
+  end
+  alias_method_chain :strip, :arg_support
+
+  # In the sense of normal characters only, it also downcases the string
+  # Can be used, for example, in file names and css classes
+  def normalize!
+    return if normalize.blank?
+    self.gsub!(/[^A-Z0-9]/i, '_')
+    self.squeeze!("_")
+    self.strip!("_")
+    self.downcase!
+  end
+
+  def normalize
+    self.gsub(/[^A-Z0-9]/i, '_').squeeze("_").strip("_").downcase
+  end
+
+end

data/lib/libraries/version.rb

@@ -1,3 +1,3 @@
 module Libraries
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/rails.rb

@@ -0,0 +1,2 @@
+require "libraries"
+require "libraries/active_record" if defined?(ActiveRecord)

data/spec/libraries/array_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Array do
+
+  describe "#each_pair" do
+    it "yeilds pairs" do
+      out = ''
+      [1,2,3,4].each_pair { |a1,a2| out << "*#{a1}#{a2}*" }
+      out.should == "*12**34*"
+    end
+  end
+
+  describe "#delete!" do
+    it "accepts one argument and returns the array after delete" do
+      [1,:a,3.14,"x"].delete!(1).should == [:a,3.14,"x"]
+    end
+    it "accepts a list of arguments and returns the array after delete" do
+      [1,:a,3.14,"x"].delete!(1, "x").should == [:a,3.14]
+    end
+    it "modifies receiver" do
+      a = [1,2,3]
+      a.delete!(2,3)
+      a.should == [1]
+    end
+  end
+
+  describe "#without" do
+    it "does not modify receiver" do
+      a = [1,2,3]
+      a.without(2,3).should == [1]
+      a.should == [1,2,3]
+    end
+  end
+
+end

data/spec/libraries/hash_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Hash do
+
+  let(:names) { {:first => 'Homer', :mi => '', :last => 'Simpson', "A" => true} }
+  let(:numbers) { {:b => "0", "c" => 1} }
+
+  describe "#parent_to?" do
+    it "returns true for existing slices" do
+      names.should be_parent_to(:first => "Homer", :last => "Simpson")
+      names.should be_parent_to(:first => "Homer")
+    end
+    it "returns false for non existing slices" do
+      names.should_not be_parent_to(:first => "Bart", :last => "Simpson")
+      names.should_not be_parent_to(:first => "Bart")
+    end
+    it "supports key, value pairs" do
+      names.should be_parent_to(:first, "Homer")
+      names.should be_parent_to(:first, "Homer", :last, "Simpson")
+      names.should_not be_parent_to(:first, "Bart")
+      names.should_not be_parent_to(:first, "Bart", :last, "Simpson")
+    end
+    it "considers string integers with the key, value pairs call" do
+      numbers.should be_parent_to(:b, 0)
+      numbers.should_not be_parent_to(:b => 0)
+      numbers.should be_parent_to("c", "1")
+      numbers.should_not be_parent_to("c" => "1")
+      numbers.should be_parent_to(:b, 0, "c", "1")
+    end
+  end
+
+  describe "#all_keys?" do
+    it "returns true when all keys are there" do
+      names.all_keys?(:first, :last).should be
+    end
+    it "returns false if one keys is not there" do
+      names.all_keys?(:first, :title).should_not be
+    end
+    it "returns false if all keys are not there" do
+      names.all_keys?(:title, :other).should_not be
+    end
+  end
+
+  describe "#any_key?" do
+    it "returns true when any keys is there" do
+      names.any_key?(:first, :title).should be
+    end
+    it "returns true if all keys are there" do
+      names.any_key?(:first, :last).should be
+    end
+    it "returns false if all keys are not there" do
+      names.any_key?(:title, :other).should_not be
+    end
+  end
+
+  describe "#any_values?" do
+    it 'returns true if one key has a value' do
+      names.any_value?(:first, :others).should be
+    end
+    it "returns false if all keys don't exist or don't have values" do
+      names.any_value?(:others, :mi).should_not be
+    end
+  end
+
+  describe "#all_values?" do
+    it 'returns true if all key have values' do
+      names.all_values?(:first, :last).should be
+    end
+    it "returns false if one keys doesn't exist or doesn't have value" do
+      names.all_values?(:others, :mi).should_not be
+      names.all_values?(:others, :last).should_not be
+      names.all_values?(:mi, :last).should_not be
+    end
+  end
+
+  describe "#recursive_symbolize_keys!" do
+    let(:hash) {
+      {"name" => "names", "value" => names, "value_in_array" => [names] }
+    }
+    before do
+      hash.recursive_symbolize_keys!
+    end
+
+    it 'symobolizes keys' do
+      hash.keys.should =~ [:name, :value, :value_in_array]
+    end
+
+    it 'symbolizes keys in sub hashes' do
+      hash[:value].keys.should =~ [:first, :mi, :last, :A]
+    end
+
+    it 'symbolizes keys in hashes inside sub arrays' do
+      hash[:value_in_array].first.keys.should =~ [:first, :mi, :last, :A]
+    end
+  end
+
+  describe "#nested_lookup" do
+    let(:hash) { {:a => {:b => {:c => 3}}}}
+    it "returns nil for non existing keys" do
+      hash.nested_lookup(:X).should be_nil
+    end
+    it "returns nil for non existing nested keys" do
+      hash.nested_lookup(:X, 1, "F").should be_nil
+    end
+    it "returns nil for non existing keys after valid keys" do
+      hash.nested_lookup(:a,:b,:X).should be_nil
+      hash.nested_lookup(:a,:X,:Y).should be_nil
+    end
+    it "returns hash value for partial lookup" do
+      hash.nested_lookup(:a, :b).should == {:c => 3}
+    end
+    it "returns value for valid lookup" do
+      hash.nested_lookup(:a,:b,:c).should == 3
+    end
+    it "returns nil for lookups that goes beyond valid ones" do
+      hash.nested_lookup(:a,:b,:c,:d).should be_nil
+    end
+  end
+
+  describe "#rename_keys" do
+    let(:source_hash) { {:a => "Symbol", 1 => "Integer", -1 => 100, "a" => "Text"} }
+    let(:renamed_hash) { source_hash.rename_keys(:a => :b, 1 => 2, -1 => -2, "a" => "b") }
+
+    it "renames symbol key" do
+      renamed_hash[:b].should == "Symbol"
+    end
+    it "renames integer key" do
+      renamed_hash[2].should == "Integer"
+    end
+    it "renames text key" do
+      renamed_hash["b"].should == "Text"
+    end
+    it "doesn't care about value type" do
+      renamed_hash[-2].should == 100
+    end
+    it "does not modify the source hash" do
+      source_hash[:a].should == "Symbol"
+      source_hash[:b].should_not be
+    end
+    it "supports a bang version" do
+      source_hash.rename_keys! :a => :b, 1 => 2, -1 => -2, "a" => "b"
+      source_hash.should == {:b => "Symbol", 2 => "Integer", -2 => 100, "b" => "Text"}
+    end
+  end
+
+end

data/spec/libraries/object_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Object do
+
+  describe "#m" do
+    it "returns receiver methods" do
+      "".m.should include("downcase")
+    end
+    it "does not include Object methods" do
+      "".m.should_not include(Object.methods)
+    end
+    it "retruns sorted output" do
+      "".m.should == "".m.sort
+    end
+    it "accepts a regexp and returns only method matching it" do
+      boolean_methods = "".m /\?$/
+      boolean_methods.should include("all?", "one?")
+      boolean_methods.should_not include("downcase")
+    end
+  end
+
+end

data/spec/libraries/string_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe String do
+
+  describe "#strip" do
+    it "accepts an argument and strips it from both ends of reciever" do
+      "**COOL**".strip("*").should == "COOL"
+      "^COOL^".strip("^").should == "COOL"
+    end
+
+    it "supports more than one character" do
+      "((((((((COOL))))))))))".strip("()").should == "COOL"
+      "((((((((COOL))))))))))".strip("()").should == "COOL"
+    end
+
+    it "supports normal and special characters" do
+      "!!@$()#^^COOLxxyyzzz".strip("!@$()#^xyz").should == "COOL"
+    end
+
+    it "has a bang version" do
+      a = "!!@$()#^^COOLxxyyzzz"
+      a.strip!("!@$()#^xyz")
+      a.should == "COOL"
+    end
+  end
+
+  describe "#normalize" do
+    it "strips anyting but A-Z and 0-9, squeezes and underscores" do
+      "** 10:10 (That's _IT_, I'm *OuT*)".normalize.should == "10_10_that_s_it_i_m_out"
+    end
+
+    it "has a bang version" do
+      a = "** 10:10 (That's _IT_, I'm *OuT*)"
+      a.normalize!
+      a.should == "10_10_that_s_it_i_m_out"
+    end
+
+    it "returns empty string, but does not alter reveiver if no A-Z|0-9 exist" do
+      a = "**%^^$%^#%*("
+      a.normalize.should == ""
+      a.normalize!.should_not be
+      a.should == "**%^^$%^#%*("
+    end
+
+    it "keeps normal letters, including repeated letters" do
+      "buzzz".normalize.should == "buzzz"
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'libraries')

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: libraries
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - On-Site.com
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-25 00:00:00 -07:00
+date: 2010-11-01 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -29,11 +29,25 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .gitignore
 - Gemfile
+- Gemfile.lock
 - Rakefile
 - lib/libraries.rb
+- lib/libraries/active_record.rb
+- lib/libraries/array.rb
+- lib/libraries/enumerable.rb
+- lib/libraries/hash.rb
+- lib/libraries/object.rb
+- lib/libraries/string.rb
 - lib/libraries/version.rb
+- lib/rails.rb
 - libraries.gemspec
+- spec/libraries/array_spec.rb
+- spec/libraries/hash_spec.rb
+- spec/libraries/object_spec.rb
+- spec/libraries/string_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://rubygems.org/gems/libraries
 licenses: []