ribbon 0.7.0 → 0.8.0

data/lib/ribbon.rb

@@ -1,9 +1,8 @@
 %w(
 
-ribbon/core_extensions/basic_object
 ribbon/gem
 ribbon/options
-ribbon/wrapper
+ribbon/raw
 
 ).each { |file| require file }
 
@@ -56,142 +55,127 @@ ribbon/wrapper
 #
 # @author Matheus Afonso Martins Moreira
 # @since 0.1.0
-# @see Ribbon::Wrapper
-class Ribbon < BasicObject
+# @see Ribbon::Raw
+class Ribbon
 
-  # The hash used internally.
+  # The raw ribbon.
   #
-  # @return [Hash] the hash used by this Ribbon instance to store data
-  # @api private
-  def __hash__
-    @hash ||= (::Hash.new &::Ribbon.default_value_proc)
+  # @return [Ribbon::Raw] this ribbon's raw ribbon
+  # @since 0.8.0
+  def raw
+    @raw ||= Ribbon::Raw.new
   end
 
-  # Initializes a new ribbon.
+  # Sets this ribbon's raw ribbon.
+  #
+  # @param [Ribbon, Ribbon::Raw, #to_hash] object the hash-like object
+  # @return [Ribbon::Raw] the raw ribbon
+  # @since 0.8.0
+  def raw=(object)
+    @raw = Ribbon.extract_raw_from object
+  end
+
+  # Initializes a new ribbon with the given values.
   #
   # If given a block, the ribbon will be yielded to it. If the block doesn't
   # take any arguments, it will be evaluated in the context of the ribbon.
   #
-  # All objects inside the hash will be converted.
-  #
-  # @param [#to_hash, Ribbon, Ribbon::Wrapper] hash the hash with the initial
-  #                                                 values
-  # @see CoreExt::BasicObject#__yield_or_eval__
-  # @see convert_all!
-  def initialize(hash = {}, &block)
-    __hash__.merge! ::Ribbon.extract_hash_from(hash)
+  # @param [Ribbon, Ribbon::Raw, #to_hash] initial_values the initial values
+  # @see #raw=
+  # @see Ribbon::Raw#initialize
+  def initialize(initial_values = Ribbon::Raw.new, &block)
+    self.raw = initial_values
     __yield_or_eval__ &block
-   ::Ribbon.convert_all! self
   end
 
-  # Fetches the value associated with the given key.
-  #
-  # If given a block, the value will be yielded to it. If the block doesn't take
-  # any arguments, it will be evaluated in the context of the value.
+  # The hash used by the raw ribbon.
   #
-  # @param key the key which identifies the value
-  # @return the value associated with the given key
-  # @see CoreExt::BasicObject#__yield_or_eval__
-  def [](key, &block)
-    value = ::Ribbon.convert __hash__[key]
-    value.__yield_or_eval__ &block
-    self[key] = value
+  # @return [Hash] the internal hash of the raw ribbon
+  # @since 0.8.0
+  def internal_hash
+    raw.__hash__
   end
 
-  # Associates the given values with the given key.
-  #
-  # @param key the key that will identify the values
-  # @param values the values that will be associated with the key
-  # @example
-  #   ribbon = Ribbon.new
-  #
-  #   ribbon[:key] = :value
-  #   ribbon[:key]
-  #   # => :value
-  #
-  #   ribbon[:key] = :multiple, :values
-  #   ribbon[:key]
-  #   # => [:multiple, :values]
-  def []=(key, *values)
-    __hash__[key] = if values.size == 1 then values.first else values end
+  # Forwards the method, arguments and block to the raw ribbon's hash, if it
+  # responds to the method, or to the raw ribbon itself otherwise.
+  def method_missing(method, *arguments, &block)
+    if (hash = internal_hash).respond_to? method then hash
+    else raw end.__send__ method, *arguments, &block
   end
 
-  # Handles the following cases:
+  # Merges everything inside this ribbon with everything inside the given
+  # ribbon, creating a new instance in the process.
   #
-  #   ribbon.method                  =>  ribbon[method]
-  #   ribbon.method   value          =>  ribbon[method] = value
-  #   ribbon.method          &block  =>  ribbon[method, &block]
-  #   ribbon.method   value, &block  =>  ribbon[method] = value
-  #                                      ribbon[method, &block]
+  # @param [Ribbon, Ribbon::Raw, #to_hash] ribbon the ribbon with new values
+  # @return [Ribbon] a new ribbon containing the results of the deep merge
+  # @yieldparam key the key which identifies both values
+  # @yieldparam old_value the value from this ribbon
+  # @yieldparam new_value the value from the given ribbon
+  # @yieldreturn the object that will be used as the new value
+  # @since 0.8.0
+  # @see #deep_merge!
+  # @see deep_merge
+  def deep_merge(ribbon, &block)
+    Ribbon.new Ribbon.deep_merge(self, ribbon, &block)
+  end
+
+  # Merges everything inside this ribbon with the given ribbon in place.
   #
