alpacabuildtool 1.0.0

data/lib/alpacabuildtool/entities/nuspec.rb

@@ -0,0 +1,107 @@
+require 'alpacabuildtool/entities/xml'
+
+module AlpacaBuildTool
+  ##
+  # Nuspec creates *.nuspec file content
+  #
+  #    Nuspec.new(id: 'Cool.Package',
+  #               version: '0.0.1',
+  #               description: 'something',
+  #               authors: ['Vasyl', 'Kate'],
+  #               false).to_s
+  #    # => <?xml version="1.0"?>
+  #    #    <package>
+  #    #      <metadata>
+  #    #        <id>Cool.Package</id>
+  #    #        <version>0.0.1</version>
+  #    #        <authors>Vasyl,Kate</authors>
+  #    #        <description>something</description>
+  #    #      </metadata>
+  #    #    </package>
+  class Nuspec
+    OPTIONAL = %w(title licenseUrl projectUrl copyright iconUrl
+                  requireLicenseAcceptance releaseNotes)
+
+    ##
+    # Creates instance and generate content from *package* config
+    #
+    # +package+:: package configuration
+    # +add_common_files+:: flag to add files like README and CHANGELOG
+    def initialize(package, add_common_files = true)
+      @content = generate(package, add_common_files)
+    end
+
+    ##
+    # Overrides to_s method to create string content from inner Xml object
+    def to_s
+      @content.to_s
+    end
+
+    ##
+    # Returns Xml object representation of package nuspec
+    #
+    # +config+:: package configuration
+    # +add_common_files+:: flag to add common files or not
+    def generate(config, add_common_files)
+      Xml.new '1.0' do
+        node 'package' do |package|
+          Nuspec.add_metadata(package, config)
+          Nuspec.add_files(package, config) if add_common_files
+        end
+      end
+    end
+
+    ##
+    # Adds metadata entry to nuspec
+    #
+    # +package+:: XmlNode where to add metadata
+    # +config+:: package configuration
+    def self.add_metadata(package, config)
+      package.node 'metadata' do |metadata|
+        Nuspec.add_mandatory_fields(metadata, config)
+        Nuspec.add_optional_fields(metadata, config)
+      end
+    end
+
+    ##
+    # Adds mandatory entries to nuspec like id, version, authors and description
+    #
+    # +metadata+:: XmlNode where to add entries
+    # +config+:: package configuration
+    def self.add_mandatory_fields(metadata, config)
+      metadata.node 'id', config['id']
+      metadata.node 'version', config['version']
+      metadata.node 'authors', config['authors'].join(',')
+      metadata.node 'description', config['description']
+    end
+
+    ##
+    # Adds optional entries to nuspec like owners, tags and so on
+    #
+    # +metadata+:: XmlNode where to add entries
+    # +config+:: package configuration
+    def self.add_optional_fields(metadata, config)
+      OPTIONAL.each { |name| metadata.node(name, config[name]) if config[name] }
+      metadata.node 'owners', config['owners'].join(',') if config['owners']
+      metadata.node 'tags', config['tags'].join(' ') if config['tags']
+    end
+
+    ##
+    # Adds README.txt and CHANGES.txt files
+    #
+    # +package+:: XmlNode where to add files entry
+    # +config+:: package configuration
+    def self.add_files(package, config)
+      package.node 'files' do
+        node 'file' do
+          attribute 'src', 'README.txt'
+          attribute 'target', ''
+        end if config['readme']
+        node 'file' do
+          attribute 'src', 'CHANGES.txt'
+          attribute 'target', ''
+        end
+      end
+    end
+  end
+end

data/lib/alpacabuildtool/entities/project.rb

@@ -0,0 +1,54 @@
+module AlpacaBuildTool
+  ##
+  # VisualStudioProject provides project representation and methods
+  # to modify it's AssemblyVersion.cs file
+  class Project
+    attr_accessor :name, :file, :dir
+
+    ##
+    # Creates instance of class
+    #
+    # +line+:: line from .sln file with project information
+    # +dir+:: solution directory
+    #
+    #   s = AlpacaBuildTool::VisualStudioProject.new(
+    #     'Project("{FAE04EC0...5254043711}"'
+    #     'd:\')
+    #     # => #<**:VisualStudioProject:** @file="d:/sln1/some.csproj" **>
+    def initialize(line, dir)
+      items = line.gsub(/".*?"/).to_a
+      _, @name, file, _ = items.map { |item| item.to_s.gsub('"', '') }
+      dir = File.expand_path(dir)
+      @dir = File.dirname(File.join(dir, file))
+      @file = File.join(dir, file)
+    end
+
+    ##
+    # Overrides *to_s* method to provide nice convertion to string
+    def to_s
+      "{#{@name};#{@file}}"
+    end
+
+    ##
+    # Updates AssemblyInfo.cs file under the project with new_version
+    #
+    # +new_version+:: version that need to be used as assembly version
+    # and assembly file version
+    def update_version(new_version)
+      info_file = File.join(@dir, 'Properties', 'AssemblyInfo.cs')
+      content = IO.readlines(info_file)
+      open(info_file, 'w') do |io|
+        content.each { |line| io.write replace_version(line, new_version) }
+      end
+    end
+
+    private
+
+    def replace_version(line, new_version)
+      line = line.gsub(/AssemblyVersion\("(.*?)"\)/,
+                       "AssemblyVersion(\"#{new_version}\")")
+      line.gsub(/AssemblyFileVersion\("(.*?)"\)/,
+                "AssemblyFileVersion(\"#{new_version}\")")
+    end
+  end
+end

