orchestrate-rails 0.1.1

data/lib/orchestrate_application/result.rb

@@ -0,0 +1,56 @@
+module Orchestrate::Application
+
+  # Packages the result data from GET requests.
+  # Orchestrate.io records are returned as Document objects.
+  #
+  class Result
+    # Array of Document objects.
+    attr_reader :results
+
+    # Count of documents in #results. Set for list, search, events, and graph.
+    attr_reader :count
+
+    # Set for list results.
+    attr_reader :next
+
+    # Upon success: the result data is extracted from the response body,
+    # but the response body itself is not inluded as part of the result.
+    #
+    # Upon failure: the original response body, Orchestrate::API::ResponseBody
+    # is left intact and included to provide access to the error details.
+    attr_reader :response
+
+    # Boolean: return status of the api call.
+    attr_reader :status
+
+    # Initialize instance variables, based on type of results.
+    # - results                     (key/value)
+    # - results, count              (events, graph)
+    # - results, count, next        (list)
+    # - results, count, total_count (search)
+    def initialize(results)
+      results.each { |k,v| instance_variable_set "@#{k}", v }
+    end
+
+    def result
+    	results.first
+    end
+
+    def result_keys
+      results.map { |result| result.metadata.key }
+    end
+
+    def success?
+      status == true
+    end
+  end
+
+  # Container class for Orchestrate.io search results.
+  # See parent class Result for more details.
+  #
+  class SearchResult < Result
+    # Total count of matched records.
+    attr_reader :total_count
+  end
+
+end

data/lib/orchestrate_application/schema.rb

@@ -0,0 +1,85 @@
+module Orchestrate::Application
+
+  # ---------------------------------------------------------------------------
+  #  Singleton class to define schema for Orchestrate.io application
+  #
+  class Schema < Object
+    include Singleton
+
+    def initialize
+      @@schema = {}
+    end
+
+    def schema
+      @@schema
+    end
+
+    def collections
+      schema
+    end
+
+    def collection_names
+      schema.keys
+    end
+
+    def get(collection_name)
+      schema[collection_name]
+    end
+
+    def get_collection(name)
+      get(name)
+    end
+
+    def load_collection(collection)
+      schema[collection.name] = collection
+    end
+
+    def define_collection(args)
+      load_collection SchemaCollection.new(args)
+    end
+
+    def define_event_type(collection_name, event_type, properties)
+      get(collection_name).define_event_type event_type, properties
+    end
+
+    def define_graph(collection_name, relation_kind, to_collection)
+      get(collection_name).define_graph relation_kind, to_collection
+    end
+
+    #  Support (optional) loading of schema from a definition file
+    #
+    #  Example usage:
+    #
+    #     Orchestrate::Application::Schema.instance.load "./schema.rb"
+    #
+    #  Example definition file - i.e. "<APP-ROOT>/schema.rb"
+    #
+    #     Orchestrate::Application::Schema.instance.define_collection(
+    #       :name           => 'films',
+    #       :properties     => [ :Title, :Year, :Rated, :Released,
+    #                            :Runtime, :Genre, :Director, :Writer,
+    #                            :Actors, :Plot, :Poster, :imdbRating,
+    #                            :imdbVotes, :imdbID, :Type, :Response ],
+    #       :event_types    => [ :comments ],
+    #       :graphs         => [ :sequel ],
+    #     )
+    #
+    #     Orchestrate::Application::Schema.instance.define_event_type(
+    #       :collection => 'films',
+    #       :event_type => :comments,
+    #       :properties => [ :User, :Comment ]
+    #     )
+    #
+    #     Orchestrate::Application::Schema.instance.define_graph(
+    #       :collection    => 'films',
+    #       :relation_kind => :sequel,
+    #       :to_collection => 'films',
+    #     )
+    #
+    def load(schema)
+      require schema
+    end
+  end
+
+end
+

data/lib/orchestrate_application/schema_collection.rb