-  #   ribbon.method = value          =>  ribbon[method] = value
+  # @param [Ribbon, Ribbon::Raw, #to_hash] ribbon the ribbon with new values
+  # @return [self] this ribbon
+  # @yieldparam key the key which identifies both values
+  # @yieldparam old_value the value from this ribbon
+  # @yieldparam new_value the value from the given ribbon
+  # @yieldreturn the object that will be used as the new value
+  # @since 0.8.0
+  # @see #deep_merge
+  # @see deep_merge!
+  def deep_merge!(ribbon, &block)
+    Ribbon.deep_merge! self, ribbon, &block
+  end
+
+  # Converts this ribbon and all ribbons inside into hashes.
   #
-  #   ribbon.method!  value          =>  ribbon[method] = value
-  #                                      self
-  #   ribbon.method!         &block  =>  ribbon[method, &block]
-  #                                      self
-  #   ribbon.method!  value, &block  =>  ribbon[method] = value
-  #                                      ribbon[method, &block]
-  #                                      self
+  # @return [Hash] the converted contents of this wrapped ribbon
+  # @since 0.8.0
+  def to_hash
+    to_hash_recursive
+  end
+
+  # Converts this ribbon to a hash and serializes it with YAML.
   #
-  #   ribbon.method?                 =>  ribbon.__hash__.fetch method
-  #   ribbon.method?  value          =>  ribbon.__hash__.fetch method, value
-  #   ribbon.method?         &block  =>  ribbon.__hash__.fetch method, &block
-  #   ribbon.method?  value, &block  =>  ribbon.__hash__.fetch method, value, &block
-  def method_missing(method, *args, &block)
-    method_string = method.to_s
-    key = method_string.strip.gsub(/[=?!]$/, '').strip.intern
-    case method_string[-1]
-      when ?=
-        __send__ :[]=, key, *args
-      when ?!
-        __send__ :[]=, key, *args unless args.empty?
-        self[key, &block]
-        self
-      when ??
-        begin self.__hash__.fetch key, *args, &block
-        rescue ::KeyError; nil end
-      else
-        __send__ :[]=, key, *args unless args.empty?
-        self[key, &block]
-    end
+  # @return [String] the YAML string that represents this ribbon
+  # @since 0.8.0
+  # @see from_yaml
+  def to_yaml
+    to_hash.to_yaml
   end
 
-  # Generates a simple <tt>key: value</tt> string representation of this ribbon.
+  # Delegates to the raw ribbon.
   #
-  # @option opts [String] :separator Separates the key/value pair.
-  #                                  Default is <tt>': '</tt>.
-  # @option opts [Symbol] :key       Will be sent to the key in order to convert
-  #                                  it to a string. Default is <tt>:to_s</tt>.
-  # @option opts [Symbol] :value     Will be sent to the value in order to
-  #                                  convert it to a string. Default is
-  #                                  <tt>:inspect</tt>.
   # @return [String] the string representation of this ribbon
-  def to_s(opts = {})
-    __to_s_recursive__ ::Ribbon.extract_hash_from(opts)
+  # @see Ribbon::Raw#to_s
+  def to_s(*arguments, &block)
+    raw.to_s *arguments, &block
   end
 
   alias inspect to_s
 
   private
 
-  # Computes a string value recursively for the given ribbon, and all ribbons
-  # inside it, using the given options.
+  # Converts this ribbon and all ribbons inside into hashes using recursion.
   #
-  # @since 0.3.0
-  # @see #to_s
-  def __to_s_recursive__(opts = {}, ribbon = self)
-    ksym = opts.fetch(:key,   :to_s).to_sym
-    vsym = opts.fetch(:value, :inspect).to_sym
-    separator = opts.fetch(:separator, ': ').to_s
-    values = ribbon.__hash__.map do |k, v|
-      k = k.ribbon if ::Ribbon.wrapped? k
-      v = v.ribbon if ::Ribbon.wrapped? v
-      k = if ::Ribbon.instance? k then __to_s_recursive__ opts, k else k.__send__ ksym end
-      v = if ::Ribbon.instance? v then __to_s_recursive__ opts, v else v.__send__ vsym end
-      "#{k}#{separator}#{v}"
-    end.join ', '
-    "{#{values}}"
+  # @return [Hash] the converted contents of this ribbon
+  def to_hash_recursive(raw_ribbon = self.raw)
+    {}.tap do |hash|
+      raw_ribbon.__hash__.each do |key, value|
+        hash[key] = case value
+          when Ribbon then to_hash_recursive value.raw
+          when Ribbon::Raw then to_hash_recursive value
+          else value
+        end
+      end
+    end
   end
 
 end
@@ -200,57 +184,70 @@ class << Ribbon
 
   alias [] new
 
-  # Proc used to store a new Ribbon instance as the value of a missing key.
+  # Whether the given object is a {Ribbon::Raw raw ribbon}.
   #
-  # @return [Proc] the proc used when constructing new hashes
-  # @since 0.4.6
-  def default_value_proc
-    @default_value_proc ||= (proc { |hash, key| hash[key] = Ribbon.new })
+  # @param object the object to be tested
+  # @return [true, false] whether the object is a raw ribbon
+  # @since 0.8.0
+  def raw?(object)
+    Ribbon::Raw === object
   end
 
-  # Converts hashes to ribbons. Will look inside arrays.
+  # Whether the object is compatible with methods that take hashes or ribbons as
+  # arguments.
   #
