rest_model 0.1.0

data/lib/rest_model/key/relation/builder.rb

@@ -0,0 +1,24 @@
+class RestModel
+  class Relation
+    module Builder
+      def relation(name, options = {})
+        key Relation.new(name, options)
+      end
+
+      def has_one(name, options = {})
+        options.merge!(many: false, has: true)
+        relation(name, options)
+      end
+
+      def has_many(name, options = {})
+        options.merge!(many: true, has: true)
+        relation(name, options)
+      end
+
+      def belongs_to(name, options = {})
+        options.merge!(many: false, has: false)
+        relation(name, options)
+      end
+    end
+  end
+end

data/lib/rest_model/key/relation/response.rb

@@ -0,0 +1,38 @@
+class RestModel
+  class Relation
+    module Response
+      def to_resource(parent)
+        included = parent.__send__(name)
+        return {} unless visible?(parent) and included
+        {name => resource_from_included(included)}
+      end
+
+      def to_relation(parent)
+        {rel: name, href: href(parent)}
+      end
+
+      private
+
+      def relation_name(parent)
+        relation = parent.class.relations.find do |key|
+          key.resource_class == self.resource_class
+        end
+        relation.name or fail
+      end
+
+      def resource_from_included(included)
+        options = {root: false}
+        one? ?
+          included.resource(options)
+        : included.map {|r| r.resource(options)}
+      end
+
+      def href(parent)
+        id_key = parent.class.id_key.name
+        has? ?
+          "#{RestModel::Configuration.host}/#{parent.class.resource_name}/#{parent.send(id_key)}/#{relation_name(parent)}"
+        : "#{RestModel::Configuration.host}/#{relation_name(parent).to_s.pluralize}/#{parent.send(id_key)}/#{parent.class.resource_name}"
+      end
+    end
+  end
+end

data/lib/rest_model/key/relation.rb

@@ -0,0 +1,23 @@
+class RestModel
+  class Relation < Association
+    autoload :Response, "rest_model/key/relation/response"
+    include Response
+
+    def initialize(name, options = {})
+      super
+      @has = options.fetch(:has, false)
+    end
+
+    def has?
+      @has
+    end
+
+    def belongs?
+      !has?
+    end
+
+    def parse(value, resource = nil)
+      nil
+    end
+  end
+end

data/lib/rest_model/key.rb

@@ -0,0 +1,44 @@
+class RestModel
+  class Key
+    attr_accessor :name, :model, :options, :summarize
+
+    def initialize(name, options = {})
+      @name    = name
+      @options = options
+    end
+
+    def convert_input_keys
+      options.fetch(:convert_input_keys, model.try(:convert_input_keys) ||
+                    RestModel::Configuration.convert_input_keys)
+    end
+
+    def source_path
+      return @source_path.clone if @source_path
+
+      @source_path = Source::Path.resolve(options, convert_input_keys)
+
+      if @source_path.empty? and !root_path?
+        @source_path = convert_input_keys.call([name])
+      end
+
+      @source_path.clone
+    end
+
+    def root_path?
+      path_definition = options.slice(:start_key, :field)
+      path_definition.any? and path_definition.first[1].empty?
+    end
+
+    def present?(resource)
+      !options[:if] ? true : resource.instance_eval(&options[:if])
+    end
+
+    def visible?(resource)
+      !present?(resource) ? false : case visible = options[:visible]
+                                    when nil  then true
+                                    when Proc then resource.instance_eval(&visible)
+                                    else visible
+                                    end
+    end
+  end
+end

data/lib/rest_model/response.rb

@@ -0,0 +1,42 @@
+class RestModel
+  module Response
+    extend ActiveSupport::Concern
+
+    def resource(options = {})
+      root = options.fetch(:root, true)
+
+      {}.tap do |resource|
+        resource_keys(options).inject(resource) do |buffer, key|
+          buffer.merge!(key.to_resource(self))
+        end
+
+        if root and self.class.relations.any? and !options[:summarize]
+          resource.merge!({link: link})
+        end
+      end
+    end
+
+    def link
+      self.class.relations.map {|key| key.to_relation(self)}
+    end
+
+    def resource_keys(options)
+      summarize?(options) ? self.class.summarized_keys + [Href.new]
+                          : self.class.keys
+    end
+
+    def summarize?(options)
+      options[:summarize] and self.class.summarized_keys.any?
+    end
+
+    module ClassMethods
+      def normalize(model, options = {})
+        model.kind_of?(Enumerable) ?
+          {entries: model.map {|m| m.resource(options.merge(summarize: true))}}
+         : model.resource(options)
+      end
+
+      alias :resources :normalize
+    end
+  end
+end

