obvious 0.0.8 → 0.2.0

data/lib/obvious/files/external/fs_plug.rb

@@ -1,99 +0,0 @@
-require 'json'
-
-class FsPlug 
-
-  def initialize filename
-    @filename = filename
-  end
-
-  def load_data
-    contents = File.read @filename
-    JSON.parse contents, :symbolize_names => true
-  end
-
-  def save_data input
-    json_data = JSON.pretty_generate input 
-    File.open(@filename, 'w') {|f| f.write(json_data) }
-  end
-
-  def save input
-    data = []
-    query = load_data 
-
-    new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
-
-    max_id = -1
-    # transform the data if needed
-    query.each do |h|
-      if input[:id] == h[:id]
-        h = input
-      end
-      max_id = h[:id] if h[:id] > max_id
-      data << h
-    end
-
-    # add data to the list if it's a new element 
-    if new_element 
-      input[:id] = max_id + 1
-      data << input 
-    end
-
-    save_data data
-
-    # return the transformed data
-    input
-  end
-
-  def list
-    load_data
-  end
-  
-  def get input
-    data = []
-    query = load_data 
-
-    # transform the data if needed
-    query.each do |h|
-      return h if h[:id] == input[:id]
-    end 
-
-    raise Exception.new 'no object found'
-  end
-
-  def remove input
-    data = []
-    # parse the json list
-    query = load_data 
-
-    # transform the data if needed
-    query.each do |h|
-      unless h[:id] == input[:id]
-        data << h 
-      end
-    end
-
-    save_data data
-
-    # return true on success
-    true 
-  end
-
-  def find input
-    data = []
-    query = load_data 
- 
-    key = input.keys[0] 
- 
-    query.each do |h|
-      if input[key] == h[key]
-        return h
-      end
-    end 
-
-    raise Exception.new 'no object found'
-  end
-end
-
-
-
-

data/lib/obvious/files/external/mongo_plug.rb

@@ -1,62 +0,0 @@
-require 'moped'
-
-# To get the mongo system to work you need to have a counters collection. The
-# code here will increment the seq field which we use to set the id. If you are
-# having problems, you probably need to create the collection and add entries
-# for each other collection you want to have an id sequence.
-
-class MongoPlug
-  def initialize collection
-    @collection = collection
-    @session = MONGO_SESSION
-  end
-
-  def list
-    result = @session[@collection].find.entries
-    result.map! do |entry|
-      clean_up entry 
-    end
-
-    result
-  end
-
-  def get input
-    result = symbolize_keys @session[@collection].find(:id => input[:id]).first
-    clean_up result
-  end
-
-  def save input
-    if input[:id] == -1
-      id = @session[:counters].find(:_id => @collection).modify({ "$inc" => { seq: 1 } }, new:true)["seq"]
-      input[:id] = id
-    end
-    result = @session[@collection].find(:id => input[:id]).modify(input, upsert: true, new: true)
-    clean_up result
-  end
-
-  def remove input
-    @session[@collection].find(:id => input[:id]).remove
-    true
-  end
-
-  def clean_up input
-    result = symbolize_keys input
-    result.delete :_id
-    result
-  end
-
-  def symbolize_keys hash
-    hash.inject({}){|result, (key, value)|
-      new_key = case key
-                when String then key.to_sym
-                else key
-                end
-      new_value = case value
-                  when Hash then symbolize_keys(value)
-                  else value
-                  end
-      result[new_key] = new_value
-      result
-    }
-  end
-end

data/lib/obvious/files/external/mysql_plug.rb

@@ -1,38 +0,0 @@
-require 'sequel'
-
-# assume that DB is defined as a global constant elsewhere
-
-class MysqlPlug 
-
-  def initialize table
-    @table = table
-  end
-
-  def save input
-    table = DB[@table]
-    input[:id] = nil if input[:id] == -1
-
-    # this does an upsert
-    result = table.on_duplicate_key_update.insert input
-
-    input[:id] = result
-    input
-  end
-
-  def list
-    table = DB[@table]
-    table.all
-  end
-
-  def get input
-    table = DB[@table]
-    table.first :id => input[:id]
-  end
-
-  def remove input
-    table = DB[@table]
-    result = table.where(:id => input[:id]).delete
-    return true if result == 1
-    false
-  end
-end