@@ -0,0 +1,53 @@
+module Orchestrate::Application
+
+  # Schema support object.
+  #
+  class SchemaCollection < Object
+    attr_reader :name, :properties, :event_types, :graphs
+
+    # args: { :name, :properties, :event_types, :graphs }
+    #
+    def initialize(args)
+      @name, @properties = args[:name], args[:properties] + [:id]
+
+      @event_types = {}
+      if args[:event_types]
+        args[:event_types].each { |etype| @event_types[etype] = etype }
+      end
+
+      @graphs = {}
+      if args[:graphs]
+        args[:graphs].each { |kind| @graphs[kind] = kind }
+      end
+
+      yield self if block_given?
+    end
+
+    def define_event_type(event_type, properties)
+     @event_types[event_type] = SchemaEventType.new(event_type, properties)
+    end
+
+    def define_graph(relation_kind, to_collection)
+      @graphs[relation_kind] = SchemaGraph.new(relation_kind, to_collection)
+    end
+  end
+
+  # Schema support object.
+  #
+  class SchemaEventType
+    attr_reader :name, :properties
+    def initialize(event_type, properties)
+      @name, @properties = event_type, properties
+    end
+  end
+
+  # Schema support object.
+  #
+  class SchemaGraph
+    attr_reader :kind, :to_collection
+    def initialize(kind, to_collection)
+      @kind, @to_collection = kind, to_collection
+    end
+  end
+
+end

data/lib/orchestrate_application/simple_cache_request.rb

@@ -0,0 +1,62 @@
+ module Orchestrate::Application
+
+  class SimpleCacheRequest
+    attr_reader :collection
+
+    def initialize(collection)
+      # puts "CACHE-init: '#{collection}'"
+      @collection = collection
+      @@cache_store ||= SimpleCacheStore.instance
+    end
+
+    def enabled?
+      cache.is_enabled?
+    end
+
+    def get(key)
+      doc = cache.get_cc(collection).fetch key
+      path = "/local_cache/#{collection}/#{key}"
+      puts "\n------- GET \"#{path}\" ------ #{doc ? 'OK' : 'not found'}"
+      response([doc]) if doc
+    end
+
+    def get_graph(key, kind)
+      docs = cache.get_cc(collection).fetch_graph key, kind
+      path = "/local_cache/#{collection}/#{key}/graph/#{kind}"
+      puts "\n------- GET \"#{path}\" ------ #{docs ? 'OK' : 'not found'}"
+      response(docs) if docs
+    end
+
+    def save_graph(key, kind)
+      cache.get_cc(collection).save_graph Metadata.new(from_key: key, kind: kind)
+    end
+
+    def get_events(key, event_type)
+      docs = cache.get_cc(collection).fetch_events key, event_type
+      path = "/local_cache/#{collection}/#{key}/events/#{event_type}"
+      puts "\n------- GET \"#{path}\" ------ #{docs ? 'OK' : 'not found'}"
+      response(docs) if docs
+    end
+
+    def save_event(key, event_type)
+      cache.get_cc(collection).save_event Metadata.new(key: key, etype: event_type)
+    end
+
+    private
+
+      def cache
+        @@cache_store
+      end
+
+      def response(docs)
+        locations = docs.map { |doc|
+          location = "/local_cache/refs/#{doc.id}"
+          puts "          from \"#{location}\""
+          location
+        }
+        r_info = { locations: locations, code: 200, :status => :cache }
+        r_info.merge!(etag: docs.first.id) if docs.length == 1
+        SimpleCacheResponse.new(r_info, docs)
+      end
+  end
+end

data/lib/orchestrate_application/simple_cache_response.rb

@@ -0,0 +1,41 @@
+module Orchestrate::Application
+
+  # ---------------------------------------------------------------------------
+  #  Class to handle Orchestrate.io API responses
+  # 
+  class SimpleCacheResponse
+    attr_accessor :header, :body
+
+    def initialize(header, body)
+      @header, @body = Header.new(header), Body.new(body)
+    end
+
+    class Header
+      attr_reader :locations, :code, :status, :etag
+
+      def initialize(header)
+        @locations = header[:locations]
+        @code, @status = header[:code], header[:status]
+        @etag = header[:etag]
+      end
+
+      def location
+        locations.first
+      end
+    end
+
+    class Body
+      attr_reader :documents
+      
+      def initialize(body)
+        @documents = body
+      end
+
+      def document
+        documents.first
+      end
+    end
+
+  end
+
+end

data/lib/orchestrate_application/simple_cache_store.rb