data/lib/rest_model/serialization/boolean.rb

@@ -0,0 +1,48 @@
+class RestModel
+  module Serialization
+    class Boolean
+      MAPPINGS  = {
+        true    => true,
+        "true"  => true,
+        "TRUE"  => true,
+        "1"     => true,
+        1       => true,
+        1.0     => true,
+        "x"     => true,
+        "X"     => true,
+        "t"     => true,
+        "T"     => true,
+        false   => false,
+        "false" => false,
+        "FALSE" => false,
+        "0"     => false,
+        0       => false,
+        0.0     => false,
+        ""      => false,
+        " "     => false,
+        "f"     => false,
+        "F"     => false,
+        nil     => false
+      }.freeze
+
+      def self.serialize(value)
+        MAPPINGS[value].tap do |bool|
+          fail "value not serializable: #{value}" if bool.nil?
+        end
+      end
+
+      def self.desserialize(value)
+        fail unless boolean?(value)
+
+        value ? RestModel.configuration.true_value
+              : RestModel.configuration.false_value
+      end
+
+      private
+
+      def self.boolean?(value)
+        !!value == value
+      end
+    end
+  end
+end

data/lib/rest_model/serialization/date.rb

@@ -0,0 +1,19 @@
+class RestModel
+  module Serialization
+    class Date
+      def self.serialize(value)
+        ::Date.parse value
+      rescue ArgumentError
+        raise "value not serializable: #{value}"
+      end
+
+      def self.desserialize(value)
+        date = value.kind_of?(::Date) ? value : ::Date.parse(value)
+        format = RestModel.configuration.date_format
+        format ? date.strftime(format) : date.to_s
+      rescue ArgumentError
+        raise "value not desserializable: #{value}"
+      end
+    end
+  end
+end

data/lib/rest_model/serialization/enumerable.rb

@@ -0,0 +1,15 @@
+class RestModel
+  module Serialization
+    class Enumerable
+      def self.serialize(value)
+        fail "value not serializable: #{value}" unless value.kind_of?(::Enumerable)
+        value
+      end
+
+      def self.desserialize(value)
+        fail "value not desserializable: #{value}" unless value.kind_of?(::Enumerable)
+        value
+      end
+    end
+  end
+end

data/lib/rest_model/serialization/float.rb

@@ -0,0 +1,17 @@
+class RestModel
+  module Serialization
+    class Float
+      def self.serialize(value)
+        Float(value)
+      rescue ArgumentError
+        raise "value not serializable: #{value}"
+      end
+
+      def self.desserialize(value)
+        Float(value)
+      rescue ArgumentError
+        raise "value not desserializable: #{value}"
+      end
+    end
+  end
+end

data/lib/rest_model/serialization/integer.rb

@@ -0,0 +1,17 @@
+class RestModel
+  module Serialization
+    class Integer
+      def self.serialize(value)
+        Integer(value)
+      rescue ArgumentError
+        raise "value not serializable: #{value}"
+      end
+
+      def self.desserialize(value)
+        Integer(value)
+      rescue ArgumentError
+        raise "value not desserializable: #{value}"
+      end
+    end
+  end
+end

data/lib/rest_model/serialization/string.rb

@@ -0,0 +1,13 @@
+class RestModel
+  module Serialization
+    class String
+      def self.serialize(value)
+        value.nil? ? nil : value.to_s
+      end
+
+      def self.desserialize(value)
+        value.nil? ? nil : value.to_s
+      end
+    end
+  end
+end

data/lib/rest_model/source/path.rb

@@ -0,0 +1,25 @@
+class RestModel
+  module Source
+    module Path
+      def self.resolve(options, convert_input_keys = Key::Converter::DefaultHandler)
+        convert_input_keys.call keys_for_path(custom_path(options))
+      end
+
+      private
+
+      def self.custom_path(options)
+        options.slice(:start_key, :field)
+      end
+
+      def self.keys_for_path(path)
+        return [] if path.empty?
+
+        if path.values.first.kind_of?(Symbol)
+          [path.values.first]
+        else
+          path.values.first.to_s.split('.')
+        end
+      end
+    end
+  end
+end

data/lib/rest_model/source/retriever.rb

