smooth-io 0.0.5

data/lib/smooth/backends/base.rb

@@ -0,0 +1,84 @@
+module Smooth
+  module Backends
+    class Base
+
+      def initialize options={}
+        @id_counter           = 0
+        @maximum_updated_at   = Time.now.to_i
+        @namespace            = options[:namespace]
+
+        records               = options[:records] || {}
+
+        if records.is_a?(Array)
+          records = records.select {|r| r.is_a?(Hash) }.inject({}) do |memo,record|
+            record.symbolize_keys!
+            record[:id] ||= @id_counter += 1
+            memo[ record[:id] ] = record
+            memo
+          end
+        end
+
+        @storage              = {id_counter: @id_counter, records: records, maximum_updated_at: @maximum_updated_at}
+      end
+
+      def records
+        @storage[:records]
+      end
+
+      def maximum_updated_at
+        @storage[:maximum_updated_at]
+      end
+
+      def index
+        records.values
+      end
+
+      def show id
+        records[id.to_i]
+      end
+
+      def update attributes={}
+        attributes.symbolize_keys!
+        @storage[:maximum_updated_at] = attributes[:updated_at] = Time.now.to_i
+        record = records[attributes[:id]]
+        record.merge!(attributes)
+        record
+      end
+
+      def create attributes={}
+        attributes.symbolize_keys!
+        attributes[:id] = increment_id
+        @storage[:maximum_updated_at] = attributes[:created_at] = attributes[:updated_at] = Time.now.to_i
+        records[attributes[:id]] ||= attributes
+      end
+
+      def destroy id
+        record = records.delete(id)
+        !record.nil?
+      end
+
+      # A Naive query method which only matches for equality
+      def query params={}
+        params.symbolize_keys!
+
+        index.select do |record|
+          record.symbolize_keys!
+
+          params.keys.all? do |key|
+            record[key] == params[key]
+          end
+        end
+      end
+
+      protected
+
+        def increment_id
+          @id_counter += 1
+        end
+
+        def storage=(object={})
+          @storage = object
+        end
+    end
+  end
+end

data/lib/smooth/backends/file.rb

@@ -0,0 +1,80 @@
+module Smooth
+  module Backends
+    class File < Base
+
+      class << self
+        attr_accessor :data_directory, :flush_threshold
+      end
+
+      self.data_directory = Smooth.data_directory
+      self.flush_threshold = 300
+
+      FileUtils.mkdir_p(data_directory)
+
+      attr_accessor :storage,
+                    :namespace
+
+      def initialize options={}
+        super
+
+        @data_directory       = options[:data_directory]
+        restore if ::File.exists?(storage_path)
+
+        setup_periodic_flushing
+      end
+
+
+      def storage_path
+        ::File.join(data_directory, "#{namespace}.json")
+      end
+
+      def url
+        "file://#{ storage_path }"
+      end
+
+
+      def kill
+        @periodic_flusher && @periodic_flusher.kill
+      end
+
+      def setup_periodic_flushing
+        @periodic_flusher ||= Thread.new do
+          while true
+            flush
+            sleep 20
+          end
+        end
+      end
+
+      protected
+
+        def throttled?
+          @last_flushed_at && (Time.now.to_i - @last_flushed_at) < self.class.flush_threshold
+        end
+
+        def restore
+          from_disk = JSON.parse( IO.read(storage_path) ) rescue {}
+
+          unless from_disk[:maximum_updated_at] && from_disk[:id_counter] && from_disk[:records]
+            return
+          end
+
+          @storage = from_disk && true
+        end
+
+        def flush force=false
+          return if !force && throttled?
+
+          ::File.open(storage_path,'w+') do |fh|
+            fh.puts( JSON.generate(storage) )
+            @last_flushed_at = Time.now.to_i
+          end
+        end
+
+        def data_directory
+          @data_directory || self.class.data_directory
+        end
+
+    end
+  end
+end

data/lib/smooth/backends/redis.rb

