hashing 0.0.1.beta.2 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd1eb92fa4ef69893588e90462ba6671051ce607
-  data.tar.gz: 22ce96b6cb54a66f481a0f8ecfeda9337e908353
+  metadata.gz: 58fbbbe8dddf5ac8299796af0123035abba17b68
+  data.tar.gz: 142748d477848bc270bdd7fc4c74be5bcd6335ab
 SHA512:
-  metadata.gz: 008576591fcb187f2bb97ac1524e6c52f13359e814cd8a0370899581c6c2186e45516293ee9de51544fd17caa1fd6854d73bc27535243f87881d86b1c67f6fb1
-  data.tar.gz: 1d37ef8ac7bfd7ffc832add6c6fa0ab754ee5a8079eadaa27bf239008867a73a3eed83637b1a2c63152e30f4dd198f7f42576ca2f3d24f17d9c261007dde9828
+  metadata.gz: a5488323cd2dc9d7d53b2f2c53eeb091b7283b7f3d37be183d2311e67fd2cc5484ce7c02a070051d40ae7e30db87c718ee97f276dd332f9034321ae9f3600dbb
+  data.tar.gz: bbfa91cdfcacc250f95b9a9a1ff66986cb281db6007b8f95dac0198641f446c3fd10a7ad8681a07c455e4f3299952aadea8332cf2b06eb30e4878715dec8e7ab

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+script: 'bundle exec rake'
+rvm:
+  - 2.1.1
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode

data/Gemfile

@@ -1,4 +1,2 @@
 source 'https://rubygems.org'
-
-# Specify your gem's dependencies in hasher.gemspec
 gemspec

data/README.md

@@ -1,8 +1,14 @@
 # Hashing
 
