api_view 0.5.0

data/example/views/basketball/event.rb

@@ -0,0 +1,15 @@
+class BasketballEventApiView < EventApiView
+
+  attributes :important, :location
+  main_object :event
+
+  def instance_convert
+    if event.ncaa? then
+      field :away_ranking, event.away_ranking
+      field :away_region,  event.away_region
+      field :home_ranking, event.home_ranking
+      field :home_region,  event.home_region
+    end
+  end
+
+end

data/example/views/basketball/play_by_play_record.rb

@@ -0,0 +1,4 @@
+class BasketballPlayByPlayRecordApiView < ::ApiView::Base
+  for_model ::PlayByPlayRecord
+  attributes :points_type, :player_fouls, :player_score, :record_type, :seconds
+end

data/example/views/basketball/team.rb

@@ -0,0 +1,3 @@
+class BasketballTeamApiView < TeamApiView
+  attributes :medium_name, :short_name
+end

data/example/views/box_score.rb

@@ -0,0 +1,5 @@
+
+class BoxScoreApiView < ::ApiView::Base
+  for_model ::BoxScore
+  attributes :has_statistics, :progress
+end

data/example/views/event.rb

@@ -0,0 +1,11 @@
+class EventApiView < EventSummaryApiView
+
+  for_model ::Event
+  attributes :share_url, :sport_name
+  main_object :event
+
+  def instance_convert
+    field :box_score, event.box_score, via: BasketballBoxScoreApiView
+  end
+
+end

data/example/views/event_summary.rb

@@ -0,0 +1,11 @@
+class EventSummaryApiView < ::ApiView::Base
+
+  attributes :game_date, :game_type, :status
+  main_object :event
+
+  def instance_convert
+    field :away_team, event.away_team, via: BasketballTeamApiView
+    field :home_team, event.home_team, via: BasketballTeamApiView
+  end
+
+end

data/example/views/team.rb

@@ -0,0 +1,4 @@
+class TeamApiView < ::ApiView::Base
+  for_model ::Team
+  attributes :abbreviation, :full_name, :location
+end

data/lib/api_view.rb

@@ -0,0 +1,5 @@
+require "api_view/version"
+require 'api_view/engine'
+require 'api_view/base'
+require 'api_view/default'
+require 'api_view/registry'

data/lib/api_view/base.rb

@@ -0,0 +1,88 @@
+module ApiView
+
+  class Base < ::Hash
+
+    class << self
+
+      def for_model(model)
+        ApiView::Registry.add_model(model, self)
+      end
+
+      def render(obj, scope={}, options={})
+        options[:use] = self
+        ApiView::Engine.render(obj, scope, options)
+      end
+
+      def parent_attributes
+        parent = self.superclass
+        return [] if parent.name == "ApiView::Base"
+        return parent.instance_variable_get(:@attributes)
+      end
+
+
+      def main_object(main_object_name)
+        alias_method main_object_name, :object
+      end
+
+      # defines the basic (flat) fields that will be copied from the main object
+      def attributes(*attrs)
+        @attributes ||= []
+        @attributes = (@attributes + attrs).flatten
+        parent_attributes.reverse.each do |a|
+          @attributes.unshift(a) if not @attributes.include? a
+        end
+
+        # create a method which reads each attribute from the model object and
+        # copies it into the hash, then returns the hash itself
+        # e.g.,
+        # def collect_attributes
+        #   self.store(:foo, @object.foo)
+        #   ...
+        #   self
+        # end
+        code = ["def collect_attributes()"]
+        @attributes.each do |a|
+          code << "self.store(:#{a}, @object.#{a})"
+        end
+        code << "end"
+        class_eval(code.join("\n"))
+      end
+      alias_method :attrs, :attributes
+
+    end
+
+    attr_reader :object
+    alias_method :obj, :object
+
+    def initialize(object)
+      super(nil)
+      @object = object
+    end
+
+    def collect_attributes
+      # no-op by default
+    end
+
+    # this is the method that is supposed to be overriden in the subclass
+    def instance_convert
+      # no-op by default, override in you subclass
+    end
+
+    def convert
+      collect_attributes()
+      instance_convert
+      self
+    end
+
+    # hides the details for serialization implementation
+    def field(fieldname, field_object, opts={})
+      serializer = opts[:via]
+      value = if serializer
+        serializer.new(field_object).convert
+      else
+        ApiView::Engine.convert(field_object)
+      end
+      store fieldname, value
+    end
+  end
+end

data/lib/api_view/default.rb

@@ -0,0 +1,20 @@
+module ApiView
+  class Default < Base
+    def self.convert(obj)
+      if obj.respond_to? :to_api then
+        obj.to_api
+      elsif obj.respond_to? :to_hash then
+        obj.to_hash
+      elsif obj.respond_to? :serializable_hash then
+        obj.serializable_hash
+      else
+        obj
+      end
+    end
+
+    # delegate to class method
+    def convert
+      self.class.convert(object)
+    end
+  end
+end

