dslize 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+Gemfile.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,92 @@
+# DSLize #
+
+## Summary ##
+
+Finally an way to generate code with a custom DSL the ruby way !
+
+### In brief: ###
+
+*  Use real ruby classes to define your DSL
+*  Add custom behaviors defining ruby methods
+*  Create custom formatters/generators extending a base class
+*  Module `DSLize::Methods` defines how your attributes are interpreted, include `DSLize::Methods::Base` to has the standard attributes
+*  Module `DSLize::Definition` defines your DSL
+
+## Installation ##
+
+    gem install dslize
+
+then:
+
+    require "dslize"
+
+## Sample ##
+
+    #! /usr/bin/env ruby
+    
+    require 'dslize'
+    
+    module DSLize::Methods
+      include DSLize::Methods::Base
+      
+      def self.my_first_custom_method(attr, args = {})
+        args[:type] = :custom
+        DSLize.current_object[attr] = args
+      end
+      
+      def self.my_second_custom_method
+        DSLize.current_object['baz'] = true
+      end
+      
+    end
+    
+    module DSLize::Definition
+      
+      class City
+        string :name
+        integer :population, :default => 42
+      end
+      
+      class Country
+        string :name, :default => 'France'
+        
+        has_many City, :as => :cities
+        
+        has_one City, :as => :capital
+      end
+      
+      class World
+        root
+        
+        has_many Country
+        
+        my_first_custom_method :foo, :default => 'bar'
+        
+        my_second_custom_method
+      end
+      
+      class Planet
+        abstract
+      end
+      
+      class GazPlanet < Planet
+      end
+      
+      class WaterPlanet < Planet
+      end
+      
+    end
+    
+    class MyCustomFormatter < DSLize::Formatter::Base
+      def do_stuff
+        # with self.object
+        # and self.superclasses
+      end
+    end
+    
+    DSLize::Formatter::XSD.new.generate!("/tmp/schema.xsd")
+    MyCustomFormatter.new.do_stuff
+    
+## About me ##
+
+Sylvain UTARD - http://sylvain.utard.info

data/Rakefile

@@ -0,0 +1,3 @@
+require 'bundler'
+
+Bundler::GemHelper.install_tasks

data/dslize.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dslize/version"
+
+Gem::Specification.new do |s|
+  s.name = "dslize"
+  s.version = DSLize::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['redox']
+  s.email = ['sylvain.utard@gmail.com']
+  s.homepage = "https://github.com/utard/dslize"
+  s.summary = %q{DSL made easy}
+  s.description = %q{}
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.requirements << 'xpain'
+end

data/lib/dslize/dslize.rb

@@ -0,0 +1,91 @@
+class Object
+
+  def self.method_missing(method_name, *args, &block)
+    return DSLize::Methods.send(method_name, *args) if self.name['DSLize::Definition::'] and DSLize::Methods.respond_to?(method_name)
+    super.method_missing(method_name, args, &block)
+  end
+
+  def self.inherited(subclass)
+    if subclass.name['DSLize::Definition::']
+      superclass = subclass.superclass
+      subclass = subclass.name.split('::').last
+      DSLize.objects ||= {}
+      DSLize.objects[subclass] = {}
+      DSLize.current_object = DSLize.objects[subclass]
+      DSLize.superclasses ||= {}
+      DSLize.superclasses[subclass] = superclass.name.split('::').last
+    end
+  end
+  
+end
+
+module DSLize
+  
+  class << self
+    attr_accessor :objects
+    attr_accessor :current_object
+    attr_accessor :superclasses
+  end  
+
+  module Methods
+    
+    module Base
+      
+      def self.included(receiver)
+        receiver.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        
+        def string(attr, args = {})
+          attribute(:string, attr, args)
+        end
+
+        def integer(attr, args = {})
+          attribute(:integer, attr, args)
+        end        
+        
+        def double(attr, args = {})
+          attribute(:double, attr, args)
+        end        
+        
+        def has_many(attr, args = {})
+          relation(:has_many, attr, args)
+        end
+
+        def has_one(attr, args = {})
+          relation(:has_one, attr, args)
+        end
+
+        def root
+          DSLize.current_object[:root] = true
+        end
+        
+        def abstract
+          DSLize.current_object[:abstract] = true
+        end
+        
+        private
+        def attribute(type, name, args)
+          args[:type] = type
+          DSLize.current_object[:attributes] = {}
+          DSLize.current_object[:attributes][name] = args
+        end
+        
+        def relation(type, name, args)
+          name = (name.name rescue name.to_s).split('::').last
+          args[:type] = name
+          if as = args.delete(:as)
+            name = as.to_s
+          end
+          DSLize.current_object[type] ||= {}
+          DSLize.current_object[type][name] = args
+        end
+        
+      end
+      
+    end
+  
+  end
+  
+end