-  # @param object the object to convert
-  # @return the converted value
-  # @since 0.2.0
-  def convert(object)
+  # @param object the object to be tested
+  # @return [true, false] whether the object is a raw ribbon
+  # @since 0.8.0
+  def compatible?(object)
+    [Ribbon, Ribbon::Raw, Hash].any? { |type| type === object }
+  end
+
+  # Extracts the hash of a ribbon. Will attempt to convert other objects.
+  #
+  # @param [Ribbon, Ribbon::Raw, #to_hash] object the object to convert
+  # @return [Hash] the resulting hash
+  # @since 0.2.1
+  def extract_hash_from(object)
     case object
-      when Hash then Ribbon.new object
-      when Array then object.map { |element| convert element }
-      else object
+      when Ribbon, Ribbon::Raw then object.__hash__
+      else object.to_hash
     end
   end
 
-  # Converts all values inside the given ribbon.
+  # Extracts a raw ribbon from the given object.
   #
-  # @param [Ribbon, Ribbon::Wrapper] ribbon the ribbon whose values are to be
-  #                                         converted
-  # @return [Ribbon, Ribbon::Wrapper] the ribbon with all values converted
-  # @since 0.2.0
-  # @see convert
-  def convert_all!(ribbon)
-    ribbon.__hash__.each do |key, value|
-      ribbon[key] = case value
-        when Ribbon then convert_all! value
-        when Ribbon::Wrapper then convert_all! value.ribbon
-        else convert value
-      end
+  # @param [Ribbon, Ribbon::Raw, #to_hash] object the hash-like object
+  # @return [Ribbon::Raw] the raw ribbon
+  # @since 0.8.0
+  def extract_raw_from(object)
+    case object
+      when Ribbon then object.raw
+      when Ribbon::Raw then object
+      else Ribbon::Raw.new object.to_hash
     end
-    ribbon
+  end
+
+  # Deserializes the hash from the string using YAML and uses it to construct a
+  # new ribbon.
+  #
+  # @param [String] string a valid YAML string
+  # @return [Ribbon] a new Ribbon
+  # @since 0.4.7
+  def from_yaml(string)
+    Ribbon.new YAML.load(string)
   end
 
   # Merges the hashes of the given ribbons.
   #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] old_ribbon the ribbon with old
-  #                                                       values
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] new_ribbon the ribbon with new
-  #                                                       values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] old_ribbon the ribbon with old values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] new_ribbon the ribbon with new values
   # @return [Ribbon] a new ribbon containing the results of the merge
   # @yieldparam key the key which identifies both values
   # @yieldparam old_value the value from old_ribbon
   # @yieldparam new_value the value from new_ribbon
   # @yieldreturn the object that will be used as the new value
-  # @since 0.3.0
+  # @since 0.8.0
   # @see merge!
   # @see extract_hash_from
   def merge(old_ribbon, new_ribbon, &block)
@@ -262,17 +259,15 @@ class << Ribbon
 
   # Merges the hashes of the given ribbons in place.
   #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] old_ribbon the ribbon with old
-  #                                                       values
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] new_ribbon the ribbon with new
-  #                                                       values
-  # @return [Ribbon, Ribbon::Wrapper, Hash] old_ribbon, which will contain the
-  #                                         results of the merge
+  # @param [Ribbon, Ribbon::Raw, #to_hash] old_ribbon the ribbon with old values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] new_ribbon the ribbon with new values
+  # @return [Ribbon, Ribbon::Raw, Hash] old_ribbon, which will contain the
+  #   results of the merge
   # @yieldparam key the key which identifies both values
   # @yieldparam old_value the value from old_ribbon
   # @yieldparam new_value the value from new_ribbon
   # @yieldreturn the object that will be used as the new value
-  # @since 0.3.0
+  # @since 0.8.0
   # @see merge
   # @see extract_hash_from
   def merge!(old_ribbon, new_ribbon, &block)
@@ -284,16 +279,14 @@ class << Ribbon
 
   # Merges everything inside the given ribbons.
   #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] old_ribbon the ribbon with old
-  #                                                       values
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] new_ribbon the ribbon with new
-  #                                                       values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] old_ribbon the ribbon with old values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] new_ribbon the ribbon with new values
   # @return [Ribbon] a new ribbon containing the results of the merge
   # @yieldparam key the key which identifies both values
   # @yieldparam old_value the value from old_ribbon
   # @yieldparam new_value the value from new_ribbon
   # @yieldreturn the object that will be used as the new value
-  # @since 0.4.5
+  # @since 0.8.0
   # @see merge
   # @see deep_merge!
   # @see extract_hash_from
@@ -303,17 +296,15 @@ class << Ribbon
 
   # Merges everything inside the given ribbons in place.
   #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] old_ribbon the ribbon with old
-  #                                                       values
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] new_ribbon the ribbon with new
-  #                                                       values
-  # @return [Ribbon, Ribbon::Wrapper, Hash] old_ribbon, which will contain the
-  #                                         results of the merge
+  # @param [Ribbon, Ribbon::Raw, #to_hash] old_ribbon the ribbon with old values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] new_ribbon the ribbon with new values
+  # @return [Ribbon, Ribbon::Raw, Hash] old_ribbon, which will contain the
+  #   results of the merge
   # @yieldparam key the key which identifies both values
   # @yieldparam old_value the value from old_ribbon
   # @yieldparam new_value the value from new_ribbon
   # @yieldreturn the object that will be used as the new value
