spectifly 0.0.1

data/spec/expectations/presented/positionless_individual.json

@@ -0,0 +1,44 @@
+{
+  "individual": {
+    "belongs_to": {
+      "party": {
+        "type": "group",
+        "required": true,
+        "description": "Which funtime party this individual happy with is"
+      }
+    },
+    "name": {
+      "type": "string",
+      "multiple": false,
+      "required": true,
+      "description": "The individual's name",
+      "example": "Wussy O'Weakling",
+      "restrictions": {
+        "unique": true
+      }
+    },
+    "age": {
+      "type": "integer",
+      "multiple": false,
+      "required": false,
+      "validations": [
+        "Must be non-negative"
+      ]
+    },
+    "joy": {
+      "type": "percent",
+      "multiple": false,
+      "required": false,
+      "restrictions": {
+        "minimum_value": 0,
+        "maximum_value": 100
+      }
+    },
+    "pickled": {
+      "type": "boolean",
+      "multiple": false,
+      "required": false,
+      "description": "Whether or not this individual is pickled"
+    }
+  }
+}

data/spec/expectations/presented/positionless_individual.xsd

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:include schemaLocation="group.xsd"/>
+  <xs:include schemaLocation="extended.xsd"/>
+  <xs:element name="Individual" type="individualType"/>
+  <xs:complexType name="individualType">
+    <xs:sequence>
+      <xs:element name="Name" type="xs:string">
+        <xs:annotation>
+          <xs:documentation>The individual's name</xs:documentation>
+          <xs:documentation>Example: Wussy O'Weakling</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="Age" type="xs:nonNegativeInteger" minOccurs="0"/>
+      <xs:element name="Joy" minOccurs="0">
+        <xs:simpleType>
+          <xs:restriction base="percentType">
+            <xs:minInclusive value="0"/>
+            <xs:maxInclusive value="100"/>
+          </xs:restriction>
+        </xs:simpleType>
+      </xs:element>
+      <xs:element name="Pickled" type="xs:boolean" minOccurs="0">
+        <xs:annotation>
+          <xs:documentation>Whether or not this individual is pickled</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+      <xs:element name="Party" type="groupType" minOccurs="0">
+        <xs:annotation>
+          <xs:documentation>Which funtime party this individual happy with is</xs:documentation>
+        </xs:annotation>
+      </xs:element>
+    </xs:sequence>
+  </xs:complexType>
+</xs:schema>

data/spec/fixtures/group.entity

@@ -0,0 +1,23 @@
+Group:
+  Description: A load of peoples
+  Fields:
+    Group ID:
+      Description: Identifier used to register group for scams
+      Validations:
+        - Must match regex "^[0-9]{2}(-?[0-9]{5})$"
+        - Must be unique
+
+    Name*:
+      Description: The name of this group
+      Validations: Must match regex "group"
+
+  Related Entities:
+    Has Many:
+      Peeps:
+        Description: Who is in the group
+        Type: Individual
+
+    Has One:
+      Master*:
+        Description: Who is the master of the group
+        Type: Individual

data/spec/fixtures/individual.entity

@@ -0,0 +1,33 @@
+Individual:
+  Description: An Individual
+  Fields:
+    Name*:
+      Description: The individual's name
+      Example: Randy McTougherson
+      Unique: True
+
+    Age:
+      Type: Integer
+      Validations: Must be non-negative
+
+    Happiness:
+      Type: Percent
+      Minimum Value: 0
+      Maximum Value: 100
+
+    Positions:
+      Description: Which positions individual occupies in a group
+      Multiple: True
+      Valid Values:
+        - Lotus
+        - Pole
+        - Third
+
+    Pickled?*:
+      Description: Whether or not this individual is pickled
+
+  Related Entities:
+    Belongs To:
+      Party*:
+        Description: Which funtime party this individual happy with is
+        Type: Group

data/spec/fixtures/invalid/multiple_root.entity

@@ -0,0 +1,8 @@
+Some Object:
+  Description: Tigers are frivolous
+  Fields:
+    Awesome Field:
+Some Other Object:
+  Description: This won't work!
+  Fields:
+    Less Awesome Field:

data/spec/fixtures/invalid/no_fields.entity

