transcriber 0.0.1 → 0.0.2

data/lib/transcriber/resource/parser.rb

@@ -1,26 +1,29 @@
-class Transcriber::Resource
-  module Parser
-    def parse(input, options = {})
-      entries(input, options).collect {|item| parse_one(item)}
-    end
+module Transcriber
+  class Resource
+    module Parser
+      def parse(input, options = {})
+        prepare_entries(input, options).collect &method(:parse_item)
+      end
 
-    private
+      private
 
-    def entries(input, options)
-      start_key = options[:start_key]
-      entries = input
-      if entries.kind_of?(Hash)
-        entries = entries[start_key.to_s.upcase] if start_key
-        entries = [entries]
+      def prepare_entries(input, options)
+        path = InputPath.resolve(options, Transcriber.configuration.convert_input_keys)
+        Array.wrap digg(input, path)
+      end
+
+      def parse_item(item)
+        self.new.tap do |resource|
+          keys.each do |key|
+            value = digg(item, key.input_path)
+            resource.__send__("#{key.name}=", key.parse(value)) if key.present?(resource)
+          end
+        end
       end
-      entries
-    end
 
-    def parse_one(item)
-      params = keys.inject({}) do |buffer, key|
-        buffer.merge key.name => key.parse(item)
+      def digg(input, path)
+        path.inject(input) {|buffer, key| buffer = buffer[key]}
       end
-      self.new(params)
     end
   end
 end

data/lib/transcriber/resource/response/embeddable.rb

@@ -0,0 +1,14 @@
+module Transcriber
+  class Resource
+    module Response
+      module Embeddable
+        def to_resource(parent)
+          return {} unless present?(parent)
+          embedded = parent.__send__(name)
+          resource = one? ? embedded.resource : embedded.map(&:resource)
+          {name => resource}
+        end
+      end
+    end
+  end
+end

data/lib/transcriber/resource/response/property.rb

@@ -0,0 +1,11 @@
+module Transcriber
+  class Resource
+    module Response
+      module Property
+        def to_resource(parent)
+          present?(parent) ? {name => parent.__send__(name)} : {}
+        end
+      end
+    end
+  end
+end

data/lib/transcriber/resource/response/relation.rb

@@ -0,0 +1,39 @@
+module Transcriber
+  class Resource
+    module Response
+      module Relation
+        def to_resource(parent)
+          included = parent.__send__(name)
+          return {} unless present?(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)
+          has? ?
+            "/#{parent.class.resource_name}/#{parent.id}/#{relation_name(parent)}"
+          : "/#{relation_name(parent).to_s.pluralize}/#{parent.id}/#{parent.class.resource_name}"
+        end
+      end
+    end
+  end
+end

data/lib/transcriber/resource/response.rb

@@ -0,0 +1,11 @@
+module Transcriber
+  class Resource
+    module Response
+      def normalize(model, options = {})
+        model.kind_of?(Enumerable) ?
+          {entries: model.map(&:resource)}
+         : model.resource
+      end
+    end
+  end
+end

data/lib/transcriber/resource/serialization/boolean.rb

@@ -1,13 +1,36 @@
-class Transcriber::Resource
-  module Serialization
-    class Boolean
-      MAPPINGS = {true  => [true,  "true",  "TRUE",  "1", 1, 1.0, "x", "X", "t", "T"],
-                  false => [false, "false", "FALSE", "0", 0, 0.0,  "", " ", "f", "F", nil]}
+module Transcriber
+  class Resource
+    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)
-        return true  if MAPPINGS[true].include?(value)
-        return false if MAPPINGS[false].include?(value)
-        raise "value not serializable: #{{value: value, mappings: MAPPINGS}}"
+        def self.serialize(value)
+          MAPPINGS[value].tap do |bool|
+            fail "value not serializable: #{value}" if bool.nil?
+          end
+        end
       end
     end
   end

data/lib/transcriber/resource/serialization/date.rb

@@ -1,11 +1,11 @@
-class Transcriber::Resource
-  module Serialization
-    class Date
-      def self.serialize(value)
-        begin
+module Transcriber
+  class Resource
+    module Serialization
+      class Date
+        def self.serialize(value)
           ::Date.parse value
-        rescue
-          raise "value not serializable: #{{value: value}}"
+        rescue ArgumentError
+          raise "value not serializable: #{value}"
         end
       end
     end

data/lib/transcriber/resource/serialization/float.rb

@@ -1,8 +1,12 @@
-class Transcriber::Resource
-  module Serialization
-    class Float
-      def self.serialize(value)
-        value.to_f
+module Transcriber
+  class Resource
+    module Serialization
+      class Float
+        def self.serialize(value)
+          Float(value)
+        rescue ArgumentError
+          raise "value not serializable: #{value}"
+        end
       end
     end
   end

