justools 1.2.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.rdoc

@@ -0,0 +1,52 @@
+== 1.2.0
+
+* Re-architecting for Jeweler compatibility
+* Removing test/ directory in favor of skeletal RSpec setup (coming soon)
+
+== 1.1.10
+
+* Ruby 1.9 doesn't need this patch mucking with the internal definition of rotate.
+
+== 1.1.8
+
+* Invalid regexp for args_and_opts
+
+== 1.1.8
+
+* Defining Object#in? regardless of its pre-existence.
+
+== 1.1.7
+
+* Ruby < 1.9 does not have Array#rotate.
+
+== 1.1.6
+
+* Renaming from CoreUtilities ('core\_utilities' gem) to Justools.
+
+* Removing unnecessary dependencies on ActiveSupport, Rails, Significance, Schrodinger's Cat.
+
+* Not doubly defining methods in extensions if they are already defined.
+
+* Stunting/disabling 'args and opts' with method missing assistance for Ruby < 1.9.
+
+* Syntax changes to conform to best practices and style guides.
+
+* Deactivating class attribute with default extension.
+
+* Merging extract options with merge options file.
+
+* Renaming (or aliasing) methods to better fit with RSpec should syntaxes.
+
+* Slowly deprecating old names by setting up transition via alias method.
+
+* Adding comment-based documentation with examples and parameters.
+
+* Updating main README file.
+
+== 0.1.0
+
+* Serious effort at making a legit gem.
+
+== 0.0.1
+
+* Testing setup

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.11.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+  # gem "rcov", ">= 0"
+  # gem 'activesupport', '>= 3.1.0'
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  jeweler (~> 1.8.4)
+  rdoc (~> 3.12)
+  rspec (~> 2.11.0)

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 caleon.
+
+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.rdoc

