hobo_support 1.3.0.RC

data/test/hobosupport/implies.rdoctest

@@ -0,0 +1,20 @@
+# HoboSupport - implies
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+The implies operator comes from Eiffel. Often comes in handy in Hobo's model-permission methods.
+
+## `TrueClass#implies` and `FalseClass#implies`
+
+    >> false.implies true
+    => true
+
+    >> false.implies false
+    => true
+
+    >> true.implies true
+    => true
+
+    >> true.implies false
+    => false

data/test/hobosupport/metaid.rdoctest

@@ -0,0 +1,59 @@
+# HoboSupport - Metaid
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+Why the Luck Stiff's essential meta-programming additions to Object. These are probably distributed elsewhere, but they're small enough to throw them in to HoboSupport and remove an external dependency.
+
+## `Object#metaclass`
+
+Returns the "metaclass", "eigenclass" or "singleton class" of a given ruby Object
+
+    >> o = Object.new
+    >> def o.foo; ;123; end
+    >> o.foo
+    => 123
+    >> o.metaclass.method_defined?(:foo)
+    => true
+
+## `Object#meta_eval`
+
+* `object.meta_eval(string)`
+* `object.meta_eval { block }`
+
+Evaluates ruby source or a block in the context of the metaclass.
+
+    >> File.meta_eval "alias_method :b, :basename"
+    >> File.b "a/b"
+    => "b"
+
+And with a block
+
+    >> File.meta_eval { alias_method :b2, :basename }
+    >> File.b2 "a/b"
+    => "b"
+
+## `Object#metaclass_eval`
+
+* `object.metaclass_eval(string)`
+* `object.metaclass_eval { block }`
+
+Like `#meta_eval`, but does a `class_eval` instead of an `instance_eval`
+
+    >> File.metaclass_eval "def b3(path); basename(path); end"
+    >> File.b3 "a/b"
+    => "b"
+
+And with a block
+
+    >> File.metaclass_eval { def b4(path); basename(path); end }
+    >> File.b4 "a/b"
+    => "b"
+
+
+## `Object#meta_def`
+
+    >> String.meta_def(:backwards_new) { |s| s.reverse }
+    >> String.backwards_new "strange"
+    => "egnarts"
+

data/test/hobosupport/methodphitamine.rdoctest

@@ -0,0 +1,18 @@
+# HoboSupport - Methodphitamine
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+## `Kernel#it` and `Kernel#its`
+
+A nice hack from Jay Phillips, christened "Methodphitamine". The low-down is in the [original blog post][1].
+
+[1]: http://jicksta.com/articles/2007/08/04/the-methodphitamine
+
+    >> (1..10).select &it % 2 == 0
+    => [2, 4, 6, 8, 10]
+    >> %w(a few short words).map &its.length
+    => [1, 3, 5, 5]
+
+Note that `it` and `its` are identical. They just read better in different contexts. Note that methodphitamine is also released directly by Jay (simply `gem install methodphitamine`) but it's small enough that it seemed easier to add it to HoboSupport and avoid an extra dependency. Thanks to Jay.
+

data/test/hobosupport/module.rdoctest