@@ -0,0 +1,48 @@
+class RestModel
+  module Source
+    module Retriever
+      def from_source!(input, options = {})
+        from_source(input, options.merge(fail: true))
+      end
+
+      def from_source(input, options = {})
+        entries = prepare_entries(input, options)
+
+        if entries.any? {|e| !e.kind_of?(Hash)}
+          fail "invalid input" if options[:fail]
+          return []
+        end
+
+        entries.collect do |item|
+          handle_item(item.with_indifferent_access, options)
+        end
+      end
+
+      alias :parse! :from_source!
+      alias :parse  :from_source
+
+      private
+
+      def prepare_entries(input, options)
+        path = Source::Path.resolve(options, RestModel::Configuration.convert_input_keys)
+        Array.wrap digg(input, path)
+      end
+
+      def handle_item(item, options)
+        self.new.tap do |resource|
+          keys.each do |key|
+            begin
+              resource.__send__("#{key.name}=", key.from_source(item, resource)) if key.present?(resource)
+            rescue => exception
+              raise exception if options[:fail]
+            end
+          end
+        end
+      end
+
+      def digg(input, path)
+        path.inject(input) {|buffer, key| buffer = buffer[key]}
+      end
+    end
+  end
+end

data/lib/rest_model/source/sender.rb

@@ -0,0 +1,38 @@
+class RestModel
+  module Source
+    module Sender
+      def to_source!(options = {})
+        to_source(options.merge(fail: true))
+      end
+
+      def to_source(options = {})
+        source = {}
+        root_options = {without_nil: options[:without_nil], fail: options[:fail]}
+
+        keys_to_source(options).each do |key|
+          value = __send__(key.name)
+          key_options = options.fetch(key.name, {}).merge(root_options)
+          source.merge! key.to_source!(value, self, key_options)
+        end
+
+        source.with_indifferent_access
+      end
+
+      alias :to_input! :to_source!
+      alias :to_input  :to_source
+
+      private
+
+      def keys_to_source(options)
+        self.class.keys.clone.tap do |keys|
+          keys.reject! {|k| k.kind_of?(Relation)}
+          keys.reject! {|k| Array(options[:without]).include?(k.name)}
+
+          keys.reject! do |key|
+            __send__(key.name).nil? and options[:without_nil]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rest_model/version.rb

@@ -0,0 +1,3 @@
+class RestModel
+  VERSION = "0.1.0"
+end

data/lib/rest_model.rb

@@ -0,0 +1,101 @@
+require "date"
+require "active_support/inflector"
+require "active_support/concern"
+require "active_support/core_ext/class/attribute_accessors"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/hash/indifferent_access"
+
+require "rest_model/source/path"
+require "rest_model/source/retriever"
+require "rest_model/source/sender"
+require "rest_model/response"
+require "rest_model/serialization/boolean"
+require "rest_model/serialization/date"
+require "rest_model/serialization/enumerable"
+require "rest_model/serialization/float"
+require "rest_model/serialization/integer"
+require "rest_model/serialization/string"
+require "rest_model/key"
+require "rest_model/key/property"
+require "rest_model/key/property/builder"
+require "rest_model/key/association"
+require "rest_model/key/relation"
+require "rest_model/key/relation/builder"
+require "rest_model/key/embeddable"
+require "rest_model/key/embeddable/builder"
+require "rest_model/key/href"
+require "rest_model/key/builder"
+require "rest_model/configuration"
+
+class RestModel
+  extend  Key::Builder
+  extend  Source::Retriever
+  include Source::Sender
+  include Response
+  include Serialization
+
+  cattr_accessor :id_key
+  cattr_writer   :resource_name
+
+  def initialize(attrs = {})
+    return if attrs.nil? or attrs.empty?
+
+    attrs = attrs.with_indifferent_access
+
+    self.class.keys.each do |key|
+      __send__("#{key.name}=", key.from_hash(attrs[key.name])) if key.present?(self)
+    end
+  end
+
+  def update_attributes(attrs = {})
+    return if attrs.nil? or attrs.empty?
+
+    attrs = attrs.with_indifferent_access
+
+    self.class.keys.each do |key|
+      value = attrs[key.name]
+
+      if value and key.present?(self)
+        __send__("#{key.name}=", key.from_hash(value, __send__(key.name)))
+      end
+    end
+
+    self
+  end
+
+  def resource_id
+    __send__(id_key.name)
+  end
+
+  def self.keys
+    @keys ||= []
+  end
+
+  def self.summarized_keys
+    @summarized_keys ||= []
+  end
+
+  def self.relations
+    @keys.find_all {|k| k.kind_of?(Relation)}
+  end
+
+  def self.resource_name(custom_name = nil)
+    @resource_name ||= custom_name or to_s.demodulize.tableize
+  end
+
+  def self.convert_input_keys(converter = nil)
+    @convert_input_keys = converter if converter
+    @convert_input_keys
+  end
+
+  def self.method_added(method_name)
+    return unless not_allowed_names.include?(method_name.to_s)
+    puts "warning: redefining '#{method_name}' may cause serious problems"
+  end
+
+  def self.not_allowed_names
+    %w(resource_id resource link)
+  end
+end

