knish 0.2.6

data/spec/model_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+RSpec.describe Knish::Model do
+  let(:model) { model_class.new(attrs) }
+
+  let(:model_class) do
+    Project # defined in support
+  end
+
+  let(:attrs) { {} }
+  let(:id) { nil }
+
+  let(:data_path) { "#{model.config.model_root}/data.json" }
+
+  before { clear_db(db_fixture_path) }
+  after  { clear_db(db_fixture_path) }
+
+  context 'when no id is provided' do
+    let(:id) { nil }
+
+    it 'uses the next id' do
+      expect(model.id).to eq(1)
+    end
+  end
+
+  context 'when an id is included in the initialization hash' do
+    let(:attrs) { {id: 42} }
+
+    it 'uses it' do
+      expect(model.id).to eq(42)
+    end
+  end
+
+  describe 'configed attributes' do
+    it 'should have getters and setters for the data attributes' do
+      expect(model).to respond_to('name')
+      expect(model).to respond_to('name=')
+      expect(model).to respond_to('url')
+      expect(model).to respond_to('url=')
+    end
+
+    it 'should have getters and setters for the markdown attributes' do
+      expect(model).to respond_to('description')
+      expect(model).to respond_to('description=')
+    end
+
+    it 'should have getters the collections' do
+      expect(model).to respond_to('stories')
+    end
+  end
+
+  context 'when initilaized with attributes' do
+    let(:attrs) {
+      {
+        name: 'My New Project',
+        url: 'github.com/baccigalupi/my-new-project',
+        description: '#Headline!'
+      }
+    }
+
+    it 'sets each of these into an attribute' do
+      expect(model.name).to eq(attrs[:name])
+      expect(model.url).to eq(attrs[:url])
+      expect(model.description).to eq(attrs[:description])
+    end
+  end
+
+  describe '#save' do
+    let(:attrs) {
+      {
+        name: 'My New Project',
+        url: 'github.com/baccigalupi/my-new-project',
+        description: '#Headline!'
+      }
+    }
+
+    let(:saved_data) { JSON.parse(File.read(data_path)) }
+
+    let(:model) { Nested::Deeply::Is::Project.new(attrs) }
+
+    it 'saves to file the data attributes' do
+      model.save
+      expect(saved_data['name']).to eq(attrs[:name])
+      expect(saved_data['url']).to  eq(attrs[:url])
+    end
+
+    it 'also save the class name in a specal attribute' do
+      model.save
+      expect(saved_data['___type']).to eq('Nested::Deeply::Is::Project')
+    end
+
+    it 'saves markdown files' do
+      model.save
+      expect(File.read("#{model.config.model_root}/_description.md")).to eq(attrs[:description])
+    end
+  end
+
+  describe '#load' do
+    let(:model_directory) { File.dirname(data_path) }
+
+    before do
+      FileUtils.mkdir_p(model_directory)
+      File.open(data_path, 'w') { |f| f.write({name: 'Name'}.to_json) }
+      File.open("#{model_directory}/_description.md", 'w') { |f| f.write("#Hello") }
+    end
+
+    it 'loads the data into attributes' do
+      model.load
+      expect(model.name).to eq('Name')
+    end
+
+    it 'loads the markdown files into attributes' do
+      model.load
+      expect(model.description).to eq('#Hello')
+    end
+  end
+
+  describe '#template' do
+    let(:reader) { double('reader') }
+
+    it 'delegates it down to the reader' do
+      allow(Knish::Reader).to receive(:new).and_return(reader)
+      expect(reader).to receive(:template).with('key').and_return("some_path")
+      expect(model.template('key')).to eq('some_path')
+    end
+  end
+
+  describe 'adding to collections, and saving on that collection directly' do
+    it 'stores and retrieves any kind of Knish object to the collection' do
+      model.stories << Feature.new(name: 'Do something great, and quickly')
+      model.stories << Bug.new(name: 'Fix all the badness, go!')
+
+      expect(model.stories.first.name).to eq('Do something great, and quickly')
+      expect(model.stories.last.name).to eq('Fix all the badness, go!')
+    end
+
+    it 'saves the models to the right location' do
+      model.stories << Feature.new(name: 'Do something great, and quickly')
+      model.stories << Bug.new(name: 'Fix all the badness, go!')
+
+      model.stories.save
+
+      expect(File.exist?("#{model.config.model_root}/stories/1")).to be(true)
+    end
+  end
+
+  describe 'loading collections, is done via direct call to collection through the model' do
+    let(:attrs) {
+      {
+        name: 'My New Project',
+        url: 'github.com/baccigalupi/my-new-project',
+        description: '#Headline!'
+      }
+    }
+
+    before do
+      model.stories << Feature.new(name: 'Make it go', description: 'Do I have to specify this?')
+      model.stories << Bug.new(name: 'It just doesn\'t work', description: 'Do I have to specify this?')
+      model.stories.save
+    end
+
+    let(:loaded_model) {
+      project = Project.new(id: model.id)
+      project.stories.load
+      project
+    }
+
+    it 'builds the right classes for collection models' do
+      expect(loaded_model.stories.size).to eq(2)
+      expect(loaded_model.stories.first).to be_a(Feature)
+      expect(loaded_model.stories.last).to be_a(Bug)
+    end
+
+    it 'models have the right ids' do
+      expect(loaded_model.stories.first.id).to eq(1)
+      expect(loaded_model.stories.last.id).to eq(2)
+    end
+  end
+
+  context 'in order to have the models work well in forms for ActiveModel' do
+    let(:naming) { double('naming class') }
+
+    it 'shortens the name' do
+      expect(ActiveModel::Name).to receive(:new).with(Nested::Deeply::Is::Project, Nested::Deeply::Is).and_return(naming)
+      Nested::Deeply::Is::Project.model_name
+    end
+  end
+end

