collabda 0.0.1a

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 72411f5cfca47c38d7810c6d0619bfb68fda266a
+  data.tar.gz: 5c73e2d894bbb0d1fbb64c7c527686a4826873f9
+SHA512:
+  metadata.gz: 647e46c9f8395fd4e99d9534764073ec36408e77dc3663fc9af315872081056678ca2da94c0f41c614169cc78a908ff8dcb699fc6adcba41f0772973dfbc0255
+  data.tar.gz: 762fa5e7c1d0e82ca7937b9d13330c2667c44bdd0147ba78cc5aaadfc58b4af65a0e14de5f9de1c6512218cb3650f9ed4153ce5680354254df8925f32e2ffb5a

data/lib/collabda.rb

@@ -0,0 +1,113 @@
+module Collabda
+  def self.included(base)
+    base.extend(Enumerable)
+    base.extend(ClassMethods)
+    @classes ||= []
+    @classes << base
+  end
+
+  def self.rebuild_collections
+    return if @classes.nil?
+    @classes.each do |c|
+      c.build_collection
+    end
+  end
+
+  def self.collection(class_name, &block)
+    model = Class.new do
+      include Collabda
+      self.class_eval(&block)
+    end
+    nesting = block.binding.eval("Module.nesting[0]") || Object
+    nesting.instance_eval{const_set(class_name, model)}
+    model.build_collection
+    return model
+  end
+
+  # def self.watch_files
+  #   @classes.map{|c| c.source_path}
+  # end
+
+  InvalidSource = Class.new(StandardError)
+  MissingAttributes = Class.new(StandardError)
+
+  module ClassMethods
+    def source(path, options={})
+      @source_path = path
+      @format = options[:type] || :yaml
+      fetch_data
+    end
+
+    def all
+      @collabda_models
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    def check_validity
+      raise InvalidSource if @source_path.nil?
+      raise MissingAttributes if @properties.nil?
+    end
+
+    def build_collection
+      check_validity
+      fetch_data
+      @collabda_models = @parsed_data.map do |el|
+        build(el)
+      end
+    end
+
+    def build(attributes_hash)
+      model = self.new
+      @properties.each do |attribute|
+        model.instance_variable_set("@#{attribute}",attributes_hash[attribute])
+      end
+      model
+    end
+
+    def properties(*attributes)
+      @properties=attributes
+    end
+
+    def source_path
+      @source_path
+    end
+
+    def parsed_data
+      @parsed_data
+    end
+
+    private
+    def fetch_data
+      io = File.open(@source_path)
+      @parsed_data = Readers.send(@format,io)
+    end
+  end
+
+  module Readers
+    def self.yaml(io)
+      YAML.load(io).map{|model| model.symbolize_keys}
+    end
+    def self.json(io)
+      JSON.load(io).map{|model| model.symbolize_keys}
+    end
+  end
+end
+
+if defined? Rails
+  # TODO: add development autoreload code
+else
+  class Hash
+    def symbolize_keys
+      dup.symbolize_keys!
+    end
+    def symbolize_keys!
+      keys.each do |key|
+        self[(key.to_sym rescue key) || key] = delete(key)
+      end
+      self
+    end
+  end
+end

data/spec/lib/collabda_spec.rb