data/lib/alpacabuildtool/entities/solution.rb

@@ -0,0 +1,104 @@
+require 'alpacabuildtool/log/log'
+require 'alpacabuildtool/configuration'
+require 'alpacabuildtool/entities/project'
+require 'alpacabuildtool/versioning/versioning'
+
+module AlpacaBuildTool
+  ##
+  # Solution provides solution representation and it's configuration storage
+  class Solution
+    include Log
+
+    attr_reader :file, :dir, :projects
+
+    ##
+    # Creates instance from *.sln file
+    # Initializes solution's semantic version and absolute path to it's file
+    #
+    # +file+:: absolute or relative path to *.sln file
+    def initialize(file)
+      @file = File.expand_path(file)
+      @dir = File.dirname(@file)
+      @semver = Versioning.find(@dir)
+    end
+
+    ##
+    # Overrides string representation. Spawned to multiple lines
+    def to_s
+      s = '------------'
+      s += "\nFile: #{@file}"
+      s += "\nVersion: #{build_version}"
+      s += "\nProjects:" unless projects.empty?
+      projects.each { |p| s += "\n\t#{p}" }
+      s + "\n------------"
+    end
+
+    ##
+    # Returns Configuration object for current solution (initialized only once)
+    def configuration
+      @configuration ||= Configuration.new(self)
+    end
+
+    ##
+    # Returns array of it's projects (initialized only once)
+    def projects
+      return @projects if @projects
+      @projects = []
+      IO.readlines(@file).each do |line|
+        @projects << Project.new(line, @dir) if /^Project.*\.csproj/ =~ line
+      end
+    end
+
+    ##
+    # Returns specific project by it's name
+    #
+    # +name+:: project's name
+    def project(name)
+      @projects.find { |p| p.name == name }
+    end
+
+    ##
+    # Updates all projects AssemblyInfo.cs files with specific version
+    #
+    # +version+:: version to be stored in AssemblyInfo.cs files
+    def update_projects_version(version)
+      projects.each do |project|
+        project.update_version version
+      end
+    end
+
+    ##
+    # Returns array of projects that correspondes to specific type
+    #
+    # +type+:: type of project defined in configuration project_types
+    def specific_projects(type)
+      types = configuration['project_types'].dup
+      types.select! { |t| t['type'] == type } unless type == 'all'
+      projects.select do |project|
+        types.any? { |t| project.name.include? t['name'] }
+      end
+    end
+
+    ##
+    # Returns true if solution is marked as *nobuild*
+    def no_build?
+      solution_name = File.basename(@file, '.*')
+      (configuration['no_build'] || []).each do |tag|
+        return true if solution_name.include?(tag)
+      end
+      false
+    end
+
+    ##
+    # Returns current build version
+    def build_version
+      @semver.to_s '%M.%m.%p'
+    end
+
+    ##
+    # Returns current package version
+    def package_version
+      @semver.to_s '%M.%m.%p%s'
+    end
+  end
+end

data/lib/alpacabuildtool/entities/xml.rb

@@ -0,0 +1,41 @@
+require 'alpacabuildtool/entities/xml_node'
+
+module AlpacaBuildTool
+  ##
+  # Xml represents simple xml document with one root node
+  #
+  #    doc = Xml.new '1.0' do
+  #      node 'a', 'b'
+  #    end
+  #    doc.to_s
+  #    # => <?xml version="1.0"?>
+  #    #    <a>b</a>
+  class Xml
+    ##
+    # Creates instance
+    #
+    # +version+:: xml version
+    # accepts &block
+    def initialize(version, &block)
+      @version, @root_node = version, nil
+      instance_eval(&block) if block_given?
+    end
+
+    ##
+    # Set/override root node
+    #
+    # +name+:: node name
+    # +content+:: node content
+    # accepts &block
+    def node(name, content = nil, &block)
+      @root = XmlNode.new(name, content, &block)
+    end
+
+    ##
+    # Overrides string representation to generate xml document content from
+    # stored objects
+    def to_s
+      "<?xml version=\"#{@version}\"?>\n#{@root}"
+    end
+  end
+end