data/lib/obvious/files/external/s3_plug.rb

@@ -1,94 +0,0 @@
-require 'json'
-require 'aws/s3'
-
-class S3Plug
-  include AWS::S3
-
-  def initialize input 
-    @filename = input[:filename]
-    @bucket = input[:bucket]
-
-    # you can test locally with the fake-s3 gem: https://github.com/jubos/fake-s3
-    # or just swap out for the filesystem plug locally
-    s3_key = ENV['S3_KEY'] || '123'
-    s3_secret = ENV['S3_SECRET'] || 'abc'
-    s3_server = ENV['S3_SERVER'] || '0.0.0.0'
-    s3_port = ENV['S3_PORT'] || '10001'
-
-    AWS::S3::Base.establish_connection!(:access_key_id => s3_key,
-                                        :secret_access_key => s3_secret,
-                                        :server => s3_server,
-                                        :port => s3_port)
-  end
-
-  def load_data
-    contents = S3Object.value @filename, @bucket
-    JSON.parse contents, :symbolize_names => true
-  end
-
-  def save_data data
-    json_data = JSON.pretty_generate data 
-    S3Object.store @filename, json_data, @bucket
-  end
-
-  def save input
-    data = []
-    result = load_data
-    new_element = true if input[:id] == -1 # by convention set new element flag if id == -1
-
-    max_id = -1
-    # transform the data if needed
-    result.each do |h|
-      if input[:id] == h[:id]
-        h = input
-      end
-      max_id = h[:id] if h[:id] > max_id
-      data << h
-    end
-
-    # add data to the list if it's a new element 
-    if new_element
-      input[:id] = max_id + 1
-      data << input
-    end
-   
-    save_data data 
-
-    # return the transformed data
-    input
-  end
-
-  def list
-    load_data 
-  end
-  
-  def get input
-    data = []
-    result = load_data
-
-    # transform the data if needed
-    result.each do |h|
-      return h if h[:id] == input[:id]
-    end 
-
-    {} 
-  end
-
-  def remove input
-    data = []
-    result = load_data
-
-    # transform the data if needed
-    result.each do |h|
-      unless h[:id] == input[:id]
-        data << h 
-      end
-    end
-
-    save_data data
-
-    # return true on success
-    true 
-  end
-end
-

data/spec/contract_spec.rb

@@ -1,63 +0,0 @@
-require_relative 'spec_helper'
-require_relative '../lib/obvious/contract'
-
-
-describe Hash do
-  describe '#has_shape?' do
-    it 'should return true for a valid shape' do
-      { id: 1 }.has_shape?(id: Fixnum).should be true
-    end
-    
-    it 'should return false for an invalid shape' do
-      { id: 1 }.has_shape?(id: String).should be false
-    end
-
-    it 'should retrn the invalid field if return_field flag is set' do
-      { id: 1 }.has_shape?({id: String}, true).should eq [false, :id]
-    end
-
-    it 'should allow for nil values to be returned' do
-      { id: nil }.has_shape?({id: String}).should be true
-    end 
-  end
-end
-
-class TestContract < Contract
-  contract_for :test, {
-    input: { id: Fixnum },
-    output: { id: Fixnum, value: String }
-  }
-
-  def test input
-    { id: 1, value: 'this is a test' } 
-  end
-end
-
-describe Contract do
-
-  describe "#call_method" do
-    it 'should return the correct output for valid input and output shapes' do
-      tc = TestContract.new
-      result = tc.test id: 1
-      result.should eq id: 1, value: 'this is a test'
-    end
-  
-    it 'should raise a contract input error with bad input' do
-      tc = TestContract.new
-      expect { tc.test Hash.new }.to raise_error ContractInputError
-    end
-
-    it 'should raise a DataNotFound error if {} is returned' do
-      tc = TestContract.new
-      tc.should_receive(:test_alias).and_return({}) 
-      expect { tc.test id: 1 }.to raise_error DataNotFoundError
-    end
-
-    it 'should raise a contract output error if nil is returned' do
-      tc = TestContract.new
-      tc.should_receive(:test_alias).and_return(nil) 
-      expect { tc.test id: 1 }.to raise_error ContractOutputError
-    end
-
-  end
-end