-  # @since 0.4.5
+  # @since 0.8.0
   # @see merge!
   # @see deep_merge
   # @see extract_hash_from
@@ -321,74 +312,26 @@ class << Ribbon
     deep :merge!, old_ribbon, new_ribbon, &block
   end
 
-  # Tests whether the given object is an instance of Ribbon.
-  #
-  # @param object the object to be tested
-  # @return [true, false] whether the object is an instance of Ribbon
-  # @since 0.2.0
-  def instance?(object)
-    Ribbon === object
-  end
-
-  # Tests whether the given object is an instance of {Ribbon::Wrapper}.
-  #
-  # @param object the object to be tested
-  # @return [true, false] whether the object is an instance of {Ribbon::Wrapper}
-  # @since 0.2.0
-  def wrapped?(ribbon)
-    Ribbon::Wrapper === ribbon
-  end
-
-  # Wraps an object in a {Ribbon::Wrapper}.
-  #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] object the object to be wrapped
-  # @return [Ribbon::Wrapper] a new wrapped ribbon
-  # @since 0.2.0
-  def wrap(object = ::Ribbon.new, &block)
-    Ribbon::Wrapper.new object, &block
-  end
-
-  # Returns the hash of a Ribbon. Will attempt to convert other objects.
-  #
-  # @param [Ribbon, Ribbon::Wrapper, #to_hash] parameter the object to convert
-  # @return [Hash] the resulting hash
-  # @since 0.2.1
-  def extract_hash_from(parameter)
-    case parameter
-      when Ribbon::Wrapper then parameter.internal_hash
-      when Ribbon then parameter.__hash__
-      else parameter.to_hash
-    end
-  end
-
-  # Deserializes the hash from the string using YAML and uses it to construct a
-  # new ribbon.
-  #
-  # @param [String] string a valid YAML string
-  # @return [Ribbon] a new Ribbon
-  # @since 0.4.7
-  def from_yaml(string)
-    Ribbon.new YAML.load(string)
-  end
-
   private
 
-  # Common logic for deep merge methods. +merge_method+ should be either
-  # +:merge+ or +:merge!+, and denotes which method will be used to merge
-  # recursively.
+  # Common logic for deep merge methods.
   #
+  # @param [:merge, :merge!] merge_method the method that will be used to merge
+  #   recursively
+  # @param [Ribbon, Ribbon::Raw, #to_hash] old_ribbon the ribbon with old values
+  # @param [Ribbon, Ribbon::Raw, #to_hash] new_ribbon the ribbon with new values
   # @yieldparam key the key which identifies both values
   # @yieldparam old_value the value from old_ribbon
   # @yieldparam new_value the value from new_ribbon
   # @yieldreturn the object that will be used as the new value
-  # @since 0.4.5
+  # @since 0.8.0
   # @see merge!
   # @see merge
   # @see deep_merge
   # @see deep_merge!
   def deep(merge_method, old_ribbon, new_ribbon, &block)
     send merge_method, old_ribbon, new_ribbon do |key, old_value, new_value|
-      if instance?(old_value) and instance?(new_value)
+      if [old_value, new_value].all? { |value| compatible? value }
         deep merge_method, old_value, new_value, &block
       else
         if block then block.call key, old_value, new_value

data/lib/ribbon/core_extensions.rb

@@ -1,4 +1,4 @@
-class Ribbon < BasicObject
+class Ribbon
 
   # Extensions to the standard library.
   #
@@ -8,6 +8,11 @@ class Ribbon < BasicObject
 
 end
 
-%w(array basic_object hash object).each do |file|
-  require file.prepend 'ribbon/core_extensions/'
-end
+%w(
+
+ribbon/core_extensions/array
+ribbon/core_extensions/basic_object
+ribbon/core_extensions/hash
+ribbon/core_extensions/object
+
+).each { |file| require file }

data/lib/ribbon/core_extensions/array.rb

@@ -1,6 +1,6 @@
 require 'ribbon'
 
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     # Methods to work with ribbons in arrays.
@@ -9,37 +9,30 @@ class Ribbon < BasicObject
     # @since 0.6.0
     module Array
 
-      # If the last argument is a hash, removes and converts it to a ribbon,
-      # otherwise returns an empty ribbon.
+      # Extracts the last argument as a ribbon or returns an empty one.
       #
-      # @return [Ribbon] the Ribbon at the end of this array
+      # @return [Ribbon] the ribbon at the end of this array
+      # @see #extract_raw_ribbon
       def extract_ribbon!
         case last
-          when Hash then Ribbon.new pop
+          when Hash, Ribbon::Raw then Ribbon.new pop
           when Ribbon then pop
-          when Ribbon::Wrapper then pop.ribbon
           else Ribbon.new
         end
       end
 
