ribbon 0.0.4 → 0.0.5

data/lib/ribbon.rb

@@ -1,7 +1,12 @@
+require 'ribbon/methods'
+
 # Ruby Object Notation.
 #
 # Inspired by JSON and OpenStruct.
 module Ribbon
+
+  extend ::Ribbon::Methods
+
 end
 
 require 'ribbon/object'

data/lib/ribbon/core_ext.rb

@@ -1,8 +1,8 @@
-require 'ribbon/core_ext/hash'
-
 module Ribbon
 
   # Optional extensions to the standard library to make life easier.
   module CoreExt; end
 
 end
+
+require 'ribbon/core_ext/hash'

data/lib/ribbon/methods.rb

@@ -0,0 +1,73 @@
+module Ribbon
+
+  # Methods that operate on Ribbons. These should be included at the class level
+  # in order to keep as many names available for use with ribbons as possible.
+  module Methods
+
+    # Returns the hash keys of the given ribbon.
+    def keys(ribbon)
+      ribbon.__hash__.keys
+    end
+
+    # Yields a key, value pair to the given block.
+    def each(ribbon, &block)
+      ribbon.__hash__.each &block
+    end
+
+    # Yields a key, value pair to the given block and returns an array
+    # containing the values returned by the block on each iteration.
+    def map(ribbon, &block)
+      ribbon.__hash__.map &block
+    end
+
+    # Merges +old+'s hash with +new+'s. This is equivalent to calling
+    # <tt>merge!</tt> on +old+'s hash and passing it +new+'s hash and the given
+    # block.
+    def merge!(old, new, &block)
+      old_hash, new_hash = old.__hash__, new.__hash__
+      old_hash.merge! new_hash, &block
+    end
+
+    # Converts +ribbon+ and all Ribbons inside into hashes.
+    def to_hash(ribbon)
+      {}.tap do |hash|
+        each(ribbon) do |key, value|
+          hash[key] = case value
+            when ::Ribbon::Object then to_hash value
+            else value
+          end
+        end
+      end
+    end
+
+    # If <tt>object</tt> is a Hash, converts it to a Ribbon::Object. If it is
+    # an Array, converts any hashes inside.
+    def convert(object)
+      case object
+        when ::Hash then ::Ribbon::Object.new object
+        when ::Array then object.map { |element| convert element }
+        else object
+      end
+    end
+
+    # Converts all values in the given ribbon.
+    def convert_all!(ribbon)
+      each(ribbon) do |key, value|
+        ribbon[key] = case value
+          when ::Ribbon::Object then convert_all! value
+          else convert value
+        end
+      end
+      ribbon
+    end
+
+    # Returns +true+ if the given +object+ is a Ribbon.
+    def instance?(object)
+      ::Ribbon::Object === object
+    end
+
+  end
+
+end
+
+require 'ribbon/object'

data/lib/ribbon/object.rb

@@ -1,3 +1,5 @@
+require 'ribbon/methods'
+
 module Ribbon
 
   # Contains a hash whose keys that are symbols or strings can be accessed via
@@ -8,6 +10,8 @@ module Ribbon
   # class level.
   class Object < BasicObject
 
+    extend Methods
+
     # The internal Hash.
     def __hash__
       @hash ||= {}
@@ -16,7 +20,7 @@ module Ribbon
     # Merges the internal hash with the given one.
     def initialize(hash = {}, &block)
       __hash__.merge! hash, &block
-      ::Ribbon::Object.convert_all! self
+      Object.convert_all! self
     end
 
     # Gets a value by key.
@@ -44,79 +48,40 @@ module Ribbon
           self[m] ? true : false
         else
           self[method] = if __hash__.has_key? method
-            ::Ribbon::Object.convert self[method]
+            Object.convert self[method]
           else
-            ::Ribbon::Object.new
+            Object.new
           end
       end
     end
 
     # Computes a simple key:value string for easy visualization.
     #
