hashy_db 0.0.1

data/.gitignore

@@ -0,0 +1,8 @@
+.idea
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.yardoc
+doc
+

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format nested

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@hashy_db --create

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Matt Simpson and Jason Mayer
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# What is this?
+
+Provides an inteface to store and retrieve data in a Hash.  
+
+# Why would you want this?
+
+- To defer choosing your database until you know most about your application.
+- Provides assitance in designing a database agnostic architecture.
+
+The hash can be loaded in memory and be used as your data store.  
+
+Example in a rails app:
+
+initializers/datastore.rb
+
+`ruby
+::DB_HASH = {}
+`
+
+View the examples folder for an example implementation.
+
+# Todos
+
+- Make this into a gem
+- Rename *.get_one into *.find
+- Add a better readme
+
+# Contribute
+
+- fork into a topic branch, write specs, make a pull request.
+
+# Owners
+
+Matt Simpson - [@railsgrammer](https://twitter.com/railsgrammer)
+<br />
+Jason Mayer - [@farkerhaiku](https://twitter.com/farkerhaiku)
+
+# Contributors
+
+David Czarnecki - [@czarneckid](https://twitter.com/czarneckid)

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+  # spec.ruby_opts = ['-w']
+end
+
+task :default => :spec

data/examples/guitar.rb

@@ -0,0 +1,16 @@
+require_relative 'guitar_document'
+
+class Guitar
+  attr_reader :brand, :price, :type, :color, :id
+
+  def initialize(attrs)
+    @brand = attrs[:brand]
+    @price = attrs[:price]
+    @type = attrs[:type]
+    @color = attrs[:color]
+  end
+
+  def store
+    @id = GuitarDocument.store(self)
+  end
+end

data/examples/guitar_document.rb

@@ -0,0 +1,8 @@
+require_relative '../lib/hashy_db/data_model'
+
+class GuitarDocument
+  include HashyDB::DataModel
+
+  data_collection :guitars
+  data_fields :brand, :price, :type, :color
+end

data/hashy_db.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'hashy_db/version'
+
+Gem::Specification.new do |s|
+  s.name        = "hashy_db"
+  s.version     = HashyDB::VERSION
+  s.authors     = ["Matt Simpson", "Jason Mayer"]
+  s.email       = ["matt@railsgrammer.com", "jason.mayer@gmail.com"]
+  s.homepage    = "https://github.com/coffeencoke/HashyDB"
+  s.summary     = %q{Provides an inteface to store and retrieve data in a Hash.}
+  s.description = %q{Provides an inteface to store and retrieve data in a Hash.}
+
+  s.rubyforge_project = "hashy_db"
+
+  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"]
+
+  s.add_dependency('activesupport', '~> 3.1.3')
+  
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec')
+end

data/lib/hashy_db/data_model.rb

@@ -0,0 +1,147 @@
+# SRP: Interface to read and write to and from the data store class for a specific collection
+
+require_relative '../hashy_db/data_store'
+
+require 'digest'
+require 'active_support/concern'
+
+module HashyDB
+  module DataModel
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :id, :model
+    end
+
+    module ClassMethods
+      def data_fields(*fields)
+        create_data_fields(*fields) if fields.any?
+        @data_fields
+      end
+
+      def data_collection(collection_name = nil)
+        set_data_collection(collection_name) if collection_name
+        @data_collection
+      end
+
+      def store(model)
+        new(model).tap do |p|
+          p.add_to_data_store
+        end.id
+      end
+
+      def update(model)
+        new(model).tap do |p|
+          p.replace_in_data_store
+        end
+      end
+
+      def remove_from_array(id, field, value)
+        HashyDB::DataStore.instance.remove_from_array(data_collection, :id, id, field, value)
+      end
+
+      def push_to_array(id, field, value)
+        HashyDB::DataStore.instance.push_to_array(data_collection, :id, id, field, value)
+      end
+
+      def get_one(id)
+        HashyDB::DataStore.instance.get_one(data_collection, :id, id)
+      end
+
+      def all
+        HashyDB::DataStore.instance.get(data_collection)
+      end
+
+      def all_by_field(field, value)
+        HashyDB::DataStore.instance.get_all_for_key_with_value(data_collection, field, value)
+      end
+
+      def all_by_fields(hash)
+        HashyDB::DataStore.instance.get_by_params(data_collection, hash)
+      end
+
+      def find_by_fields(hash)
+        all_by_fields(hash).first
+      end
+
+      def containing_any(field, values)
+        HashyDB::DataStore.instance.containing_any(data_collection, field, values)
+      end
+
+      def array_contains(field, value)
+        HashyDB::DataStore.instance.array_contains(data_collection, field, value)
+      end
+
+      private
+
+      def set_data_collection(collection_name)
+        @data_collection = collection_name
+      end
+
+      def create_data_fields(*fields)
+        attr_accessor *fields
+        @data_fields = fields
+      end
+    end
+
+    def initialize(model)
+      @model = model
+      set_data_field_values
+      set_id
+    end
+
+    def data_fields
+      self.class.data_fields
+    end
+
+    def data_collection
+      self.class.data_collection
+    end
+
+    def add_to_data_store
+      HashyDB::DataStore.instance.add(data_collection, attributes)
+    end
+
+    def replace_in_data_store
+      HashyDB::DataStore.instance.replace(data_collection, attributes)
+    end
+
+    private
+
+    def attributes
+      { id: id }.merge(data_field_attributes)
+    end
+
+    def data_field_attributes
+      {}.tap do |hash|
+        data_fields.each do |field|
+          hash[field] = self.send(field)
+        end
+      end
+    end
+
+    def set_id
+      @id = if(model.respond_to?(:id) && model.id)
+        model.id
+      else
+        new_hash(Time.current)
+      end
+    end
+
+    def new_hash(salt)
+      Digest::SHA256.hexdigest("#{salt}#{model}")[0..6]
+    end
+
+    def set_data_field_values
+      data_fields.each { |field| set_data_field_value(field) }
+    end
+
+    def set_data_field_value(field)
+      self.send("#{field}=", model.send(field)) if field_exists?(field)
+    end
+
+    def field_exists?(field)
+      model.respond_to?(field) && !model.send(field).nil?
+    end
+  end
+end

data/lib/hashy_db/data_store.rb

@@ -0,0 +1,84 @@
+# SRP: Model with implementation on how to store each collection in a data store
+require 'singleton'
+require 'active_support/core_ext/module/delegation'
+
+module HashyDB
+  class DataStore
+    include Singleton
+
+    attr_writer :data_store
+
+    def add(collection_name, hash)
+      get(collection_name) << hash
+    end
+
+    def replace(collection_name, hash)
+      collection = get(collection_name)
+      index = collection.index{ |object| object[:id] == hash[:id] }
+      collection[index] =  hash
+    end
+
+    def get_all_for_key_with_value(collection_name, key, value)
+      get(collection_name).select { |a| a[key] == value }
+    end
+
+    def get_by_params(collection_name, hash)
+      get(collection_name).select do |record|
+        hash.all?{|k,v| record[k] == v }
+      end
+    end
+
+    def get(collection_name)
+      data_store[collection_name] ||= []
+    end
+
+    def get_one(collection_name, key, value)
+      get(collection_name).find { |x| x[key] == value }
+    end
+
+    def push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
+      record = get_one(collection_name, identifying_key, identifying_value)
+      if (record[array_key])
+        record[array_key] << value_to_push
+      else
+        record[array_key] = [value_to_push]
+      end
+      record[array_key].uniq!
+    end
+
+    def remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_pop)
+      record = get_one(collection_name, identifying_key, identifying_value)
+      record[array_key].reject! { |x| x == value_to_pop }
+    end
+
+    def containing_any(collection_name, key, values)
+      get(collection_name).select do |x|
+        result = if x[key].is_a?(Array)
+          (x[key] & values).any?
+        else
+          values.include?(x[key])
+        end
+      end
+    end
+
+    def array_contains(collection_name, key, value)
+      get(collection_name).select do |x|
+        x[key] && x[key].include?(value)
+      end
+    end
+
+    def clear
+      data_store.clear
+    end
+
+    def insert(collection_name, data)
+      data_store[collection_name] = data
+    end
+
+    private
+
+    def data_store
+      @data_store ||= ::DB_HASH
+    end
+  end
+end

data/lib/hashy_db/version.rb

@@ -0,0 +1,3 @@
+module HashyDB
+  VERSION = '0.0.1'
+end

data/lib/hashy_db.rb

@@ -0,0 +1,2 @@
+require 'hashy_db/data_store'
+require 'hashy_db/data_model'

data/spec/examples/guitar_document_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../../examples/guitar_document'
+
+require_relative '../support/examples/data_model_examples'
+
+describe GuitarDocument do
+  let(:collection_name) { :guitars }
+  let(:data_field_attributes) do
+    {
+            brand: 'a brand everyone knows',
+            price: 'a price you save up for',
+            type: 'the kind you want',
+            color: 'should be your favorite'
+    }
+  end
+
+  it_behaves_like 'a data model'
+end

data/spec/examples/guitar_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../../examples/guitar'
+
+describe Guitar do
+  let(:attrs) { { brand: 'Gibson', price: 3399.99, type: 'Les Paul', color: 'Mahogany' } }
+  
+  subject { described_class.new(attrs)}
+
+  its(:brand){ should == attrs[:brand] }
+  its(:price){ should == attrs[:price] }
+  its(:type){ should == attrs[:type] }
+  its(:color){ should == attrs[:color] }
+
+  describe "storing the guitar" do
+    let(:mock_id) { mock 'unique id for the guitar' }
+
+    before do
+      GuitarDocument.stub(store: mock_id)
+    end
+
+    it 'uses the guitar document to store it' do
+      GuitarDocument.should_receive(:store).with(subject).and_return(mock_id)
+
+      subject.store
+    end
+
+    it 'sets the id received from the document to the guitar so we can find it later' do
+      subject.store
+
+      subject.id.should == mock_id
+    end
+  end
+end

data/spec/lib/data_store_spec.rb

@@ -0,0 +1,75 @@
+require_relative '../../lib/hashy_db/data_store'
+
+describe HashyDB::DataStore do
+  subject { HashyDB::DataStore.instance }
+
+  let(:data1) { { id: 1, field_1: 'value 1', field_2: 3, field_3: [1,2,3], shared_between_1_and_2: 'awesome_value', :some_array => [1,2,3,4] } }
+  let(:data2) { { id: 2, field_1: 'value 1.2', field_2: 6, shared_between_1_and_2: 'awesome_value', :some_array => [4,5,6] } }
+  let(:data3) { { id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1,7] } }
+
+  before do
+    subject.data_store = {}
+    subject.insert(:some_collection, [data1, data2, data3])
+  end
+
+  it 'can write and read data to and from a collection' do
+    data4 = { id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1,7] }
+
+    subject.add(:some_collection, data4)
+    subject.get(:some_collection).should == [data1, data2, data3, data4]
+  end
+
+  it 'can replace a record' do
+    data2[:field_1] = 'value modified'
+    subject.replace(:some_collection, data2)
+
+    subject.get_one(:some_collection, :id, 2)[:field_1].should == 'value modified'
+  end
+
+  it 'can get one document' do
+    subject.get_one(:some_collection, :field_1, 'value 1').should == data1
+    subject.get_one(:some_collection, :field_2, 6).should == data2
+  end
+
+  it 'can clear the data store' do
+    subject.clear
+
+    subject.get(:some_collection).should == []
+  end
+
+  it 'can get all records of a specific key value' do
+    subject.get_all_for_key_with_value(:some_collection, :shared_between_1_and_2, 'awesome_value').should == [data1, data2]
+  end
+
+  it 'can get all records where a value includes any of a set of values' do
+    subject.containing_any(:some_collection, :some_array, []).should == []
+    subject.containing_any(:some_collection, :some_array, [7, 2, 3]).should == [data1, data3]
+    subject.containing_any(:some_collection, :id, [1, 2, 5]).should == [data1, data2]
+  end
+  
+  it 'can get all records where the array includes a value' do
+    subject.array_contains(:some_collection, :some_array, 1).should == [data1, data3]
+    subject.array_contains(:some_collection, :some_array_2, 1).should == []
+  end
+
+  it 'can push a value to an array for a specific record' do
+    subject.push_to_array(:some_collection, :id, 1, :field_3, 'add to existing array')
+    subject.push_to_array(:some_collection, :id, 1, :new_field, 'add to new array')
+
+    subject.get_one(:some_collection, :id, 1)[:field_3].should include('add to existing array')
+    subject.get_one(:some_collection, :id, 1)[:new_field].should == ['add to new array']
+  end
+
+  it 'can remove a value from an array for a specific record' do
+    subject.remove_from_array(:some_collection, :id, 1, :field_3, 2)
+
+    subject.get_one(:some_collection, :id, 1)[:field_3].should_not include(2)
+  end
+
+  it 'can get all records that match a given set of keys and values' do
+    records = subject.get_by_params(:some_collection, field_1: 'value 1', shared_between_1_and_2: 'awesome_value')
+    records.size.should be(1)
+    records.first[:id].should == 1
+    subject.get(:some_collection).size.should == 3
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'hashy_db'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+end

