spectifly-sequel 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+spec/tmp/migrations/*.rb
+coverage/*

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p392

data/Gemfile

@@ -0,0 +1,6 @@
+# A sample Gemfile
+source "https://rubygems.org"
+
+gemspec
+
+

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    spectifly-sequel (0.0.1)
+      activesupport
+      sequel
+      spectifly
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (3.2.12)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    builder (3.2.0)
+    columnize (0.3.6)
+    debugger (1.5.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.0)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.0)
+    diff-lcs (1.2.4)
+    i18n (0.6.4)
+    json (1.8.0)
+    multi_json (1.7.2)
+    rake (10.0.4)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    sequel (3.47.0)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    spectifly (0.0.1)
+      builder
+      json
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  debugger
+  rake
+  rspec
+  simplecov
+  spectifly-sequel!

data/README.md

@@ -0,0 +1,99 @@
+# Spectifly Sequel Add-on
+
+An add-on to Spectifly, which uses entity definitions based on YAML, to
+create Sequel migrations and model files
+
+## Caveat
+
+This is very much a work in progress and any migrations generated from
+the gem should be carefully scrutinized for correctness prior to
+applying them to your database.  Right now, the gem's output is only
+tested with Postgres and only creates new tables but does not update
+schema that already exists (though ideally, that would be a future
+feature).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'spectifly-sequel'
+
+And then execute:
+
+    $ bundle
+
+Once on rubygems, you'll also be able to install it yourself as:
+
+    $ gem install spectifly-sequel
+
+## Usage
+
+The Spectifly markup language is a subset of YAML. Only one root node is allowed
+per file (since a single `.entity` file represents a single business entity),
+and there are other restrictions, as well as additional features, which we'll
+discuss here.
+
+Given a Spectifly entity defintion `lib/entities/widget.entity`:
+
+```YAML
+Widget:
+  Description: A widget produced by WidgetCo
+  Fields:
+    Name*:
+      Description: Display name of widget
+
+    Created At:
+      Description: When the widget was built
+      Type: DateTime
+
+    Awesome?:
+      Description: Whether or not the widget is awesome
+```
+When `rake spectifly:sequel:generate['widget']` is run, the following
+migration `db/migrate/001_create_widgets.rb` will be created.
+```ruby
+Sequel.migration do
+  change do
+    create_table(:widgets) do
+      primary_key :id
+      String :name, :null => false
+      DateTime :created_at
+      Boolean :awesome
+    end
+  end
+end
+```
+
+## Configuration
+
+Spectifly Sequel does not make any assumptions about where you put your
+entity definitions or migrations.  In order for the gem to run
+correctly, you'll need to specifly the path to a YAML file or set the
+config directly via a hash.
+
+```ruby
+# to set via YAML file
+Spectifly::Sequel.configure_with PATH_TO_CONFIG_YAML
+
+# to set via hash
+Spectifly::Sequel.configure {
+  'migration_path' => PATH_TO_MIGRATION_DIRECTORY
+  'entity_definition_path' => PATH_TO_ENTITY_DEFINITION_DIRECTORY
+}
+```
+
+The YAML configuration file should look something like this:
+```yaml
+Sequel:
+  Spectifly:
+    migration_path: PATH_TO_MIGRATION_DIRECTORY
+    entity_definition_path: PATH_TO_ENTITY_DEFINITION_DIRECTORY
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => [:spec]
+
+require 'sequel'
+require 'spectifly'
+require 'spectifly/base'
+require 'spectifly/sequel'
+require 'spectifly/sequel/tasks'

data/lib/spectifly/sequel/builder.rb

@@ -0,0 +1,30 @@
+require 'erb'
+module Spectifly
+  module Sequel
+    class Builder < Spectifly::Base::Builder
+      attr_accessor :entities, :model
+      def initialize(entity, options = {})
+        super(entity, options)
+        @entities = Spectifly::Entity.from_directory(File.dirname(entity.path))
+        @model = Spectifly::Sequel::Model.new(entity, fields)
+      end
+
+      def field_class
+        Spectifly::Sequel::Field
+      end
+
+      def build
+        template_path = File.join(*File.dirname(__FILE__), 'erb', 'new_migration.erb')
+        render template_path
+      end
+
+      private
+        def render path
+          content = File.read(File.expand_path(path))
+          t = ERB.new(content, nil, '-') # third param lets us use trim
+          t.filename = File.expand_path(path)
+          t.result(binding)
+        end
+    end
+  end
+end

data/lib/spectifly/sequel/config.rb

@@ -0,0 +1,53 @@
+module Spectifly
+  module Sequel
+    @valid_config_keys = [:migration_path, :entity_definition_path, :migration_version_type]
+    @config = {}
+
+    def self.configure_with(path_to_config_file)
+      begin
+        config = YAML.load_file(path_to_config_file)['Spectifly']['Sequel']
+      rescue NoMethodError
+        raise config_instructions
+      end
+      configure(config)
+    end
+
+    def self.configure(opts)
+      opts.each {|k,v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym}
+    end
+
+    def self.migration_path
+      @config[:migration_path] or raise missing_configuration('migration_path')
+    end
+
+    def self.entity_definition_path
+      @config[:entity_definition_path] or raise missing_configuration('entity_definition_path')
+    end
+
+    def self.migration_version_type
+      type = @config[:migration_version_type].to_s
+      if %w(Timestamp Integer).include? type
+        type
+      else
+        'Timestamp'
+      end
+    end
+
+private
+    def self.config_instructions 
+<<-INSTRUCTIONS
+Please format config files in the following manner:
+``- begin YAML
+Sequel:
+  Spectifly:
+    migration_path: PATH_TO_MIGRATION_DIRECTORY
+    entity_definition_path: PATH_TO_ENTITY_DEFINITION_DIRECTORY
+``- end YAML
+INSTRUCTIONS
+    end
+
+    def self.missing_configuration(config_param)
+      "Spectify::Sequel is not configured properly. \"#{config_param}\" must be set via YAML or a hash."
+    end
+  end
+end

data/lib/spectifly/sequel/erb/create_association_tables.erb

@@ -0,0 +1,4 @@
+<% @model.multiple_value_fields.each do |field| -%>
+<%= field.for_new_migration(@model, @entities) -%>
+<% end -%>
+<%= render File.expand_path('field/many_to_many_association.erb', File.dirname(__FILE__)) -%>

data/lib/spectifly/sequel/erb/create_table.erb

@@ -0,0 +1,9 @@
+    create_table(:<%= @model.table_name %>) do
+      primary_key :id
+<% @model.single_value_fields.each do |field| -%>
+      <%= field.for_new_migration(@model, @entities) %>
+<% end -%>
+<% @model.foreign_keys.each do |key| -%>
+      foreign_key :<%= key.field_name %>, :<%= key.table_name %><%= ", :unique => true" if key.unique -%><%= ", :null => false" if key.required %>
+<% end -%>
+    end

data/lib/spectifly/sequel/erb/field/many_to_many_association.erb

@@ -0,0 +1,9 @@
+<% @model.has_and_belong_to_many.each do |relationship| -%>
+
+    create_table(:<%= relationship.many_to_many_table_name %>) do
+      foreign_key :<%= @model.name_as_foreign_key %>, :<%= @model.table_name %>, :null => false
+      foreign_key :<%= relationship.field_name %>, :<%= relationship.table_name %>, :null => false
+    end
+
+    add_index [:<%=@model.name_as_foreign_key -%>, :<%= relationship.field_name -%>], :<%= relationship.many_to_many_table_name -%>, :unique => true
+<% end -%>

data/lib/spectifly/sequel/erb/field/multiple_value_simple_type_field.erb

@@ -0,0 +1,8 @@
+
+    create_table(:<%= @model.table_name %>_<%= @field.name %>) do
+      primary_key :id
+      foreign_key :<%= @model.name_as_foreign_key %>, :<%= @model.table_name %>, :null => false
+      <%= @field.type %> :name, :null => false
+    end
+
+    add_index [:<%=@model.name_as_foreign_key %>, :name], :<%= @model.table_name %>_<%= @field.name %>, :unique => true

data/lib/spectifly/sequel/erb/field/single_value_simple_type_field.erb

@@ -0,0 +1 @@
+<%= @field_type %> :<%= @field_name %><%= ", #{@options.join(', ')}" if !@options.empty? -%>

data/lib/spectifly/sequel/erb/new_migration.erb

@@ -0,0 +1,6 @@
+Sequel.migration do
+  change do
+<%= render File.expand_path('create_table.erb', File.dirname(__FILE__)) -%>
+<%= render File.expand_path('create_association_tables.erb', File.dirname(__FILE__)) -%>
+  end
+end

data/lib/spectifly/sequel/field.rb

@@ -0,0 +1,22 @@
+module Spectifly
+  module Sequel
+    class Field < Spectifly::Base::Field
+      def type
+        field_type = super
+        if base_type = Spectifly::Sequel::Types::Extended[field_type]
+          field_type = base_type['Type']
+        end
+
+        Spectifly::Support.camelize(field_type)
+      end
+
+      # The entity_references param is the list of entity namesthat the caller
+      # knows about.  This lets us figure out whether the field should actually
+      # be the id of the entity/model being referenced by the field type.
+      def for_new_migration(model, entity_references = [])
+        @field_for_migration = Spectifly::Sequel::FieldForMigration.new(self, model, entity_references)
+        @field_for_migration.render
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/field_for_migration.rb

@@ -0,0 +1,45 @@
+module Spectifly
+  module Sequel
+    class FieldForMigration
+      attr_accessor :field_name, :field_type, :options, :model
+
+      def initialize(field, model, entity_references)
+        @field = field
+        @field_name = field.name
+        @field_type = field.type
+        @model = model
+        @options = retrieve_options(field)
+      end
+
+      def retrieve_options(field)
+        options = []
+        options << ':null => false' if field.required?
+        options << ':unique => true' if field.unique?
+        options
+      end
+
+      def render
+        template = if single_value_simple_type?
+                     'single_value_simple_type_field'
+                   elsif multiple_value_simple_type?
+                     'multiple_value_simple_type_field'
+                   end
+        return if template.nil?
+
+        path = File.expand_path(File.join(*File.dirname(__FILE__), 'erb', 'field', "#{template}.erb"))
+        content = File.read(path)
+        t = ERB.new(content, nil, '-')
+        t.filename = path
+        t.result(binding)
+      end
+
+      def single_value_simple_type?
+        @model_for_field.nil? && !@field.multiple?
+      end
+
+      def multiple_value_simple_type?
+        @model_for_field.nil? && @field.multiple?
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/migration_generator.rb

@@ -0,0 +1,39 @@
+module Spectifly
+  module Sequel
+    class MigrationGenerator
+      def initialize(entity, migration_path=nil, entity_path=nil, migration_version_type=nil)
+        @migration_path = File.expand_path(migration_path || Spectifly::Sequel.migration_path)
+        @entity_definition_path = File.expand_path(entity_path || Spectifly::Sequel.entity_definition_path)
+        @migration_version_type = migration_version_type || Spectifly::Sequel.migration_version_type
+        @builder = Spectifly::Sequel::Builder.from_path(File.join(@entity_definition_path, entity + '.entity'))
+      end
+
+      def run!
+        migration_output = @builder.build
+        File.open(File.join(@migration_path, migration_name), 'w') { |f| f.write(migration_output) }
+      end
+
+      def migration_name
+        '%s_create_%s.rb' % [next_migration_version, @builder.model.table_name]
+      end
+
+      def next_migration_version
+        if @migration_version_type == 'Timestamp'
+          DateTime.now.strftime('%Y%m%d%H%M%S')
+        else
+          last_migration = 0
+          length = 3
+          Dir.glob("#{@migration_path}/*.rb") do |rb_file|
+            migration = File.basename(rb_file).split('_').first
+            if migration.to_i > last_migration
+              last_migration = migration.to_i
+              length = migration.length
+            end
+          end
+
+          (last_migration + 1).to_s.rjust(length, "0")
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/model.rb

@@ -0,0 +1,47 @@
+module Spectifly
+  module Sequel
+    class Model
+      attr_accessor :table_name, :display_name, :model_name,
+        :single_value_fields, :multiple_value_fields,
+        :has_and_belong_to_many, :name_as_foreign_key,
+        :foreign_keys
+
+      def initialize(entity, fields)
+        @display_name = entity.root
+        @model_name = Spectifly::Support.camelize(display_name)
+        @table_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.pluralize(display_name))
+
+        @single_value_fields = fields.select { |f| !f.multiple? }
+        @multiple_value_fields = fields.select { |f| f.multiple? }
+
+        @name_as_foreign_key = Spectifly::Support.tokenize(display_name) + '_id'
+        get_relationships(entity)
+      end
+
+      def get_relationships(entity)
+        @foreign_keys = []
+        @has_and_belong_to_many = []
+        entity.relationships.each do |relationship_type, rels|
+          camelized_type = Spectifly::Support.camelize(relationship_type)
+          rels.each do |name, attributes|
+            if %w(BelongsTo HasOne HasA).include? camelized_type
+              relation = create_relation(camelized_type, name, attributes, entity)
+              @foreign_keys << relation
+            elsif %(BelongsToMany HasAndBelongsToMany HasMany).include?(camelized_type)
+              relation = create_relation(camelized_type, name, attributes, entity)
+              # as long as the has_many has a coinciding belongs_to_many and the association table makes sense...
+              if relation.multiple_related_entity? && !(@name_as_foreign_key == relation.field_name && @table_name == relation.table_name)
+                @has_and_belong_to_many << relation
+              end
+            end
+          end
+        end
+      end
+
+      def create_relation(type, name, attributes, entity)
+        relationship_class = ActiveSupport::Inflector.constantize('Spectifly::Sequel::Relationship::%s' % type)
+        relation = relationship_class.new(name, attributes, entity)
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/base.rb

@@ -0,0 +1,14 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class Base
+        attr_accessor :entity, :related_entity
+
+        def initialize(name, attributes, related_entity)
+          @entity = Spectifly::Base::EntityNode.new(name, attributes)
+          @related_entity = related_entity
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/belongs_to.rb

@@ -0,0 +1,17 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class BelongsTo < Base
+        attr_accessor :field_name, :table_name, :required, :unique
+
+        def initialize(name, attributes, related_entity)
+          super
+          @table_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.pluralize(@entity.type))
+          @field_name = Spectifly::Support.tokenize(@entity.name) + '_id'
+          @required = @entity.required?
+          @unique = @entity.unique?
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/belongs_to_many.rb

@@ -0,0 +1,8 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class BelongsToMany < HasAndBelongsToMany
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/has_a.rb

@@ -0,0 +1,8 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class HasA < OneToOne
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/has_and_belongs_to_many.rb

@@ -0,0 +1,21 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class HasAndBelongsToMany < Base
+        attr_accessor :field_name, :table_name, :many_to_many_table_name
+
+        def initialize(name, attributes, related_entity)
+          super
+          related_table_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.pluralize(related_entity.root))
+          @field_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.singularize(@entity.name)) + '_id'
+          @table_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.pluralize(@entity.type))
+          @many_to_many_table_name = [related_table_name, Spectifly::Support.tokenize(@entity.name)].sort.join('_')
+        end
+
+        def multiple_related_entity?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/has_many.rb

@@ -0,0 +1,12 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class HasMany < HasAndBelongsToMany
+        def multiple_related_entity?
+          related_entity = Spectifly::Entity.from_directory(File.dirname(@related_entity.path))[@entity.type]
+          (related_entity.relationships['Belongs To Many'] || {}).any? { |rel_name, attrs| attrs['Type'] == @related_entity.root }
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/has_one.rb

@@ -0,0 +1,8 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class HasOne < OneToOne
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/relationship/one_to_one.rb

@@ -0,0 +1,17 @@
+module Spectifly
+  module Sequel
+    module Relationship
+      class OneToOne < Base
+        attr_accessor :field_name, :table_name, :required, :unique
+
+        def initialize(name, attributes, related_entity)
+          super
+          @table_name = Spectifly::Support.tokenize(ActiveSupport::Inflector.pluralize(@entity.type))
+          @field_name = Spectifly::Support.tokenize(@entity.name) + '_id'
+          @required = @entity.required?
+          @unique = @entity.unique?
+        end
+      end
+    end
+  end
+end

data/lib/spectifly/sequel/tasks.rb

@@ -0,0 +1,2 @@
+path = File.join(File.dirname(__FILE__), '../../tasks/*.rake')
+Dir.glob(path).each {|r| load r}

data/lib/spectifly/sequel/types.rb

@@ -0,0 +1,22 @@
+require 'sequel'
+module Spectifly
+  module Sequel
+    class Types
+      Native = ::Sequel::Schema::CreateTableGenerator::GENERIC_TYPES.map { |type| type.to_s }
+
+      Extended = {
+        'percent' => {
+          'Type' => 'Numeric',
+        },
+        'currency' => {
+          'Type' => 'Numeric',
+        },
+        'year' => {
+          'Type' => 'Integer'
+        },
+      }
+
+      All = Native + Extended.map { |k, v| v['Type'] }
+    end
+  end
+end

data/lib/spectifly/sequel/version.rb

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

data/lib/spectifly/sequel.rb

@@ -0,0 +1,24 @@
+require 'active_support/inflector/methods'
+require 'spectifly'
+require_relative 'sequel/config'
+require_relative 'sequel/types'
+require_relative 'sequel/model'
+require_relative 'sequel/tasks'
+require_relative 'sequel/relationship/base'
+require_relative 'sequel/relationship/one_to_one'
+require_relative 'sequel/relationship/belongs_to'
+require_relative 'sequel/relationship/has_and_belongs_to_many'
+require_relative 'sequel/relationship/belongs_to_many'
+require_relative 'sequel/relationship/has_a'
+require_relative 'sequel/relationship/has_one'
+require_relative 'sequel/relationship/has_many'
+require_relative 'sequel/field'
+require_relative 'sequel/field_for_migration'
+require_relative 'sequel/builder'
+require_relative 'sequel/migration_generator'
+require_relative 'sequel/version'
+
+module Spectifly
+  module Sequel
+  end
+end

data/lib/tasks/spectifly-sequel.rake

@@ -0,0 +1,12 @@
+require 'rake'
+require 'spectifly/sequel'
+
+namespace 'spectifly' do
+  namespace 'sequel' do
+    desc 'Generate migration from entity definition file'
+    task :generate, [:entity_type] do |t, args|
+      Spectifly::Sequel.configure_with File.join(Dir.pwd, 'config', 'spectifly.yml')
+      Spectifly::Sequel::MigrationGenerator.new(args[:entity_type]).run!
+    end
+  end
+end