kashmir 0.1

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+desc 'Test the kashmir gem.'
+task :default => :test
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/**/*_test.rb']
+  test.verbose = true
+end

data/kashmir.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kashmir/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kashmir"
+  spec.version       = Kashmir::VERSION
+  spec.authors       = ["IFTTT", "Netto Farah"]
+  spec.email         = ["ops@ifttt.com", "nettofarah@gmail.com"]
+  spec.summary       = %q{Kashmir is a DSL for quickly defining contracts to decorate your models.}
+  spec.description   = %q{
+    Kashmir helps you easily define decorators/representers/presenters for ruby objects.
+    Optionally, Kashmir will also cache these views for faster lookups.
+  }
+  spec.homepage      = "http://ifttt.github.io/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "colorize", "~> 0.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "minitest-around", "~> 0.3"
+  spec.add_development_dependency "mocha", "~> 1.1"
+  spec.add_development_dependency "sqlite3", "1.3.10"
+
+  spec.add_development_dependency "dalli", "~> 2.7"
+  spec.add_development_dependency "activerecord", "3.2.8"
+end

data/lib/kashmir.rb

@@ -0,0 +1,42 @@
+require "kashmir/version"
+require "kashmir/representation"
+require "kashmir/dsl"
+require "kashmir/inline_dsl"
+require "kashmir/plugins/ar"
+require "kashmir/caching"
+require "kashmir/representable"
+
+module Kashmir
+
+  class << self
+
+    attr_accessor :logger
+
+    def included(klass)
+      klass.extend Representable::ClassMethods
+      klass.send(:include, Representable)
+
+      if klass.ancestors.include?(::ActiveRecord::Base)
+        klass.send(:include, Kashmir::AR)
+      end
+    end
+
+    def init(options={})
+      if client = options[:cache_client]
+        @caching = client
+      end
+
+      if logger = options[:logger]
+        @logger = logger
+      end
+    end
+
+    def logger
+      @logger ||= defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+    end
+
+    def caching
+      @caching ||= Kashmir::Caching::Null.new
+    end
+  end
+end

data/lib/kashmir/caching.rb

@@ -0,0 +1,50 @@
+require 'kashmir/plugins/memory_caching'
+require 'kashmir/plugins/null_caching'
+require 'kashmir/plugins/memcached_caching'
+require 'colorize'
+
+module Kashmir
+  module Caching
+
+    def from_cache(representation_definition, object)
+      log("#{"read".blue}: #{log_key(object, representation_definition)}", :debug)
+
+      cached_representation = Kashmir.caching.from_cache(representation_definition, object)
+
+      if cached_representation
+        log("#{"hit".green}: #{log_key(object, representation_definition)}")
+      else
+        log("#{"miss".red}: #{log_key(object, representation_definition)}")
+      end
+
+      cached_representation
+    end
+
+    def bulk_from_cache(representation_definition, objects)
+      class_name = objects.size > 0 ? objects.first.class.to_s : ''
+      log("#{"read_multi".blue}: [#{objects.size}]#{class_name} : #{representation_definition}", :debug)
+      Kashmir.caching.bulk_from_cache(representation_definition, objects)
+    end
+
+    def store_presenter(representation_definition, representation, object, ttl)
+      log("#{"write".blue} TTL: #{ttl}: #{log_key(object, representation_definition)}", :debug)
+      Kashmir.caching.store_presenter(representation_definition, representation, object, ttl)
+    end
+
+    def bulk_write(representation_definition, representations, objects, ttl)
+      class_name = objects.size > 0 ? objects.first.class.to_s : ''
+      log("#{"write_multi".blue}: TTL: #{ttl}: [#{objects.size}]#{class_name} : #{representation_definition}", :debug)
+      Kashmir.caching.bulk_write(representation_definition, representations, objects, ttl)
+    end
+
+    def log_key(object, representation_definition)
+      "#{object.class.name}-#{object.id}-#{representation_definition}"
+    end
+
+    def log(message, level=:info)
+      Kashmir.logger.send(level, ("\n#{"Kashmir::Caching".magenta} #{message}\n"))
+    end
+
+    module_function :from_cache, :bulk_from_cache, :bulk_write, :store_presenter, :log_key, :log
+  end
+end