-Permits you to say which instance variables of your objects should be used to
-serialize it into a `Hash`. Gives you a nice way to inform this, and facilitates
-to recreation of your serializable objects from hashes.
+Gives you an easy way to specify which instances vars of your objects should be
+used as `key => value` to serialize it into a hash returned by the `#to_h`
+method. Also gives you a `YourClass::from_hash` to reconstruct the instances.
+
+## Status
+[![Gem Version](https://badge.fury.io/rb/hashing.svg)](http://badge.fury.io/rb/hashing)
+[![Build Status](https://travis-ci.org/ricardovaleriano/hashing.png?branch=master)](http://travis-ci.org/ricardovaleriano/hashing?branch=master)
+[![Code Climate](https://codeclimate.com/github/ricardovaleriano/hashing.png)](https://codeclimate.com/github/ricardovaleriano/hashing)
+[![Inline docs](http://inch-pages.github.io/github/ricardovaleriano/hashing.png)](http://inch-pages.github.io/github/ricardovaleriano/hashing)
 
 ## Installation
 
@@ -78,7 +84,7 @@ class File
   include Hashing
   hasherize :path, :commit, :content
 
-  from_hash ->(hash) {
+  loading ->(hash) {
     new hash[:path], hash[:commit], hash[:content]
   }
 
@@ -105,7 +111,7 @@ The previous example can be writen like this:
 class File
   include Hasherize.new :path, :commit, :content
 
-  from_hash ->(hash) {
+  loading ->(hash) {
     new hash[:path], hash[:commit], hash[:content]
   }
 
@@ -138,7 +144,7 @@ class File
     to_hash: ->(content) { Base64.encode64 content },
     from_hash: ->(content_string) { Base64.decode64 content_string }
 
-  from_hash ->(hash) {
+  loading ->(hash) {
     new hash[:path], hash[:commit], hash[:content]
   }
 
@@ -146,6 +152,20 @@ class File
 end
 ```
 
+#### Custom hasherizing and loading strategies for multiple ivars
+
+You can indicate the same strategies for hasherzing and load from hashes for
+multiple `ivars` if it makes sense to your program:
+
+```ruby
+class File
+  include Hashing
+
+  hasherize :path, :commit,
+    to_hash: ->(value) { value.downcase },
+    from_hash: ->(value) { value.downcase }
+end
+```
 
 #### Nested hasherized objects
 
@@ -203,7 +223,14 @@ this is all that `Hashing` needs to build a `File` instances from a valid `Hash`
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/hasher/fork )
+This was a rapid "scratch your own itch" kind of project. It will make me real
+happy if it can be used used in your software anyhow. If you need something
+different than what is in it, or can solve us some bugs or add documentation, it
+will be very well received!
+
+Here is how you can help this gem:
+
+1. Fork it ( https://github.com/ricardovaleriano/hashing/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/Rakefile

@@ -1,2 +1,13 @@
 require "bundler/gem_tasks"
 
+Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each { |rake| load rake }
+task default: "test"
+
+desc 'line number statistics'
+task :lines do
+  libdir = File.join File.dirname(__FILE__), 'lib'
+  Dir["lib/**/*.rb"].each { |file|
+    lines = File.readlines(file).reject { |line| line =~ /^(\s*)#/ }.count
+    puts "#{lines.to_s.rjust(3)} in #{file}"
+  }
+end

data/hashing.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ricardo Valeriano"]
   spec.email         = ["ricardo.valeriano@gmail.com"]
   spec.summary       = %q{Serialize your objects as Hashes}
-  #spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.description   = %q{Gives you an easy way to specify which instances vars of your objects should be used as `key => value` to serialize it into a hash returned by the `#to_h` method. Also gives you a `YourClass::from_hash` to reconstruct the instances.}
   spec.homepage      = "http://github.com/ricardovaleriano/hashing"
   spec.license       = "MIT"
 
@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest-reporters", "~> 1.0"
 end

data/lib/hasherize.rb

@@ -0,0 +1,40 @@
+require 'hashing'
+
+# Provides some sugar syntax to declare which `ivars` should be used to
+# represent an object as a `Hash`.
+#
+# It respects all the behavior you will get by including {Hashing}. In fact,
+# using this constructor is a shortcut to `include Hashing`, and call
+# `.hasherize`
+#
+# @since 0.0.1
+#
+# @example shortcut to `include Hashing` and call `.hasherize`
+#   class File
+#     include Hasherize.new :path, :commit
+#   end
+#
+# @example configuring :to_hash and :from_hash strategies
+#   class File
+#     include Hasherize.new :content,
+#       to_hash: ->(content) { Base64.encode64 content },
+#       from_hash: ->(content_string) { Base64.decode64 content_string }
+#   end
+class Hasherize < Module
+  # Stores the ivars and options to be repassed to `Hashing.serialize` by the
+  # hook {#included}
+  #
+  # @param ivars_and_options [*args] ivar names and options (`:to_hash` and `:from_hash`)
+  def initialize(*ivars_and_options)
+    @ivars = ivars_and_options
+  end
+
+  # Includes the `Hashing` module and calls {Hashing.hasherize}, repassing the
+  # ivar names an the options received in the constructor
+  def included(serializable_class)
+    serializable_class.module_eval do
+      include Hashing
+    end
+    serializable_class.send :hasherize, *@ivars
+  end
+end

data/lib/hashing/ivar.rb

@@ -0,0 +1,94 @@
+module Hashing
+  # Represents each one of the instance variables in a class that should be used
+  # to represent an object in a `Hash` form (serialization).
+  class Ivar
+    attr_reader :name
+
+    # Configure the name of an `ivar` and the 'callable' objects thath will be
+    # used to prepare the `ivar` value for serialization, and to load the object
+    # from a `Hash`.
+    #
+    # @param name [Symbol] name of a class `ivar`
+    # @param to_h [#call] callable to transform the value when serializing
+    # @param from_hash [#call] callable to transform the value from a `Hash`
+    def initialize(name, to_h = nil, from_hash = nil)
+      @name = name.to_sym
+      @to_h = to_h
+      @from_hash = from_hash
+    end
+
+    # Processes the parameter acordingly to the configuration made in the
+    # constructor. If some was made, return the value after being processed or
+    # else return the value as it is.
+    #
+    # Also guarantee that if a value is a #map, every item with `Hashing` in his
+    # method lookup will be sent the message `#to_h`.
+    #
+    # @param value [Object] object to be processed before being stored in a `Hash`
+    # @return the value that will be stored in the `Hash`
+    def to_h(value)
+      return value unless @to_h
+
+      if value.respond_to? :map
+        value = hasherize value
+      end
+      @to_h.call value
+    end
+
+    # Processes the Object provinient from a `Hash` so it can be used to
+    # reconstruct an instance.
+    #
+    # @param value [Object] object provinient from a hash
+    # @return the value that will be used to reconstruct the original instance
+    def from_hash(value, metadata = {})
+      return value unless @from_hash
+
+      if value.respond_to? :map
+        value = normalize(value, metadata)
+      end
+      @from_hash.call value
+    end
+
+    def to_sym
+      @name.to_sym
+    end
+
+    def to_s
+      @name.to_s
+    end
+
+    private
+    # Is an object descendent of {Hashing}?
+    #
+    # @param value [Object]
+    def hashing?(value)
+      value.class.ancestors.include? Hashing
+    end
+
+    # Hasherize a value when it has {Hashing} in it's method lookup or return
+    # the value. Util when a collection of {Hashing} objects is given and need
+    # to be "hasherized"
+    #
+    # @param value [#map] the value to be verified as a {Hashing} (or not)
+    # @return [#map] collection of hashes
+    def hasherize(collection)
+      collection.map { |item| hashing?(item) ? item.to_h : item }
+    end
+
+    # If a collection of {Hashing} objects is given, we have to reconstruct all
+    # collections members before while reconstructing the collection itself.
+    # This method provides that
+    #
+    # TODO: (need?) recursion to reconstruct collections of collections
+    #
+    # @param value [#map] the collection of {Hashing} objects
+    # @param metadata [Hash] containing serialized data about the original object
+    # @return [#map] collection of {Hashing} instances
+    def normalize(collection, metadata)
+      elements_class = metadata.fetch(:types, {}).fetch(@name, nil)
+      return collection unless elements_class.respond_to? :from_hash
+
+      collection.map { |element| elements_class.from_hash element }
+    end
+  end
+end

data/lib/hashing/version.rb

@@ -1,3 +1,3 @@
 module Hashing
-  VERSION = "0.0.1.beta.2"
+  VERSION = "0.0.1"
 end

data/lib/hashing.rb

@@ -1,5 +1,170 @@
-require "hashing/version"
+require 'hashing/version'
+require 'hashing/ivar'
+require 'hasherize'
 
 module Hashing
-  # Your code goes here...
+  # Inform the user about an attempt to create an instance, using a `Hash` with
+  # keys that does not correspond to the mape made using `.hasherize`
+  class UnconfiguredIvar < StandardError
+    def initialize(ivar_name, class_name)
+      super "The Hash has a :#{ivar_name} key, "+
+        "but no @#{ivar_name} was configured in #{class_name}"
+    end
+  end
+
+  # Inject the public api into the client class.
+  #
+  # @since 0.0.1
+  #
+  # @example including Hashing
+  #   require 'hashing'
+  #
+  #   class File
+  #     include Hashing
+  #     hasherize :path, :commit
+  #
+  #     def initialize(path, commit)
+  #       @path, @commit = path, commit
+  #     end
+  #   end
+  #
+  # When `Hashing` is included, the host class will gain the `.from_hash({})`
+  # method and the `#to_h` instance method.
+  # Another method that will be added is the private class method `.hasherize`
+  # will be added so you can indicate what ivars do you want in your sarialized
+  # objects.
+  def self.included(client_class)
+    client_class.extend Hasherizer
+  end
+
+  def meta_data(name, value)
+    @_hashing_meta_data ||= { __hashing__: { types: {} } }
+    @_hashing_meta_data[:__hashing__][:types][name] = value
+    @_hashing_meta_data
+  end
+
+  #
+  # The `Hash` returned by `#to_h` will be formed by keys based on the ivars
+  # names passed to `hasherize` method.
+  #
+  # @example File hahserized (which include `Hashing`)
+  #
+  #   file = File.new 'README.md', 'cfe9aacbc02528b'
+  #   file.to_h
+  #   # => { path: 'README.md', commit: 'cfe9aacbc02528b' }
+  def to_h
+    hash_pairs = self.class.ivars.map { |ivar|
+      value = instance_variable_get "@#{ivar}"
+      if value.respond_to? :map
+        meta_data ivar.to_sym, value.first.class
+      end
+      [ivar.to_sym, ivar.to_h(value)]
+    }
+    Hash[hash_pairs].merge(@_hashing_meta_data || {})
+  end
+
+  # Define the class methods that should be available in a 'hasherized ®' class
+  # (a class that include `Hashing`).
+  module Hasherizer
+    # Configures which instance variables will be used to compose the `Hash`
+    # generated by `#to_h`
+    #
+    # @api
+    # @param ivars_and_options [*arguments]
+    def hasherize(*ivars_and_options)
+      @ivars ||= []
+      ivars = extract_ivars ivars_and_options
+      to_strategy = strategy_for_key :to_hash, ivars_and_options
+      from_strategy = strategy_for_key :from_hash, ivars_and_options
+      @ivars += ivars.map { |ivar| Ivar.new ivar, to_strategy, from_strategy }
+    end
+
+    # Configures the strategy to (re)create an instance of the 'hasherized ®'
+    # class based on a `Hash` instance. This strategy will be used by the
+    # `.from_hash({})` method.
+    #
+    # This configuration is optional, if it's not called, then the strategy will
+    # be just repassing the `Hash` to the initializer.
+    #
+    # @param strategy [#call]
+    # @return void
+    def loading(strategy)
+      @strategy = strategy
+    end
+
+    # Provides the default strategy for recreate objects from hashes (which is
+    # just call .new passing the `Hash` as is.
+    #
+    # @return the result of calling the strategy
+    def strategy
+      @strategy || ->(h) { new h }
+    end
+
+    # those methods are private but part of the class api (macros).
+    # #TODO: there is a way to document the 'macros' for a class in YARD?
+    private :hasherize, :loading, :strategy
+
+    # provides access to the current configuration on what `ivars` should be
+    # used to generate a `Hash` representation of instances of the client class.
+    #
+    # @return [Array] ivars that should be included in the final Hash
+    def ivars
+      @ivars ||= []
+    end
+
+    # Receives a `Hash` and uses the strategy configured by `.loading` to
+    # (re)create an instance of the 'hasherized ®' class.
+    #
+    # @param pairs [Hash] in a valid form defined by `.hasherize`
+    # @return new object
+    def from_hash(pairs)
+      metadata = pairs.delete(:__hashing__) || {}
+      hash_to_load = pairs.map do |ivar_name, value|
+        ivar = ivar_by_name ivar_name.to_sym
+        [ivar.to_sym, ivar.from_hash(value, metadata)]
+      end
+      strategy.call Hash[hash_to_load]
+    end
+
+    private
+    # Cleanup the arguments received by `.hasherize` so only the `ivar` names
+    # are returned. This is necessarey since the `.hasherize` can receive a
+    # `Hash` with strategies `:from_hash` and `:to_hash` as the last argument.
+    #
+    # @param ivars_and_options [Array] arguments received by `.serialize`
+    # @return [Array[:Symbol]] ivar names that should be used in the `Hash` serialization
+    def extract_ivars(ivars_and_options)
+      ivars = ivars_and_options.dup
+      if ivars.last.is_a? Hash
+        ivars.pop
+      end
+      ivars
+    end
+
+    # Fetches the strategy to serialize or deserialize (defined by the first
+    # param `strategy`) the `ivars` passed as second parameter
+    #
+    # @param hash_key [Symbol] (:to_hash || :from_hash) type of strategy to fetch
+    # @param ivars_and_options [*args | *args, Hash]
+    # @return [#call] strategy to be used
+    def strategy_for_key(strategy, ivars_and_options)
+      default_strategy_just_returns = ->(ivar_value) { ivar_value }
+      strategies = { strategy => default_strategy_just_returns }
+      strategies = ivars_and_options.last if ivars_and_options.last.is_a? Hash
+      strategies[strategy]
+    end
+
+    # Search an `ivar` by it's name in the class ivars collection
+    #
+    # #TODO: Can be enhanced since now the ivars doesn't have a sense of
+    # equality.
+    #
+    # @param ivar_name [Symbol] `ivar` name
+    # @return [Ivar]
+    def ivar_by_name(ivar_name)
+      ivar = ivars.select { |ivar| ivar.to_sym == ivar_name }.first
+      raise UnconfiguredIvar.new ivar_name, name unless ivar
+      ivar
+    end
+  end
 end

data/tasks/test.rake

@@ -0,0 +1,26 @@
+desc "run all tests"
+
+args = ARGV
+args.shift
+files = args
+
+desc "run all the tests"
+
+task :test do
+  lib = File.expand_path("../lib", __FILE__)
+  $: << lib
+
+  loader = ->(files_list){
+    files_list.each do |f|
+      if File.directory?(f)
+        loader.call(Dir.glob(f + "/**/*_test.rb"))
+      else
+        load f
+      end
+    end
+  }
+
+  require_relative "../test/test_helper"
+  files = Dir.glob("test/**/*_test.rb") unless files.size > 0
+  loader.call(files)
+end

data/test/hasherize_test.rb

@@ -0,0 +1,32 @@
+describe Hasherize do
+  let(:hasherized) do
+    Class.new do
+      attr_reader :file, :commit
+
+      include Hasherize.new :file, :commit,
+        to_hash: ->(value) { "X-#{value}" },
+        from_hash: ->(value) { "#{value}-X" }
+
+      loading ->(params) { new params[:file], params[:commit] }
+
+      def initialize(file, commit)
+        @file, @commit = file, commit
+      end
+    end
+  end
+
+  it "just sugar to `include Hashing` and call `hasherize`" do
+    hasherized.ancestors.include?(Hashing).must_be :==, true
+  end
+
+  it "configures the ivars correctly (so I can recreate instances by Hash)" do
+    object = hasherized.from_hash file: 'README.md', commit: 'omglolbbq123'
+    object.file.must_be :==, 'README.md-X'
+    object.commit.must_be :==, 'omglolbbq123-X'
+  end
+
+  it "configure `:to_hash` e `:from_hash` serialization strategies" do
+    object = hasherized.new 'README.md', 'omglolbbq123'
+    object.to_h.must_be :==, { file: 'X-README.md', commit: 'X-omglolbbq123' }
+  end
+end

data/test/hashing/ivar_test.rb

@@ -0,0 +1,32 @@
+describe Hashing::Ivar do
+  it "knows it's ivar name" do
+    ivar = Hashing::Ivar.new :file
+    ivar.name.must_be :==, :file
+  end
+
+  describe '#to_h' do
+    it "uses the lambda passed as parameter to transform the value" do
+      called = false
+      ivar = Hashing::Ivar.new :file, ->(value) { called = value }
+      ivar.to_h 'some value'
+      called.must_be :==, 'some value'
+    end
+
+    it "by default just returns the value as is" do
+      Hashing::Ivar.new(:file).to_h('x').must_be :==, 'x'
+    end
+  end
+
+  describe '#from_hash' do
+    it "uses the lambda passed as parameter to transform the value" do
+      called = false
+      ivar = Hashing::Ivar.new :file, nil, ->(value) { called = value }
+      ivar.from_hash 'loading hash'
+      called.must_be :==, 'loading hash'
+    end
+
+    it "by default just returns the value as is" do
+      Hashing::Ivar.new(:file).from_hash('x').must_be :==, 'x'
+    end
+  end
+end

data/test/hashing/nested_test.rb

@@ -0,0 +1,76 @@
+describe Hashing do
+  describe 'when one of the ivars is an `Array` of hasherized objects' do
+    class HashingCollectionOwner
+      attr_reader :file, :commit, :annotations
+      include Hasherize.new :file, :commit, :annotations
+
+      loading ->(hash) { new hash[:file], hash[:commit], hash[:annotations] }
+
+      def initialize(file, commit, annotations)
+        @file, @commit, @annotations = file, commit, annotations
+      end
+    end
+
+    class HashingCollectionMember
+      attr_reader :annotation
+      include Hasherize.new :annotation,
+        to_hash: ->(value) { "--#{value}" },
+        from_hash: ->(value) { "#{value}--" }
+
+      loading ->(hash) { new hash[:annotation] }
+
+      def initialize(annotation)
+        @annotation = annotation
+      end
+    end
+
+    describe '#to_h' do
+      it 'calls #to_h for each array item when hashifying the object' do
+        owner = HashingCollectionOwner.new 'README.md', 'cfe9aacbc02528b', [
+          HashingCollectionMember.new('first'),
+          HashingCollectionMember.new('second'),
+        ]
+        owner.to_h.must_be :==, {
+          file: 'README.md',
+          commit: 'cfe9aacbc02528b',
+          annotations: [
+            { annotation: '--first' },
+            { annotation: '--second' },
+          ],
+          __hashing__: {
+            types: {
+              annotations: HashingCollectionMember
+            }
+          }
+        }
+        p owner.to_h
+      end
+
+      it "don't call the #to_h on inner object that don't include `Hashing`"
+    end
+
+    describe '#from_h' do
+      let(:hash_values) do
+        {
+          file: "README.md",
+          commit: "cfe9aacbc02528b",
+          annotations: [
+            {annotation: "first"},
+            {annotation: "second"}
+          ],
+          __hashing__: {
+            types: {
+              annotations: HashingCollectionMember
+            }
+          }
+        }
+      end
+
+      it 'calls #from_h for each on an yaml array that contains hasherized objects' do
+        owner = HashingCollectionOwner.from_hash hash_values
+        owner.annotations.first.annotation.must_be :==, 'first--'
+        owner.annotations.last.annotation.must_be :==, 'second--'
+      end
+    end
+  end
+end

data/test/hashing_test.rb

@@ -0,0 +1,123 @@
+require "base64"
+
+describe Hashing do
+  describe 'interface' do
+    let(:hasherized) do
+      # if in doubt about the absense of assertions in this test, please
+      # refer to:
+      # - http://blog.zenspider.com/blog/2012/01/assert_nothing_tested.html
+      # and https://github.com/seattlerb/minitest/issues/159
+      Class.new do
+        include Hashing
+        hasherize :ivar
+        loading ->() {}
+      end
+    end
+
+    it 'adds the ::from_hash method' do
+      hasherized.respond_to?(:from_hash).must_be :==, true
+    end
+
+    it 'adds the #to_h method' do
+      hasherized.new.respond_to?(:to_h).must_be :==, true
+    end
+  end# interface
+
+  describe 'Recreating a `hasherized` class instance' do
+    let(:hasherized) do
+      Class.new do
+        attr_reader :h
+
+        include Hashing
+        hasherize :h
+
+        def initialize(h)
+          @h = h
+        end
+      end
+    end
+
+    describe '.loading' do
+      it 'uses (`#call`) the strategy defined by `.loading`' do
+        called = false
+        my_strategy = ->(h) { called = true }
+        hasherized.send :loading, my_strategy
+        hasherized.from_hash Hash.new
+        called.must_be :==, true
+      end
+    end
+
+    describe '#from_hash' do
+      it 'just calls .new if none strategy was defined by .loading' do
+        new_object = hasherized.from_hash h: 'hasherizing'
+        new_object.h.must_be :==, { h: 'hasherizing' }
+      end
+
+      it 'give an informative message in case the Hash is malformed' do
+        OmgLolBBQ = hasherized
+        message = nil
+        proc {
+          begin
+            OmgLolBBQ.from_hash xpto: 'JUST NO!'
+          rescue => e
+            message = e.message
+            raise e
+          end
+        }.must_raise Hashing::UnconfiguredIvar
+        message.must_be :==, 'The Hash has a :xpto key, but no @xpto '+
+          'was configured in OmgLolBBQ'
+      end
+    end
+  end
+
+  describe '.hasherize' do
+    let(:hasherized) do
+      Class.new do
+        include Hashing
+
+        attr_reader :content
+
+        hasherize :file, :commit
+        hasherize :content,
+          to_hash: ->(content) { Base64.encode64(content) },
+          from_hash: ->(hash_string) { Base64.decode64(hash_string) }
+        loading ->(hash) { new hash[:file], hash[:commit], hash[:content] }
+
+        def initialize(file, commit, content)
+          @file, @commit, @content = file, commit, content
+        end
+      end
+    end
+
+    it 'allows configure how to serialize a specific `ivar`' do
+      file = hasherized.new 'README.md', 'cfe9aacbc02528b', '#Hashing\n\nWow. Such code...'
+      file.to_h[:content].must_be :==, Base64.encode64('#Hashing\n\nWow. Such code...')
+    end
+
+    it 'allows configure how to load a value for a specific `ivar`' do
+      file = hasherized.from_hash file: 'README.md',
+        commit: 'cfe9aacbc02528b',
+        content: Base64.encode64('#Hashing\n\nWow. Such code...')
+      file.content.must_be :==, '#Hashing\n\nWow. Such code...'
+    end
+  end
+
+  describe '#to_h' do
+    let(:hasherized) do
+      Class.new do
+        include Hashing
+        hasherize :file, :commit
+        loading ->(hash) { new hash[:file], hash[:commit] }
+
+        def initialize(file, commit)
+          @file, @commit = file, commit
+        end
+      end
+    end
+
+    it 'creates a hash using the ivars based on `.hasherize`' do
+      object = hasherized.new 'README.md', 'cfe9aacbc02528b'
+      object.to_h.must_be :==, { file: 'README.md', commit: 'cfe9aacbc02528b' }
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require "minitest/autorun"
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require_relative "../lib/hashing"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashing
 version: !ruby/object:Gem::Version
-  version: 0.0.1.beta.2
+  version: 0.0.1
 platform: ruby
 authors:
 - Ricardo Valeriano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-26 00:00:00.000000000 Z
+date: 2014-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +38,23 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Gives you an easy way to specify which instances vars of your objects
+  should be used as `key => value` to serialize it into a hash returned by the `#to_h`
+  method. Also gives you a `YourClass::from_hash` to reconstruct the instances.
 email:
 - ricardo.valeriano@gmail.com
 executables: []
@@ -46,13 +62,22 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - hashing.gemspec
+- lib/hasherize.rb
 - lib/hashing.rb
+- lib/hashing/ivar.rb
 - lib/hashing/version.rb
+- tasks/test.rake
+- test/hasherize_test.rb
+- test/hashing/ivar_test.rb
+- test/hashing/nested_test.rb
+- test/hashing_test.rb
+- test/test_helper.rb
 homepage: http://github.com/ricardovaleriano/hashing
 licenses:
 - MIT
@@ -68,13 +93,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Serialize your objects as Hashes
-test_files: []
+test_files:
+- test/hasherize_test.rb
+- test/hashing/ivar_test.rb
+- test/hashing/nested_test.rb
+- test/hashing_test.rb
+- test/test_helper.rb