kashmir 0.1

data/lib/kashmir/plugins/memory_caching.rb

@@ -0,0 +1,66 @@
+require 'kashmir/extensions'
+
+module Kashmir
+  module Caching
+    class Memory
+
+      def from_cache(definitions, instance)
+        key = presenter_key(definitions, instance)
+        if cached_data = get(key)
+          return cached_data
+        end
+      end
+
+      def bulk_from_cache(definitions, instances)
+        keys = instances.map do |instance|
+          presenter_key(definitions, instance) if instance.respond_to?(:id)
+        end
+
+        keys.map do |key|
+          get(key)
+        end
+      end
+
+      def store_presenter(definitions, representation, instance, ttl=0)
+        key = presenter_key(definitions, instance)
+        set(key, representation)
+      end
+
+      def bulk_write(definitions, representations, objects, ttl)
+        objects.each_with_index do |instance, index|
+          store_presenter(definitions, representations[index], instance, ttl)
+        end
+      end
+
+      def presenter_key(definition_name, instance)
+        "presenter:#{instance.class}:#{instance.id}:#{definition_name}"
+      end
+
+      def get(key)
+        @@cache ||= {}
+        if data = @@cache[key]
+          SymbolizeHelper.symbolize_recursive JSON.parse(data)
+        end
+      end
+
+      def set(key, value)
+        @@cache ||= {}
+        @@cache[key] = value.to_json
+      end
+
+      def clear(definition, instance)
+        key = presenter_key(definition, instance)
+        @@cache ||= {}
+        @@cache.delete(key)
+      end
+
+      def flush!
+        @@cache = {}
+      end
+
+      def keys
+        @@cache.keys
+      end
+    end
+  end
+end

data/lib/kashmir/plugins/null_caching.rb

@@ -0,0 +1,42 @@
+require 'kashmir/extensions'
+
+module Kashmir
+  module Caching
+    class Null
+
+      def from_cache(definitions, instance)
+        nil
+      end
+
+      def bulk_from_cache(definitions, instances)
+        []
+      end
+
+      def store_presenter(definitions, representation, instance, black_list=[], ttl=0)
+      end
+
+      def bulk_write(representation_definition, representations, objects, ttl)
+      end
+
+      def presenter_key(definition_name, instance)
+        "presenter:#{instance.class}:#{instance.id}:#{definition_name}"
+      end
+
+      def get(key)
+      end
+
+      def set(key, value)
+      end
+
+      def clear(definition, instance)
+      end
+
+      def flush!
+      end
+
+      def keys
+        []
+      end
+    end
+  end
+end

data/lib/kashmir/representable.rb

@@ -0,0 +1,88 @@
+module Kashmir
+  module Representable
+
+    def represent(representation_definition=[], level=1, skip_cache=false)
+      if !skip_cache && cacheable? and cached_presenter = Kashmir::Caching.from_cache(representation_definition, self)
+        return cached_presenter
+      end
+
+      representation = {}
+
+      (representation_definition + base_representation).each do |representation_definition|
+        key, arguments = parse_definition(representation_definition)
+
+        unless self.class.definitions.keys.include?(key)
+          raise "#{self.class.to_s}##{key} is not defined as a representation"
+        end
+
+        represented_document = self.class.definitions[key].run_for(self, arguments, level)
+        representation = representation.merge(represented_document)
+      end
+
+      if !skip_cache
+        cache!(representation_definition.dup, representation.dup, level)
+      end
+
+      representation
+    end
+
+    def cache!(representation_definition, representation, level=1)
+      return unless cacheable?
+
+      (cache_black_list & representation_definition).each do |field_name|
+        representation_definition = representation_definition - [ field_name ]
+        representation.delete(field_name)
+      end
+
+      Kashmir::Caching.store_presenter(representation_definition, representation, self, level * 60)
+    end
+
+    def cache_black_list
+      self.class.definitions.values.reject(&:should_cache?).map(&:field)
+    end
+
+    def cacheable?
+      respond_to?(:id)
+    end
+
+    def base_representation
+      self.class.definitions.values.select(&:is_base?).map(&:field)
+    end
+
+    def represent_with(&block)
+      definitions = Kashmir::InlineDsl.build(&block).definitions
+      represent(definitions)
+    end
+
+    def parse_definition(representation_definition)
+      if representation_definition.is_a?(Symbol)
+        [ representation_definition, [] ]
+      elsif representation_definition.is_a?(Hash)
+        [ representation_definition.keys.first, representation_definition.values.flatten ]
+      end
+    end
+
+    module ClassMethods
+
+      def representations(&definitions)
+        @definitions = {}
+        class_eval(&definitions)
+      end
+
+      def base(fields)
+        fields.each do |field|
+          rep(field, { is_base: true })
+        end
+      end
+
+      def rep(field, options={})
+        representation = Representation.new(field, options)
+        definitions[field] = representation
+      end
+
+      def definitions
+        @definitions ||= {}
+      end
+    end
+  end
+end