data/lib/alpacabuildtool/entities/xml_node.rb

@@ -0,0 +1,75 @@
+require 'cgi'
+
+module AlpacaBuildTool
+  ##
+  # XmlNode represents simple xml node that can contain attributes and other
+  # nodes or string as a content
+  class XmlNode
+    attr_reader :name, :content
+
+    ##
+    # Creates an instance
+    #
+    # +name+:: name of node
+    # +content+:: content of node (if set, block is ignored)
+    # accepts &block to set content to array of nodes
+    def initialize(name, content = nil, &block)
+      @name = name
+      return @content = content unless content.nil?
+      return unless block_given?
+      @arity = block.arity
+      if @arity <= 0
+        @context = eval('self', block.binding)
+        instance_eval(&block)
+      else
+        yield self
+      end
+    end
+
+    ##
+    # Adds new node into content
+    #
+    # +name+:: node name
+    # +content+:: node content
+    # accepts &block for this new node
+    #
+    #    XmlNode.new 'a' do
+    #      node 'b' do
+    #        node 'c' do
+    #          ...
+    #        end
+    #      end
+    #    end
+    def node(name, content = nil, &block)
+      (@content ||= []) << XmlNode.new(name, content, &block)
+    end
+
+    ##
+    # Adds attribute to node
+    #
+    # +name+:: attribute name
+    # +value+:: attribute value
+    def attribute(name, value)
+      (@attributes ||= {})[name] = value
+    end
+
+    ##
+    # Overrides string representation to populate xml pretty formatted content
+    def to_s
+      return "<#{@name}#{attributes_to_s}/>" if @content.nil?
+      content = @content.is_a?(Array) ? array_to_s : CGI.escape_html(@content)
+      "<#{@name}#{attributes_to_s}>#{content}</#{@name}>"
+    end
+
+    private
+
+    def attributes_to_s
+      (@attributes || {}).map { |n, v| " #{n}=\"#{v}\"" }.reduce(&:+)
+    end
+
+    def array_to_s
+      nodes = @content.map { |n| "\t#{n}".gsub(/\n/, "\n\t") }
+      "\n#{nodes.join("\n")}\n"
+    end
+  end
+end

data/lib/alpacabuildtool/log/font.rb

@@ -0,0 +1,92 @@
+module AlpacaBuildTool
+  ##
+  # Font class provides representation of .flf fonts so they can be used
+  class Font
+    attr_reader :height, :hard_blank
+
+    ##
+    # Absolute path to data folder where *.flf fonts stored
+    FONTPATH = File.expand_path(File.dirname(__FILE__) + '/../data')
+
+    ##
+    # Creates instance of class
+    #
+    # +name+:: font name(currently 'doom' or 'lean' exist)
+    def initialize(name)
+      @filename = File.join FONTPATH, name + '.flf'
+      File.open(@filename, 'rb') do |f|
+        header = f.gets.strip.split(/ /)
+        @hard_blank = header[0]
+        @height = header[1].to_i
+        load_characters f
+      end
+    end
+
+    ##
+    # Returns true if font have representation for char.ord
+    #
+    # +ord+:: character code(char.ord)
+    def char?(ord)
+      @characters.key? ord
+    end
+
+    ##
+    # Returns array of lines that represent current character
+    #
+    # +ord+:: character code(char.ord)
+    def [](ord)
+      @characters[ord]
+    end
+
+    private
+
+    def load_characters(file)
+      @characters = {}
+      load_ascii_characters file
+      load_german_characters file
+      load_extended_characters file
+    end
+
+    def load_ascii_characters(file)
+      (32..126).each { |i| @characters[i] = load_char(file) }
+    end
+
+    def load_german_characters(file)
+      [91, 92, 93, 123, 124, 125, 126].each do |i|
+        char = load_char(file)
+        break unless char
+        @characters[i] = char
+      end
+    end
+
+    def load_extended_characters(file)
+      until file.eof?
+        i = file.gets.strip.split(/ /).first
+        if i && i.empty?
+          next
+        else
+          char = load_char(file)
+          return unless char
+          @characters[i] = char
+        end
+      end
+    end
+
+    def load_char(file)
+      char = []
+      @height.times do
+        return false if file.eof?
+        char << load_line(file)
+      end
+      char
+    end
+
+    def load_line(file)
+      line = file.gets.rstrip
+      match = /(.){1,2}$/.match(line)
+      line.gsub!(match[1], '') if match
+      line << "\x00"
+      line
+    end
+  end
+end