data/rest_model.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rest_model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rest_model"
+  s.version     = RestModel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Victor Rodrigues",           "Vinicius Higa",                "William Yokoi"]
+  s.email       = ["victorcrodrigues@gmail.com", "vinicius.higa@locaweb.com.br", "thekina@gmail.com"]
+  s.homepage    = "http://github.com/rodrigues/rest_model"
+  s.summary     = %q{}
+  s.description = %q{}
+
+  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"]
+
+  s.add_dependency "activesupport", "~> 3.0"
+  s.add_dependency "i18n",          ">= 0.5"
+  s.add_development_dependency "rspec",       "~> 2.6"
+  s.add_development_dependency "guard",       "~> 0.5"
+  s.add_development_dependency "guard-rspec", "~> 0.4"
+  s.add_development_dependency "growl",       "~> 1.0"
+end

data/spec/integration/embeds_many_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require "spec_helper"
+
+describe_example "embeds_many/simple" do
+  it "parses first embedded item" do
+    root.items[0].id.should == 2000
+  end
+
+  it "parses second embedded item" do
+    root.items[1].id.should == 2001
+  end
+end
+
+describe_example "embeds_many/invisible" do
+  it "parses invisible items correctly" do
+    root.locale.should == "pt-BR"
+    root.names.should == {"en"=>"Woot", "pt-BR"=>"Úia", "es"=>"Me gusta"}
+  end
+
+  it "doesn't show embedded items in resource" do
+    root.resource.should_not have_key("locale")
+    root.resource.should_not have_key("names")
+  end
+end
+
+describe_example "embeds_many/with_array" do
+  it ""
+end
+
+describe_example "embeds_many/with_class_name" do
+  it "parses embedded item" do
+    root.items[0].id.should == 2000
+  end
+end
+
+describe_example "embeds_many/with_if" do
+  context "when an embeddable has a conditional proc (:if)" do
+    context "and it evaluates to true" do
+      it "parses embedded item" do
+        root_with_items.items.first.id.should == "2000"
+      end
+    end
+
+    context "and it evaluates to false" do
+      it "doesn't parse embedded item" do
+        root_without_items.items.should_not be
+      end
+    end
+  end
+end
+
+describe_example "embeds_many/with_start_key" do
+  it "parses embedded items" do
+    root.items.first.id.should == "2000"
+  end
+end

data/spec/integration/embeds_one_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe_example "embeds_one/simple" do
+  it 'parses embedded item' do
+    root.item.id.should == "2000"
+  end
+end
+
+describe_example "embeds_one/with_class_name" do
+  context 'when a different class name is used for embeddable' do
+    it 'parses embedded item' do
+      root.item.id.should == "2000"
+    end
+  end
+end
+
+describe_example "embeds_one/with_if" do
+  context 'when an embeddable has a conditional proc (:if)' do
+    context 'and it evaluates to true' do
+      it 'parses embedded item' do
+        root_with_item.id.should == "1"
+        root_with_item.item.id.should == "2000"
+      end
+    end
+
+    context 'and it evaluates to false' do
+      it "doesn't parse embedded item" do
+        root_without_item.id.should == "100"
+        root_without_item.item.should_not be
+      end
+    end
+  end
+end
+
+describe_example "embeds_one/with_start_key" do
+  context 'when there is a start key to parse input' do
+    it 'parses embedded item' do
+      root.item.id.should == "2000"
+    end
+  end
+end

data/spec/integration/has_many_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe_example "has_many/simple" do
+  it 'parses properly' do
+    root.id.should == 123
+    root.login.should == 'jackiechan2010'
+  end
+
+  describe "#resource" do
+    subject {root.resource}
+
+    it 'has a link' do
+      subject[:link].should be_an(Array)
+    end
+
+    [:services, :billing, :devops].each do |rel|
+      it "has a #{rel} relation" do
+        subject[:link].any? {|l| l[:rel] == rel}.should be_true
+      end
+
+      it "has a href for #{rel} relation" do
+        link = subject[:link].find {|l| l[:rel] == rel}
+        link[:href].should =~ %r{/customers/123/#{rel}}
+      end
+    end
+  end
+end