knish 0.2.6

data/lib/knish/model_config.rb

@@ -0,0 +1,51 @@
+module Knish
+  class ModelConfig < SimpleDelegator
+    attr_accessor :db_config, :path, :id, :omitted_namespace
+    attr_writer :data_attributes, :markdown_attributes, :collections
+
+    def initialize(db_config, path, id=nil)
+      super(db_config)
+      @path = path
+      @db_config = db_config
+      @id = id || next_id
+    end
+
+    def data_attributes
+      @data_attributes ||= []
+    end
+
+    def markdown_attributes
+      @markdown_attributes ||= []
+    end
+
+    def collections
+      @collections ||= []
+    end
+
+    def all_attributes
+      data_attributes + markdown_attributes
+    end
+
+    def collection_root
+      "#{db_config.db_root}/#{path}"
+    end
+
+    def model_root
+      "#{collection_root}/#{id}"
+    end
+
+    def next_id
+      ExistingModels.new(collection_root).next_id
+    end
+
+    def template_path
+      "#{view_to_db_path}/#{db_name}/#{path}/#{id}"
+    end
+
+    def inspect
+      DelegateInspector.new(self,
+        [:db_config, :path, :id, :omitted_namespace, :data_attributes, :markdown_attributes, :collections]
+      ).to_inspect
+    end
+  end
+end

data/lib/knish/reader.rb

@@ -0,0 +1,47 @@
+module Knish
+  class Reader
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def get_json
+      JSON.parse(read_file(config.data_filename) || '{}')
+    end
+
+    def get_markdown
+      config.markdown_attributes.inject({}) do |hash, key|
+        hash[key] = read_markdown(key)
+        hash
+      end
+    end
+
+    def get_collections
+      config.collections.inject({}) do |hash, collection_name|
+        collection = Collection.new(collection_name, config)
+        collection.load
+        hash[collection_name] = collection
+        hash
+      end
+    end
+
+    def template(key)
+      "#{config.template_path}/#{key}"
+    end
+
+    def persisted?
+      !!read_file(config.data_filename)
+    end
+
+    def read_file(filename)
+      File.read("#{config.model_root}/#{filename}") rescue nil
+    end
+
+    private
+
+    def read_markdown(key)
+      read_file("_#{key}.md") || ""
+    end
+  end
+end

data/lib/knish/version.rb

@@ -0,0 +1,3 @@
+module Knish
+  VERSION = "0.2.6"
+end

data/lib/knish/writer.rb

@@ -0,0 +1,40 @@
+module Knish
+  class Writer
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def build_directories(directories)
+      make_root
+      directories.each {|dir| make_directory(dir) }
+    end
+
+    def save_json(attributes)
+      make_root
+      write_file(config.data_filename, attributes.to_json)
+    end
+
+    def save_markdown(attributes)
+      make_root
+      attributes.each do |key, data|
+        write_file("_#{key}.md", data)
+      end
+    end
+
+    private
+
+    def write_file(filename, data)
+      File.open("#{config.model_root}/#{filename}", 'w') { |f| f.write(data) }
+    end
+
+    def make_root
+      FileUtils.mkdir_p(config.model_root) unless File.exist?(config.model_root)
+    end
+
+    def make_directory(dir)
+      FileUtils.mkdir_p("#{config.model_root}/#{dir}") unless File.exist?("#{config.model_root}/#{dir}")
+    end
+  end
+end