@@ -0,0 +1,215 @@
+module Orchestrate::Application
+
+  #  Class PrimaryKey
+  #
+  class PrimaryKey
+    attr_reader :events, :graphs
+    attr_accessor :ref
+
+    def initialize(ref)
+      # puts "SCC-primary_key: '#{ref}'"
+      @ref = ref
+      @events, @graphs = {}, {}
+    end
+
+    def add_event(etype, ref=nil)
+      # puts "SCC-add event"
+      @events[etype] = [] unless @events[etype]
+      @events[etype] << ref if ref
+      # puts "SCC-added event"
+    end
+
+    def add_graph(data)
+      # puts "SCC-add graph: '#{data.kind}'"
+      @graphs[data.kind] = [] unless @graphs[data.kind]
+      @graphs[data.kind] << data.ref if data.ref
+      # puts "SCC-added graph '#{@graphs[data.kind].last}'"
+    end
+  end
+
+
+  #  Class SimpleCacheCollection
+  #
+  class SimpleCacheCollection
+
+    attr_reader :name, :primary_keys, :events, :graphs
+
+    def initialize(name)
+      @name = name
+      @primary_keys, @events, @graphs = {}, {}, {}
+    end
+
+    def flush!
+      @primary_keys, @events, @graphs = {}, {}, {}
+    end
+
+    def fetch(key)
+      # puts "SCC-fetching: '#{key}', '#{primary_keys[key]}'"
+      if primary_keys[key]
+        # puts "SCC-fetching: '#{primary_keys[key].ref}'"
+        SimpleCacheRefs.instance.document primary_keys[key].ref
+      end
+    end
+
+    def fetch_events(key, etype)
+      # puts "SCC-fetch_events: '#{key}', '#{etype}'"
+      if primary_keys[key] and primary_keys[key].events[etype]
+        primary_keys[key].events[etype].map { |ref|
+          # puts "SCC-fetch_events: '#{ref}'"
+          SimpleCacheRefs.instance.document ref
+        }
+      end
+    end
+
+    def fetch_graph(key, kind)
+      # puts "SCC-fetch_graph 1: '#{key}', '#{kind}'"
+      if primary_keys[key] and primary_keys[key].graphs and primary_keys[key].graphs[kind]
+        primary_keys[key].graphs[kind].map { |ref|
+          # puts "SCC-fetch_graph: '#{ref}'"
+          SimpleCacheRefs.instance.document ref
+        }
+      end
+    end
+
+    def get_ref(key)
+      primary_keys[key] and primary_keys[key].ref
+    end
+
+    def save(data)
+      key, ref = data.key, data.ref
+      @primary_keys[key] = PrimaryKey.new(ref) if primary_keys[key].nil?
+      if data.respond_to? :etype and data.etype
+        @primary_keys[key].add_event(data.etype, ref)
+      else
+        @primary_keys[key].ref = ref
+      end
+    end
+
+    def save_event(data)
+      @primary_keys[data.key] = PrimaryKey.new(0) if primary_keys[data.key].nil?
+      @primary_keys[data.key].add_event data.etype
+    end
+
+    def save_graph(data)
+      @primary_keys[data.from_key] = PrimaryKey.new(0) if primary_keys[data.from_key].nil?
+      @primary_keys[data.from_key].add_graph data
+    end
+
+
+  end
+
+  # Stores documents in cache, indexed by ref value.
+  #
+  class SimpleCacheRefs
+    include Singleton
+
+    def initialize
+      @@documents = {}
+    end
+
+    def save(ref, document)
+      @@documents[ref] = document
+    end
+
+    def document(ref)
+      @@documents[ref]
+    end
+
+    def flush!
+      @@documents = {}
+    end
+  end
+
+  #  When enabled, the cache mechanism:
+  #  * is useful for development/testing, minimizing calls to the server.
+  #  * is updated upon each GET or PUT request.
+  #  * remains active for the lifespan of the application.
+  #
+  class SimpleCacheStore
+
+    def initialize
+      @@is_enabled ||= false
+      @@cache ||= simple_cache_init
+      # puts "SC-init: cache -> '#{@@cache}', '#{!@@cache.nil?}'"
+      @@refs ||= {}
+    end
+
+    def simple_cache_init
+      cache = Hash[Schema.instance.collection_names.map { |name|
+        [name, SimpleCacheCollection.new(name)]
+      }]
+      # puts "SC-sc_init -> '#{cache}', is_enabled -> '#{@@is_enabled}'"
+      cache == {} ? nil : cache
+    end
+
+    def self.instance
+      @@cache ||= @@instance.simple_cache_init
+      @@instance
+    end
+
+    def self.enable
+      # puts "SC-ENABLE"
+      # @@is_enabled = true
+      puts "SIMPLE-CACHE has been DISABLED for the current version."
+    end
+
+    def self.disable
+      puts "SC-DISABLE"
+      @@is_enabled = false
+    end
+
+    @@instance = SimpleCacheStore.new
+    private_class_method :new
+
+    # -------------------------------------------------------------------------
+
+    #
+    def cache
+      @@cache
+    end
+
+    def flush!(collection=nil)
+      if collection
+        get_cc(collection).flush!
+      else
+        @@cache = simple_cache_init
+      end
+    end
+
+    def get_cache_collection(name)
+      cache[name]
+    end
+
+    def get_cc(name)
+      get_cache_collection name
+    end
+
+    def save(document)
+      m = document.metadata
+      get_cc(m.from_collection).save_graph(m) if m.respond_to? :kind and m.kind
+      get_cc(m.collection).save m
+      SimpleCacheRefs.instance.save m.ref, document
+    end
+
+    def get_ref(collection_name, key)
+      get_cc(collection_name).get_ref key
+    end
+
+    def fetch(collection, key)
+      get_cc(collection).fetch(key)
+    end
+
+    def is_enabled?
+      @@is_enabled
+    end
+
+    def enable
+      self.class.enable
+    end
+
+    def disable
+      self.class.disable
+    end
+
+  end
+end