data/spec/reader_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe Knish::Reader do
+  let(:reader) { Knish::Reader.new(config) }
+  let(:config) {
+    c = Knish::ModelConfig.new(fixture_db_config, 'posts', id)
+    c.markdown_attributes = ['key']
+    c
+  }
+  let(:id) { 32 }
+
+  before { clear_db(db_fixture_path) }
+  after  { clear_db(db_fixture_path) }
+
+  context 'when the collection directory does not exist' do
+    it '#get_json returns an empty hash' do
+      expect(reader.get_json).to eq({})
+    end
+
+    it '#get_markdown returns an empty string' do
+      expect(reader.get_markdown).to eq({'key' => ''})
+    end
+
+    it '#template returns the path as though it were there' do
+      expect(reader.template('key')).to eq("/../../knish/posts/32/key")
+    end
+
+    it 'should not be persisted' do
+      expect(reader.persisted?).to eq(false)
+    end
+  end
+
+  context 'when the data exists' do
+    before do
+      FileUtils.mkdir_p(config.model_root)
+      File.open("#{config.model_root}/data.json", 'w') {|f| f.write({hello: 'happy json'}.to_json)}
+      File.open("#{config.model_root}/_key.md", 'w') {|f| f.write("#hello!")}
+    end
+
+    it '#get_json returns the found data' do
+      expect(reader.get_json).to eq({'hello' => 'happy json'})
+    end
+
+    it '#get_markdown returns the contents of the file' do
+      expect(reader.get_markdown).to eq({'key' =>"#hello!"})
+    end
+
+    it '#template returns the path to the markdown file, rails style' do
+      expect(reader.template('key')).to eq("/../../knish/posts/32/key")
+    end
+
+    it 'should be persisted' do
+      expect(reader.persisted?).to eq(true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+$: << File.dirname(__FILE__) + "/../lib"
+
+require_relative "fixtures/active_model_mock"
+
+require 'knish'
+require 'bundler'
+
+Dir.glob(File.dirname(__FILE__) + "/support/**/*").each {|f| require f}
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+
+  if config.files_to_run.one?
+    config.default_formatter = 'doc'
+  end
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.before {
+    Knish.clear_config
+    Knish.configure do |c|
+      c.db_directory = db_fixture_path
+    end
+  }
+end

data/spec/support/file_helpers.rb

@@ -0,0 +1,19 @@
+def clear_db(path)
+  Dir.glob(path).each { |p| FileUtils.rm_rf(p) }
+end
+
+def db_fixture_path
+  File.expand_path(File.dirname(__FILE__) + "/../fixtures/db")
+end
+
+def full_db_path
+  db_fixture_path + "/knish"
+end
+
+def fixture_db_config
+  c = Knish::DbConfig.new
+  c.db_directory = db_fixture_path
+  c
+end
+
+

data/spec/support/model_classes.rb

@@ -0,0 +1,32 @@
+Project = Knish.build('projects') do |config|
+  config.db_directory = db_fixture_path
+  config.data_attributes = ['name', 'url']
+  config.markdown_attributes = ['description']
+  config.collections = ['stories']
+end
+
+Feature = Knish.build('features') do |config|
+  config.db_directory = db_fixture_path
+  config.data_attributes = ['name']
+  config.markdown_attributes = ['overview', 'description', 'scenarios']
+end
+
+Bug = Knish.build('bugs') do |config|
+  config.db_directory = db_fixture_path
+  config.data_attributes = ['name']
+  config.markdown_attributes = ['description', 'reproduction_steps', 'expected', 'actual', 'additional_information']
+end
+
+module Nested
+  module Deeply
+    module Is
+      Project = Knish.build('projects') do |config|
+        config.db_directory = db_fixture_path
+        config.data_attributes = ['name', 'url']
+        config.markdown_attributes = ['description']
+        config.collections = ['stories']
+        config.omitted_namespace = Nested::Deeply::Is
+      end
+    end
+  end
+end

data/spec/writer_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Knish::Writer do
+  let(:writer) { Knish::Writer.new(config) }
+  let(:config) { Knish::ModelConfig.new(fixture_db_config, 'posts', id) }
+  let(:id) { 32 }
+
+  before { clear_db(db_fixture_path) }
+  after { clear_db(db_fixture_path) }
+
+  describe '#build_directories' do
+    it 'will create the collection root directory' do
+      writer.build_directories([])
+      expect(File.exist?(config.model_root)).to eq(true)
+    end
+
+    it 'will create directories specified' do
+      writer.build_directories(['foo', 'bar'])
+      expect(File.exist?("#{config.model_root}/foo")).to eq(true)
+      expect(File.exist?("#{config.model_root}/bar")).to eq(true)
+    end
+  end
+
+  describe '#save_json' do
+    it 'will build the root if it does not exist' do
+      writer.save_json({})
+      expect(File.exist?(config.model_root)).to eq(true)
+    end
+
+    it 'creates a data.json file in the root directory' do
+      writer.save_json({})
+      expect(File.exist?("#{config.model_root}/data.json")).to eq(true)
+    end
+
+    it 'has the right data' do
+      writer.save_json({hello: 'knish'})
+      data = JSON.load(File.read("#{config.model_root}/data.json"))
+      expect(data).to eq({'hello' => 'knish'})
+    end
+  end
+
+  describe '#save_markdown' do
+    it 'will build the root if it does not exist' do
+      writer.save_markdown({description: '#Description'})
+      expect(File.exist?(config.model_root)).to eq(true)
+    end
+
+    it 'creates file with named for the key' do
+      writer.save_markdown({description: '#Description'})
+      expect(File.exist?("#{config.model_root}/_description.md")).to eq(true)
+    end
+
+    it 'has the markdown' do
+      writer.save_markdown({description: '#Description'})
+      data = File.read("#{config.model_root}/_description.md")
+      expect(data).to eq('#Description')
+    end
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: knish
+version: !ruby/object:Gem::Version
+  version: 0.2.6
+platform: ruby
+authors:
+- Kane Baccigalupi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  The problem with CMSs is that you really want your application content in source control,
+    not a database. Knish provides a structured data model for saving data to json, and formatted html to markdown
+email:
+- baccigalupi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- knish.gemspec
+- lib/knish.rb
+- lib/knish/builder.rb
+- lib/knish/collection.rb
+- lib/knish/collection_config.rb
+- lib/knish/db_config.rb
+- lib/knish/delegate_inspector.rb
+- lib/knish/existing_models.rb
+- lib/knish/member.rb
+- lib/knish/model.rb
+- lib/knish/model_config.rb
+- lib/knish/reader.rb
+- lib/knish/version.rb
+- lib/knish/writer.rb
+- spec/builder_spec.rb
+- spec/collection_config_spec.rb
+- spec/collection_spec.rb
+- spec/fixtures/active_model_mock.rb
+- spec/knish_spec.rb
+- spec/model_config_spec.rb
+- spec/model_spec.rb
+- spec/reader_spec.rb
+- spec/spec_helper.rb
+- spec/support/file_helpers.rb
+- spec/support/model_classes.rb
+- spec/writer_spec.rb
+homepage: http://github.com/baccigalupi/knish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: File backed data models, excellent for CMS apps!
+test_files:
+- spec/builder_spec.rb
+- spec/collection_config_spec.rb
+- spec/collection_spec.rb
+- spec/fixtures/active_model_mock.rb
+- spec/knish_spec.rb
+- spec/model_config_spec.rb
+- spec/model_spec.rb
+- spec/reader_spec.rb
+- spec/spec_helper.rb
+- spec/support/file_helpers.rb
+- spec/support/model_classes.rb
+- spec/writer_spec.rb