data/spec/builder_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+RSpec.describe Knish, '.build' do
+  let(:config) { project_class.config }
+
+  context 'when all model level configuration is provided' do
+    let(:project_class) {
+      Project # defined in support
+    }
+
+    it 'builds a model class with the right attributes' do
+      expect(project_class.ancestors).to include(Knish::Model)
+    end
+
+    it 'has the right data in the model config' do
+      expect(config).to be_a(Knish::ModelConfig)
+      expect(config.path).to eq('projects')
+    end
+
+    it 'adds the right class configuration attributes to the model class' do
+      expect(config.data_attributes).to eq(['name', 'url'])
+      expect(config.markdown_attributes).to eq(['description'])
+      expect(config.collections).to eq(['stories'])
+    end
+  end
+
+  context 'when some model level configuration is set' do
+    let(:project_class) {
+      Knish.build('projects') { |c| c.collections = ['features'] }
+    }
+
+    it 'sets missing model configuration to an empty array' do
+      expect(config.data_attributes).to eq([])
+      expect(config.markdown_attributes).to eq([])
+    end
+  end
+
+  context 'when setting db level configuration' do
+    let(:project_class) {
+      Knish.build('projects') do |config|
+        config.db_name = 'pizza'
+        config.data_attributes = ['name', 'url']
+      end
+    }
+
+    it 'updates the database related configuration' do
+      expect(config.db_name).to eq('pizza')
+    end
+  end
+
+  context 'when Knish already has custom global database configuration' do
+    let(:project_class) {
+      Knish.build('projects') do |config|
+        config.db_name = 'pizza'
+        config.data_attributes = ['name', 'url']
+      end
+    }
+
+    before do
+      Knish.configure do |config|
+        config.data_filename = 'json-data.json'
+      end
+    end
+
+    it 'does not mutate the Knish global configuration' do
+      expect(Knish.config.db_name).to_not eq('pizza')
+    end
+
+    it 'model db configuration includes changes made at Knish level' do
+      expect(config.data_filename).to eq('json-data.json')
+    end
+
+    it 'includes configured modifications to the db setup' do
+      expect(config.db_name).to eq('pizza')
+    end
+
+    it 'uses model level configurations' do
+      expect(config.data_attributes).to eq(['name', 'url'])
+    end
+  end
+end
+

data/spec/collection_config_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe Knish::CollectionConfig do
+  let(:config) { Knish::CollectionConfig.new(model_config, path) }
+  let(:model_config) { Project.config }
+  let(:path) { 'stories' }
+
+  let(:project_path) { full_db_path + '/projects/1' }
+  let(:stories_path) { project_path + '/stories' }
+
+  before do
+    # setup file system of a collection
+    FileUtils.mkdir_p(project_path + "/stories/1")
+    File.open(project_path + "/data.json", 'w') {|f| f.write({name: 'hello project'}.to_json) }
+    File.open(project_path + "/stories/1/data.json", 'w') {|f| f.write({name: 'hello feature', ___type: 'Feature'}.to_json) }
+  end
+
+  after { clear_db(full_db_path) }
+
+  describe '#collection_root' do
+    it 'should be based on the model config and the path' do
+      expect(config.collection_root).to eq(stories_path)
+    end
+  end
+
+  describe '#next_id' do
+    it 'should be the next available id' do
+      expect(config.next_id).to eq(2)
+    end
+  end
+
+  describe '#memeber_config(klass, id)' do
+    let(:member_config) { config.member_config(Bug.config, 2) }
+
+    it 'should have the model attributes of the class' do
+      expect(member_config.all_attributes).to eq(Bug.config.all_attributes)
+    end
+
+    it 'should have the path specific to this model' do
+      expect(member_config.model_root).to eq(project_path + "/stories/2")
+    end
+  end
+end