data/lib/kashmir/dsl.rb

@@ -0,0 +1,41 @@
+module Kashmir
+  module Dsl
+
+    def self.included(klass)
+      klass.extend ClassMethods 
+    end
+
+    module ClassMethods
+
+      def prop(name)
+        definitions << name
+      end
+
+      def props(*names)
+        names.each do |name|
+          prop(name)
+        end
+      end
+
+      def group(name, fields)
+        definition = Hash.new
+        definition[name] = fields
+        definitions << definition
+      end
+
+      def embed(name, representer)
+        group(name, representer.definitions) 
+      end
+
+      def inline(name, &inline_representer)
+        representer = Kashmir::InlineDsl.build(&inline_representer)
+        embed(name, representer) 
+      end
+
+      def definitions
+        @definitions ||= []
+        @definitions
+      end
+    end
+  end
+end

data/lib/kashmir/extensions.rb

@@ -0,0 +1,18 @@
+module SymbolizeHelper
+  def self.symbolize_recursive(hash)
+    {}.tap do |h|
+      hash.each { |key, value| h[key.to_sym] = map_value(value) }
+    end
+  end
+
+  def self.map_value(thing)
+    case thing
+    when Hash
+      symbolize_recursive(thing)
+    when Array
+      thing.map { |v| map_value(v) }
+    else
+      thing
+    end
+  end
+end

data/lib/kashmir/inline_dsl.rb

@@ -0,0 +1,13 @@
+module Kashmir
+  module InlineDsl
+
+    def self.build(&definitions)
+      inline_representer = Class.new do
+        include Kashmir::Dsl
+      end
+
+      inline_representer.class_eval(&definitions) if block_given?
+      inline_representer
+    end
+  end
+end

data/lib/kashmir/patches/active_record.rb

@@ -0,0 +1,68 @@
+# We have to reopen Preloader to allow for it
+# to accept any random attribute name as a preloadable association.
+#
+# This allows us to send any abirtrary Hash to Preloader.
+# Not only keys that we know are ActiveRecord relations in advance.
+#
+
+module ArV4Patch
+
+  def self.included(klass)
+    klass.instance_eval do
+      remove_method :grouped_records
+    end
+  end
+
+  def grouped_records(association, records)
+    h = {}
+    records.each do |record|
+      next unless record
+
+      unless record.class._reflect_on_association(association)
+        next
+      end
+
+      assoc = record.association(association)
+      klasses = h[assoc.reflection] ||= {}
+      (klasses[assoc.klass] ||= []) << record
+    end
+    h
+  end
+end
+
+module ArV3Patch
+
+  def self.included(klass)
+    klass.instance_eval do
+      remove_method :records_by_reflection
+    end
+  end
+
+  def records_by_reflection(association)
+    grouped = records.group_by do |record|
+      reflection = record.class.reflections[association]
+
+      unless reflection
+        next
+      end
+
+      reflection
+    end
+
+    ## This takes out the unexisting relations
+    grouped.delete(nil)
+    grouped
+  end
+end
+
+module ActiveRecord
+  module Associations
+    class Preloader
+      if ActiveRecord::VERSION::STRING >= "4.0.2"
+        include ::ArV4Patch
+      else
+        include ::ArV3Patch
+      end
+    end
+  end
+end

data/lib/kashmir/plugins/active_record_representation.rb

@@ -0,0 +1,14 @@
+module Kashmir
+  class ActiveRecordRepresentation < Representation
+
+    def present_value(value, arguments, level=1, skip_cache=false)
+      if value.is_a?(Kashmir) || value.is_a?(Kashmir::ArRelation)
+        return value.represent(arguments, level, skip_cache)
+      end
+
+      if value.respond_to?(:represent)
+        value.represent(arguments, level, skip_cache)
+      end
+    end
+  end
+end

data/lib/kashmir/plugins/ar.rb

