smooth-io 0.0.5

data/lib/smooth/presentable/controller.rb

@@ -0,0 +1,39 @@
+module Smooth
+  module Presentable
+    module Controller
+      extend ActiveSupport::Concern
+
+      included do
+        respond_to :json
+        class_attribute :resource
+      end
+
+      def index
+        records = base_scope.present(params)
+                      .as(presenter_format)
+                      .to(current_user_role)
+
+        render :json => records.results, :root=> false
+      end
+
+      protected
+
+        def current_user_role
+          (current_user && current_user.try(:role)) || :default
+        end
+
+        def presenter_format
+          params[:presenter] || params[:presenter_format] || :default
+        end
+
+        def base_scope
+          resource_model
+        end
+
+        def resource_model
+          resource = self.class.resource || params[:resource]
+          "#{ resource }".singularize.camelize.constantize
+        end
+    end
+  end
+end

data/lib/smooth/queryable.rb

@@ -0,0 +1,35 @@
+require "smooth/queryable/converter"
+require "smooth/queryable/settings"
+
+module Smooth
+  module Queryable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :smooth_queryable_settings
+      self.smooth_queryable_settings ||= Settings.new()
+
+      Smooth::MetaData.register_resource(self)
+    end
+
+    module ClassMethods
+      def can_be_queried_by parameter, *args
+        options = args.extract_options!
+        settings = self.smooth_queryable_settings ||= Settings.new()
+
+        settings.apply_query_options(parameter, options)
+      end
+
+      # It is expected that each model class will implement
+      # its own query method, which handles all of the various
+      # parameters that make sense for that resource
+      def query(params={})
+        scoped if respond_to?(:scoped)
+      end
+
+      def queryable_keys
+        smooth_queryable_settings.available_query_parameters
+      end
+    end
+  end
+end

data/lib/smooth/queryable/converter.rb

@@ -0,0 +1,8 @@
+module Smooth
+  module Queryable
+    class Converter
+      def initialize query={}
+      end
+    end
+  end
+end

data/lib/smooth/queryable/settings.rb

@@ -0,0 +1,23 @@
+module Smooth
+  module Queryable
+    class Settings
+      attr_accessor :query_parameters
+
+      def initialize(options={})
+        @query_parameters = {}
+      end
+
+      def apply_query_options parameter, options={}
+        self.query_parameters[parameter] ||= options
+      end
+
+      def to_hash
+        self.query_parameters
+      end
+
+      def available_query_parameters
+        self.query_parameters.keys
+      end
+    end
+  end
+end

data/lib/smooth/resource.rb

@@ -0,0 +1,10 @@
+module Smooth
+  module Resource
+    extend ActiveSupport::Concern
+
+    included do
+      include Smooth::Queryable
+      include Smooth::Presentable
+    end
+  end
+end

data/lib/smooth/version.rb

@@ -0,0 +1,3 @@
+module Smooth
+  Version = '0.0.5'
+end

data/smooth-io.gemspec

@@ -0,0 +1,35 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'smooth/version'
+
+Gem::Specification.new do |s|
+  s.name          = "smooth-io"
+  s.version       = Smooth::Version
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Jonathan Soeder"]
+  s.email         = ["jonathan.soeder@gmail.com"] 
+  s.homepage      = "http://smooth.io"
+  s.summary       = "Smooth persistence"
+  s.description   = "Cross platform, syncable persistence"
+
+  s.add_dependency 'activerecord', '>= 3.2.12'
+  s.add_dependency 'activesupport', '>= 3.2.12'
+  s.add_dependency 'redis'
+  s.add_dependency 'redis-namespace'
+  s.add_dependency 'typhoeus'
+  s.add_dependency 'virtus', '0.5.5'
+  s.add_dependency 'faye'
+  s.add_dependency 'sinatra'
+  s.add_dependency 'squeel'
+
+  s.add_development_dependency 'rspec', '~> 2.6.0'
+  s.add_development_dependency 'machinist', '~> 1.0.6'
+  s.add_development_dependency 'faker', '~> 0.9.5'
+  s.add_development_dependency 'sqlite3', '~> 1.3.3'
+  s.add_development_dependency 'rack-test'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+end

data/spec/blueprints/people.rb

@@ -0,0 +1,4 @@
+Person.blueprint do
+  name
+  salary
+end