@@ -0,0 +1,135 @@
+= Justools (formerly CoreUtilities)
+
+Ruby-level extensions, utilities, convenience methods that I've found I'm constantly using in all my projects.
+
+== Usage:
+
+    gem 'justools', :git => "git://github.com/caleon/justools.git"
+
+== Selected Examples:
+
+=== Object
+
+==== Object#as
+
+    [:donkey, { :class => 'list-item' }].as { |arg, opts| link_to(arg, opts) }
+
+==== Object#is_included_in? (deprecated by ActiveSupport's newest Object#in?)
+
+    User.find(1).class.is_included_in?(User, Article, Authentication)
+		
+or alternatively:
+
+    @user.is_one_kind_of?(User, Article, Authentication)
+		
+which has the same effect as:
+
+    @user.is_one_kind_of?([User, Article, Authentication])
+
+by virtue of:
+
+=== Array
+
+==== Array#flatten_splat!
+
+#flatten_splat is for the common pattern of writing a method whose arguments are prepended by the splat operator, like the following:
+
+  def find(*types)
+    types = types.first if types.size == 1 and types.first.is_a?(Array)
+    # ...
+  end
+
+... which can now be written as:
+
+  def find(*types)
+    types.flatten_splat!
+  end
+
+==== array/base, array/filters
+
+These contain further convenience methods, none of them really novel or anything.
+
+==== Array#extract_options(!)
+
+Extending the behavior introduced by ActiveSupport, this one goes further to define Array#extract_options as the non-destructive analog, and also introduces Array#extract_options_with_merge. Previously you may have written:
+
+  def find(*args)
+    opts = args.extract_options!
+    opts[:user_id] = self.article.user_id
+    opts[:found_at] = Time.now
+  end
+		
+but now you can write:
+
+  def find(*args)
+    opts = args.extract_options_with_merge(:user_id => self.article.user_id, :found_at => Time.now)
+  end
+
+Note: The inclusion of this gem makes the *_with_merge methods the default behavior for extract_options(!) via alias_method_chain.
+
+==== Array#merge_options(!)
+
+If you find yourself extracting options as above only to re-inject that hash back into the original array to pass the arguments to a helper method (after some merging of the options hash), you may consider utilizing #merge_options:
+
+  def find(*args)
+    find_helper(*args.merge_options(:user_id => self.article.user_id, :found_at => Time.now))
+  end
+
+==== Array #arguments_and_options (a.k.a. #args_and_opts)
+
+The above Array methods lead to this handy method whose utility, in essence, is in its shortening a common Ruby pattern into a single line. Previously you may have written:
+
+  def find(*arguments)
+    mandatory_opts = { :user_id => self.article.user_id, :found_at => Time.now }
+    
+    opts = arguments.extract_options!
+    an_id = arguments.shift
+    
+    opts.merge!(mandatory_opts)
+  end
+		
+which, with the help of #args_and_opts (and the help of of #method_missing for extending its functionality) you can write:
+
+  def find(*arguments)
+    an_id, opts = arguments.args_with_shift_and_opts_with_merge!(:user_id => self.article.user_id, :found_at => Time.now)
+  end
+  
+==== Note
+
+The method_missing hook to allow the above functionality (explained in more detail below) is only available for Ruby 1.9+ because it depends, to an extent, on the availability of the method Method#parameters.
+
+Basically the format of the method call is arg(ument)?s(\_with\_[ARGMETHOD])?\_and_opt(ion)?s(\_with\_[OPTSMETHOD])?!, where the ARGMETHOD is the name of the method which applies to the "args" part of the array, and OPTSMETHOD would be the name of the method which is called on the "opts" part of the array.
+
+Additionally, arguments can be passed to #args_and_opts, but as of now, in the event that both ARGMETHOD and OPTSMETHOD are defined, the arguments will be passed to the OPTSMETHOD only. Some effort was made to utilize arity to determine where the arguments should be passed to, but to my recollection this is still an unfinished aspect.
+
+
+=== Enumerable
+
+Has #map_select and #map_detect.
+
+=== Set
+
+Has #not_subset?(set)
+
+=== Hash
+
+Has #append_value which is similar to merging hashes, but in cases where you don't want to override the value of one of the hashes and would rather JOIN the values corresponding to the same key, (for example, wanting to add class names in a DOM element in Rails rather than overriding the original { :class => 'className' } hash):
+
+  { :id => "user_1-comments", :class => "user-comments" }.append_value!(:class, 'comments')
+  # => { :id => "user_1-comments", :class => "user-comments comments" }
+
+== Additional information
+
+=== Contributors
+
+Please feel free to contact me about collaborating on this project.
+
+http://github.com/caleon/justools/contributors
+
+=== Maintainers
+
+* caleon (http://github.com/caleon)
+
+== License
+
+MIT License. Copyright 2012 caleon.

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "justools"
+  gem.homepage = "http://github.com/caleon/justools"
+  gem.license = "MIT"
+  gem.summary     = %Q{Core extensions with lots of handy methods}
+  gem.description = %Q{Core extensions with lots of handy methods}
+  gem.email = "caleon@gmail.com"
+  gem.authors = ["caleon"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Justools #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.2.0

data/lib/justools.rb

@@ -0,0 +1,7 @@
+require 'justools/core_ext'
+
+module Justools
+  ARGS_AND_OPTS_REGEXP = /^#{%w(arg(?:ument)?s opt(?:ion)?s).
+                             zip(Array.new(2, "(?:_with_(\\w+))?")).
+                             map(&:join) * '_and_'}!?$/
+end

data/lib/justools/core_ext.rb

@@ -0,0 +1,6 @@
+# require 'justools/core_ext/class'
+require 'justools/core_ext/object'
+require 'justools/core_ext/enumerable'
+require 'justools/core_ext/set'
+require 'justools/core_ext/array'
+require 'justools/core_ext/hash'

data/lib/justools/core_ext/array.rb

@@ -0,0 +1,5 @@
+require 'justools/core_ext/array/filters'
+require 'justools/core_ext/array/flatten_splat'
+require 'justools/core_ext/array/inquiry'
+require 'justools/core_ext/array/merge_options'
+require 'justools/core_ext/array/args_and_opts'

data/lib/justools/core_ext/array/args_and_opts.rb

@@ -0,0 +1,41 @@
+require 'justools/core_ext/array/merge_options'
+
+class Array
+  unless Array.instance_methods.include?(:rotate) # Was only patch for 1.8
+    def rotate
+      self[0..-2].unshift(self[-1])
+    end
+  end
+  
+  def arguments_and_options(update_hash = {})
+    merge_options(update_hash).args_and_opts!
+  end
+  
+  def arguments_and_options!(update_hash = {})
+    [extract_options_with_merge!(update_hash), self].rotate
+  end
+  
+  [:args_and_opts!, :args_and_opts_with_merge!,
+                    :arguments_and_options_with_merge!].each do |meth|
+    alias_method meth,                    :arguments_and_options!
+    alias_method meth.to_s[0..-2].to_sym, :arguments_and_options
+  end
+  
+  # Method#parameters only available in Ruby 1.9+  
+  if RUBY_VERSION > '1.9'  
+    private 
+    def method_missing(method_symbol, *args, &block)
+      return super unless method_symbol =~ Justools::ARGS_AND_OPTS_REGEXP
+    
+      [$1, $2].zip(args_and_opts).map do |m, obj|
+        next if m.respond_to?(:empty?) ? empty? : !m
+        obj.send(m.to_sym, *args.send(:constrained_by_method, obj.method(m.to_sym)))
+      end
+    end
+    
+    def constrained_by_method(methud)    
+      methud.parameters.detect { |t, _| t == :rest } or return self
+      take([methud.parameters.size, methud.arity.abs].max)
+    end
+  end
+end

data/lib/justools/core_ext/array/filters.rb

@@ -0,0 +1,7 @@
+class Array
+  # Quick selectors/filters
+  def select_kind_of(klass);   select { |el| el.kind_of?(klass) }; end
+  def reject_kind_of(klass);   reject { |el| el.kind_of?(klass) }; end
+  def select_kind_of!(klass); select! { |el| el.kind_of?(klass) }; end
+  def reject_kind_of!(klass); reject! { |el| el.kind_of?(klass) }; end
+end

data/lib/justools/core_ext/array/flatten_splat.rb

@@ -0,0 +1,27 @@
+class Array
+  # flatten_splat! is used for dealing conveniently with the common pattern
+  # where a method's arguments has a splat (*) operator, but the developer wants
+  # to provide the option of the method accepting either a list or an array for
+  # the argument.
+  #
+  # === Examples
+  #
+  #   Before:                                 Now:
+  #   def do_something(*args)                 def do_something(*args)
+  #     if args.one? && args[0].is_a?(Array)    args.flatten_splat!
+  #       args = args.shift                   end
+  #     end
+  #   end
+  def flatten_splat!
+    flatten_splat(true)
+  end
+
+  def flatten_splat(with_bang=false)
+    flatten_splat_needed? ? with_bang ? flatten! : flatten : self
+  end
+
+  def flatten_splat_needed?
+    self.size == 1 and first.is_a?(Array)
+  end
+  private :flatten_splat_needed?
+end

data/lib/justools/core_ext/array/inquiry.rb

@@ -0,0 +1,42 @@
+require 'set'
+require 'justools/core_ext/object'
+require 'justools/core_ext/set'
+require 'justools/core_ext/array/flatten_splat'
+
+class Array
+  # Compares two arrays to see if the elements are same but simply rearranged.
+  #
+  # === Parameters
+  #
+  # * +other_ary+ - An Array or a list of its elements.
+  def rearranged?(*other_ary)
+    Set.new(self) == Set.new(other_ary.flatten_splat)
+  end
+  alias_method :rearranges?, :rearranged?
+  
+  def subset_of?(other_ary)
+    Set.new(self).subset?(Set.new(other_ary))
+  end
+  alias_method :subset?, :subset_of?
+  
+  def is_included_in?(other_ary)
+    super || subset?(other_ary)
+  end
+  alias_method :in?, :is_included_in?
+  
+  # Careful with this. This means 4 out of 5 elements can be the same but if not
+  # all of this self Array object are a part of other_ary, this returns true, as
+  # in "Yes, depite having 4 out of 5 in other_ary, I am excluded from the
+  # other_ary."
+  def out_of?(other_ary)
+    super || not_subset?(other_ary)
+  end
+  alias_method :is_excluded_from?, :out_of?
+
+  alias_method :include_one?, :include?
+  def include_all?(*other_ary)
+    other_ary.flatten_splat!
+    include_one(other_ary) || superset?(other_ary)
+  end
+  # alias_method :include?, :include_all?
+end

data/lib/justools/core_ext/array/merge_options.rb

@@ -0,0 +1,45 @@
+unless Hash.method_defined?(:extractable_options?)
+  class Hash
+    # Duplicated from ActiveSupport
+    def extractable_options?
+      instance_of?(Hash)
+    end
+  end
+end
+
+class Array
+  def extract_options_without_merge
+    options_extractable? ? last : {}
+  end
+  
+  def extract_options_without_merge!
+    options_extractable? ? pop  : {}
+  end
+  
+  def options_extractable?
+    last.is_a?(Hash) && last.extractable_options?
+  end
+  
+  def extract_options_with_merge(update_hash = {})
+    extract_options_without_merge.merge(update_hash  || {})
+  end
+  alias_method :extract_options, :extract_options_with_merge
+  
+  def extract_options_with_merge!(update_hash = {})
+    extract_options_without_merge!.merge(update_hash || {})
+  end
+  alias_method :extract_options!, :extract_options_with_merge!
+  
+  ##
+  # == Merging options
+  def merge_options(update_hash = {})
+    endex, base_hash = options_extractable? ? [-2, last] : [-1, {}]
+    self[0..endex] + Array[base_hash.merge(update_hash || {})]
+  end
+  alias_method :merge_opts, :merge_options
+
+  def merge_options!(update_hash = {})
+    push(extract_options!(update_hash))
+  end
+  alias_method :merge_opts!, :merge_options!
+end

data/lib/justools/core_ext/class.rb

@@ -0,0 +1,41 @@
+# Not enabling until fixed.
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/aliasing'
+
+class Class
+  # Purpose is to be able to define a default value for a class_attribute when
+  # one isn't initially set.
+  def class_attribute_with_default(*attrs)
+    hash = attrs.last.is_a?(Hash) ? attrs.pop : {}
+    my_default = hash.delete(:default)
+    instance_writer = hash.blank? || hash[:instance_writer]
+
+    attrs.each do |name|
+      # By the way, FIXME: i think this should be broken because if i want to
+      # use a string as a default, that will not be reflected.
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{name}() #{my_default || 'nil'} end
+        def self.#{name}?() !!#{name} end
+
+        def self.#{name}=(val)
+          singleton_class.class_eval do
+            remove_possible_method(:#{name})
+            define_method(:#{name}) { val }
+          end
+          val
+        end
+
+        def #{name}
+          defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+        end
+
+        def #{name}?
+          !!#{name}
+        end
+      RUBY
+
+      attr_writer name if instance_writer
+    end
+  end
+  alias_method_chain :class_attribute, :default
+end

data/lib/justools/core_ext/enumerable.rb

@@ -0,0 +1,12 @@
+module Enumerable
+  def map_select(value_for_skip = nil)
+    self.inject([]) do |acc, item|
+      (value = yield(item)) == value_for_skip ? acc : acc << value
+    end
+  end
+  
+  def map_detect(value_for_no_matching = nil)
+    self.each { |el| if result = yield(el) then return result end }
+    value_for_no_matching
+  end
+end

data/lib/justools/core_ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def append_value(key, val, delimiter = ' ')
+    self.dup[key] = [self[key], val].compact.join(delimiter)
+  end
+  
+  def append_value!(key, val, delimiter = ' ')
+    self[key]     = [self[key], val].compact.join(delimiter)
+  end  
+end

data/lib/justools/core_ext/object.rb

@@ -0,0 +1,92 @@
+require 'justools/core_ext/array/flatten_splat'
+
+class Object
+  
+  # === Examples
+  #
+  #   { :a=>1, .., :z=>26 }.as { |h| h.each { |k, v| h[k] = v + h[26 - v] } }
+  #
+  #   User.find(15).stories.joins(:tasks).as { |s| [s.class.to_s, s.count] }.
+  #        as { |klass_name, count| "#{count} stories in #{klass_name}" }
+  #
+  #   [15, { :includes => { :stories => :tasks } }, 56, 78, 102].
+  #        as { |id, opts, *ns| ns.each { |n| puts n }; User.find(id, opts) }
+  def as(&block)
+    yield self
+  end
+  
+  # === Examples
+  #
+  #   user = User.find_by_id(10).or_else { |res| raise "Got back #{res}" }
+  def or_else(&block)
+    self || yield(self)
+  end
+  
+  # === Examples
+  #
+  #   authorization = User.find_by_id(10).and_also { |u| u.authorization }
+  def and_also(&block)
+    self && yield(self)
+  end
+  
+  # unless Object.method_defined?(:in?)
+    # Copy of Object#in? from Rails 3.2.1 which also allows list.
+    #
+    # === Parameters
+    #
+    # * +args+ - Array or a list of its contents.
+    def in?(*args)
+      if args.length > 1
+        args.include? self
+      else
+        another_object = args.first
+        if another_object.respond_to? :include?
+          another_object.include?(self)
+        else
+          raise ArgumentError.new("The single parameter passed to #in? must respond to #include?")
+        end
+      end
+    end
+  # end
+  # def is_included_in?(*others) #d deprecated
+  #   others.flatten_splat.include?(self)
+  # end
+  alias_method :is_included_in?, :in?
+  
+  def out_of?(*others)
+    others.flatten_splat.exclude?(self)
+  end
+  alias_method :is_excluded_from?, :out_of?
+
+  # Similar to is_a? or kind_of? but with an array of possible classes.
+  # Returns the matching class or a nil.
+  #
+  # === Parameters
+  #
+  # * +klasses+ - List of Class constants, or an Array of Class constants.
+  #
+  # === Examples
+  #
+  #   rec_or_num.one_kind_of?(User, Admin).or_else { User.find(rec_or_num) }
+  def one_kind_of?(*klasses)
+    klasses.flatten_splat.detect { |klass| self.kind_of?(klass) }
+  end
+  alias_method :is_one_kind_of?, :one_kind_of?
+  
+  # Similar to is_a? or kind_of? but with an array of possible classes.
+  # Returns the matching class or a nil. Renamed here from is_one_kind_of?
+  # because it uses the 'klass === self' which isn't necessarily equivalent to
+  # 'self.is_a?(klass)'.
+  #
+  # === Parameters
+  #
+  # * +args+ - List of arguments.
+  #
+  # === Examples
+  #
+  #   rec_or_num.one_of?(User, Admin).or_else { User.find(rec_or_num) }
+  def one_of?(*args)
+    args.flatten_splat.detect { |arg| arg === self}
+  end
+  alias_method :is_when?, :one_of?
+end

data/lib/justools/core_ext/set.rb

@@ -0,0 +1,7 @@
+class Set
+  def not_subset?(set)
+    set.is_a?(Set) or raise ArgumentError, "value must be a set"
+    return true if set.size > size
+    any? { |o| set.exclude?(o) }
+  end
+end

data/lib/tasks/core_utilities_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :core_utilities do
+#   # Task goes here
+# end

data/spec/justools_spec.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Justools' do
+
+  it 'needs to have specs written' do
+    true.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'justools'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: justools
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: 
+  segments: 
+  - 1
+  - 2
+  - 0
+  version: 1.2.0
+platform: ruby
+authors: 
+- caleon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 2
+        - 11
+        - 0
+        version: 2.11.0
+  type: :development
+  name: rspec
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 3
+        - 12
+        version: "3.12"
+  type: :development
+  name: rdoc
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  name: bundler
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 1
+        - 8
+        - 4
+        version: 1.8.4
+  type: :development
+  name: jeweler
+  version_requirements: *id004
+description: Core extensions with lots of handy methods
+email: caleon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .document
+- .rspec
+- CHANGELOG.rdoc
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/justools.rb
+- lib/justools/core_ext.rb
+- lib/justools/core_ext/array.rb
+- lib/justools/core_ext/array/args_and_opts.rb
+- lib/justools/core_ext/array/filters.rb
+- lib/justools/core_ext/array/flatten_splat.rb
+- lib/justools/core_ext/array/inquiry.rb
+- lib/justools/core_ext/array/merge_options.rb
+- lib/justools/core_ext/class.rb
+- lib/justools/core_ext/enumerable.rb
+- lib/justools/core_ext/hash.rb
+- lib/justools/core_ext/object.rb
+- lib/justools/core_ext/set.rb
+- lib/tasks/core_utilities_tasks.rake
+- spec/justools_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/caleon/justools
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Core extensions with lots of handy methods
+test_files: []
+