@@ -0,0 +1,49 @@
+require "active_record"
+require "kashmir/plugins/active_record_representation"
+require "kashmir/plugins/ar_relation"
+require "kashmir/patches/active_record"
+
+module ActiveRecord
+# = Active Record Relation
+  class Relation
+    include Kashmir::ArRelation
+  end
+end
+
+# TODO: extract kashmir array module
+class Array
+  include Kashmir::ArRelation
+end
+
+module Kashmir
+  module AR
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def rep(field, options={})
+        if reflection_names.include?(field)
+          return activerecord_rep(field, options)
+        end
+
+        super
+      end
+
+      def reflection_names
+        if self.respond_to?(:reflections)
+          return reflections.keys.map(&:to_sym)
+        end
+
+        []
+      end
+
+      def activerecord_rep(field, options)
+        representation = ActiveRecordRepresentation.new(field, options)
+        definitions[field] = representation
+      end
+    end
+  end
+end

data/lib/kashmir/plugins/ar_relation.rb

@@ -0,0 +1,35 @@
+module Kashmir
+  module ArRelation
+
+    def represent(representation_definition=[], level=1, skip_cache=false)
+      cached_presenters = Kashmir::Caching.bulk_from_cache(representation_definition, self)
+
+      to_load = []
+      self.zip(cached_presenters).each do |record, cached_presenter|
+        if cached_presenter.nil?
+          to_load << record
+        end
+      end
+
+      if to_load.any?
+        ActiveRecord::Associations::Preloader.new(to_load, representation_definition).run
+      end
+
+      to_load_representations = to_load.map do |subject|
+        subject.represent(representation_definition, level, skip_cache) if subject.respond_to?(:represent)
+      end
+
+      if rep = to_load.first and rep.is_a?(Kashmir) and rep.cacheable?
+        Kashmir::Caching.bulk_write(representation_definition, to_load_representations, to_load, level * 60)
+      end
+
+      cached_presenters.compact + to_load_representations
+    end
+
+    def represent_with(&block)
+      map do |subject|
+        subject.represent_with(&block)
+      end
+    end
+  end
+end

data/lib/kashmir/plugins/memcached_caching.rb

@@ -0,0 +1,83 @@
+require 'dalli'
+
+module Kashmir
+  module Caching
+    class Memcached
+
+      attr_reader :client
+
+      def initialize(client, default_ttl = 3600)
+        @client = client
+        @default_ttl = default_ttl
+      end
+
+      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.compact
+
+
+        # TODO improve this
+        # Creates a hash with all the keys (sorted by the array sort order)
+        # and points everything to null
+        # ex: [a, b, c] -> { a: nil, b: nil, c: nil }
+        results = Hash[keys.map {|x| [x, nil]}]
+
+        # Get results from memcached
+        # This will ONLY return cache hits as a Hash
+        # ex: { a: cached_a, b: cached_b } note that C is not here
+        from_cache = client.get_multi(keys)
+
+        # This assigns each one of the cached values to its keys
+        # preserving cache misses (that still point to nil)
+        from_cache.each_pair do |key, value|
+          results[key] = JSON.parse(value, symbolize_names: true)
+        end
+
+        # returns the cached results in the same order as requested.
+        # this will also return nil values for cache misses
+        results.values
+      end
+
+      def bulk_write(definitions, representations, instances, ttl)
+        client.multi do
+          instances.each_with_index do |instance, index|
+            key = presenter_key(definitions, instance)
+            set(key, representations[index], ttl)
+          end
+        end
+      end
+
+      def store_presenter(definitions, representation, instance, ttl=0)
+        key = presenter_key(definitions, instance)
+        set(key, representation, ttl)
+      end
+
+      def presenter_key(definition_name, instance)
+        "#{instance.class}:#{instance.id}:#{definition_name}"
+      end
+
+      def get(key)
+        if data = client.get(key)
+          JSON.parse(data, symbolize_names: true)
+        end
+      end
+
+      def set(key, value, ttl=nil)
+        client.set(key, value.to_json, ttl || @default_ttl)
+      end
+
+      def clear(definition, instance)
+        key = presenter_key(definition, instance)
+        client.delete(key)
+      end
+    end
+  end
+end