-      # Extracts the last argument as a wrapped ribbon, or returns an empty one.
-      # See #extract_ribbon! for details.
-      #
-      # @return [Ribbon::Wrapper] the wrapped Ribbon at the end of this array
-      def extract_wrapped_ribbon!
-        Ribbon.wrap extract_ribbon!
-      end
-
-      # Same as #extract_ribbon!
-      #
-      #
-      # @return [Ribbon] the Ribbon at the end of this array
       alias extract_options_as_ribbon! extract_ribbon!
 
-      # Same as #extract_wrapped_ribbon!
+      # Extracts the last argument as a raw ribbon or returns an empty one.
       #
-      # @return [Ribbon::Wrapper] the wrapped Ribbon at the end of this array
-      alias extract_options_as_wrapped_ribbon! extract_wrapped_ribbon!
+      # @return [Ribbon::Raw] the raw ribbon at the end of this array
+      # @since 0.8.0
+      # @see #extract_ribbon!
+      def extract_raw_ribbon!
+        Ribbon::Raw.new extract_ribbon!
+      end
+
+      alias extract_options_as_raw_ribbon! extract_raw_ribbon!
 
     end
 

data/lib/ribbon/core_extensions/basic_object.rb

@@ -1,4 +1,4 @@
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     # Some useful methods.
@@ -8,12 +8,16 @@ class Ribbon < BasicObject
     module BasicObject
 
       # Evaluates the block using +instance_eval+ if it takes no arguments;
-      # yields +self+ to it otherwise.
+      # yields this object to it otherwise.
       #
-      # @yieldparam [self] object this instance
-      # @return [Object, nil] the result of the block or nil if not given one
+      # @yieldparam [self] object this object
+      # @return [::Object, nil] the result of the block or nil if not given one
       def __yield_or_eval__(&block)
-        if block.arity.zero? then instance_eval &block else block.call self end if block
+        if block.arity.zero?
+          instance_eval &block
+        else
+          block.call self
+        end unless block.nil?
       end
 
     end

data/lib/ribbon/core_extensions/hash.rb

@@ -1,6 +1,6 @@
 require 'ribbon'
 
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     # Includes methods to convert hashes to ribbons.
@@ -9,29 +9,22 @@ class Ribbon < BasicObject
     # @since 0.6.0
     module Hash
 
-      # Converts this hash to a Ribbon.
+      # Converts this hash to a ribbon.
       #
-      # @return a new Ribbon with the contents of this hash
+      # @return [Ribbon] a new ribbon with the contents of this hash
       def to_ribbon
         Ribbon.new self
       end
 
-      # Converts this hash to a Ribbon::Wrapper.
-      #
-      # @return a new wrapped Ribbon with the contents of this hash
-      def to_ribbon_wrapper
-        Ribbon.wrap self
-      end
-
-      # Same as #to_ribbon.
-      #
-      # @return a new Ribbon with the contents of this hash
       alias to_rbon to_ribbon
 
-      # Same as #to_ribbon_wrapper.
+      # Converts this hash to a raw ribbon.
       #
-      # @return a new wrapped Ribbon with the contents of this hash
-      alias to_wrapped_ribbon to_ribbon_wrapper
+      # @return [Ribbon::Raw] a new raw ribbon with the contents of this hash
+      # @since 0.8.0
+      def to_raw_ribbon
+        Ribbon.wrap self
+      end
 
     end
 

data/lib/ribbon/core_extensions/object.rb

@@ -1,4 +1,4 @@
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     # Methods available to all objects.
@@ -13,6 +13,9 @@ class Ribbon < BasicObject
   end
 end
 
-%w(option_scope yield_or_eval).each do |file|
-  require file.prepend 'ribbon/core_extensions/object/'
-end
+%w(
+
+ribbon/core_extensions/object/option_scope
+ribbon/core_extensions/object/yield_or_eval
+
+).each { |file| require file }

data/lib/ribbon/core_extensions/object/option_scope.rb

@@ -1,6 +1,6 @@
 require 'ribbon/options'
 
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     module Object

data/lib/ribbon/core_extensions/object/yield_or_eval.rb

@@ -1,6 +1,6 @@
 require 'ribbon/core_extensions/basic_object'
 
-class Ribbon < BasicObject
+class Ribbon
   module CoreExtensions
 
     module Object

data/lib/ribbon/gem.rb

@@ -1,6 +1,6 @@
 require 'jewel'
 
-class Ribbon < BasicObject
+class Ribbon
 
   # Ribbon gem information and metadata.
   #

data/lib/ribbon/options.rb

@@ -1,7 +1,11 @@
-require 'ribbon'
-require 'ribbon/core_extensions/array'
+%w(
 
-class Ribbon < BasicObject
+ribbon
+ribbon/core_extensions/array
+
+).each { |file| require file }
+
+class Ribbon
 
   # Applies options to all method calls.
   #
@@ -23,10 +27,9 @@ class Ribbon < BasicObject
     # the block immediately, if given one.
     #
     # @param receiver the object that will be receiving the methods
-    # @param [Ribbon, Ribbon::Wrapper, #to_hash] options the options that will
-    #                                                    be applied to all
-    #                                                    methods
-    # @see CoreExt::BasicObject#__yield_or_eval__
+    # @param [Ribbon, Ribbon::Raw, #to_hash] options the options that will be
+    #   applied to all methods
+    # @see CoreExtensions::BasicObject#__yield_or_eval__
     def initialize(receiver, options = {}, &block)
       @receiver, @options = receiver, options
       __yield_or_eval__ &block