data/lib/orchestrate_rails/document.rb

@@ -0,0 +1,38 @@
+module Orchestrate::Rails
+
+  # Extensions #update_rails, #to_rails, #to_event are defined in the
+  # Orchestrate::Rails module and are accessible within that namespace.
+  #
+  class Orchestrate::Application::Document
+
+    # Updates the key/value pairs for the model instance with key/value data
+    # from the document.
+    # Defined by Orchestrate::Rails.
+    def update_rails(instance)
+      key_value_pairs.each { |k,v|
+        instance.instance_variable_set "@#{k.to_orchio_rails_attr}", v
+      }
+      instance.instance_variable_set "@__ref_value__", metadata.ref # JMC
+      instance
+    end
+
+    # Creates a new model instance, and calls #update_rails.
+    # Defined by Orchestrate::Rails.
+    def to_rails
+      update_rails Object.const_get(classname).new
+    end
+
+    # Creates a new event instance from the document's key/value data.
+    # Defined by Orchestrate::Rails.
+    def to_event
+      Object.const_get('Orchestrate::Rails::Event').new key_value_pairs
+    end
+
+    private
+      def classname
+        Orchestrate::Rails::Schema.instance.fullclassname metadata.collection
+        # Orchestrate::Rails::Schema.instance.classname(metadata.collection) JMC
+      end
+  end
+
+end

data/lib/orchestrate_rails/event.rb

@@ -0,0 +1,23 @@
+module Orchestrate::Rails
+
+  require "active_model"
+
+  #  Class to support *dynamically defined* orchestrate.io/event instances
+  #
+  class Event
+    include ::ActiveModel::Conversion
+    extend ::ActiveModel::Naming
+
+    def initialize(event_record)
+      event_record.each do |k,v|
+        self.class.send(:attr_reader, k.to_orchio_rails_attr)
+        instance_variable_set("@#{k.to_orchio_rails_attr}", v)
+      end
+    end
+
+    def id
+      @timestamp
+    end
+  end
+
+end

data/lib/orchestrate_rails/extensions.rb

@@ -0,0 +1,21 @@
+module Orchestrate::Rails
+
+  # ---------------------------------------------------------------------------
+  #  Add String and Symbol instance methods for easy conversion of
+  #  orchestrate.io property names to rails-style model attribute names.
+
+  # Convert property name to attribute name.
+  class ::String
+    def to_orchio_rails_attr
+      underscore.downcase
+    end
+  end
+
+  # Convert property name to attribute name. Calls ::String#to_orchio_rails_attr.
+  class ::Symbol
+    def to_orchio_rails_attr
+      to_s.to_orchio_rails_attr
+    end
+  end
+
+end