data/lib/dslize/formatter/formatter.rb

@@ -0,0 +1,16 @@
+module DSLize
+  module Formatter
+    
+    class Base
+      attr_accessor :objects
+      attr_accessor :superclasses
+      
+      def initialize
+        self.objects = DSLize.objects
+        self.superclasses = DSLize.superclasses
+      end
+    end
+    
+  end
+  
+end

data/lib/dslize/formatter/xsd_formatter.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/formatter'
+
+module DSLize
+  module Formatter
+    
+    class XSD < Base
+      
+      def generate!(*args)
+        schema = XPain::Builder.new do |xsd|
+          xsd.schema do
+            objects.each do |name, options|
+              parent = superclasses[name]
+              
+              xsd.element(name, :type => (options[:type] or name))
+              
+              xsd.complexType({ :name => name, :abstract => options[:abstract], :mixed => false }.select { |k,v| !v.nil? }) do
+                extends_base_if_needed(xsd, parent) do
+                  
+                  # relations
+                  xsd.sequence do
+                    { :has_one => nil, :has_many => "unbounded"}.each do |relation, max_occurs|
+                      (options[relation] or []).each do |k, v|
+                        named_object_if_needed(xsd, k, v) do
+                          xsd.element(nil, { :ref => (v[:type] or k), :maxOccurs => max_occurs }.select { |k,v| !v.nil? })
+                        end
+                      end
+                    end
+                  end
+                
+                  # attributes
+                  (options[:attributes] or []).each do |k, v|
+                    xsd.attribute({ :name => k, :default => v[:default], :type => xsd_type(v[:type]) }.select { |k,v| !v.nil? })
+                  end
+                  
+                end
+              end
+              
+            end
+          end
+        end
+        
+        File.open(args[0], "w") do |f|
+          f << schema.to_xml.gsub(' name=""', '') # xpain is buggy and always write a name on <element>
+        end
+      end
+      
+      private
+      def extends_base_if_needed(xsd, parent)
+        if parent != "Object"
+          xsd.complexContent :mixed => false do
+            xsd.extension :base => parent do
+              yield
+            end
+          end
+        else
+          yield
+        end
+      end
+      
+      def named_object_if_needed(xsd, name, options)
+        if options[:type] and name != options[:type]
+          xsd.element name, :contains => 'none' do
+            xsd.complexType do
+              xsd.sequence do
+                yield
+              end
+            end
+          end
+        else
+          yield
+        end
+      end
+      
+      def xsd_type(type)
+        case type
+        when :float
+          "xsd:double"
+        when :integer
+          "xsd:int"
+        when :string
+          "xsd:string"
+        else
+          type
+        end
+      end
+      
+    end
+  
+  end
+  
+end

data/lib/dslize/version.rb

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

data/lib/dslize.rb

@@ -0,0 +1,6 @@
+module DSLize
+  require 'xpain'
+  
+  require File.dirname(__FILE__) + '/dslize/dslize'
+  require File.dirname(__FILE__) + '/dslize/formatter/xsd_formatter'
+end

data/sample.rb

@@ -0,0 +1,61 @@
+#! /usr/bin/env ruby
+
+begin
+  # dev mode
+  require File.dirname(__FILE__) + '/lib/dslize'
+rescue
+  require 'dslize'
+end
+
+module DSLize::Methods
+  include DSLize::Methods::Base
+  
+  def self.my_first_custom_method(attr, args = {})
+    args[:type] = :custom
+    DSLize.current_object[attr] = args
+  end
+  
+  def self.my_second_custom_method
+    DSLize.current_object['baz'] = true
+  end
+  
+end
+
+module DSLize::Definition
+  
+  class City
+    string :name
+    integer :population, :default => 42
+  end
+  
+  class Country
+    string :name, :default => 'France'
+    
+    has_many City, :as => :cities
+    
+    has_one City, :as => :capital
+  end
+  
+  class World
+    root
+    
+    has_many Country
+    
+    my_first_custom_method :foo, :default => 'bar'
+    
+    my_second_custom_method
+  end
+  
+  class Planet
+    abstract
+  end
+  
+  class GazPlanet < Planet
+  end
+  
+  class WaterPlanet < Planet
+  end
+  
+end
+
+DSLize::Formatter::XSD.new.generate!(ARGV[0])

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: dslize
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- redox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-10 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: ""
+email: 
+- sylvain.utard@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- dslize.gemspec
+- lib/dslize.rb
+- lib/dslize/dslize.rb
+- lib/dslize/formatter/formatter.rb
+- lib/dslize/formatter/xsd_formatter.rb
+- lib/dslize/version.rb
+- sample.rb
+has_rdoc: true
+homepage: https://github.com/utard/dslize
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- xpain
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: DSL made easy
+test_files: []
+