data/spec/environment.rb

@@ -0,0 +1,17 @@
+class Object
+  def reload!
+    require 'machinist/active_record'
+    require 'sham'
+    require 'faker'
+
+    require File.expand_path('../support/schema.rb', __FILE__)
+    require File.expand_path('../support/models.rb', __FILE__)
+
+    require 'smooth'
+
+    true
+  end
+end
+
+reload!
+

data/spec/lib/backends/active_record_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Smooth::Backends::ActiveRecord do
+  let(:backend) do
+    Smooth::Backends::ActiveRecord.new(model:Person)    
+  end
+
+  it "should decorate the model with the smooth query method" do
+    backend.model.should respond_to(:smooth_query)
+  end
+
+  it "should perform a query against the model" do
+    backend.query.count.should == 10
+  end
+
+end
+

data/spec/lib/backends/base_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+describe Smooth::Backends::Base do
+
+  let(:backend) { Smooth::Backends::Base.new(namespace:"test") }
+
+  it "should be queryable" do
+    backend.query(attribute:"x-ray").should be_empty
+    backend.create(attribute:"yankee")
+    backend.query(attribute:"yankee").length.should == 1
+  end
+
+  it "should return an empty set for a query" do
+    backend.create(attribute:"yankee")
+    backend.query(smooth:"yankee").length.should == 0
+  end
+
+  it "should return an empty set for a query" do
+    backend.create(attribute:"smooth")
+    backend.query(attribute:"hotel").length.should == 0
+    backend.query(smooth:"attribute").length.should == 0
+  end
+
+  it "should track the maximum updated at" do
+    backend.maximum_updated_at.should >= Time.now.to_i
+  end
+
+  it "should update the maximum updated at timestamp" do
+    current = backend.maximum_updated_at
+    backend.create(attribute:"indigo")
+    backend.maximum_updated_at.should >= current
+  end
+
+  it "should allow me to create records" do
+    result = backend.create(attribute: "alpha")
+    fetched = backend.show(result[:id])
+    fetched.should be_present
+    fetched[:attribute].should == "alpha"
+  end
+
+  it "should timestamp creates" do
+    current = Time.now.to_i
+    backend.create(attribute:"lima")[:created_at].should >= current
+  end
+
+  it "should timestamp updates" do
+    result = backend.create(attribute:"x-ray")
+    backend.update(result.merge(:name=>"whiskey"))
+    backend.show(result[:id])[:updated_at].should >= result[:created_at]
+  end
+
+  it "should assign an id to records" do
+    result = backend.create(attribute:"hotel")
+    result[:id].should_not be_nil
+  end
+
+  it "should allow me to destroy records" do
+    result = backend.create(attribute:"yankee")
+    backend.destroy(result[:id])
+    backend.show(result[:id]).should be_nil
+  end
+
+  it "should show me a record" do
+    result = backend.create(attribute:"walt whitman")
+    result[:id].should be_present
+    backend.show(result[:id]).should be_a(Hash)
+  end
+
+  it "should allow me to update records" do
+    result = backend.create(attribute:"foxtrot",name:"wilco")
+    backend.update result.merge(name:"mermaid")
+    fetched = backend.show(result[:id])
+    fetched[:name].should == "mermaid"
+  end
+
+
+end

data/spec/lib/backends/file_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'tmpdir'
+
+describe Smooth::Backends::File do
+  before(:all) do
+    @tmpdir = File.join(Dir::tmpdir, "#{ Time.now.to_i }")
+    FileUtils.mkdir_p(@tmpdir)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  let(:backend) do 
+    Smooth::Backends::File.new(namespace:"test",data_directory: @tmpdir)
+  end
+
+  it "should not be throttled by default" do
+    backend.should_not be_throttled
+  end
+
+  it "should be throttled after a flush" do
+    backend.send(:flush)
+    backend.should be_throttled
+  end
+
+  it "should have a storage path" do
+    backend.storage_path.should include("test.json")
+  end
+
+  it "should not persist its data on disk after every write" do
+    backend.create(:attribute=>"delta")
+    IO.read(backend.storage_path).should_not include("delta")
+  end
+
+  it "should persist its data on disk after being flushed" do
+    backend.create(attribute:"charlie") && backend.send(:flush, true)
+    IO.read(backend.storage_path).should include("charlie")
+  end
+
+  it "should flush periodically" do
+    backend.setup_periodic_flushing
+    backend.instance_variable_get("@periodic_flusher").should be_a(Thread)
+  end
+
+end