data/spec/entity_spec.rb

@@ -1,75 +0,0 @@
-require_relative '../lib/obvious/entity'
-
-class Thing < Obvious::Entity
-  value :id, Fixnum 
-  value :name, String 
-end
-
-class Thing2 < Obvious::Entity
-  value :foo , String
-
-  validation :something, Proc.new {
-    if foo != "hello world"
-      msg = "Validation Error: Invalid value for foo, should be 'hello world'"
-      raise Obvious::ValidationError.new msg 
-    end
-  }
-
-  def modify_foo 
-    @values[:foo] = 100
-  end
-
-end
-
-class Thing3 < Obvious::Entity
-  value :foo , String
-
-  validation :something, Proc.new {
-    @values[:foo] = 12
-  }
-
-end
-
-# To test the entity, we are going to use classes that inherit from it instead
-# of poking at it directly. In this case, I think that makes the most sense.
-describe Thing do
-  it 'should create a valid object with valid input' do
-    input = { name: 'Thing', id: 1 }
-    t = Thing.new input
-    t.name.should eq 'Thing'
-    t.id.should eq 1
-  end
-
-  it 'should raise an error with invalid input types' do
-    input = { name: nil, id: nil }
-    expect { Thing.new input }.to raise_error Obvious::TypeError
-  end
-
-  it 'should raise an error with extra fields in input' do
-    input = { name: 'Thing', id: 1, extra: 'should explode' }
-    expect { Thing.new input }.to raise_error Obvious::ShapeError
-  end
-
-  it 'should raise an error when a method tries to modify a value' do
-    t = Thing2.new foo: 'hello world'
-    expect { t.modify_foo }.to raise_error RuntimeError
-  end
-
-  describe '#to_hash' do
-    it 'should return a hash representation of the object' do
-      input = { name: 'Thing', id: 1 }
-      t = Thing.new input
-      t.to_hash.should eq input
-    end
-  end
-
-  describe 'validation' do
-    it 'should raise a validation error on a failed validation' do
-      expect { Thing2.new foo: 'not valid I promise!' }.to raise_error Obvious::ValidationError
-    end
-    
-    it 'should raise an error when trying to modify an object in a validation' do
-      expect { Thing3.new foo: 'hello world' }.to raise_error RuntimeError
-    end
-  end
-end

data/spec/generators/descriptor_spec.rb

@@ -1,34 +0,0 @@
-require_relative '../../lib/generators/descriptor'
-
-require File.expand_path('spec/spec_helper')
-
-module Obvious
-  module Generators
-    describe Descriptor do
-      subject {Descriptor.new(yaml_file)}
-
-      describe "#to_file" do
-       
-        context "when the descriptor is empty" do
-          let( :yaml_file ) { {} }
-
-          it "should raise a meaningful error" do
-           expect {subject.to_file}.to raise_error(InvalidDescriptorError)
-          end
-        end
-
-        ["Action", "Code", "Description"].each do |section|
-          context "when the '#{section}' section is omitted" do
-            let( :yaml_file ) {
-              {"Action" => "Jackson", "Description" => "This is something"}.delete(section)
-            }
-
-            it "should raise a meaningful error" do
-              expect {subject.to_file}.to raise_error(InvalidDescriptorError)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-RSpec.configure do |c|
-  c.mock_with :rspec 
-end