data/lib/ribbon/raw.rb

@@ -0,0 +1,195 @@
+%w(
+
+ribbon
+ribbon/core_extensions/basic_object
+
+).each { |file| require file }
+
+class Ribbon
+
+  # Ribbon with the least amount of helper methods defined.
+  #
+  # @author Matheus Afonso Martins Moreira
+  # @since 0.8.0
+  # @see Ribbon
+  class Raw < BasicObject
+
+    # The hash used internally.
+    #
+    # @return [Hash] the hash used by this Ribbon instance to store data
+    # @api private
+    def __hash__
+      @hash ||= (::Hash.new &::Ribbon::Raw.default_value_proc)
+    end
+
+    # Initializes a new raw ribbon with the given values.
+    #
+    # If given a block, the raw ribbon will be yielded to it. If the block
+    # doesn't take any arguments, it will be evaluated in the context of the raw
+    # ribbon.
+    #
+    # All objects inside the hash will be {convert_all! converted}.
+    #
+    # @param [Ribbon, Ribbon::Raw, #to_hash] hash the hash with initial values
+    # @see CoreExtensions::BasicObject#__yield_or_eval__
+    def initialize(hash = {}, &block)
+      __hash__.merge! ::Ribbon.extract_hash_from hash
+      __yield_or_eval__ &block
+     ::Ribbon::Raw.convert_all! self
+    end
+
+    # Fetches the value associated with the given key.
+    #
+    # If given a block, the value will be yielded to it. If the block doesn't take
+    # any arguments, it will be evaluated in the context of the value.
+    #
+    # @param key the key which identifies the value
+    # @return the value associated with the given key
+    # @see CoreExtensions::BasicObject#__yield_or_eval__
+    def [](key, &block)
+      value = ::Ribbon::Raw.convert __hash__[key]
+      value.__yield_or_eval__ &block
+      self[key] = value
+    end
+
+    # Associates the given values with the given key.
+    #
+    # @param key the key that will identify the values
+    # @param values the values that will be associated with the key
+    # @raise [ArgumentError] if the given key is a raw ribbon
+    # @example
+    #   ribbon = Ribbon.new
+    #
+    #   ribbon[:key] = :value
+    #   ribbon[:key]
+    #   # => :value
+    #
+    #   ribbon[:key] = :multiple, :values
+    #   ribbon[:key]
+    #   # => [:multiple, :values]
+    def []=(key, *values)
+      raise ArgumentError, 'Raw Ribbons can not be used as hash keys' if ::Ribbon.raw? key
+      __hash__[key] = if values.size == 1 then values.first else values end
+    end
+
+    # Handles the following cases:
+    #
+    #   ribbon.method                  =>  ribbon[:method]
+    #   ribbon.method   value          =>  ribbon[:method] = value
+    #   ribbon.method          &block  =>  ribbon[:method, &block]
+    #   ribbon.method   value, &block  =>  ribbon[:method] = value
+    #                                      ribbon[:method, &block]
+    #
+    #   ribbon.method = value          =>  ribbon[:method] = value
+    #
+    #   ribbon.method!  value          =>  ribbon[:method] = value
+    #                                      self
+    #   ribbon.method!         &block  =>  block.call ribbon[:method] if ribbon.__hash__.include? :method
+    #                                      self
+    #   ribbon.method!  value, &block  =>  ribbon[:method] = value
+    #                                      block.call ribbon[:method]
+    #                                      self
+    #
+    #   ribbon.method?                 =>  ribbon.__hash__.fetch :method
+    #   ribbon.method?  value          =>  ribbon.__hash__.fetch :method, value
+    #   ribbon.method?         &block  =>  ribbon.__hash__.fetch :method, &block
+    #   ribbon.method?  value, &block  =>  ribbon.__hash__.fetch :method, value, &block
+    def method_missing(method, *arguments, &block)
+      method_name = method.to_s
+      key = method_name.strip.gsub(/[=?!]$/, '').strip.intern
+      case method_name[-1]
+        when ?=
+          __send__ :[]=, key, *arguments
+        when ?!
+          __send__ :[]=, key, *arguments unless arguments.empty?
+          block.call self[key] if block and __hash__.include? key
+          self
+        when ??
+          begin __hash__.fetch key, *arguments, &block
+          rescue ::KeyError; nil end
+        else
+          __send__ :[]=, key, *arguments unless arguments.empty?
+          self[key, &block]
+      end
+    end
+
+    # Generates a simple and customizable human-readable string representation
+    # of this raw ribbon.
+    #
+    # @option options [#to_s] :separator (': ') separates the key/value pair
+    # @option options [#to_sym] :key (:to_s) will be sent to the key in order to
+    #   convert it to a string.
+    # @option options [#to_sym] :value (:inspect) will be sent to the value in
+    #   order to convert it to a string.
+    # @return [String] the string representation of this raw ribbon
+    def to_s(options = {})
+      __to_s_recursive__ ::Ribbon.extract_hash_from(options)
+    end
+
+    alias inspect to_s
+
+    private
+
+    # Computes a string value recursively for the given ribbon, and all ribbons
+    # inside it, using the given options.
+    #
+    # @see #to_s
+    def __to_s_recursive__(options = {}, ribbon = self)
+      ksym = options.fetch(:key,   :to_s).to_sym
+      vsym = options.fetch(:value, :inspect).to_sym
+      separator = options.fetch(:separator, ': ').to_s
+      '{%s}' % ribbon.__hash__.map do |k, v|
+        k = k.__send__ ksym
+        v = v.raw if ::Ribbon === v
+        v = if ::Ribbon.raw? v then __to_s_recursive__ options, v
+        else v.__send__ vsym end
+        '%s%s%s' % [ k, separator, v ]
+      end.join(', ')
+    end
+
+  end
+
+end
+
+class << Ribbon::Raw
+
+  alias [] new
+
+  # Proc used to store a new {Ribbon ribbon} instance as the value of a missing
+  # key.
+  #
+  # @return [Proc] the proc used when constructing new hashes
+  def default_value_proc
+    @default_value_proc ||= (proc { |hash, key| hash[key] = Ribbon.new })
+  end
+
+  # Converts hashes to ribbons. Will look inside arrays.
+  #
+  # @param object the object to convert
+  # @return the converted value
+  def convert(object)
+    case object
+      when Hash then Ribbon.new object
+      when Array then object.map { |element| convert element }
+      else object
+    end
+  end
+
+  # Converts all values inside the given ribbon.
+  #
+  # @param [Ribbon, Ribbon::Raw] ribbon the ribbon whose values are to be
+  #   converted
+  # @return [Ribbon, Ribbon::Raw] the ribbon with all values converted
+  # @see convert
+  def convert_all!(ribbon)
+    ribbon.__hash__.each do |key, value|
+      ribbon[key] = case value
+        when Ribbon then convert_all! value.raw
+        when Ribbon::Raw then convert_all! value
+        else convert value
+      end
+    end
+    ribbon
+  end
+
+end