data/spec/lib/backends/multi_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe "Swappable Backends" do
+  class ModelHelper < Smooth::Model
+    attribute :id
+    attribute :name
+  end
+
+  let(:records) do
+    3.times.collect do |n|
+      {
+        id: n,
+        name: "person #{ n }"
+      }
+    end
+  end
+
+  let(:redis) { Smooth::Collection.new(namespace:"test",backend:"redis",model_class: ModelHelper) }
+  let(:redis_namespace) { Smooth::Collection.new(namespace:"test",backend:"redis_namespace", model_class: ModelHelper) }
+  let(:file) { Smooth::Collection.new(namespace:"test",backend:"file",model_class:ModelHelper) }
+
+  before(:each) { Redis.new.flushdb }
+
+  it "should have the correct backend" do
+    redis.backend.should be_a(Smooth::Backends::Redis)
+    redis_namespace.backend.should be_a(Smooth::Backends::RedisNamespace)
+    file.backend.should be_a(Smooth::Backends::File)
+  end
+
+  it "should encode everything the same" do
+    records.each do |hash|
+      redis.backend.create(hash)
+      file.backend.create(hash)
+      redis_namespace.backend.create(hash)
+    end
+
+    expected = [
+      "person 0",
+      "person 1",
+      "person 2"
+    ].to_set
+
+    redis.models.map(&:name).to_set.should == expected
+    redis_namespace.models.map(&:name).to_set.should == expected
+    file.models.map(&:name).to_set.should == expected
+  end
+end

data/spec/lib/backends/redis_namespace_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+require "fakeredis/rspec"
+
+describe Smooth::Backends::RedisNamespace do
+  let(:backend) do
+    Smooth::Backends::RedisNamespace.new(namespace:"test", redis: ::Redis.new)
+  end
+
+  before(:each) { backend.connection.flushdb }
+
+  it "should allow me to create records" do
+    result = backend.create(attribute:"alpha")
+    fetched = backend.show(result[:id])
+    fetched.should_not be_nil
+  end
+
+  it "should allow me to destroy records" do
+    result = backend.create(attribute:"bravo")
+    fetched = backend.show(result[:id])
+    fetched.should be_present
+    backend.destroy(fetched[:id]).should be_true
+  end
+
+  it "should allow me to update records" do
+    record = backend.create(attribute:"yankee")
+    fetched = backend.show(record[:id])
+    backend.update(fetched.merge(attribute:"hotel"))
+    backend.show(record[:id])[:attribute].should == "hotel"
+  end
+
+  it "should allow me to view records" do
+    record = backend.create(attribute:"updawg")
+    backend.show(record[:id])[:attribute].should == "updawg"
+  end
+
+  it "should store an id" do
+    record = backend.create(attribute:"supbaby")
+    record[:id].should be_present
+  end
+
+end

data/spec/lib/backends/redis_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "fakeredis/rspec"
+
+describe Smooth::Backends::Redis do
+  let(:backend) do
+    Smooth::Backends::Redis.new(namespace:"test")
+  end
+
+  before(:each) { backend.connection.flushdb }
+
+  it "should allow me to create records" do
+    result = backend.create(attribute:"alpha")
+    fetched = backend.show(result[:id])
+    fetched.should_not be_nil
+  end
+
+  it "should allow me to destroy records" do
+    result = backend.create(attribute:"bravo")
+    fetched = backend.show(result[:id])
+    fetched.should be_present
+    backend.destroy(fetched[:id]).should be_true
+  end
+
+  it "should allow me to update records" do
+    record = backend.create(attribute:"yankee")
+    fetched = backend.show(record[:id])
+    backend.update(fetched.merge(attribute:"hotel"))
+    backend.show(record[:id])[:attribute].should == "hotel" 
+  end
+
+  it "should allow me to view records" do
+    record = backend.create(attribute:"updawg")
+    backend.show(record[:id])[:attribute].should == "updawg"
+  end
+
+  it "should store an id" do
+    record = backend.create(attribute:"supbaby")
+    record[:id].should be_present
+  end
+end