data/lib/transcriber/resource/serialization/integer.rb

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

data/lib/transcriber/resource/serialization/string.rb

@@ -1,8 +1,10 @@
-class Transcriber::Resource
-  module Serialization
-    class String
-      def self.serialize(value)
-        "#{value}"
+module Transcriber
+  class Resource
+    module Serialization
+      class String
+        def self.serialize(value)
+          value.nil? ? nil : value.to_s
+        end
       end
     end
   end

data/lib/transcriber/resource.rb

@@ -1,18 +1,13 @@
 module Transcriber
   class Resource
-    autoload :Serialization, 'transcriber/resource/serialization'
-    autoload :Properties,    'transcriber/resource/properties'
-    autoload :Property,      'transcriber/resource/properties/property'
-    autoload :Embeddables,   'transcriber/resource/embeddables'
-    autoload :Embeddable,    'transcriber/resource/embeddables/embeddable'
-    autoload :Parser,        'transcriber/resource/parser'
-    autoload :Responses,     'transcriber/resource/responses'
-
-    extend  Properties
-    extend  Embeddables
+    extend  Builder
     extend  Parser
+    extend  Response
     include Serialization
 
+    cattr_accessor :id_key
+    cattr_writer   :resource_name
+
     def initialize(attrs = {})
       attrs.map {|name, value| send("#{name}=", value)}
     end
@@ -21,12 +16,37 @@ module Transcriber
       @keys ||= []
     end
 
-    def self.resources(entries)
-      {entries: entries.map(&:resource)}
+    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 resource_id
+      __send__(id_key.name)
+    end
+
+    def resource(options = {})
+      root = options.fetch(:root, true)
+      {}.tap do |resource|
+        self.class.keys.inject(resource) {|buffer, key| buffer.merge!(key.to_resource(self))}
+        resource.merge!({links: links}) if root and self.class.relations.any?
+      end
+    end
+
+    def links
+      self.class.relations.map {|key| key.to_relation(self)}
+    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 resource
-      self.class.keys.inject({}) {|buffer, key| buffer.merge key.to_resource(self)}
+    def self.not_allowed_names
+      ["resource_id", "resource", "links"]
     end
   end
 end

data/lib/transcriber/version.rb

@@ -1,3 +1,3 @@
 module Transcriber
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/transcriber.rb

@@ -1,6 +1,42 @@
 require 'date'
-require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
+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 'transcriber/resource/input_path'
+require 'transcriber/resource/parser'
+require 'transcriber/resource/response'
+require 'transcriber/resource/serialization/boolean'
+require 'transcriber/resource/serialization/date'
+require 'transcriber/resource/serialization/float'
+require 'transcriber/resource/serialization/integer'
+require 'transcriber/resource/serialization/string'
+require 'transcriber/resource/key'
+require 'transcriber/resource/parser/property'
+require 'transcriber/resource/parser/embeddable'
+require 'transcriber/resource/response/property'
+require 'transcriber/resource/response/embeddable'
+require 'transcriber/resource/response/relation'
+require 'transcriber/resource/key/property'
+require 'transcriber/resource/key/association'
+require 'transcriber/resource/key/relation'
+require 'transcriber/resource/key/embeddable'
+require 'transcriber/resource/builder/keys'
+require 'transcriber/resource/builder/relations'
+require 'transcriber/resource/builder/embeddables'
+require 'transcriber/resource/builder/properties'
+require 'transcriber/resource/builder'
+require 'transcriber/resource'
+require 'transcriber/configuration'
 
 module Transcriber
-  autoload :Resource, 'transcriber/resource'
+  def self.configuration
+    @configuration ||= Transcriber::Configuration.new
+  end
+
+  def self.configure
+    yield configuration if block_given?
+  end
 end

data/spec/integration/has_many_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "has many" do
+  context_from_example "has_many/simple" do
+    it "sets root" do
+      root.resource.should be_a(Hash)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,22 @@
-require 'transcriber'
+$:.push '../lib'
+
+require 'transcriber'
+require 'ostruct'
+require 'json'
+require 'stringio'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'support/examples'
+require 'support/out'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    [:Example, :ExampleChild].each do |klass|
+      Object.send(:remove_const, klass) if Object.const_defined? klass
+    end
+  end
+end
+
+include Transcriber
+include Output
+include Examples

data/spec/support/examples.rb