data/spec/collection_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+RSpec.describe Knish::Collection do
+  let(:collection) { Knish::Collection.new('stories', parent_config) }
+  let(:parent_config) { Knish::ModelConfig.new(fixture_db_config, 'projects') }
+
+  let(:model_class) {
+    Knish.build('features') do |config|
+      config.db_directory = db_fixture_path
+      config.data_attributes = ['name']
+      config.markdown_attributes = ['description']
+    end
+  }
+
+  describe '#add' do
+    let(:model) { model_class.new }
+
+    it 'puts the model in the collection' do
+      collection.add(model)
+      expect(collection.first).to eq(model)
+    end
+
+    it 'raises an error if the model is not a Knish object' do
+      expect{
+        collection.add({})
+      }.to raise_error
+    end
+
+    it 'changes the configuration on the way in' do
+      collection.add(model)
+      expect(model.config.path).to eq('projects/1/stories')
+    end
+
+    context 'when objects of that class already exist in the model configured location' do
+      let(:original_model_collection_path) { db_fixture_path + "/knish/features" }
+
+      before do
+        FileUtils.mkdir_p(original_model_collection_path + "/3")
+      end
+
+      after do
+        clear_db(db_fixture_path)
+      end
+
+      it 'reevaluates the id in the configuration' do
+        expect {
+          collection.add(model)
+        }.to change { model.config.id }
+
+        expect(collection.first.id).to eq(1)
+      end
+    end
+  end
+
+  describe '#save' do
+    let(:models) {
+      [model_class.new(name: 'bar'), model_class.new(name: 'foo')]
+    }
+
+    it 'calls save on each of the models' do
+      models.each do |m|
+        expect(m).to receive(:save)
+        collection.add(m)
+      end
+      collection.save
+    end
+  end
+
+  describe '#load' do
+    before do
+      FileUtils.mkdir_p(collection.config.collection_root + "/1")
+      File.open(collection.config.collection_root + "/1/data.json", 'w') {|f| f.write({name: 'Hello', ___type: 'Feature'}.to_json) }
+      FileUtils.mkdir_p(collection.config.collection_root + "/2")
+      File.open(collection.config.collection_root + "/2/data.json", 'w') {|f| f.write({name: 'Goodbye', ___type: 'Bug'}.to_json) }
+    end
+
+    after  { clear_db(db_fixture_path) }
+
+    it 'should be the right size' do
+      collection.load
+      expect(collection.size).to eq(2)
+    end
+
+    it 'should remove existing models' do
+      project = Project.new(name: 'not for saving, thanks!')
+      collection << project
+      collection.load
+      expect(collection).not_to include(project)
+    end
+
+    it 'should build the right type of models for each' do
+      collection.load
+
+      expect(collection.first).to be_a(Feature)
+      expect(collection.last).to be_a(Bug)
+    end
+  end
+end

data/spec/fixtures/active_model_mock.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  module Model
+  end
+
+  class Name < Struct.new(:klass, :namespace)
+  end
+end

data/spec/knish_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+RSpec.describe Knish, '.configure' do
+  it 'allows the configuration any values in the global config' do
+    Knish.configure do |config|
+      config.db_directory = db_fixture_path
+      config.view_to_db_path = 'view_to_db_path'
+      config.data_filename = 'my-data.json'
+      config.db_name = 'my-db'
+    end
+
+    expect(Knish.config.db_directory).to eq(db_fixture_path)
+    expect(Knish.config.view_to_db_path).to eq('view_to_db_path')
+    expect(Knish.config.data_filename).to eq('my-data.json')
+    expect(Knish.config.db_name).to eq('my-db')
+  end
+
+  it 'uses a set of default values if not configured' do
+    expect(Knish.config.view_to_db_path).to eq('/../..')
+    expect(Knish.config.data_filename).to eq('data.json')
+    expect(Knish.config.db_name).to eq('knish')
+  end
+
+  it 'constructs the database root from the db directory and the db name' do
+    Knish.configure do |config|
+      config.db_directory = 'db_dir'
+      config.db_name = 'my-db'
+    end
+
+    expect(Knish.config.db_root).to eq('db_dir/my-db')
+  end
+end

data/spec/model_config_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe Knish::ModelConfig do
+  let(:config) { Knish::ModelConfig.new(fixture_db_config, 'projects') }
+
+  describe '#id' do
+    context 'when no id is passed in' do
+      it 'uses the next id' do
+        expect(config.id).to eq(config.next_id)
+      end
+    end
+
+    context 'when an id is given' do
+      let(:config) { Knish::ModelConfig.new(fixture_db_config, 'projects', 44) }
+
+      it 'uses it' do
+        expect(config.id).to eq(44)
+      end
+    end
+  end
+
+  describe '#collection_root' do
+    it 'returns the collection root path' do
+      expect(config.collection_root).to eq(File.expand_path("#{db_fixture_path}/knish/projects"))
+    end
+  end
+
+  describe '#next_id' do
+    before { clear_db(db_fixture_path) }
+    after  { clear_db(db_fixture_path) }
+
+    context 'when there are no models in the collection' do
+      it 'returns 1' do
+        expect(config.next_id).to eq(1)
+      end
+    end
+
+    context 'when there are already models in the system' do
+      before { FileUtils.mkdir_p("#{config.collection_root}/1") }
+
+      it 'returns the next available id' do
+        expect(config.next_id).to eq(2)
+      end
+    end
+
+    context 'when a model is missing but was built' do
+      before { FileUtils.mkdir_p("#{config.collection_root}/2") }
+
+      it 'returns the next available id' do
+        expect(config.next_id).to eq(3)
+      end
+    end
+  end
+end