data/ribbon.version

@@ -1 +1 @@
-0.7.0
+0.8.0

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ribbon
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000 Z
+date: 2012-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jewel
@@ -98,7 +98,7 @@ files:
 - lib/ribbon/core_extensions/object/yield_or_eval.rb
 - lib/ribbon/gem.rb
 - lib/ribbon/options.rb
-- lib/ribbon/wrapper.rb
+- lib/ribbon/raw.rb
 - ribbon.gemspec
 - ribbon.version
 homepage: https://github.com/matheusmoreira/ribbon
@@ -115,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1868364444812272642
+      hash: 834480014355200814
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -124,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1868364444812272642
+      hash: 834480014355200814
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24

data/lib/ribbon/wrapper.rb

@@ -1,224 +0,0 @@
-require 'ribbon'
-
-class Ribbon < BasicObject
-
-  # Wraps a Ribbon in order to provide general-purpose methods.
-  #
-  # Ribbons are designed to use methods as hash keys. In order to maximize the
-  # number of possibilities, many useful methods, including methods from Object,
-  # were left out and included in this class instead.
-  #
-  # You can use wrapped ribbons like an ordinary hash. Any undefined methods
-  # will be sent to the ribbon's hash. If the hash doesn't respond to the
-  # method, it will be sent to the ribbon itself.
-  #
-  #   wrapper = Ribbon::Wrapper.new
-  #
-  #   wrapper.a.b.c
-  #    => {}
-  #   wrapper.keys
-  #    => [:a]
-  #
-  # Keep in mind that nested ribbons may or may not be wrapped:
-  #
-  #   wrapper.a.b.c.keys
-  #    => {}
-  #   wrapper
-  #    => {a: {b: {c: {keys: {}}}}}
-  #
-  # You can wrap and unwrap all ribbons inside:
-  #
-  #   wrapper.wrap_all!
-  #   wrapper.unwrap_all!
-  # @author Matheus Afonso Martins Moreira
-  # @since 0.2.0
-  # @see Ribbon
-  class Wrapper
-
-    # The wrapped Ribbon.
-    #
-    # @return [Ribbon] the ribbon wrapped by this instance
-    def ribbon
-      @ribbon ||= Ribbon.new
-    end
-
-    # Wraps a Ribbon, another Wrapper's Ribbon or a hash.
-    #
-    # @param [Ribbon, Ribbon::Wrapper, #to_hash] ribbon the ribbon that will be
-    #                                                   wrapped
-    # @return [Ribbon] the wrapped Ribbon
-    def ribbon=(ribbon)
-      @ribbon = case ribbon
-        when Wrapper then ribbon.ribbon
-        when Ribbon then ribbon
-        else Ribbon.new ribbon.to_hash
-      end
-    end
-
-    # Wraps the given Ribbon, another Wrapper's Ribbon or a hash.
-    #
-    # If given a block, the wrapper will be yielded to it. If the block doesn't
-    # take any arguments, it will be evaluated in the context of the wrapper.
-    #
-    # @see #ribbon=
-    # @see Ribbon#initialize
-    def initialize(ribbon = Ribbon.new, &block)
-      self.ribbon = ribbon
-      __yield_or_eval__ &block
-    end
-
-    # The hash used by the wrapped Ribbon.
-    #
-    # @return [Hash] the internal hash of the Ribbon wrapped by this instance
-    # @since 0.5.0
-    def internal_hash
-      ribbon.__hash__
-    end
-
-    # Forwards the method, arguments and block to the wrapped Ribbon's hash, if
-    # it responds to the method, or to the ribbon itself otherwise.
-    def method_missing(method, *args, &block)
-      if (hash = internal_hash).respond_to? method then hash
-      else ribbon end.__send__ method, *args, &block
-    end
-
-    # Merges the contents of this wrapped Ribbon with the contents of the given
-    # Ribbon into a new Ribbon::Wrapper instance.
-    #
-    # @param [Ribbon, Ribbon::Wrapper, #to_hash] ribbon the ribbon with new
-    #                                                   values
-    # @return [Ribbon::Wrapper] a new wrapped ribbon containing the results of
-    #                           the merge
-    # @yieldparam key the key which identifies both values
-    # @yieldparam old_value the value from this wrapped Ribbon
-    # @yieldparam new_value the value from the given ribbon
-    # @yieldreturn the object that will be used as the new value
-    # @since 0.4.5
-    # @see #deep_merge!
-    # @see Ribbon.deep_merge
-    def deep_merge(ribbon, &block)
-      Ribbon.wrap Ribbon.deep_merge(self, ribbon, &block)
-    end
-
-    # Merges this wrapped Ribbon with the given Ribbon.
-    #
-    # @param [Ribbon, Ribbon::Wrapper, #to_hash] ribbon the ribbon with new
-    #                                                   values
-    # @return [self] this Ribbon::Wrapper instance
-    # @yieldparam key the key which identifies both values
-    # @yieldparam old_value the value from this wrapped Ribbon
-    # @yieldparam new_value the value from the given ribbon
-    # @yieldreturn the object that will be used as the new value
-    # @since 0.4.5
-    # @see #deep_merge
-    # @see Ribbon.deep_merge!
-    def deep_merge!(ribbon, &block)
-      Ribbon.deep_merge! self, ribbon, &block
-    end
-
-    # Wraps all ribbons contained by this wrapper's ribbon.
-    #
-    # @return [self] this Ribbon::Wrapper instance
-    # @since 0.3.0
-    def wrap_all!
-      wrap_all_recursive!
-    end
-
-    # Unwraps all ribbons contained by this wrapper's ribbon.
-    #
-    # @return [Ribbon] the Ribbon wrapped by this instance
-    # @since 0.3.0
-    def unwrap_all!
-      unwrap_all_recursive!
-    end
-
-    # Converts the wrapped Ribbon and all ribbons inside into hashes.
-    #
-    # @return [Hash] the converted contents of this wrapped Ribbon
-    def to_hash
-      to_hash_recursive
-    end
-
-    # Converts the wrapped ribbon to a hash and serializes it with YAML.
-    #
-    # @return [String] the YAML string that represents this Ribbon
-    # @see from_yaml
-    def to_yaml
-      to_hash.to_yaml
-    end
-
-    # Delegates to the wrapped Ribbon.
-    #
-    # @return [String] the string representation of this Ribbon::Wrapper
-    # @see Ribbon#to_s
-    def to_s
-      ribbon.to_s
-    end
-
-    private
-
-    # Converts the wrapped ribbon and all ribbons inside into hashes using
-    # recursion.
-    #
-    # @return [Hash] the converted contents of the wrapped Ribbon
-    def to_hash_recursive(ribbon = self.ribbon)
-      {}.tap do |hash|
-        ribbon.__hash__.each do |key, value|
-          hash[key] = case value
-            when Ribbon then to_hash_recursive value
-            when Ribbon::Wrapper then to_hash_recursive value.ribbon
-            else value
-          end
-        end
-      end
-    end
-
-    # Recursively wraps all ribbons and hashes inside.
-    #
-    # @return [self] this Ribbon::Wrapper instance
-    # @since 0.3.0
-    def wrap_all_recursive!(wrapper = self)
-      (hash = wrapper.internal_hash).each do |key, value|
-        hash[key] = case value
-          when Ribbon, Hash then wrap_all_recursive! Ribbon::Wrapper[value]
-          else value
-        end
-      end
-      wrapper
-    end
-
-    # Recursively unwraps all wrapped ribbons inside.
-    #
-    # @return [Ribbon] the Ribbon wrapped by this instance
-    # @since 0.3.0
-    def unwrap_all_recursive!(ribbon = self.ribbon)
-      ribbon.__hash__.each do |key, value|
-        ribbon[key] = case value
-          when Ribbon::Wrapper then unwrap_all_recursive! value.ribbon
-          else value
-        end
-      end
-      ribbon
-    end
-
-  end
-
-  class << Wrapper
-
-    # Wraps a Ribbon instance.
-    #
-    # @see #initialize
-    alias [] new
-
-    # Deserializes the hash from the +string+ using YAML and uses it to
-    # construct a new wrapped ribbon.
-    #
-    # @return [Ribbon::Wrapper] a new wrapped Ribbon
-    # @since 0.4.4
-    # @see #to_yaml
-    def from_yaml(string)
-      ::Ribbon::Wrapper.new YAML.load(string)
-    end
-
-  end
-end