-    # If given a block, yields the key and value and the value returned from the
-    # block will be used as the string. The block will also be passed to any
-    # internal Ribbon::Object instances.
-    def to_s(&block)
-      values = __hash__.map do |key, value|
-        value = value.to_s &block if ::Ribbon::Object === value
-        block ? block.call(key, value) : "#{key.to_s}: #{value.inspect}"
-      end
-      "{ Ribbon #{values.join ', '} }"
+    # In +opts+ can be specified several options that customize how the string
+    # is generated. Among those options:
+    #
+    # [:separator]  Used to separate a key/value pair. Default is <tt>': '</tt>.
+    # [:key]        Symbol that will be sent to the key in order to obtain its
+    #               string representation. Defaults to <tt>:to_s</tt>.
+    # [:value]      Symbol that will be sent to the value in order to obtain its
+    #               string representation. Defaults to <tt>:inspect</tt>.
+    #
+    # No matter what is given as the key or value of a
+    def to_s(opts = {})
+      ksym = opts.fetch(:key,   :to_s).to_sym
+      vsym = opts.fetch(:value, :inspect).to_sym
+      separator = opts.fetch(:separator, ': ').to_s
+      values = Object.map(self) do |k, v|
+        k = if Object.instance? k then k.to_s opts else k.send ksym end
+        v = if Object.instance? v then v.to_s opts else v.send vsym end
+        "#{k}#{separator}#{v}"
+      end.join ', '
+      "{Ribbon #{values}}"
     end
 
     # Same as #to_s.
     alias :inspect :to_s
 
-    # If <tt>object</tt> is a Hash, converts it to a Ribbon::Object. If it is
-    # an Array, converts any hashes inside.
-    def self.convert(object)
-      case object
-        when ::Hash then self.new object
-        when ::Array then object.map { |element| convert element }
-        else object
-      end
-    end
-
-    # Converts all values in the given ribbon.
-    def self.convert_all!(ribbon)
-      each(ribbon) do |key, value|
-        ribbon[key] = case value
-          when ::Ribbon::Object then convert_all! value
-          else convert value
-        end
-      end
-      ribbon
-    end
-
-    # Converts +ribbon+ and all Ribbons inside into hashes.
-    def self.to_hash(ribbon)
-      {}.tap do |hash|
-        each(ribbon) do |key, value|
-          hash[key] = case value
-            when ::Ribbon::Object then to_hash value
-            else value
-          end
-        end
-      end
-    end
-
-    # Merges +old+'s hash with +new+'s. This is equivalent to calling
-    # <tt>merge!</tt> on +old+'s hash and passing it +new+'s hash and the given
-    # block.
-    def self.merge!(old, new, &block)
-      old_hash, new_hash = old.__hash__, new.__hash__
-      old_hash.merge! new_hash, &block
-    end
-
-    # Returns the hash keys of the given ribbon.
-    def self.keys(ribbon)
-      ribbon.__hash__.keys
-    end
-
-    def self.each(ribbon, &block)
-      ribbon.__hash__.each &block
-    end
-
   end
 
 end

data/lib/ribbon/version.rb

@@ -16,7 +16,7 @@ module Ribbon
     # Patch version.
     #
     # Increments denote changes in implementation.
-    PATCH = 4
+    PATCH = 5
 
     # Build version.
     #

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ribbon
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-27 00:00:00.000000000 Z
+date: 2011-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rookie
-  requirement: &9983820 !ruby/object:Gem::Requirement
+  requirement: &21981980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9983820
+  version_requirements: *21981980
 description: Ruby Object Notation. Inspired by JSON and OpenStruct.
 email: matheus.a.m.moreira@gmail.com
 executables: []
@@ -37,6 +37,7 @@ files:
 - lib/ribbon.rb
 - lib/ribbon/core_ext.rb
 - lib/ribbon/core_ext/hash.rb
+- lib/ribbon/methods.rb
 - lib/ribbon/object.rb
 - lib/ribbon/version.rb
 - ribbon.gemspec