@@ -0,0 +1,2 @@
+An Invalid Object:
+  Description: An underachiever

data/spec/fixtures/presenters/masterless_group.entity

@@ -0,0 +1,8 @@
+Group:
+  Description: A load of peoples
+  Fields:
+    Group ID:
+    Name*:
+  Related Entities:
+    Has Many:
+      Peeps:

data/spec/fixtures/presenters/positionless_individual.entity

@@ -0,0 +1,12 @@
+Individual:
+  Description: A Positionless Individual
+  Fields:
+    Name*:
+      Example: Wussy O'Weakling
+    Age:
+    Joy:
+      Inherits From: Happiness
+    Pickled?:
+  Related Entities:
+    Belongs To:
+      Party*:

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+SimpleCov.start
+
+require_relative '../lib/spectifly'
+require_relative '../lib/spectifly/xsd'
+require_relative '../lib/spectifly/json'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

data/spec/spectifly/base/builder_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'json'
+
+describe Spectifly::Base::Builder do
+  describe '.from_path' do
+    it 'generates builder from entity at given path' do
+      path_builder = described_class.from_path(fixture_path('individual'))
+      path_builder.root.should == 'Individual'
+    end
+  end
+
+  describe '#build' do
+    it 'raises subclass responsibility error' do
+      entity = Spectifly::Entity.parse(fixture_path('individual'))
+      expect {
+        described_class.new(entity).build
+      }.to raise_error("Subclass Responsibility")
+    end
+  end
+
+  describe '#custom_types' do
+    it 'return an array of all non-built-in types in result' do
+      entity = Spectifly::Entity.parse(fixture_path('group'))
+      described_class.new(entity).custom_types.should =~ [
+        'individual'
+      ]
+    end
+  end
+end

data/spec/spectifly/base/entity_node_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Spectifly::Base::EntityNode do
+  describe 'uniqueness restriction' do
+    it 'unique should be false by default and there should be no unique restriction' do
+      field = described_class.new("Mini me")
+      field.should_not be_unique
+      field.restrictions.keys.should_not be_include('unique')
+    end
+
+    it 'adds a restriction and returns true for unique? if there is a uniqueness validation' do
+      field = described_class.new("Little Snowflake", {"Validations" => "must be unique"})
+      field.should be_unique
+      field.restrictions.keys.include?('unique').should be_true
+    end
+
+    it 'adds a restriction and returns true for unique? if there is an attribute Unique set to true' do
+      field = described_class.new("Little Snowflake", {"Unique" => "true"})
+      field.should be_unique
+      field.restrictions.keys.include?('unique').should be_true
+    end
+
+    it 'throws an error if the two ways of setting uniqueness contradict each other' do
+      lambda {
+      field = described_class.new("Little Snowflake?", {"Validations" => "must be unique", "Unique" => false})
+      }.should raise_error
+    end
+  end
+end