data/lib/api_view/engine.rb

@@ -0,0 +1,116 @@
+
+module ApiView
+  class Engine
+
+    # Classes which require no further conversion
+    BASIC_TYPES = [
+      String, Integer, Fixnum, Bignum, Float,
+      TrueClass, FalseClass,
+      Time, Date, DateTime
+    ]
+    BASIC_TYPES_LOOKUP = BASIC_TYPES.to_set
+    DEFAULT_FORMAT     = 'json'.freeze
+
+    class << self
+
+      # Render the given object as JSON or XML
+      #
+      # @param [Object] obj
+      # @param [ActionDispatch::Request] scope
+      # @param [Hash] options
+      # @option options [String] :format Request a particular format ("json" or "xml")
+      #
+      # @return [String]
+      def render(obj, scope={}, options={})
+        ret = convert(obj, options)
+        # skip the serialization, useful for extra-speed in unit-tests
+        return ret if should_skip?(options)
+
+        # already converted (by default converter, for ex)
+        return ret if ret.kind_of? String
+
+        # TODO cache_results { self.send("to_" + format.to_s) }
+        format = options[:format] || self.request_format(scope)
+        self.send("to_" + format.to_s, ret)
+      end
+
+      def should_skip?(options)
+        options.fetch(:skip_serialization) { @skip_serialization }
+      end
+
+      def skip_serialization=(value)
+        @skip_serialization = value
+      end
+
+      # Convert the given object into a hash, array or other simple type
+      # (String, Fixnum, etc) that can be easily serialized into JSON or XML.
+      #
+      # @param [Object] obj
+      # @return [Object]
+      def convert(obj, options={})
+        return obj                              if is_basic_type?(obj)
+        return convert_hash(obj, options)       if obj.kind_of?(Hash)
+        return convert_enumerable(obj, options) if obj.respond_to?(:map)
+        return convert_custom_type(obj, options)
+      end
+
+      def is_basic_type?(obj)
+        BASIC_TYPES_LOOKUP.include?(obj.class)
+      end
+
+      def convert_hash(obj, options)
+        ret = {}
+        obj.each{ |k,v| ret[k] = convert(v, options) }
+        ret
+      end
+
+      def convert_enumerable(obj, options)
+        if (options.count == 0) then
+          converter = converter_for(obj.first.class, options)
+          return obj.map { |o| converter.new(o).convert }
+        else
+          return obj.map { |o| convert(o, options) }
+        end
+      end
+
+      def convert_custom_type(obj, options)
+        converter_for(obj.class, options).new(obj).convert
+      end
+
+      def converter_for(klazz, options)
+        ApiView::Registry.converter_for(klazz, options)
+      end
+
+      # Returns a JSON representation of the data object
+      def to_json(obj)
+        MultiJson.dump(obj)
+      end
+
+      # Returns an XML representation of the data object
+      def to_xml(obj)
+        obj.to_xml
+      end
+
+      # Returns a guess at the format in this scope
+      # request_format => "xml"
+      def request_format(scope)
+        format   = format_from_params(scope)
+        format ||= format_from_request(scope)
+        return format if (format && self.respond_to?("to_#{format}"))
+        DEFAULT_FORMAT
+      end
+
+      def format_from_params(scope)
+        params = scope.respond_to?(:params) ? scope.params : {}
+        params[:format]
+      end
+
+      def format_from_request(scope)
+        request = scope.respond_to?(:request) && scope.request
+        return unless request
+        request.format.to_sym.to_s if request.respond_to?(:format)
+      end
+
+    end
+  end
+end

data/lib/api_view/registry.rb

@@ -0,0 +1,20 @@
+module ApiView
+  class Registry
+    class << self
+      def models
+        @models ||= {}
+      end
+
+      def add_model(model, converter)
+        models[model.to_s] = converter
+      end
+
+      def converter_for(clazz, options=nil)
+        if options && options[:use].kind_of?(Class) then
+          return options[:use]
+        end
+        models[clazz.to_s] || ApiView::Default
+      end
+    end
+  end
+end

data/lib/api_view/version.rb

@@ -0,0 +1,3 @@
+module ApiView
+  VERSION = "0.5.0"
+end

data/sh/c

@@ -0,0 +1 @@
+irb -r ./sh/env.rb

data/sh/env.rb

@@ -0,0 +1,5 @@
+require 'bundler'
+Bundler.setup
+require 'api_view'
+require './example/require_models'
+puts "API VIEW LOADED"

