hard_boiled 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in hard-boiled.gemspec
+gemspec
+
+gem 'rspec'

data/README.md

@@ -0,0 +1,40 @@
+## HardBoiled
+
+simply define mapping from you model to a simple hash. For those who worked with [thoughtbot](http://thoughtbot.com)'s [factory girl](http://github.com/thoughtbot/factory_girl) the DSL should be familiar.
+
+### Installation
+
+    gem install hard-boiled
+
+### Usage
+
+```ruby
+require 'hard-boiled'
+
+egg = OpenStruct.new({
+  :boil_time => 7,
+  :temperature => 99,
+  :colour => "beige"
+})
+
+HardBoiled::Presenter.define egg do
+  time :from => :boil_time
+  colour
+  temperature :format => "%d ℃"
+end # => { :time => 7, :temperature => "99 ℃", :colour => "beige" }
+```
+
+for more examples see the tests in the `spec` directory.
+
+### Similar Projects
+
+If _hard-boiled_ isn't your cup of tea, go and check out other ways to map models
+to hashes (for data serialization):
+
+* [Representative](https://github.com/mdub/representative)
+* [Tokamak](https://github.com/abril/tokamak)
+* [Builder](http://rubygems.org/gems/builder)
+* [JSONify](https://github.com/bsiggelkow/jsonify)
+* [Argonaut](https://github.com/jbr/argonaut)
+* [JSON Builder](https://github.com/dewski/json_builder)
+* [RABL](https://github.com/nesquena/rabl)

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/hard_boiled.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hard_boiled/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hard_boiled"
+  s.version     = HardBoiled::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lennart Melzer"]
+  s.email       = ["me@lmaa.name"]
+  s.homepage    = ""
+  s.summary     = %q{Get your models boiled down to plain hashes!}
+  s.description = %q{
+    HardBoiled helps you reducing your complex models (including their associations)
+    down to simple hashes usable for serialization into JSON or XML.
+
+    It leverages a DSL similar to thoughtbot's FactoryGirl
+    to make mappings maintainable and pain-free.
+  }
+
+  s.rubyforge_project = "hard_boiled"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/hard_boiled/blank.rb

@@ -0,0 +1,13 @@
+class Array
+  # Synonym for #empty?
+  def blank?
+    self.empty?
+  end
+end
+
+class NilClass
+  # Synonym for #nil?
+  def blank?
+    self.nil?
+  end
+end

data/lib/hard_boiled/extract_options.rb

@@ -0,0 +1,32 @@
+# Somebody said, I won't depend on `ActiveSupport` for one method. Ok
+# these are two but still… taken from the
+# [rails project](https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/array/extract_options.rb)
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)           # => {}
+  #   options(1, 2, :a => :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/lib/hard_boiled/presenter.rb

@@ -0,0 +1,107 @@
+module HardBoiled
+  # Boilerplate
+  require File.dirname(__FILE__)+'/extract_options' unless {}.respond_to?(:extractable_options?)
+  require File.dirname(__FILE__)+'/blank' unless nil.respond_to?(:blank?)
+
+  # This class pretty much resembles what Thoughtbot did in
+  # [FactoryGirl's DefinitionProxy](https://github.com/thoughtbot/factory_girl/blob/master/lib/factory_girl/definition_proxy.rb)
+  # although it just reduces a `class` to a simple `Hash`
+  class Presenter
+    class MissingFilterError < StandardError; end
+    UNPROXIED_METHODS = %w(__send__ __id__ nil? respond_to? class send object_id extend instance_eval initialize block_given? raise)
+
+    (instance_methods + private_instance_methods).each do |m|
+      undef_method m unless UNPROXIED_METHODS.include? m
+    end
+
+    attr_reader :subject, :parent_subject
+
+    def self.define *args, &block
+      # if I could only remove the duplicate `obj`
+      obj = new(*args)
+      obj.instance_eval(&block)
+      obj.to_hash
+    end
+
+    def initialize *args
+      @options = args.extract_options!
+      @subject, @parent_subject = args
+      @hash = {}
+    end
+
+
+    # Decide whether the given trait is being needed
+    #
+    # @param [Symbol] name the identifier for a trait, like :profile
+    # @param [Hash{:only => Array, :except => Array}]
+    # @return [true, false] dependening on in- or exclusion of this trait
+    def with_trait name, &block
+      if (@options[:except].blank? || !@options[:except].include?(name)) &&
+        (@options[:only].blank? || @options[:only].include?(name))
+        self.instance_eval(&block)
+      end
+    end
+
+    def to_hash
+      @hash
+    end
+
+    private
+    def method_missing id, *args, &block
+      options = args.extract_options!
+      params = options[:params]
+      value =
+        if options[:nil]
+          nil
+        else
+          if static = args.shift
+            static
+          else
+            object = options[:parent] ? parent_subject : subject
+            method_name = options[:from] || id
+            if params
+              object.__send__ method_name, *params
+            else
+              object.__send__ method_name
+            end
+          end
+        end
+      @hash[id] =
+        if block_given?
+          if value.kind_of? Array
+            value.map do |v|
+              self.class.define(v, self.subject, &block)
+            end
+          else
+            self.class.define(value, self.subject, &block)
+          end
+        else
+          __set_defaults __format_value(__apply_filters(value, options), options), options
+        end
+      self
+    end
+
+    def __set_defaults value, options
+      if value.nil? and default = options[:default]
+        default
+      else
+        value
+      end
+    end
+
+    def __apply_filters value, options
+      if filters = options[:filters]
+        filters.inject(value) { |result, filter|
+          raise MissingFilterError, filter.to_s unless self.respond_to?(filter)
+          self.__send__(filter, result)
+        }
+      else
+        value
+      end
+    end
+
+    def __format_value value, options
+      (format = options[:format]) ? format % value : value
+    end
+  end
+end

data/lib/hard_boiled/version.rb

@@ -0,0 +1,3 @@
+module HardBoiled
+  VERSION = "0.2.1"
+end

data/lib/hard_boiled.rb

@@ -0,0 +1,3 @@
+module HardBoiled
+  autoload :Presenter, 'hard-boiled/presenter'
+end

data/spec/presenter_spec.rb

@@ -0,0 +1,215 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+module MyFilters
+  def upcase value
+    value.upcase
+  end
+
+  def twice_and_a_half value
+    value * 2.5
+  end
+end
+
+class Filterable < HardBoiled::Presenter
+  include MyFilters
+end
+
+class Calculator
+  def add a, b
+    a + b
+  end
+
+  def zero
+    0
+  end
+
+  def negative
+    -100
+  end
+
+  def tax val = 0.0
+    ((val + 1) * 2700).to_i
+  end
+end
+
+describe HardBoiled::Presenter do
+  let(:egg) {
+    OpenStruct.new({:temperature => 25, :boil_time => 7, :colour => "white"})
+  }
+
+  let(:conventional_egg) {
+    OpenStruct.new({:temperature => 25, :boil_time => 5,
+      :colour => "brownish", :organic => false})
+  }
+
+  it "should produce correct hash" do
+    definition = described_class.define(egg) do
+      colour
+      time :from => :boil_time
+      consumer "Lennart"
+    end
+
+    definition.should == {
+      :colour => "white",
+      :time => 7,
+      :consumer => "Lennart"
+    }
+  end
+
+  context :paramified do
+    it "should pass params to member function" do
+      definition = described_class.define(Calculator.new) do
+        negative
+        zero
+        add :params => [5, 2]
+      end
+
+      definition.should == {
+        :negative => -100,
+        :zero => 0,
+        :add => 7
+      }
+    end
+
+    it "should pass param to member function" do
+      definition = described_class.define(Calculator.new) do
+        null :from => :zero
+        tax
+        sales :from => :tax, :params => 0.19
+      end
+
+      definition.should == {
+        :null => 0,
+        :tax => 2700,
+        :sales => 3213
+      }
+    end
+  end
+
+  context :nested do
+    let(:egg_box) {
+      OpenStruct.new({
+        :eggs => [egg, conventional_egg],
+        :flavour => "extra tasty",
+        :packaged_at => "2011-11-22"
+      })
+    }
+
+    it "should allow nested objects" do
+      definition = Filterable.define egg_box do
+        contents :from => :eggs do
+          colour
+          time :from => :boil_time, :filters => [:twice_and_a_half], :format => "%.2f minutes"
+          taste :from => :flavour, :parent => true
+          consumer "Lennart", :filters => [:upcase]
+          "Return value has to be ignored"
+        end
+
+        date :from => :packaged_at, :format => "on %s"
+      end
+
+      definition.should == {
+        :contents => [
+          {
+            :colour => "white",
+            :time => "17.50 minutes",
+            :consumer => "LENNART",
+            :taste => "extra tasty"
+          },
+          {
+            :colour => "brownish",
+            :time => "12.50 minutes",
+            :consumer => "LENNART",
+            :taste => "extra tasty"
+          }
+        ],
+        :date => "on 2011-11-22"
+      }
+    end
+  end
+
+  context :filtering do
+    it "should apply filters" do
+      definition = Filterable.define egg do
+        colour :filters => [:upcase]
+        time :from => :boil_time
+        consumer "Lennart"
+      end
+
+      definition.should == {
+        :colour => "WHITE",
+        :time => 7,
+        :consumer => "Lennart"
+      }
+    end
+
+    it "should raise on missing filter" do
+      expect {
+        definition = described_class.define egg do
+          colour :filters => [:upcase]
+          time :from => :boil_time
+          consumer "Lennart"
+        end
+      }.to raise_error(HardBoiled::Presenter::MissingFilterError)
+    end
+
+  end
+
+  context :defaults do
+    def with_defaults obj
+      Filterable.define obj do
+        colour :filters => [:upcase]
+        time :from => :boil_time
+        consumer "Lennart"
+        organic :default => true
+      end
+    end
+
+    it "should fallback to defaults" do
+      with_defaults(egg).should == {
+        :colour => "WHITE",
+        :time => 7,
+        :consumer => "Lennart",
+        :organic => true
+      }
+    end
+
+    it "should still use defined values" do
+      with_defaults(conventional_egg).should == {
+        :colour => "BROWNISH",
+        :time => 5,
+        :consumer => "Lennart",
+        :organic => false
+      }
+    end
+  end
+
+  context :traits do
+    def with_traits obj, options = {}
+      Filterable.define(obj, options) {
+        with_trait(:instructions) {
+          with_trait(:timing) {
+            boil_time
+          }
+          temperature
+        }
+        with_trait(:presentation) {
+          colour
+        }
+      }
+    end
+
+    it "should just map instructions" do
+      with_traits(egg, :only => [:instructions]).should == {
+        :temperature => 25
+      }
+    end
+
+    it "should map everything except for timing information" do
+      with_traits(egg, :except => [:timing]).should == {
+        :colour => "white",
+        :temperature => 25
+      }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'hard_boiled'
+
+require 'ostruct'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification
+name: hard_boiled
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Lennart Melzer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-24 00:00:00.000000000 Z
+dependencies: []
+description: ! "\n    HardBoiled helps you reducing your complex models (including
+  their associations)\n    down to simple hashes usable for serialization into JSON
+  or XML.\n\n    It leverages a DSL similar to thoughtbot's FactoryGirl\n    to make
+  mappings maintainable and pain-free.\n  "
+email:
+- me@lmaa.name
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- hard_boiled.gemspec
+- lib/hard_boiled.rb
+- lib/hard_boiled/blank.rb
+- lib/hard_boiled/extract_options.rb
+- lib/hard_boiled/presenter.rb
+- lib/hard_boiled/version.rb
+- spec/presenter_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+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: '0'
+requirements: []
+rubyforge_project: hard_boiled
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Get your models boiled down to plain hashes!
+test_files:
+- spec/presenter_spec.rb
+- spec/spec_helper.rb
+has_rdoc: