spectifly 0.0.1

data/lib/spectifly/base/entity_node.rb

@@ -0,0 +1,55 @@
+module Spectifly
+  module Base
+    class EntityNode
+      attr_accessor :name, :attributes, :description, :example, :validations,
+        :restrictions, :inherits_from
+
+      def initialize(field_name, options = {})
+        @field_name = field_name
+        @tokens = @field_name.match(/(\W+)$/).to_s.scan(/./)
+        @attributes = options
+        extract_attributes
+        extract_restrictions
+      end
+
+      def extract_attributes
+        @description = @attributes.delete('Description')
+        @example = @attributes.delete('Example')
+        @type = @attributes.delete('Type')
+        @inherits_from = @attributes.delete('Inherits From')
+        @validations = [@attributes.delete('Validations')].compact.flatten
+      end
+
+      def extract_restrictions
+        @restrictions = {}
+        unique_validation = @validations.reject! { |v| v =~ /must be unique/i }
+        unique_attribute = @attributes.delete("Unique")
+        if (unique_validation && unique_attribute.nil?) ^ (unique_attribute.to_s == "true")
+          @restrictions['unique'] = true
+        elsif unique_validation && !["true", ""].include?(unique_attribute.to_s)
+          raise "Field/association #{name} has contradictory information about uniqueness."
+        end
+      end
+
+      def name
+        Spectifly::Support.tokenize(@field_name).gsub(/\W/, '')
+      end
+
+      def type
+        Spectifly::Support.tokenize(@type)
+      end
+
+      def display_type
+        type
+      end
+
+      def unique?
+        @restrictions['unique'] == true
+      end
+
+      def required?
+        @tokens.include? '*'
+      end
+    end
+  end
+end

data/lib/spectifly/base/field.rb

@@ -0,0 +1,42 @@
+require_relative 'entity_node'
+
+module Spectifly
+  module Base
+    class Field < EntityNode
+      def extract_attributes
+        super
+        @multiple = @attributes.delete('Multiple') == true
+        if @tokens.include?('?') && @type && @type != 'Boolean'
+          raise ArgumentError, "Boolean field has conflicting type"
+        end
+      end
+
+      def extract_restrictions
+        super
+        ['Minimum Value', 'Maximum Value', 'Valid Values'].each do |restriction|
+          if @attributes[restriction]
+            token = Spectifly::Support.tokenize(restriction)
+            @restrictions[token] = @attributes.delete(restriction)
+          end
+        end
+        @validations.each do |validation|
+          if validation =~ /^Must match regex "(.*)"$/
+            @validations.delete(validation)
+            @restrictions['regex'] = /#{$1}/
+          end
+        end
+        @restrictions
+      end
+
+      def type
+        type = super
+        type = 'boolean' if @tokens.include?('?')
+        type || 'string'
+      end
+
+      def multiple?
+        @multiple
+      end
+    end
+  end
+end

data/lib/spectifly/base/types.rb

@@ -0,0 +1,27 @@
+module Spectifly
+  module Base
+    class Types
+      Native = [
+        'boolean',
+        'string',
+        'date',
+        'date_time',
+        'integer',
+        'decimal'
+      ]
+
+      Extended = {
+        'percent' => {
+          'Type' => 'Decimal',
+        },
+        'currency' => {
+          'Type' => 'Decimal',
+        },
+        'year' => {
+          'Type' => 'Integer'
+        },
+        'phone' => {}
+      }
+    end
+  end
+end

data/lib/spectifly/configuration.rb

@@ -0,0 +1,17 @@
+module Spectifly
+  class Configuration
+    def initialize(config = {})
+      @entity_path = config.fetch(:entity_path)
+      @presenter_path = config[:presenter_path]
+    end
+
+    def presenter_path
+      @presenter_path ||= begin
+        proposed_path = File.join(@entity_path, 'presenters')
+        if Dir.exists?(proposed_path)
+          @presenter_path = proposed_path
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/entity.rb

