ucd 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7949eed66b84881ded30a6e6ab40e9413c450dec
+  data.tar.gz: 68661990858b2a975ed47d2fffa008746c0e6b05
+SHA512:
+  metadata.gz: c11ee5b2f389e3cc2c425154c9ff7b259fe8e8257eeab64c75603975997733219602be796401a78782ee6daeca2d8eb6903fdda48940068833a1b1acf4679fbf
+  data.tar.gz: 3aa9ad7cd7da7f3bf66450488b1ac795600a33e884626c820a1230d94a3e24b42b744b731c5c3008446c282342f9521b4db5365e2301eaa1b5e672800a41e47e

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at ryan@rynet.us. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ucd.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Ryan Lewis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+# UCD
+
+UML Class Diagram (UCD) is a language for specifying UML class diagrams and a tool for converting it into various
+different formats.
+
+## Install
+
+### Bundler: `gem "ucd"`
+
+### RubyGems: `gem install ucd`
+
+## Executable
+
+```sh
+# Convert composite.ucd to composite.png
+$ ucd --type png --output . composite.ucd
+```
+
+## Language
+
+### Examples
+
+See the examples directory for UCD files and their generated DOT and PNG files.
+
+### Syntax
+
+> Note: Syntax is represented in [ABNF](https://tools.ietf.org/html/rfc5234) and are omitting spaces for clarity
+
+UCD language simply defines one or more `class` definitions, inside of which the fields, methods, relationships, and
+class relationships are defined.
+
+```abnf
+NAME       = 1*( ALPHA / DIGIT / "-" / "_" )
+TYPE       = NAME
+CLASS_BODY = *( ( FIELD / METHOD / RELATIONSHIP / CLASS_RELATIONSHIP ) NEWLINE )
+ACCESS     = ( "public" / "protected" / "private")
+ARGUMENT   = NAME [ ":" TYPE ]
+ARGUMENTS  = ARGUMENT *( "," ARGUMENT )
+FROM       = 1*( ALPHA / DIGIT / "-" / "_" / "*" )
+TO         = FROM
+
+CLASS              = [ "abstract" / "interface" ] "class" NAME [ "{" CLASS_BODY "}" ]
+FIELD              = [ "static" ] [ ACCESS ] field NAME [ ":" TYPE ]
+METHOD             = [ "abstract" ] [ "static" ] [ ACCESS ] method NAME [ "(" [ ARGUMENTS ] ")"] [ ":" TYPE ]
+RELATIONSHIP       = [ "generalizes" / "realizes" ] NAME
+CLASS_RELATIONSHIP = [ "directional" / "bidirectional" ] ( "dependency" / "association" / "aggregation" / "composition" ) NAME [ FROM ] [ TO ]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/RyanScottLewis/ucd. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rake/version_task'
+Rake::VersionTask.new
+
+task :default => :spec

data/TODO.md

@@ -0,0 +1,4 @@
+# TODO
+
+* Atom, VIM, etc color schemes/snippets
+* Use https://github.com/glejeune/Ruby-Graphviz

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ucd"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/composite - minimal.ucd

@@ -0,0 +1,17 @@
+abstract class Component {
+  method operation
+}
+
+class Leaf {
+  generalizes Component
+}
+
+class Composite {
+  protected field children
+  method addChild(child)
+  method removeChild(child)
+  method getChild(index)
+
+  generalizes Component
+  aggregation Component
+}

data/examples/composite.ucd

@@ -0,0 +1,17 @@
+abstract class Component {
+  method operation
+}
+
+class Leaf {
+  generalizes Component
+}
+
+class Composite {
+  protected field children : Component
+  method addChild(child : Component) : Component
+  method removeChild(child : Component) : Component
+  method getChild(index : Integer) : Component
+
+  generalizes Component
+  aggregation Component *
+}

data/exe/ucd

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -W0
+
+require "ucd/interface/command_line"
+
+UCD::Interface::CommandLine.run

data/lib/ucd/formatter/base.rb

@@ -0,0 +1,67 @@
+require "ucd/node"
+require "ucd/formatter"
+require "ucd/has_attributes"
+
+module UCD
+  module Formatter
+    class Base
+
+      class << self
+
+        def inherited(subclass)
+          Formatter.all << subclass
+        end
+
+        def format(node, attributes={})
+          new(attributes).format(node)
+        end
+
+        def name
+          to_s.split("::").last.downcase.to_sym
+        end
+
+      end
+
+      include HasAttributes
+
+      def initialize(attributes={})
+        update_attributes(attributes)
+      end
+
+      def name
+        self.class.name
+      end
+
+      attr_reader :output_path
+
+      def output_path=(value)
+        @output_path = value.is_a?(Pathname) ? value : Pathname.new(value.to_s) unless value.nil?
+      end
+
+      attr_reader :type
+
+      def type=(value)
+        @type = value.to_s.strip.downcase.to_sym
+      end
+
+      def format(node)
+        case node
+        when Node::Field             then format_field(node)
+        when Node::Method            then format_method(node)
+        when Node::Relationship      then format_relationship(node)
+        when Node::ClassRelationship then format_class_relationship(node)
+        when Node::ClassNode         then format_class(node)
+        when Node::Document          then format_document(node)
+        end
+      end
+
+      def format_field(node);              raise NotImplementedError; end
+      def format_method(node);             raise NotImplementedError; end
+      def format_relationship(node);       raise NotImplementedError; end
+      def format_class_relationship(node); raise NotImplementedError; end
+      def format_class(node);              raise NotImplementedError; end
+      def format_document(node);           raise NotImplementedError; end
+
+    end
+  end
+end

data/lib/ucd/formatter/graphviz.rb

@@ -0,0 +1,196 @@
+require "open3"
+require "ucd/formatter/base"
+
+module UCD
+  module Formatter
+    class Graphviz < Base
+
+      class Attributes < Hash
+        def to_s
+          to_a.map { |(a, b)| "#{a}=#{b.inspect}" }.join(" ")
+        end
+      end
+
+      ACCESS_SYMBOLS = {
+        "public"    => "+",
+        "protected" => "#",
+        "private"   => "-",
+      }
+
+      VALID_TYPES = %i[dot xdot ps pdf svg svgz fig png gif jpg jpeg json imap cmapx]
+
+      def initialize(attributes={})
+        super
+
+        @graph_attributes = Attributes.new
+        @graph_attributes["splines"] = "ortho"
+        @graph_attributes["rankdir"] = "BT"
+
+        @edge_attributes = Attributes.new
+        @edge_attributes["color"] = "gray50"
+
+        @node_attributes = Attributes.new
+        @node_attributes["shape"] = "plain"
+      end
+
+      attr_reader :graph_attributes
+      attr_reader :edge_attributes
+      attr_reader :node_attributes
+
+      def type=(value)
+        super
+
+        @type = VALID_TYPES.include?(@type) ? @type : nil
+      end
+
+      def format(node)
+        dot = super.lines.map(&:rstrip).join("\n")
+        data = generate_from_dot(dot)
+
+        if @output_path.nil?
+          puts data
+        else
+          self.type ||= @output_path.extname.gsub(/^\./, "")
+          output_path = @output_path.extname.empty? ? Pathname.new("#{@output_path}.#{@type}") : @output_path
+
+          output_path.open("w+") { |file| file.write(data) }
+        end
+      end
+
+      def format_field(node)
+        symbol = ACCESS_SYMBOLS[node.access]
+        result = "#{symbol} #{node.name}"
+        result << " : #{node.type}" if node.type
+        result = "<U>#{result}</U>" if node.static
+
+        result
+      end
+
+      def format_method(node)
+        symbol = ACCESS_SYMBOLS[node.access]
+        result = "#{symbol} #{node.name}"
+        arguments = node.arguments.map do |argument|
+          "#{argument.name}#{" : #{argument.type}" if argument.type}"
+        end.join(", ") if node.arguments
+
+        result << "(#{arguments})"
+        result << " : #{node.type}" if node.type
+        result = "<U>#{result}</U>" if node.static
+        result = "<I>#{result}</I>" if node.abstract
+
+        result
+      end
+
+      def format_relationship(node)
+        arrow = "diamond" if "composition"
+        arrow = "odiamond" if "aggregation"
+        dir = "back" if %w[aggregation composition].include?(node.type)
+        arrow_key = dir == "back" ? "arrowtail" : "arrowhead"
+
+        attributes = Attributes.new
+
+        attributes["style"] = "dashed" if node.type == "dependency"
+        attributes["dir"] = dir if dir
+        attributes[arrow_key] = arrow
+        attributes["headlabel"] = node.from if node.from
+        attributes["taillabel"] = node.to if node.to
+
+        %Q{Class#{node.parent.name} -> Class#{node.name} [#{attributes}]}
+      end
+
+      def format_class_relationship(node)
+        attributes = Attributes.new
+
+        attributes["arrowhead"] = "onormal"
+        attributes["style"] = "dashed" if node.type == "realizes"
+
+        %Q{Class#{node.parent.name} -> Class#{node.name} [#{attributes}]}
+      end
+
+      def format_class(node)
+        name = "<B>#{node.name}</B>"
+        name = "«abstract»<BR/><I>#{name}</I>" if node.modifier == "abstract"
+
+        unless node.fields.empty?
+          field_rows  = node.fields.map { |field| %Q{<TR><TD ALIGN="LEFT">#{format_field(field)}</TD></TR>}}
+          field_table = <<-HEREDOC.chomp
+
+        <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+#{field_rows.map { |row| " " * 10 + row }.join("\n")}
+        </TABLE>
+HEREDOC
+          field_table << "\n" << " " * 6
+        end
+
+        unless node.methods.empty?
+          method_rows  = node.methods.map { |method| %Q{<TR><TD ALIGN="LEFT">#{format_method(method)}</TD></TR>}}
+          method_table = <<HEREDOC.chomp
+
+        <TABLE BORDER="0" CELLPADDING="0" CELLSPACING="0">
+#{method_rows.map { |row| " " * 10 + row }.join("\n")}
+        </TABLE>
+HEREDOC
+          method_table << "\n" << " " * 6
+        end
+
+        <<-HEREDOC.chomp
+<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
+    <TR>
+      <TD>#{name}</TD>
+    </TR>
+    <TR>
+      <TD>#{field_table}</TD>
+    </TR>
+    <TR>
+      <TD>#{method_table}</TD>
+    </TR>
+  </TABLE>
+HEREDOC
+      end
+
+      def format_document(node)
+        classes = node.classes.map do |node|
+          <<-HEREDOC
+Class#{node.name} [label=<
+  #{format_class(node)}
+>]
+          HEREDOC
+        end.join("\n")
+        class_relationships = node.classes.map(&:class_relationships).flatten.map { |node| format_class_relationship(node) }.join("\n")
+        relationships = node.classes.map(&:relationships).flatten.map { |node| format_relationship(node) }.join("\n")
+
+        classes = classes.lines.map { |line| "  #{line}" }.join.chomp
+        class_relationships = class_relationships.lines.map { |line| "  #{line}" }.join.chomp
+        relationships = relationships.lines.map { |line| "  #{line}" }.join.chomp
+
+        <<-HEREDOC
+digraph G {
+  graph [#{@graph_attributes}]
+  edge [#{@edge_attributes}]
+  node [#{@node_attributes}]
+
+#{classes}
+
+#{class_relationships}
+
+#{relationships}
+}
+HEREDOC
+      end
+
+      protected
+
+      def generate_from_dot(dot)
+        return dot if @type.nil?
+
+        Open3.popen3("dot -T#{type}") do |stdin, stdout, stderr, wait|
+          stdin.puts(dot)
+          stdin.close
+          # unless (err = stderr.read).empty? then raise err end
+          stdout.read
+        end
+      end
+
+    end
+  end
+end

data/lib/ucd/formatter.rb

@@ -0,0 +1,19 @@
+module UCD
+  module Formatter
+    class << self
+
+      def all
+        @all ||= []
+      end
+
+      def find_by_name(name)
+        name = name.to_sym
+
+        all.find { |formatter_class| formatter_class.name == name }
+      end
+
+    end
+  end
+end
+
+require "ucd/formatter/graphviz"

data/lib/ucd/has_attributes.rb

@@ -0,0 +1,9 @@
+module UCD
+  module HasAttributes
+
+    def update_attributes(attributes={})
+      attributes.to_h.each { |name, value| send("#{name}=", value) }
+    end
+
+  end
+end

data/lib/ucd/interface/base.rb

@@ -0,0 +1,24 @@
+require "optparse"
+require "ucd/has_attributes"
+
+module UCD
+  module Interface
+    class Base
+
+      def self.run(attributes={})
+        new(attributes).run
+      end
+
+      include HasAttributes
+
+      def initialize(attributes={})
+        update_attributes(attributes)
+      end
+
+      def run
+        raise NotImplementedError
+      end
+
+    end
+  end
+end

data/lib/ucd/interface/command_line.rb

@@ -0,0 +1,156 @@
+require "optparse"
+require "pathname"
+require "ucd/interface/base"
+require "ucd/parser"
+require "ucd/formatter"
+
+module UCD
+  module Interface
+    class CommandLine < Base
+
+      class Error < StandardError; end
+      class FileError < Error; end
+
+      def initialize(attributes={})
+        @formatter = Formatter::Graphviz.new
+        @verbose = false
+        setup_parser
+
+        super
+      end
+
+      def output_path=(value)
+        @output_path = Pathname.new(value.to_s)
+      end
+
+      def paths=(values)
+        @paths = values.to_a.map { |path| Pathname.new(path) }
+      end
+
+      def run
+        @option_parser.parse!
+        self.paths = ARGV
+
+        @paths.each do |input_path|
+          raise FileError, "File does not exist: #{input_path}" unless input_path.exist?
+
+          @formatter.output_path = @output_path.directory? ? @output_path.join(input_path.basename(".*")) : @output_path if @output_path
+          data = input_path.read
+          document = Parser.parse(data)
+
+          result = @formatter.format(document)
+        end
+      end
+
+      protected
+
+      def text_bold(body=nil)
+        text_effect(1, body)
+      end
+
+      def text_italic(body=nil)
+        text_effect(3, body)
+      end
+
+      def text_bold_italic(body=nil)
+        text_bold(text_italic(body))
+      end
+
+      def text_underline(body=nil)
+        text_effect(4, body)
+      end
+
+      def text_effect(num, body=nil)
+        result = "\e[#{num}m"
+        result << "#{body}#{text_reset}" unless body.nil?
+
+        result
+      end
+
+      def text_reset
+        "\e[0m"
+      end
+
+      def setup_parser
+        @option_parser = OptionParser.new do |parser|
+          parser.banner = <<~BANNER
+            #{text_bold("Usage:")} ucd [options] PATHS
+
+            #{text_bold("Overview:")} Generate output from UML Class Diagram language files
+
+            #{text_bold("Options:")}
+
+          BANNER
+
+          parser.on("-f", "--formatter VALUE", "The output formatter (Default: '#{@formatter.name}')") do |value|
+            value = value.to_s.strip.downcase.to_sym
+            value = Formatter.find_by_name(value)
+            raise Error, "Formatter not found: #{value}" if value.nil?
+
+            @formatter = value
+          end
+          parser.on("-t", "--type VALUE", "The output format type") { |value| @formatter.type = value }
+          parser.on("-o", "--output VALUE", "The output path") { |value| self.output_path = value }
+          parser.on("-h", "--help", "Prints this help") do
+            puts parser
+            puts <<~HELP
+
+              #{text_bold("Paths:")}
+
+                  UCD can accept multiple paths for parsing for easier batch processing.
+
+                  The location of the output by default is standard output.
+
+                  The output can be directed to a path with #{text_bold_italic("--output")}, which can be a file or a directory.
+                  If the output path is a directory, then the filename will be the same as the input filename,
+                  with it's file extension substituted with the #{text_bold_italic("--type")}.
+                  If the output path is a file when multiple input files are given, the current input file index is appended
+                  to the output filename.
+
+                  #{text_underline("Examples")}
+
+                      `ucd project.ucd`
+
+                          Produces DOT notation, sent to standard output
+
+                      `ucd -o . project.ucd`
+
+                          Produces DOT notation, written to #{text_italic("./project.dot")}
+
+                      `ucd -o ./diagram.dot project.ucd`
+
+                          Produces DOT notation, written to #{text_italic("./diagram.dot")}
+
+                      `ucd -o ./diagram.png project.ucd`
+
+                          Produces PNG image, written to #{text_italic("./diagram.png")}
+
+                      `ucd -t png -o . project.ucd`
+
+                          Produces PNG image, written to #{text_italic("./project.png")}
+
+                      `ucd -t png -o . project.ucd core_ext.ucd`
+
+                          Produces PNG images, written to #{text_italic("./project.png")} and #{text_italic("./core_ext.png")}
+
+              #{text_bold("Formatters:")}
+
+                  #{text_underline("Graphviz")}
+
+                    Generates DOT notation and can use the DOT notation to generate any format Graphviz can produce.
+
+                    The output format is based on #{text_bold_italic("--type")}, which by default is "dot".
+                    If #{text_bold_italic("--type")} is not given and #{text_bold_italic("--output")} is, the file extension of the #{text_bold_italic("--output")} path will be used.
+
+                    Valid types/extensions are: #{Formatter::Graphviz::VALID_TYPES.join(", ")}
+
+            HELP
+
+            exit
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ucd/node/base.rb

@@ -0,0 +1,17 @@
+require "ucd/has_attributes"
+
+module UCD
+  module Node
+    class Base
+
+      include HasAttributes
+
+      def initialize(attributes={})
+        update_attributes(attributes)
+      end
+
+      attr_accessor :parent
+
+    end
+  end
+end

data/lib/ucd/node/class_node.rb

@@ -0,0 +1,56 @@
+require "ucd/node/base"
+require "ucd/node/field"
+require "ucd/node/method"
+require "ucd/node/relationship"
+require "ucd/node/class_relationship"
+require "ucd/node/has_name"
+
+module UCD
+  module Node
+    class ClassNode < Base
+
+      include HasName
+
+      attr_reader :modifier
+
+      def modifier=(value)
+        @modifier = value.to_s # TODO: Validate?
+      end
+
+      attr_reader :members
+
+      def members=(value)
+        @members = value.to_a.map do |member|
+          type       = member.to_a[0][0] # TODO: This is dumb
+          attributes = member.to_a[0][1]
+          attributes[:parent] = self
+
+          case type
+          when :field              then Field.new(attributes)
+          when :method             then Method.new(attributes)
+          when :relationship       then Relationship.new(attributes)
+          when :class_relationship then ClassRelationship.new(attributes)
+          else # TODO: Raise or something
+          end
+        end
+      end
+
+      def fields
+        @members.find_all { |member| member.class == Field }
+      end
+
+      def methods
+        @members.find_all { |member| member.class == Method }
+      end
+
+      def relationships
+        @members.find_all { |member| member.class == Relationship }
+      end
+
+      def class_relationships
+        @members.find_all { |member| member.class == ClassRelationship }
+      end
+
+    end
+  end
+end

data/lib/ucd/node/class_relationship.rb

@@ -0,0 +1,12 @@
+require "ucd/node/relationship"
+require "ucd/node/has_name"
+
+module UCD
+  module Node
+    class ClassRelationship < Relationship
+
+      include HasName
+
+    end
+  end
+end

data/lib/ucd/node/document.rb

@@ -0,0 +1,16 @@
+require "ucd/node/base"
+require "ucd/node/class_node"
+
+module UCD
+  module Node
+    class Document < Base
+
+      attr_reader :classes
+
+      def classes=(value)
+        @classes = value.to_a.map { |attributes| ClassNode.new(attributes) }
+      end
+
+    end
+  end
+end

data/lib/ucd/node/field.rb

@@ -0,0 +1,32 @@
+require "ucd/node/base"
+require "ucd/node/has_name"
+require "ucd/node/has_type"
+
+module UCD
+  module Node
+    class Field < Base
+
+      include HasName
+      include HasType
+
+      def initialize(attributes={})
+        @access = "public"
+
+        super
+      end
+
+      attr_reader :static
+
+      def static=(value)
+        @static = !!value
+      end
+
+      attr_reader :access
+
+      def access=(value)
+        @access = value.to_s # TODO: Validate?
+      end
+
+    end
+  end
+end

data/lib/ucd/node/has_name.rb

@@ -0,0 +1,15 @@
+module UCD
+  module Node
+
+    module HasName
+
+      attr_reader :name
+
+      def name=(value)
+        @name = value.to_s
+      end
+
+    end
+
+  end
+end

data/lib/ucd/node/has_type.rb

@@ -0,0 +1,15 @@
+module UCD
+  module Node
+
+    module HasType
+
+      attr_reader :type
+
+      def type=(value)
+        @type = value.to_s
+      end
+
+    end
+
+  end
+end

data/lib/ucd/node/method.rb

@@ -0,0 +1,25 @@
+require "ucd/node/field"
+require "ucd/node/method_argument"
+require "ucd/node/has_name"
+
+module UCD
+  module Node
+    class Method < Field
+
+      include HasName
+
+      attr_reader :abstract
+
+      def abstract=(value)
+        @abstract = !!value
+      end
+
+      attr_reader :arguments
+
+      def arguments=(value)
+        @arguments = value.to_a.map { |attributes| MethodArgument.new(attributes) }
+      end
+
+    end
+  end
+end

data/lib/ucd/node/method_argument.rb

@@ -0,0 +1,16 @@
+require "ucd/node/base"
+require "ucd/node/has_name"
+require "ucd/node/has_type"
+
+module UCD
+  module Node
+
+    class MethodArgument < Base
+
+      include HasName
+      include HasType
+
+    end
+
+  end
+end

data/lib/ucd/node/relationship.rb

@@ -0,0 +1,26 @@
+require "ucd/node/base"
+require "ucd/node/has_name"
+require "ucd/node/has_type"
+
+module UCD
+  module Node
+    class Relationship < Base
+
+      include HasName
+      include HasType
+
+      attr_reader :from
+
+      def from=(value)
+        @from = value.to_s
+      end
+
+      attr_reader :to
+
+      def to=(value)
+        @to = value.to_s
+      end
+
+    end
+  end
+end

data/lib/ucd/node.rb

@@ -0,0 +1,6 @@
+require "ucd/node/field"
+require "ucd/node/method"
+require "ucd/node/relationship"
+require "ucd/node/class_relationship"
+require "ucd/node/class_node"
+require "ucd/node/document"

data/lib/ucd/parser.rb

@@ -0,0 +1,105 @@
+require "parslet"
+require "ucd/node/document"
+
+module UCD
+  class Parser < Parslet::Parser
+
+    def self.parse(io, options={})
+      new.parse(io, options)
+    end
+
+    def parse(io, options={})
+      Node::Document.new(super)
+    end
+
+    KEYWORDS = %w[
+      class
+      interface
+      abstract static
+      public protected private
+      field method
+      generalizes realizes
+      directional bidirectional
+      dependency association aggregation composition
+    ]
+
+    KEYWORDS.each do |keyword|
+      rule("kw_#{keyword}") { str(keyword) }
+    end
+
+    rule(:newlines)    { (match("\n") | str(";")).repeat(1) } # TODO: Unused
+    rule(:newlines?)   { newlines.maybe } # TODO: Unused
+    rule(:spaces)      { match("\s").repeat(1) }
+    rule(:spaces?)     { spaces.maybe }
+    rule(:whitespace)  { (match("\s") | match("\n") | str(";")).repeat(1) }
+    rule(:whitespace?) { whitespace.maybe }
+
+    rule(:name) { match["[:alnum:]_-"].repeat(1) } # TODO: Any other needed?
+
+    # -- Field/Method
+
+    rule(:kw_access_modifier) { kw_public | kw_protected | kw_private }
+
+    rule(:member_static) { (kw_static.as(:static) >> spaces).maybe }
+    rule(:member_access) { (kw_access_modifier.as(:access) >> spaces).maybe }
+
+    rule(:method_abstract) { (kw_abstract.as(:abstract) >> spaces).maybe }
+    rule(:member_type)     { (spaces >> str(":") >> spaces >> name.as(:type)).maybe }
+
+    rule(:field_keyword)     { kw_field >> spaces }
+    rule(:field_name)        { name.as(:name) }
+    rule(:field_return_type) { member_type.maybe }
+    rule(:field_definition)  { (member_static >> member_access >> field_keyword >> field_name >> field_return_type).as(:field) }
+
+    rule(:method_keyword)         { kw_method >> spaces }
+    rule(:method_argument)        { name.as(:name) >> member_type }
+    rule(:method_arguments_inner) { (method_argument >> (spaces? >> str(",") >> spaces? >> method_argument).repeat).repeat.as(:arguments) }
+    rule(:method_arguments)       { (str("(") >> spaces? >> method_arguments_inner >> spaces? >> str(")")).maybe }
+
+    rule(:method_name)        { name.as(:name) }
+    rule(:method_return_type) { member_type.maybe }
+    rule(:method_definition)  { (method_abstract >> member_static >> member_access >> method_keyword >> method_name >> method_arguments >> method_return_type).as(:method) }
+
+    # -- Class Relationship
+
+    rule(:kw_class_relationship_type) { kw_generalizes | kw_realizes }
+
+    rule(:class_relationship_type)       { kw_class_relationship_type.as(:type) >> spaces }
+    rule(:class_relationship_definition) { (class_relationship_type >> name.as(:name)).as(:class_relationship) }
+
+    # -- Relationship
+
+    rule(:kw_relationship_directionality) { kw_directional | kw_bidirectional }
+    rule(:kw_relationship_type)           { kw_dependency | kw_association | kw_aggregation | kw_composition }
+
+    rule(:relationship_directionality) { (kw_relationship_directionality.as(:directionality) >> spaces).maybe }
+    rule(:relationship_type)           { kw_relationship_type.as(:type) >> spaces }
+    rule(:relationship_from)           { (spaces >> (name.as(:name) | str("*").repeat(1)).as(:from)).maybe }
+    rule(:relationship_to)             { (spaces >> (name.as(:name) | str("*").repeat(1)).as(:to)).maybe }
+    rule(:relationship_definition)     { (relationship_directionality >> relationship_type >> name.as(:name) >> relationship_from >> relationship_to).as(:relationship) }
+
+    # -- Class
+
+    rule(:kw_class_modifier) { kw_abstract | kw_interface }
+
+    rule(:class_modifier)          { (kw_class_modifier.as(:modifier) >> spaces).maybe }
+    rule(:class_keyword)           { kw_class >> spaces }
+    rule(:class_inner_definitions) { field_definition | method_definition | class_relationship_definition | relationship_definition }
+    rule(:class_inner_definition)  { class_inner_definitions >> whitespace? }
+    rule(:class_body)              { spaces? >> str("{") >> whitespace? >> class_inner_definition.repeat.as(:members) >> str("}") }
+    rule(:class_body?)             { class_body.maybe }
+
+    rule(:class_definition) { class_modifier >> class_keyword >> name.as(:name) >> class_body? }
+
+    # -- Document
+
+    rule(:document_definitions) { class_definition >> whitespace? }
+
+    rule(:document) { whitespace? >> document_definitions.repeat.as(:classes) }
+
+    # -- Root
+
+    root(:document)
+
+  end
+end

data/lib/ucd.rb

@@ -0,0 +1,7 @@
+require "version"
+require "ucd/parser"
+require "ucd/formatter/graphviz"
+
+module UCD
+  is_versioned
+end

data/ucd.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ucd"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ucd"
+  spec.version       = UCD::VERSION.to_s
+  spec.authors       = ["Ryan Scott Lewis"]
+  spec.email         = ["ryanscottlewis@gmail.com"]
+
+  spec.summary       = %q{UML Class Diagram Language}
+  spec.description   = %q{A simple language for easily specifying UML class diagrams and generating output based on them}
+  spec.homepage      = "https://github.com/RyanScottLewis/ucd"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "parslet", "~> 1.7.1"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "version", "~> 1.0.0"
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: ucd
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Scott Lewis
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: version
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: A simple language for easily specifying UML class diagrams and generating
+  output based on them
+email:
+- ryanscottlewis@gmail.com
+executables:
+- ucd
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- VERSION
+- bin/console
+- bin/setup
+- examples/composite - minimal.ucd
+- examples/composite.png
+- examples/composite.ucd
+- exe/ucd
+- lib/ucd.rb
+- lib/ucd/formatter.rb
+- lib/ucd/formatter/base.rb
+- lib/ucd/formatter/graphviz.rb
+- lib/ucd/has_attributes.rb
+- lib/ucd/interface/base.rb
+- lib/ucd/interface/command_line.rb
+- lib/ucd/node.rb
+- lib/ucd/node/base.rb
+- lib/ucd/node/class_node.rb
+- lib/ucd/node/class_relationship.rb
+- lib/ucd/node/document.rb
+- lib/ucd/node/field.rb
+- lib/ucd/node/has_name.rb
+- lib/ucd/node/has_type.rb
+- lib/ucd/node/method.rb
+- lib/ucd/node/method_argument.rb
+- lib/ucd/node/relationship.rb
+- lib/ucd/parser.rb
+- ucd.gemspec
+homepage: https://github.com/RyanScottLewis/ucd
+licenses:
+- MIT
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: UML Class Diagram Language
+test_files: []