data/spec/spectifly/base/field_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Spectifly::Base::Field do
+  describe '#name' do
+    it 'returns tokenized version of field name' do
+      field = described_class.new('A really cool hat')
+      field.name.should == 'a_really_cool_hat'
+    end
+  end
+
+  describe '.initialize' do
+    it 'throws an exception if Boolean shortcut conflicts with type' do
+      expect {
+        described_class.new('Caramel tuba?', 'Type' => 'DateTime')
+      }.to raise_error(ArgumentError, "Boolean field has conflicting type")
+    end
+  end
+
+  describe '#type' do
+    it 'defaults to string if no type specified' do
+      field = described_class.new('A really cool hat')
+      field.type.should == 'string'
+    end
+
+    it 'returns boolean if field name has "?" token' do
+      field = described_class.new('A really cool hat?')
+      field.type.should == 'boolean'
+    end
+
+    it 'returns type if specified' do
+      field = described_class.new('some field', 'Type' => 'Rhubarb')
+      field.type.should == 'rhubarb'
+    end
+  end
+
+  describe '#extract_restrictions' do
+    it 'sets up minimum and maximum value restrictions' do
+      field = described_class.new('some field', {
+        'Minimum Value' => 3, 'Maximum Value' => 145
+      })
+      field.restrictions.should == {
+        'minimum_value' => 3,
+        'maximum_value' => 145
+      }
+    end
+
+    it 'sets up enumerations' do
+      field = described_class.new('some field', {
+        'Valid Values' => [34, 52, 100, 4]
+      })
+      field.restrictions.should == {
+        'valid_values' => [34, 52, 100, 4]
+      }
+    end
+
+    it 'pulls regex restriction from validations' do
+      field = described_class.new('some field', {
+        'Validations' => 'Must match regex "^[0-9]{4}"'
+      })
+      field.validations.should be_empty
+      field.restrictions.should == {
+        'regex' => /^[0-9]{4}/
+      }
+    end
+
+    it 'sets restrictions to empty hash if none exist' do
+      field = described_class.new('some field')
+      field.restrictions.should be_empty
+    end
+  end
+
+  describe '#multiple?' do
+    it 'returns true if multiple set to true' do
+      field = described_class.new('some field', 'Multiple' => true)
+      field.should be_multiple
+    end
+
+    it 'returns false if multiple set to anything but true' do
+      field = described_class.new('some field', 'Multiple' => 'Whatever')
+      field.should_not be_multiple
+    end
+
+    it 'returns false if multiple not set' do
+      field = described_class.new('some field')
+      field.should_not be_multiple
+    end
+  end
+
+  describe '#required?' do
+    it 'returns true if field name has "*" token' do
+      field = described_class.new('some field*')
+      field.should be_required
+    end
+
+    it 'returns false if field name does not have "*" token' do
+      field = described_class.new('some field')
+      field.should_not be_required
+    end
+  end
+end

data/spec/spectifly/configuration_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Spectifly::Configuration do
+  let(:configuration_args) {
+    {
+      :entity_path => base_fixture_path
+    }
+  }
+  describe '.initialize' do
+    it 'succeeds if entity and destination paths provided' do
+      expect { described_class.new(configuration_args) }.not_to raise_error
+    end
+
+    it 'fails if no entity path provided' do
+      configuration_args.delete(:entity_path)
+      expect { described_class.new(configuration_args) }.to raise_error
+    end
+  end
+
+  describe '#presenter_path' do
+    it 'returns configured value if set' do
+      configuration = described_class.new(
+        configuration_args.merge(:presenter_path => 'goose')
+      )
+      configuration.presenter_path.should == 'goose'
+    end
+
+    it 'returns nil if no presenter path exists at entity path' do
+      configuration = described_class.new(
+        configuration_args.merge(:entity_path => spec_path)
+      )
+      configuration.presenter_path.should be_nil
+    end
+
+    it 'returns {entity_path}/presenters if exists' do
+      configuration = described_class.new(
+        configuration_args
+      )
+      configuration.presenter_path.should == base_presenter_path
+    end
+  end
+end