@@ -0,0 +1,71 @@
+module Smooth
+  module Backends
+    class Redis < Base
+      attr_reader :connection,
+                  :namespace
+
+      def initialize options={}
+        redis = ::Redis.new(options[:redis_options] || {})
+
+        @namespace        = options[:namespace]
+        @priority         = options[:priority] || 0
+
+        if options[:use_redis_namespace]
+          @connection       = ::Redis::Namespace.new(Smooth.namespace, redis: redis)
+        else
+          @connection = redis
+        end
+      end
+
+      def create attributes={}
+        attributes.symbolize_keys!
+        attributes[:created_at] = attributes[:updated_at] = touch
+        attributes[:id] = increment_id
+        connection.hset("#{ namespace }:records", attributes[:id], JSON.generate(attributes))
+        attributes
+      end
+
+      def update attributes={}
+        attributes.symbolize_keys!
+        if record = show(attributes[:id])
+          record.merge!(attributes)
+          record[:updated_at] = touch
+          connection.hset("#{ namespace }:records", attributes[:id], JSON.generate(record))
+          record
+        end
+      end
+
+      def destroy id
+        !!(connection.hdel("#{ namespace }:records", id.to_s))
+      end
+
+      def index
+        records = connection.hvals("#{ namespace }:records")
+        records.map! {|r| JSON.parse(r) }
+        records
+      end
+
+      def show id
+        record = connection.hget("#{ namespace }:records", id)
+        parsed = JSON.parse(record)
+        parsed && parsed.symbolize_keys!
+        parsed
+      end
+
+      protected
+        def maximum_updated_at
+          connect.get("#{ namespace }:maximum_updated_at")
+        end
+
+        def touch
+          stamp = Time.now.to_i
+          connection.set("#{ namespace }:maximum_updated_at", stamp)
+          stamp
+        end
+
+        def increment_id
+          connection.incr("#{ namespace }:id_incrementer")
+        end
+    end
+  end
+end

data/lib/smooth/backends/redis_namespace.rb

@@ -0,0 +1,10 @@
+module Smooth
+  module Backends
+    class RedisNamespace < Smooth::Backends::Redis
+      def initialize options={}
+        @namespace, @priority = options.values_at(:namespace, :priority)
+        @connection           = ::Redis::Namespace.new( @namespace, redis: ::Redis.new(options.fetch(:redis_options, {})))
+      end
+    end
+  end
+end

data/lib/smooth/backends/rest_client.rb

@@ -0,0 +1,29 @@
+module Smooth
+  module Backends
+    class RestClient
+
+      def initialize options={}
+
+      end
+
+      def query params={}
+        response = Typhoeus::Request.get(url_with_query_string(params))        
+      end
+
+      def url
+        @options[:url]
+      end
+
+      protected
+
+        def url_with_query_string params={}
+          parts = params.inject([]) do |memo,element|
+            key, value = element
+            memo << "#{ key }=#{ value }"
+          end
+
+          url + "?#{ parts.join('&') }"
+        end
+    end
+  end	
+end

data/lib/smooth/collection.rb