data/spec/support/examples/data_model_examples.rb

@@ -0,0 +1,147 @@
+require 'digest'
+require_relative '../../../lib/hashy_db/data_store'
+
+shared_examples_for 'a data model' do
+  let(:mock_data_store) { mock 'data store data model' }
+
+  before do
+    HashyDB::DataStore.stub(:instance => mock_data_store)
+  end
+
+  describe "storing a data model" do
+    let(:current_time) { mock 'current time' }
+    let(:mock_data_model_string_rep) { mock 'data model string representation used for generating an id' }
+    let(:data_model_id) { full_data_model_id[0..6] }
+    let(:full_data_model_id) { '1234567891423456789' }
+    let(:mock_data_model) { mock 'a data model', data_field_attributes }
+
+    before do
+      Time.stub(:current => current_time)
+      Digest::SHA256.stub(:hexdigest => full_data_model_id)
+      mock_data_store.stub(:add)
+    end
+
+    it 'creates a unique hash for the id' do
+      Digest::SHA256.should_receive(:hexdigest).with("#{current_time}#{mock_data_model}").and_return(full_data_model_id)
+
+      described_class.store(mock_data_model)
+    end
+
+    it 'adds the data model to the db store' do
+      mock_data_store.should_receive(:add).with(collection_name, {id: data_model_id}.merge(data_field_attributes))
+
+      described_class.store(mock_data_model)
+    end
+  end
+
+  describe "updating a data model" do
+    let(:data_model_id) { '1234567' }
+    let(:mock_model) { mock 'a model', {:id => data_model_id}.merge(data_field_attributes) }
+
+    before do
+      mock_data_store.stub(:replace)
+    end
+
+    it 'replaces the data model in the db store' do
+      mock_data_store.should_receive(:replace).with(collection_name, {id: data_model_id}.merge(data_field_attributes))
+
+      described_class.update(mock_model)
+    end
+  end
+
+  describe "pushing a value to an array for a data model" do
+    let(:data_model_id) { '1234567' }
+
+    it 'replaces the data model in the db store' do
+      mock_data_store.should_receive(:push_to_array).with(collection_name, :id, data_model_id, :array_field, 'some value')
+
+      described_class.push_to_array(data_model_id, :array_field, 'some value')
+    end
+  end
+
+  describe "getting all data models with a specific value for a field" do
+    let(:mock_data_models) { mock 'data models in the data store' }
+    subject { described_class.array_contains(:some_field, 'some value') }
+
+    it 'returns the stored data models with the requested field / value' do
+      mock_data_store.should_receive(:array_contains).with(collection_name, :some_field, 'some value').and_return(mock_data_models)
+
+      subject.should == mock_data_models
+    end
+  end
+
+  describe "removing a value from an array for a data model" do
+    let(:data_model_id) { '1234567' }
+
+    it 'removes the value from the array' do
+      mock_data_store.should_receive(:remove_from_array).with(collection_name, :id, data_model_id, :array_field, 'some value')
+
+      described_class.remove_from_array(data_model_id, :array_field, 'some value')
+    end
+  end
+
+  describe 'getting all of the data models' do
+    let(:mock_data_models) { mock 'data models in the data store' }
+
+    it 'returns the stored data models' do
+      mock_data_store.should_receive(:get).with(collection_name).and_return(mock_data_models)
+
+      described_class.all.should == mock_data_models
+    end
+  end
+
+  describe "getting all the data fields by a parameter hash" do
+    let(:mock_data_models) { mock 'some data model'}
+    let(:sample_hash) { {field1: nil, field2: 'not nil' }}
+
+    it 'passes the hash to the DataStore' do
+      mock_data_store.should_receive(:get_by_params).with(collection_name, sample_hash).and_return(mock_data_models)
+      
+      described_class.all_by_fields(sample_hash).should == mock_data_models
+    end
+  end
+
+  describe "getting a record by a set of key values" do
+    let(:mock_data_model) { mock 'some data model' }
+    let(:mock_data_models) { [mock_data_model]}
+    let(:sample_hash) { {field1: nil, field2: 'not nil' }}
+
+    it 'passes the hash to the DataStore' do
+      mock_data_store.should_receive(:get_by_params).with(collection_name, sample_hash).and_return(mock_data_models)
+
+      described_class.find_by_fields(sample_hash).should == mock_data_model
+    end
+  end
+
+  describe "getting all of the data models for a where a field contains any value of a given array of values" do
+    let(:mock_data_models) { mock 'data models in the data store' }
+    subject { described_class.containing_any(:some_field, ['value 1', 'value 2']) }
+
+    it 'returns the stored data models' do
+      mock_data_store.should_receive(:containing_any).with(collection_name, :some_field, ['value 1', 'value 2']).and_return(mock_data_models)
+
+      subject.should == mock_data_models
+    end
+  end
+
+  describe "getting all data models with a specific value for a field" do
+    let(:mock_data_models) { mock 'data models in the data store' }
+    subject { described_class.all_by_field(:some_field, 'some value') }
+
+    it 'returns the stored data models with the requested field / value' do
+      mock_data_store.should_receive(:get_all_for_key_with_value).with(collection_name, :some_field, 'some value').and_return(mock_data_models)
+
+      subject.should == mock_data_models
+    end
+  end
+
+  describe 'getting a specific data model' do
+    let(:mock_data_model) { mock 'data_model', :id => 'id' }
+
+    it 'returns the data model from the data store' do
+      mock_data_store.should_receive(:get_one).with(collection_name, :id, mock_data_model.id).and_return(mock_data_model)
+
+      described_class.get_one(mock_data_model.id).should == mock_data_model
+    end
+  end
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: hashy_db
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Simpson
+- Jason Mayer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70126083361020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *70126083361020
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70126083360000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70126083360000
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70126083359160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70126083359160
+description: Provides an inteface to store and retrieve data in a Hash.
+email:
+- matt@railsgrammer.com
+- jason.mayer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/guitar.rb
+- examples/guitar_document.rb
+- hashy_db.gemspec
+- lib/hashy_db.rb
+- lib/hashy_db/data_model.rb
+- lib/hashy_db/data_store.rb
+- lib/hashy_db/version.rb
+- spec/examples/guitar_document_spec.rb
+- spec/examples/guitar_spec.rb
+- spec/lib/data_store_spec.rb
+- spec/spec_helper.rb
+- spec/support/examples/data_model_examples.rb
+homepage: https://github.com/coffeencoke/HashyDB
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: hashy_db
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Provides an inteface to store and retrieve data in a Hash.
+test_files:
+- spec/examples/guitar_document_spec.rb
+- spec/examples/guitar_spec.rb
+- spec/lib/data_store_spec.rb
+- spec/spec_helper.rb
+- spec/support/examples/data_model_examples.rb