@@ -0,0 +1,106 @@
+module Spectifly
+  class Entity
+    class Invalid < StandardError; end
+
+    attr_reader :root, :path, :options, :name, :presented_as
+    attr_accessor :metadata, :fields, :relationships
+
+    class << self
+      def parse(*args)
+        new(*args)
+      end
+
+      def from_directory(entities_path, options = {})
+        presenter_path = options[:presenter_path]
+        entities = {}
+        entities_glob = File.join(entities_path, '*.entity')
+        Dir[entities_glob].each do |path|
+          path = File.expand_path(path)
+          entity = Spectifly::Entity.parse(path)
+          entities[entity.name] = entity
+        end
+        if presenter_path
+          presenters_glob = File.join(presenter_path, '*.entity')
+          Dir[presenters_glob].each do |path|
+            path = File.expand_path(path)
+            presenter = Spectifly::Entity.parse(path)
+            base_entity = entities[Spectifly::Support.tokenize(presenter.root)]
+            entity = base_entity.present_as(presenter)
+            entities[entity.name] = entity
+          end
+        end
+        entities
+      end
+    end
+
+    def initialize(path, options = {})
+      @options = options
+      @path = path
+      @name = File.basename(@path).sub(/(.*)\.entity$/, '\1')
+      @parsed_yaml = YAML.load_file(@path)
+      @root = @parsed_yaml.keys.first
+      @metadata = @parsed_yaml.values.first
+      @fields = @metadata.delete('Fields')
+      @relationships = @metadata.delete('Related Entities') || {}
+      if @presented_as = options[:presenter]
+        @path = @presented_as.path
+        @name = @presented_as.name
+      end
+      unless valid?
+        raise Invalid, @errors.join(', ')
+      end
+    end
+
+    def valid?
+      @errors = []
+      @errors << 'Exactly one root element required' unless @parsed_yaml.count == 1
+      @errors << 'Entity is missing "Fields" key' if @fields.nil?
+      @errors.empty?
+    end
+
+    def attributes_for_field_by_base_name(base_name)
+      @fields.select { |name, attributes|
+        name.gsub(/\W+$/, '') == base_name
+      }.values.first
+    end
+
+    def attributes_for_relationship_by_base_name(type, base_name)
+      @relationships[type].select { |name, attributes|
+        name.gsub(/\W+$/, '') == base_name
+      }.values.first
+    end
+
+    def present_as(presenter_entity)
+      unless @root == presenter_entity.root
+        raise ArgumentError, "Presenter entity has different root"
+      end
+      merged_fields = {}
+      merged_relationships = {}
+      presenter_entity.fields.each_pair do |name, attributes|
+        attributes ||= {}
+        inherit_from = attributes['Inherits From'] || name.gsub(/\W+$/, '')
+        parent_attrs = attributes_for_field_by_base_name(inherit_from)
+        merged_fields[name] = (parent_attrs || {}).merge(attributes)
+      end
+
+      if presenter_entity.relationships
+        presenter_entity.relationships.each_pair do |type, relationships|
+          relationships.each do |name, attributes|
+            attributes ||= {}
+            inherit_from = attributes['Inherits From'] || name.gsub(/\W+$/, '')
+            parent_attrs = attributes_for_relationship_by_base_name(type, inherit_from)
+            (merged_relationships[type] ||= {})[name] = (parent_attrs || {}).merge(attributes)
+          end
+        end
+      end
+
+      merged_entity = self.class.parse(
+        path, options.merge(:presenter => presenter_entity)
+      )
+      merged_entity.relationships = merged_relationships
+      merged_entity.fields = merged_fields
+      merged_entity.metadata.merge!(presenter_entity.metadata)
+      merged_entity
+    end
+  end
+end

data/lib/spectifly/json.rb

@@ -0,0 +1,8 @@
+require_relative 'json/builder'
+require_relative 'json/field'
+require_relative 'json/types'
+
+module Spectifly
+  module Json
+  end
+end

data/lib/spectifly/json/association.rb

@@ -0,0 +1,19 @@
+module Spectifly
+  module Json
+    class Association < Spectifly::Base::Association
+      def to_h
+        fields = {
+          :type => type,
+          :required => required?,
+        }
+        [:description, :example, :restrictions].each do |opt|
+          value = self.send(opt)
+          if value && !value.empty?
+            fields[opt] = value
+          end
+        end
+        { name.to_sym => fields}
+      end
+    end
+  end
+end

data/lib/spectifly/json/builder.rb