@@ -0,0 +1,236 @@
+module Smooth
+  class Collection
+    include Cacheable
+
+    InvalidBackend = Class.new(Exception)
+
+    attr_reader :options, :backend
+
+    class << self
+      attr_accessor :model_class,
+                    :backend,
+                    :namespace
+    end
+
+    def self.uses_model model=Smooth::Model
+      self.model_class = model
+      self
+    end
+
+    def self.uses_namespace namespace="smooth:collections"
+      self.namespace = namespace
+      self
+    end
+
+    def self.uses_backend backend=:file
+      self.backend = backend
+      self
+    end
+
+    # Create an instance of a Smooth::Collection.
+    #
+    # Examples:
+    #
+    #   Smooth::Collection.new(namespace: "namespace", backend: "file")
+    #
+    def initialize namespace, models=[], options={}
+      if models.is_a?(Hash)
+        options = models
+        models  = Array(options[:models])
+      end
+
+      if namespace.is_a?(Hash)
+        options = namespace
+      end
+
+      if namespace.is_a?(String)
+        options[:namespace] = namespace
+      end
+
+      @options = options
+
+      if options[:model] and !options[:backend]
+        options[:backend] = "active_record"
+      end
+
+      validate_backend
+
+      if options[:cache].is_a?(String)
+        options[:cache] = {
+          backend: "redis"
+        }
+      end
+
+      if options[:cache]
+        @cache_adapter = create_cache_adapter(options[:cache])
+      end
+
+      @model_class = options[:model_class] || self.class.model_class
+
+      @models = models
+    end
+
+    def sync method="read", model={}, options={}, &block
+
+      case method.to_sym
+
+      when :read
+        fetch_from_index
+      when :update
+        model = data_to_model(model,options)
+        backend.update model.as_json
+        fetch_from_index
+      when :create
+        model = data_to_model(model,options)
+        attributes = backend.create(model.as_json)
+        fetch_from_index
+
+        model = data_to_model(attributes, options)
+      when :destroy
+        backend.destroy model.id
+      else
+        fetch_from_index
+      end
+    end
+
+    def add data={}, options={}
+      options[:collection] = self
+
+      model = data_to_model(data, options)
+
+      @models << model
+
+      model
+    end
+
+    def find_by attribute, value
+      q = {}
+      q[attribute.to_sym] = value
+      data_to_model query(q).first
+    end
+
+    def find id
+      find_by(:id, id)
+    end
+
+    def models
+      fetch_from_index unless @fetched
+
+      Array(@models).map do |model|
+        data_to_model(model, collection: self)
+      end
+    end
+
+    def url
+      backend.url rescue @namespace
+    end
+
+    def query params={}, options={}
+      query = Query.new(params)
+      query = apply_scope_parameters_to(query)
+
+      return backend.query(query) unless cacheable?
+
+      cache_adapter.fetch(query.cache_key) do
+        backend.query(query)
+      end
+    end
+
+    def fetch options={}
+      response = query(options, options[:query_options])
+      reset parse(response, options)
+    end
+
+    def parse response, options={}
+      response
+    end
+
+    def reset models=nil
+      @models = Array(models)
+    end
+
+    def length
+      models.length
+    end
+
+    private
+      def fetch_from_index
+        @fetched = true
+        @models = Array(backend && backend.index)
+      end
+
+      def data_to_model data={}, options={}
+        data = JSON.parse(data) if data.is_a?(String)
+
+        begin
+          if data.class.ancestors.include?(Smooth::Model)
+            model = data
+          elsif data.is_a?(Hash)
+            model = model_class.new(data, options)
+          end
+
+          model.collection ||= self
+
+          model
+        rescue
+          binding.pry if $k
+        end
+      end
+
+      def model_class
+        @model_class || Smooth::Model
+      end
+
+      def cache_adapter
+        @cache_adapter
+      end
+
+      def cacheable?
+        !!(options[:cache])
+      end
+
+      def apply_scope_parameters_to query={}
+        query
+      end
+
+      def namespace
+        namespace = options[:namespace] || self.class.namespace
+
+        if options[:backend] == "active_record" and options[:model] and namespace.nil?
+          namespace = options[:model].table_name
+        end
+
+        namespace
+      end
+
+      def backend_options
+        default = {namespace: namespace}
+        default[:model] ||= options[:model]
+
+        default.merge!(backend_options: options.fetch(:backend_options,{}))
+        default
+      end
+
+      def configure_backend
+        options[:backend] ||= self.class.backend || "file"
+        options[:backend] = options[:backend].to_s if options[:backend].is_a?(Symbol)
+
+        if options[:backend].is_a?(String)
+          klass = if options[:backend].match(/::/)
+            options[:backend]
+          else
+            "Smooth::Backends::#{ options[:backend].camelize }"
+          end
+
+          @backend = klass.constantize.new(backend_options)
+        end
+      end
+
+      def validate_backend
+        configure_backend unless @backend
+
+        raise InvalidBackend unless backend.respond_to?(:query)
+        @backend
+      end
+  end
+end