data/lib/kashmir/representation.rb

@@ -0,0 +1,117 @@
+module Kashmir
+  class Representation
+
+    attr_reader :field
+
+    def initialize(field, options)
+      @field = field
+      @options = options
+    end
+
+    def run_for(instance, arguments, level=1)
+      representation = {}
+      instance_vars = instance.instance_variables
+
+      value = read_value(instance, @field)
+      if primitive?(value)
+        representation[@field] = value
+      else
+        if value.is_a?(Hash)
+          representation[@field] = new_hash
+        else
+          representation[@field] = present_value(value, arguments, level)
+        end
+      end
+
+      representation
+    end
+
+    def is_base?
+      @options.has_key?(:is_base) and !!@options[:is_base]
+    end
+
+    def should_cache?
+      if @options.has_key?(:cacheable)
+        return !!@options[:cacheable]
+      end
+
+      true
+    end
+
+    def present_value(value, arguments, level=1, skip_cache=false)
+
+      if value.is_a?(Kashmir)
+        return value.represent(arguments, level + 1, skip_cache)
+      end
+
+      if value.is_a?(Hash)
+        return present_hash(value, arguments, level + 1, skip_cache)
+      end
+
+      if value.is_a?(Array)
+        return present_array(value, arguments, level + 1, skip_cache)
+      end
+
+      if value.respond_to?(:represent)
+        return value.represent(arguments, skip_cache)
+      end
+    end
+
+    def present_array(value, arguments, level=1, skip_cache=false)
+      cached_presenters = Kashmir::Caching.bulk_from_cache(arguments, value)
+
+      uncached = []
+      value.zip(cached_presenters).each do |record, cached_presenter|
+        if cached_presenter.nil?
+          uncached << record
+        end
+      end
+
+      uncached_representations = uncached.map do |element|
+        if primitive?(element)
+          element
+        else
+          present_value(element, arguments, level, true)
+        end
+      end
+
+      if rep = uncached.first and rep.is_a?(Kashmir) and rep.cacheable?
+        Kashmir::Caching.bulk_write(arguments, uncached_representations, uncached, level * 60)
+      end
+
+      cached_presenters.compact + uncached_representations
+    end
+
+    def present_hash(value, arguments, level=1, skip_cache=false)
+      new_hash = {}
+      value.each_pair do |key, value|
+        args = if arguments.is_a?(Hash)
+                 arguments[key.to_sym]
+               else
+                 arg = arguments.find do |arg|
+                   (arg.is_a?(Hash) && arg.has_key?(key.to_sym)) || arg == key.to_sym
+                 end
+                 if arg.is_a?(Hash)
+                   arg = arg[key.to_sym]
+                 end
+
+                 arg
+               end
+        new_hash[key] = primitive?(value) ? value : present_value(value, args || [], level, skip_cache)
+      end
+      new_hash
+    end
+
+    def read_value(instance, field)
+      if instance.respond_to?(field)
+        instance.send(field)
+      else
+        instance.instance_variable_get("@#{field}")
+      end
+    end
+
+    def primitive?(field_value)
+      [Fixnum, String, Date, Time, TrueClass, FalseClass, Symbol].include?(field_value.class)
+    end
+  end
+end