@@ -0,0 +1,21 @@
+module Examples
+  def context_from_example(file, &block)
+    context "example #{file}" do
+      silently {eval File.read("examples/#{file}.rb")}
+
+      variables = instance_variables.reject {|var| var.to_s =~ /metadata$/}
+
+      values = variables.inject({}) do |buffer, name|
+        method_name = name.to_s.gsub(/@/, "")
+        let(method_name)           {instance_variable_get(name)}
+        buffer.merge method_name => instance_variable_get(name)
+      end
+
+      before :all do
+        values.each {|name, value| instance_variable_set "@#{name}", value}
+      end
+
+      instance_eval &block if block
+    end
+  end
+end

data/spec/support/out.rb

@@ -0,0 +1,17 @@
+module Output
+  def out
+    output  = StringIO.new
+    begin
+      $stdout = output
+      yield
+    ensure
+      $stdout = STDOUT
+    end
+    output.string
+  end
+
+  def silently
+    out {yield}
+    nil
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Configuration do
+  after(:all) do
+    Transcriber.configuration.convert_input_keys = nil
+  end
+
+  context "when no custom input keys converter is set" do
+    it "returns default key converter" do
+      default_handler = Transcriber::Configuration::DefaultHandler
+      Transcriber.configuration.convert_input_keys.should == default_handler
+    end
+  end
+
+  context "when a custom input keys converter is set" do
+    let(:custom_convert_input_keys) {lambda {|keys| keys}}
+
+    before {Transcriber.configuration.convert_input_keys = custom_convert_input_keys}
+
+    it "returns custom key converter" do
+      Transcriber.configuration.convert_input_keys.should == custom_convert_input_keys
+    end
+  end
+end

data/spec/unit/input_path_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+module Upcasing
+  def self.call(keys)
+    keys.map {|key| key.to_s.upcase}
+  end
+end
+
+describe Resource::InputPath do
+  shared_examples_for "an input path" do
+    it "brings the correct input path" do
+      subject.input_path.should == path
+    end
+  end
+
+  context "when a custom path is not defined" do
+    context "and there is'nt a custom keys input converter" do
+      subject    {Resource::Key.new(:name)}
+      let(:path) {['name']}
+      it_behaves_like "an input path"
+    end
+
+    context "and there is a custom keys input converter" do
+      subject {Resource::Key.new(:name, convert_input_keys: Upcasing)}
+      let(:path) {['NAME']}
+      it_behaves_like "an input path"
+    end
+  end
+
+  context "when a custom path is defined" do
+    context "and it is a simple name" do
+      subject    {Resource::Key.new(:name, field: :other_name)}
+      let(:path) {['other_name']}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot" do
+      subject    {Resource::Key.new(:name, field: 'a.long.way.to.go')}
+      let(:path) {['a', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot" do
+      subject    {Resource::Key.new(:name, field: 'a.long.long.way.to.go')}
+      let(:path) {['a', 'long', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and it is a set of names composed by dot using :start_key instead of :field" do
+      subject    {Resource::Key.new(:name, start_key: 'a.long.way.to.go')}
+      let(:path) {['a', 'long', 'way', 'to', 'go']}
+      it_behaves_like "an input path"
+    end
+
+    context "and there is a custom keys input converter" do
+      let(:options) do
+        {
+          start_key:          'yay.upcase.path',
+          convert_input_keys: Upcasing
+        }
+      end
+
+      subject {Resource::Key.new(:name, options)}
+      let(:path) {['YAY', 'UPCASE', 'PATH']}
+      it_behaves_like "an input path"
+    end
+  end
+end

data/spec/unit/key_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Resource::Key do
+  let(:name)    {"key_name"}
+  let(:options) {{any_option: "here"}}
+
+  subject {Resource::Property.new(name, options)}
+
+  describe "#initialize" do
+    it "sets key name" do
+      subject.name.should == name
+    end
+
+    it "sets options" do
+      subject.options.should == options
+    end
+  end
+
+  describe "present?" do
+    context "when :if option was defined with a proc" do
+      context "and it evaluates to false" do
+        subject {Resource::Property.new(name, {if: proc {false}})}
+
+        it "returns false" do
+          subject.present?(nil).should be_false
+        end
+      end
+
+      context "and it evaluates to true" do
+        subject {Resource::Property.new(name, {if: proc {true}})}
+
+        it "returns true" do
+          subject.present?(nil).should be_true
+        end
+      end
+
+      context "and it depends on resource instance" do
+        subject {Resource::Property.new(name, {if: proc {show}})}
+
+        it "uses it" do
+          resource = OpenStruct.new
+          resource.show = true
+          subject.present?(resource).should be_true
+        end
+      end
+    end
+  end
+end