data/spec/spectifly/entity_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe Spectifly::Entity do
+  before :each do
+    @entity = Spectifly::Entity.parse(fixture_path('individual'))
+  end
+
+  describe '.from_directory' do
+    it 'returns entities generated from files at given path' do
+      entities = Spectifly::Entity.from_directory(fixture_path)
+      entities.keys.should =~ ['individual', 'group']
+      entities.values.map(&:class).uniq.should == [Spectifly::Entity]
+      entities.values.map(&:name).should =~ ['individual', 'group']
+    end
+
+    it 'includes presenters if option passed' do
+      entities = Spectifly::Entity.from_directory(
+        fixture_path, :presenter_path => base_presenter_path
+      )
+      entities.keys.should =~ ['individual', 'group', 'positionless_individual', 'masterless_group']
+      entities.values.map(&:class).uniq.should == [Spectifly::Entity]
+      entities.values.map(&:name).should =~ ['individual', 'group', 'positionless_individual', 'masterless_group']
+    end
+  end
+
+  describe '.parse' do
+    it 'delegates to initializer' do
+      Spectifly::Entity.should_receive(:new).with(:arguments)
+      Spectifly::Entity.parse(:arguments)
+    end
+  end
+
+  describe '.new' do
+    it 'raises error if file not found' do
+      expect {
+        Spectifly::Entity.parse(fixture_path('missing'))
+      }.to raise_error
+    end
+
+    it 'raises Invalid if file has multiple roots' do
+      expect {
+        Spectifly::Entity.parse(fixture_path('invalid/multiple_root'))
+      }.to raise_error(Spectifly::Entity::Invalid)
+    end
+
+    it 'raises Invalid if file has no fields' do
+      expect {
+        Spectifly::Entity.parse(fixture_path('invalid/multiple_root'))
+      }.to raise_error(Spectifly::Entity::Invalid)
+    end
+  end
+
+  describe '#root' do
+    it 'returns root element of parsed yaml' do
+      @entity.root.should == 'Individual'
+    end
+  end
+
+  describe '#name' do
+    before :each do
+      @presenter_entity = Spectifly::Entity.parse(
+        fixture_path('presenters/positionless_individual')
+      )
+    end
+
+    it 'returns name from entity file' do
+      @entity.name.should == 'individual'
+      @presenter_entity.name.should == 'positionless_individual'
+    end
+
+    it 'returns presenter name when presented' do
+      @entity.present_as(@presenter_entity).name.should == 'positionless_individual'
+    end
+  end
+
+  describe '#presented_as' do
+    it 'returns nil if not presented' do
+      @entity.presented_as.should be_nil
+    end
+
+    it 'returns presenter if presented' do
+      @presenter_entity = Spectifly::Entity.parse(
+        fixture_path('presenters/positionless_individual')
+      )
+      @entity.present_as(@presenter_entity).presented_as.should == @presenter_entity
+    end
+  end
+
+  describe '#metadata' do
+    it 'returns metadata from parsed yaml' do
+      @entity.metadata.should == {
+        "Description" => "An Individual"
+      }
+    end
+  end
+
+  describe '#fields' do
+    it 'returns fields from parsed yaml' do
+      @entity.fields.should == {
+        "Name*" => {
+          "Description" => "The individual's name",
+          "Example" => "Randy McTougherson",
+          "Unique" => true
+        },
+        "Age" => {
+          "Type" => "Integer",
+          "Validations" => "Must be non-negative"
+        },
+        "Happiness" => {
+          "Type" => "Percent",
+          "Minimum Value" => 0,
+          "Maximum Value" => 100
+        },
+        "Positions" => {
+          "Description" => "Which positions individual occupies in a group",
+          "Multiple" => true,
+          "Valid Values" => [
+            'Lotus',
+            'Pole',
+            'Third'
+          ]
+        },
+        "Pickled?*" => {
+          "Description" => "Whether or not this individual is pickled"
+        }
+      }
+    end
+  end
+
+  describe '#present_as' do
+    before :each do
+      @presenter_entity = Spectifly::Entity.parse(fixture_path('presenters/positionless_individual'))
+    end
+
+    it 'raises exception if presenter entity has different root' do
+      @presenter_entity.instance_variable_set(:@root, 'Whatever')
+      expect {
+        @entity.present_as(@presenter_entity)
+      }.to raise_error(ArgumentError, "Presenter entity has different root")
+    end
+
+    it 'uses presenter fields only, but merges metadata and field attributes' do
+      @merged_entity = @entity.present_as(@presenter_entity)
+      @merged_entity.fields.should == {
+        "Name*" => {
+          "Description" => "The individual's name",
+          "Example" => "Wussy O'Weakling",
+          "Unique" => true
+        },
+        "Age" => {
+          "Type" => "Integer",
+          "Validations" => "Must be non-negative"
+        },
+        "Joy" => {
+          "Type" => "Percent",
+          "Minimum Value" => 0,
+          "Maximum Value" => 100,
+          "Inherits From" => "Happiness"
+        },
+        "Pickled?" => {
+          "Description" => "Whether or not this individual is pickled"
+        }
+      }
+      @merged_entity.metadata.should == {
+        "Description" => "A Positionless Individual"
+      }
+    end
+  end
+
+  describe '#relationships' do
+    it 'returns relationships from parsed yaml' do
+      @group_entity = Spectifly::Entity.parse(fixture_path('group'))
+      @group_entity.relationships.should == {
+        "Has Many" => {
+          "Peeps" => {
+            "Description" => "Who is in the group",
+            "Type" => "Individual"
+          }
+        },
+        "Has One" => {
+          "Master*" => {
+            "Description" => "Who is the master of the group",
+            "Type" => "Individual"
+          }
+        }
+      }
+    end
+  end
+end