data/lib/kashmir/version.rb

@@ -0,0 +1,3 @@
+module Kashmir
+  VERSION = "0.1"
+end

data/test/activerecord_test.rb

@@ -0,0 +1,127 @@
+require 'ar_test_helper'
+
+# see support/ar_models for model definitions
+
+describe 'ActiveRecord integration' do
+
+  before(:each) do
+    @tom = TestData.create_tom
+    @pastrami_sandwich = AR::Recipe.find_by_title('Pastrami Sandwich')
+    @belly_burger = AR::Recipe.find_by_title('Belly Burger')
+    @restaurant = AR::Restaurant.find_by_name('Chef Tom Belly Burgers')
+  end
+
+  it 'represents ar objects' do
+    ps = @pastrami_sandwich.represent_with do
+      prop :title
+    end
+
+    assert_equal ps, { title: 'Pastrami Sandwich' }
+  end
+
+  describe 'ActiveRecord::Relation' do
+    it 'represents relations' do
+      recipes = AR::Recipe.all.represent_with do
+        prop :title
+      end
+
+      assert_equal recipes, [
+        { title: 'Pastrami Sandwich' },
+        { title: 'Belly Burger' }
+      ]
+    end
+
+    it 'represents nested relations' do
+      recipes = AR::Recipe.all.represent_with do
+        prop :title
+        inline :ingredients do
+          prop :name
+        end
+      end
+
+      assert_equal recipes, [
+        {
+          title: 'Pastrami Sandwich',
+          ingredients: [ { name: 'Pastrami' }, { name: 'Cheese' } ]
+        },
+        {
+          title: 'Belly Burger',
+          ingredients: [ {name: 'Pork Belly'}, { name: 'Green Apple' } ]
+        }
+      ]
+    end
+  end
+
+  describe 'belongs_to' do
+    it 'works for basic relations' do
+      ps = @pastrami_sandwich.represent_with do
+        prop :title
+        inline :chef do
+          prop :name
+        end
+      end
+
+      assert_equal ps, {
+        title: 'Pastrami Sandwich',
+        chef: {
+          name: 'Tom'
+        }
+      }
+    end
+
+    it 'works with custom names' do
+      r = @restaurant.represent_with do
+        prop :name
+        inline :owner do
+          prop :name
+        end
+      end
+
+      assert_equal r, {
+        name: 'Chef Tom Belly Burgers',
+        owner: {
+          name: 'Tom'
+        }
+      }
+    end
+  end
+
+  describe 'has_many' do
+    it 'works for basic associations' do
+      t = @tom.represent_with do
+        prop :name
+        inline :recipes do
+          prop :title
+        end
+      end
+
+      assert_equal t, {
+        name: 'Tom',
+        recipes: [
+          { title: 'Pastrami Sandwich' },
+          { title: 'Belly Burger'}
+        ]
+      }
+    end
+
+    it 'works with :through associations' do
+      tom_with_ingredients = @tom.reload.represent_with do
+        prop :name
+        inline :ingredients do
+          prop :name
+          prop :quantity
+        end
+      end
+
+      assert_equal tom_with_ingredients, {
+        name: 'Tom',
+        ingredients: [
+          { name: 'Pastrami'    , quantity: 'a lot'    },
+          { name: 'Cheese'      , quantity: '1 slice'  },
+          { name: 'Pork Belly'  , quantity: 'plenty'   },
+          { name: 'Green Apple' , quantity: '2 slices' }
+        ]
+      }
+    end
+  end
+end