@@ -0,0 +1,179 @@
+require 'collabda'
+
+FOO_YAML = <<-yaml
+- name: Foo
+  description: "yo foo"
+- name: Bar
+  description: "at the bar"
+- name: Baz
+  description: "get some baz"
+yaml
+
+FOO_JSON = <<-json
+[
+  {"name": "FooJ", "description": "yo foo"},
+  {"name": "BarJ", "description": "at the bar"},
+  {"name": "BazJ", "description": "get some baz"}
+]
+json
+
+describe "Collabda" do
+  before(:each) do
+    File.stub(:open){StringIO.open(FOO_YAML)}
+  end
+
+  let(:class_builder) do
+    ->(&block) do
+      -> do
+        Class.new do
+          include Collabda
+          # include Collabda::Document
+          block.call(self)
+          attr_reader :description
+          properties :name, :description
+        end
+      end
+    end
+  end
+
+  let(:yaml_class_factory) do
+    class_builder.call{|c| c.source "spec/lib/foo.yaml", :type=>:yaml}
+  end
+
+
+  it "opens specified file during class definition" do
+    File.should_receive(:open)
+    model_class = yaml_class_factory.call
+  end
+
+  describe "errors" do
+    let(:model_class){Class.new{include Collabda}}
+    it "raises InvalidSource error if source not set" do
+      expect{model_class.build_collection}.to raise_error Collabda::InvalidSource
+    end
+    it "raises MissingAttributes error if not set" do
+      model_class.source "foo.yaml"
+      expect{model_class.build_collection}.to raise_error Collabda::MissingAttributes
+    end
+  end
+
+  describe "Yaml model" do
+    let!(:model_class){yaml_class_factory.call}
+    specify "source sets a source_path class variable" do
+      expect(model_class.source_path).to be_a String
+    end
+
+    specify "properties sets fields to use" do
+      expect(model_class.instance_variable_get(:@properties)).to eq [:name, :description]
+    end
+
+    it "tracks where Collabda is included" do
+      FooList = model_class
+      expect(Collabda.instance_variable_get(:@classes)).to include FooList
+    end
+
+    # it "maintains a list of yaml files to watch" do
+    #   expect(Collabda.watch_files).to include "spec/lib/foo.yaml"
+    # end
+
+    it "loads yaml data from file" do
+      expect(model_class.parsed_data.count).to eq 3
+    end
+
+    it "uses symbols as attribute keys for consistency" do
+      expect(model_class.parsed_data.first.keys.first).to be_a Symbol
+    end
+
+    it "builds a new model for each element in the data" do
+      model_class.should_receive(:new).exactly(3).times.and_return(double(:test))
+      model_class.build_collection
+    end
+
+    it "reloads the yaml file on build_collection" do
+      model_class.should_receive(:fetch_data).and_call_original
+      model_class.build_collection
+    end
+
+    it "can build a new instance from an attributes hash, bypassing yaml" do
+      instance = model_class.build(:name=>"Bat",:description=>"man")
+      expect(instance.description).to eq "man"
+    end
+
+    context "when collection built" do
+      before(:each){model_class.build_collection}
+      it "it provides access to all models" do
+        expect(model_class.all.count).to eq 3
+        expect(model_class.all.first.class).to eq model_class
+      end
+
+      it "sets instance variables for each yaml attribute" do
+        expect(model_class.all.first.instance_variable_get(:@name)).to eq "Foo"
+      end
+
+      it "implements enumerable correctly" do
+        expect(model_class.map{|m| m.instance_variable_get(:@name)}).to eq ["Foo","Bar","Baz"]
+      end
+
+      it "works alongside attr_reader" do
+        expect(model_class.first.description).to eq "yo foo"
+      end
+    end
+  end
+
+  describe "Json model" do
+    before(:each) do
+      File.stub(:open){StringIO.open(FOO_JSON)}
+    end
+    let(:json_class_factory) do
+      class_builder.call{|c| c.source "http://foo.bar/baz.json", :type=>:json}
+    end
+    it "parses json into ruby data" do
+      model_class = json_class_factory.call
+      expect(model_class.parsed_data.first[:name]).to eq "FooJ"
+    end
+  end
+
+  describe "collection" do
+    let(:built_collection) do
+      Collabda.collection(:Food) do
+        source ""
+        properties :none
+        def foo
+        end
+        def self.bar
+        end
+      end
+    end
+
+    after(:each){Object.send(:remove_const,:Food) rescue nil}
+
+    it "creates a class in parent context" do
+      built_collection = module TestModels
+        class C
+          Collabda.collection(:Food){source "";properties :none}
+        end
+      end
+      expect(built_collection.to_s).to eq "TestModels::C::Food"
+    end
+
+    it "creates a class root context if not in module" do
+      expect(built_collection.to_s).to eq "Food"
+    end
+
+    it "includes Collabda in the new class" do
+      expect(built_collection).to respond_to :source
+    end
+
+    it "executes its block while building the class" do
+      expect(built_collection).to respond_to :bar
+    end
+
+    it "executes is block in the correct context" do
+      expect(built_collection.new).to respond_to :foo
+    end
+
+    it "auto-builds the collection from its source" do
+      expect{Collabda.collection(:Food){}}.to raise_error Collabda::InvalidSource
+    end
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: collabda
+version: !ruby/object:Gem::Version
+  version: 0.0.1a
+platform: ruby
+authors:
+- James Edwards-Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Collabda uses JSON or YAML files to build a collection of classes.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/collabda.rb
+- spec/lib/collabda_spec.rb
+homepage: https://github.com/Jamedjo/Collabda
+licenses:
+- Apache-2.0
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: A library for building models from data files
+test_files:
+- spec/lib/collabda_spec.rb