@@ -0,0 +1,108 @@
+# HoboSupport - Module extensions
+
+    doctest_require: '../../lib/hobo_support'
+{.hidden}
+
+## `Module#included_in_class_callbacks`
+
+Bit involved, this one :-)
+
+When a module is included in a class, it gets a callback on the `included` method, with the class passed as argument. However, if a module M2 is included in M1, and a class C includes M1, then M2 never gets to know about C. So, for example, M2 could not `alias_method_chain` a class method on C.
+
+`included_in_class_callbacks` makes it easy to implement a notification from M1 to M2, so that M2 does have full access to the class. All you do is insert a call to `included_in_class_callbacks(base)` as the end of the module's `self.included` method.
+
+(Note we're using the metaid extensions here too)
+
+    >>
+     module M2
+       def self.included_in_class(klass)
+         klass.metaclass_eval do
+           def name_with_shouting; name_without_shouting.upcase; end
+           alias_method_chain :name, :shouting
+         end
+       end
+     end
+
+     module M1
+       def self.included(base)
+         included_in_class_callbacks(base)
+       end
+       include M2
+     end
+
+     class C
+       def self.name
+         "my name is C"
+       end
+       include M1
+     end
+
+     C.name
+    => "MY NAME IS C"
+
+
+## `Module#interiting_cattr_reader`
+
+Declares a reader for an instance variable on the class. The attribute is looked up on the superclass if not defined on the receiving class. In other words, the superclass defines a default that subclasses can override. The declaration can also give a default, as shown here.
+
+    >>
+     class A
+       inheriting_cattr_reader :nickname => "Andy"
+     end
+
+     class B < A; end
+
+`B` has the same nickname as its superclass `A`
+
+    >> A.nickname
+    => "Andy"
+    >> B.nickname
+    => "Andy"
+
+Now we change the nickname of `B`. `A` retains it's existing nickname.
+
+    >> class B; @nickname = "Bob"; end
+    >> B.nickname
+    => "Bob"
+    >> A.nickname
+    => "Andy"
+
+
+## `Kernel#classy_module`
+
+In Ruby we use modules to factor out features that are shared by more than one class. By including the module, a class gets the module's features, just as if they were defined inside the class. This mechanism is very simple if the shared features are all instance methods, but starts to get complicated when we want to share class-level features. For example, to create a module that adds class-methods to the including class, Ruby programmers often use the ClassMethods sub-module idiom:
+
+    >>
+     module M
+       def self.included(base)
+         base.send(:extend, ClassMethods)
+       end
+
+       module ClassMethods
+         def foo; 123; end
+       end
+     end
+
+     class C; include M; end
+
+    >> C.foo
+    => 123
+
+It's a shame that such a basic capability isn't more declarative.
+
+`classy_module` provides a mechanism for creating a module that, when included, will `class_eval` it's entire body (the block passed to `classy_module`). This means we can write shared class features exactly as we would write them if they were inside the class:
+
+    >>
+     MyClassyModule = classy_module do
+
+       def self.foo; 123; end
+
+     end
+
+    >> MyClassyModule.class
+    => Module
+    >> class C2; include MyClassyModule; end
+    >> C2.foo
+    => 123
+
+

data/test/hobosupport/xss.rdoctest

@@ -0,0 +1,44 @@
+# HoboSupport - XSS helpers
+
+    >> require 'active_support'
+    >> $:.unshift File.join(File.expand_path(File.dirname(__FILE__)), '../../../hobo_support/lib')
+    >> require 'hobo_support'
+
+## safe_join
+
+Version of Array#join that preserves html\_safe:
+
+    >> $,=nil
+    >> ["<a>", "<b>"].safe_join
+    => "&lt;a&gt;&lt;b&gt;"
+
+    >> ["<a>", "<b>"].safe_join.html_safe?
+    => true
+
+    >> ["<a>".html_safe, "<b>"].safe_join
+    => "<a>&lt;b&gt;"
+
+    >> ["<a>".html_safe, "<b>"].safe_join.html_safe?
+    => true
+
+    >> ["<a>".html_safe, "<b>".html_safe].safe_join
+    => "<a><b>"
+
+    >> ["<a>".html_safe, "<b>".html_safe].safe_join.html_safe?
+    => true
+
+
+    >> ["<a>", "<b>"].safe_join("<br>")
+    => "&lt;a&gt;&lt;br&gt;&lt;b&gt;"
+
+    >> ["<a>", "<b>"].safe_join("<br>").html_safe?
+    => true
+
+    >> ["<a>".html_safe, "<b>".html_safe].safe_join("<br>")
+    => "<a>&lt;br&gt;<b>"
+
+    >> ["<a>".html_safe, "<b>".html_safe].safe_join("<br>".html_safe)
+    => "<a><br><b>"
+
+
+

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: hobo_support
+version: !ruby/object:Gem::Version 
+  prerelease: 6
+  version: 1.3.0.RC
+platform: ruby
+authors: 
+- Tom Locke
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-10 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rubydoctest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Core Ruby extensions from the Hobo project
+email: tom@tomlocke.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGES.txt
+- README.txt
+- Rakefile
+- VERSION
+- hobo_support.gemspec
+- lib/generators/hobo_support/eval_template.rb
+- lib/generators/hobo_support/model.rb
+- lib/generators/hobo_support/thor_shell.rb
+- lib/hobo_support.rb
+- lib/hobo_support/array.rb
+- lib/hobo_support/blankslate.rb
+- lib/hobo_support/command.rb
+- lib/hobo_support/common_tasks.rb
+- lib/hobo_support/enumerable.rb
+- lib/hobo_support/fixes/chronic.rb
+- lib/hobo_support/fixes/module.rb
+- lib/hobo_support/fixes/pp.rb
+- lib/hobo_support/hash.rb
+- lib/hobo_support/implies.rb
+- lib/hobo_support/kernel.rb
+- lib/hobo_support/metaid.rb
+- lib/hobo_support/methodcall.rb
+- lib/hobo_support/methodphitamine.rb
+- lib/hobo_support/module.rb
+- lib/hobo_support/string.rb
+- lib/hobo_support/xss.rb
+- test/hobosupport.rdoctest
+- test/hobosupport/chronic.rdoctest
+- test/hobosupport/enumerable.rdoctest
+- test/hobosupport/hash.rdoctest
+- test/hobosupport/implies.rdoctest
+- test/hobosupport/metaid.rdoctest
+- test/hobosupport/methodphitamine.rdoctest
+- test/hobosupport/module.rdoctest
+- test/hobosupport/xss.rdoctest
+has_rdoc: true
+homepage: http://hobocentral.net
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: hobo
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Core Ruby extensions from the Hobo project
+test_files: []
+