data/sh/test

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+require 'rake/testtask'
+
+pattern = "{test,lib/**/__tests__}/**/**_test.rb"
+
+if ARGV[0]
+  regex         = %r[#{ARGV[0]}]
+  all_tests = (Dir[pattern]).grep(regex)
+end
+Rake::TestTask.new("my_test") do |test|
+  if all_tests
+    test.test_files = all_tests
+  else
+    test.pattern = pattern
+  end
+  test.verbose = true
+end
+
+Rake::Task['my_test'].invoke

data/sh/update_benchmark

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+
+class Updater
+  def run
+    run_benchmark
+    fix_formatting
+  end
+
+  def run_benchmark
+    exec('ruby example/benchmark.rb > benchmark_results.md')
+  end
+
+  def fix_formatting
+    name = 'benchmark_results.md'
+    c = File.read(name)
+    new_c = c.split("\n").map{|l|
+      if l == ''
+        ''
+      else
+        (" " * 4) + l
+      end
+    }.join("\n")
+    File.open(name, 'w') do |f|
+      f.puts new_c
+    end
+  end
+
+  def exec(cmd)
+    `#{cmd}`
+  end
+end
+
+Updater.new.run

data/test/base_test.rb

@@ -0,0 +1,119 @@
+require './test/test_helper'
+
+describe 'ApiView::Base' do
+  before do
+    ApiView::Engine.skip_serialization = true
+  end
+  after do
+    ApiView::Engine.skip_serialization = false
+  end
+
+  describe 'class methods' do
+    describe '#render' do
+      class RenderTestApiView < ::ApiView::Base
+        attributes :abbreviation, :full_name, :location
+      end
+
+      it "renders json by default" do
+        ApiView::Engine.skip_serialization = false
+        obj      = OpenStruct.new(abbreviation: 'hey', full_name: 'full name', location: 'loc')
+        res      = RenderTestApiView.render(obj)
+        expected = {"abbreviation"=>"hey", "full_name"=>"full name", "location"=>"loc"}
+        MultiJson.load(res).must_equal expected
+      end
+
+      describe 'serialization skipping' do
+        it "global skipping can be overriden for each render call" do
+          ApiView::Engine.skip_serialization = true
+          obj      = OpenStruct.new(abbreviation: 'hey', full_name: 'full name', location: 'loc')
+          res      = RenderTestApiView.render(obj, {}, {skip_serialization: false})
+          expected = "{\"abbreviation\":\"hey\",\"full_name\":\"full name\",\"location\":\"loc\"}"
+          res.must_equal expected
+        end
+
+        it "also returns a hash, if global serialization is skipped" do
+          ApiView::Engine.skip_serialization = true
+          obj      = OpenStruct.new(abbreviation: 'hey', full_name: 'full name', location: 'loc')
+          res      = RenderTestApiView.render(obj)
+          expected = {abbreviation: "hey", full_name: "full name", location: "loc"}
+          res.must_equal expected
+        end
+      end
+    end
+
+    describe '#main_object' do
+      class MainObjectApiView < ::ApiView::Base
+        main_object :main_obj
+        attributes :location
+        def instance_convert
+          field :hey, main_obj.no_hey
+        end
+      end
+
+      it "allows to call object by some custom name" do
+        obj = OpenStruct.new(location: 'some location', no_hey: 'some hey')
+        res = MainObjectApiView.render(obj)
+        res.must_equal({:location=>"some location", :hey=>"some hey"})
+      end
+    end
+
+    describe 'for_model' do
+      class ForModelModel
+        attr_accessor :a, :b
+      end
+      class ForModelApiView < ::ApiView::Base
+        main_object :main_obj
+        for_model ForModelModel
+        attributes :a, :b
+      end
+
+      it "registers this specific serializer with a specific model" do
+        ApiView::Registry.converter_for(ForModelModel).must_equal ForModelApiView
+      end
+    end
+
+
+    describe 'parent_attributes' do
+      parent = Class.new(ApiView::Base) do
+        attributes :a, :b
+      end
+
+      child = Class.new(parent) do
+        attributes :c
+      end
+      it "allows to use attributes from the parent class" do
+        obj = OpenStruct.new(a: 'a', b: 'b', c: 'c')
+        child.render(obj).must_equal({:a=>"a", :b=>"b", :c=>"c"})
+      end
+    end
+  end
+
+  describe 'instance methods' do
+    describe '#convert' do
+      class ConvertSimpleApiView < ::ApiView::Base
+        attributes :some_value
+
+        def instance_convert
+          field :simple, true
+        end
+      end
+
+      class ConvertTestApiView < ::ApiView::Base
+        attributes :abbreviation, :full_name, :location
+
+        def instance_convert
+          field :away_team, 'away_team'
+          field :simple_view, object.simple_view, via: ConvertSimpleApiView
+        end
+      end
+
+      it "works for nested serialization" do
+        simple_view = OpenStruct.new(some_value: 'very simple value')
+        obj         = OpenStruct.new(abbreviation: 'hey', full_name: 'full name', location: 'loc', simple_view: simple_view)
+        res         = ConvertTestApiView.render(obj)
+        expected    = {:abbreviation=>"hey", :full_name=>"full name", :location=>"loc", :away_team=>"away_team", :simple_view=>{:some_value=>"very simple value", :simple=>true}}
+        res.must_equal expected
+      end
+    end
+  end
+end