@@ -0,0 +1,21 @@
+require_relative 'field'
+require_relative 'association'
+require_relative 'types'
+
+module Spectifly
+  module Json
+    class Builder < Spectifly::Base::Builder
+      def build
+        field_hashes = {}
+        associations.each do |association|
+          field_hashes[association.relationship] ||= {}
+          field_hashes[association.relationship].merge! association.to_h
+        end
+        fields.each do |field|
+          field_hashes.merge! field.to_h
+        end
+        { Spectifly::Support.tokenize(root) => field_hashes }
+      end
+    end
+  end
+end

data/lib/spectifly/json/field.rb

@@ -0,0 +1,28 @@
+module Spectifly
+  module Json
+    class Field < Spectifly::Base::Field
+      def to_h
+        fields = {
+          :type => type,
+          :multiple => multiple?,
+          :required => required?,
+        }
+        [:description, :example, :validations, :restrictions].each do |opt|
+          value = self.send(opt)
+          if value && !value.empty?
+            fields[opt] = value
+          end
+        end
+        { name.to_sym => fields}
+      end
+
+      def restrictions
+        @restrictions.inject({}) do |result, (type, value)|
+          value = value.source if type == 'regex'
+          result[type] = value
+          result
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/json/types.rb

@@ -0,0 +1,6 @@
+module Spectifly
+  module Json
+    class Types < Spectifly::Base::Types
+    end
+  end
+end

data/lib/spectifly/support.rb

@@ -0,0 +1,32 @@
+module Spectifly
+  module Support
+    module_function
+
+    def camelize(string, lower = false)
+      string = if lower
+        string.sub(/^[A-Z\d]*/) { $&.downcase }
+      else
+        string.sub(/^[a-z\d]*/) { $&.capitalize }
+      end
+      string = string.gsub(/(?:_| |(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+
+    def lower_camelize(string)
+      camelize(string, true)
+    end
+
+    def tokenize(string)
+      return nil if string.nil?
+      string = string.gsub(/&/, ' and ').
+        gsub(/[ \/]+/, '_').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        downcase
+    end
+
+    def get_module(constant)
+      tokens = constant.to_s.split('::')
+      module_name = tokens[0, tokens.length - 1].join('::')
+      module_name == '' ? nil : module_name
+    end
+  end
+end

data/lib/spectifly/tasks.rb

@@ -0,0 +1,20 @@
+require 'rake'
+require 'rake/tasklib'
+
+module Spectifly
+  class Task < ::Rake::TaskLib
+    attr_accessor :config_path
+
+    def initialize(task_name, *args, &block)
+      @stuff = 'default stuff'
+      task task_name, *args do |task_name, task_args|
+        block.call(self) if block
+        puts "This is #{task_name} task with #{config_path}"
+      end
+    end
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), '..', 'tasks', '*.rake')].each do |path|
+  load path
+end

data/lib/spectifly/version.rb

@@ -0,0 +1,3 @@
+module Spectifly
+  VERSION = "0.0.1"
+end

data/lib/spectifly/xsd.rb

@@ -0,0 +1,8 @@
+require_relative 'xsd/builder'
+require_relative 'xsd/field'
+require_relative 'xsd/types'
+
+module Spectifly
+  module Xsd
+  end
+end

data/lib/spectifly/xsd/association.rb

@@ -0,0 +1,31 @@
+module Spectifly
+  module Xsd
+    class Association < Spectifly::Base::Association
+      def name
+        Spectifly::Support.camelize(@field_name).gsub(/\W/, '')
+      end
+
+      def to_xsd(builder = nil)
+        builder ||= ::Builder::XmlMarkup.new(:indent => 2)
+        attributes['type'] = "#{Spectifly::Support.lower_camelize(type)}Type"
+        attributes['minOccurs'] = '0' unless required? && relationship != 'belongs_to'
+        attributes['maxOccurs'] = 'unbounded' if multiple?
+        block = embedded_block
+        builder.xs :element, { :name => name }.merge(attributes), &block
+      end
+
+      def embedded_block
+        if description || example
+          Proc.new { |el|
+            if description || example
+              el.xs :annotation do |ann|
+                ann.xs :documentation, description if description
+                ann.xs :documentation, "Example: #{example}" if example
+              end
+            end
+          }
+        end
+      end
+    end
+  end
+end