shaun 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e6e1e67d80575fc1d34735200b6388269d939c3f
+  data.tar.gz: 4b321f883efb357cd4685e0642178c6d35c90076
+SHA512:
+  metadata.gz: c06eaf873d54732a48cb1d2eefc376617be485f1acc379678c457fdd454f59b4bd632925c8d12eb40e5f571c0ff900bd33b92e574eb36aac5afd517d3d13c07b
+  data.tar.gz: 8f27fd9d632f87fe720dab76fd1358733688275acaa16388bc9bc54e3d6955da25d76fa923dfc7114368fb41243cd90f7d2b1ccc43812f710ff8ab4cce03cd81

data/lib/shaun.rb

@@ -0,0 +1,161 @@
+# The main module that holds every SHAUN related classes and some helper functions
+module Shaun
+  # Helper module for classes that are tranparent SHAUN values (String, Boolean, Object)
+  # It provides a default #to_sn method
+  module ShaunValue
+    # Cast to a SHAUN object.
+    def to_sn
+      self
+    end
+  end
+
+  # A SHAUN object. SHAUN objects are like Ruby hashes except they only manipulate SHAUN values.
+  class Object
+    include ShaunValue
+
+    # Create a SHAUN Object from a Ruby hash.
+    # Every value in the hash is casted into a SHAUN value with the #to_sn method.
+    # Object values are stored as instance attributes
+    #
+    # === Example
+    # obj = Sn::Object.new({ greetings: 'hello' })
+    # greetings = obj.greetings
+    # obj.greetings = 'New hello!'
+    def initialize(hash = {})
+      hash.each_pair do |k,v|
+        name = k.to_s
+        metaclass.class_eval { attr_reader name.to_sym }
+        create_writer name.to_sym
+        instance_variable_set "@#{name}".to_sym, v.to_sn
+      end
+    end
+
+    # Add a new attribute to the object if the method name matches an attribute writer (i.e. #whatever=)
+    # or calls the superclass' #method_missing method
+    def method_missing(m, *params)
+      res = m.match /([a-zA-Z_][a-zA-Z0-9_]*)=/
+      if res and params.length == 1
+        name = res[1].to_s
+        metaclass.class_eval { attr_reader name.to_sym }
+        create_writer name.to_sym
+        instance_variable_set "@#{name}".to_sym, params[0].to_sn
+      else
+        super m, *params
+      end
+    end
+
+    private
+      # Get the object's metaclass
+      def metaclass
+        class << self ; self ; end
+      end
+
+      # Create an attribute writer for the given symbol that castes the value into a SHAUN value
+      # before assignment
+      def create_writer(sym)
+        metaclass.class_eval do
+          define_method(sym.to_s + "=") do |value|
+            instance_variable_set "@#{sym.to_s}".to_sym, value.to_sn
+          end
+        end
+      end
+  end
+
+  # A SHAUN number. SHAUN Numbers can be integers or floats indifferently. They can also have a unit
+  #
+  # === Example
+  # 5.2 km
+  # 44 kHz
+  class Number
+    include ShaunValue
+
+    # Create a new number with its value and unit
+    def initialize(value, unit = nil)
+      @value = value
+      @unit = unit
+    end
+
+    # Cast the number to a bare Ruby Integer
+    def to_i
+      @value
+    end
+
+    # Cast the number to a bare Ruby Float
+    def to_f
+      @value
+    end
+
+    # Print the number to a String
+    def to_s
+      if @unit
+        "#{@value.to_s} #{@unit.to_s}"
+        else
+          "#{@value.to_s}"
+      end
+    end
+  end
+
+  # Helper method to create a SHAUN object
+  def self.object(hash)
+    Object.new hash
+  end
+
+  # Helper method to create a SHAUN list
+  def self.list(ary)
+    ary.to_sn
+  end
+
+  # Helper method to create a SHAUN number
+  def self.number(value, unit = nil)
+    Number.new value, unit
+  end
+end
+
+class Hash
+  def to_sn
+    Sn::Object.new self
+  end
+end
+
+class Numeric
+  # Cast to a SHAUN number
+  def to_sn
+    Sn::Number.new self
+  end
+
+  # Patched method #method_missing in order to generate a SHAUN number
+  # if the method called looks like an attribute reader
+  def method_missing(m, *params)
+    res = m.match /([a-zA-Z_][a-zA-Z0-9_]*)/
+    if res and params.empty?
+      unit = res[1].to_s
+      Sn::Number.new self, unit
+    else
+      super m, *params
+    end
+  end
+end
+
+class String
+  include Sn::ShaunValue
+end
+
+class TrueClass
+  include Sn::ShaunValue
+end
+
+class FalseClass
+  include Sn::ShaunValue
+end
+
+class NilClass
+  include Sn::ShaunValue
+end
+
+class Array
+  # Cast to a SHAUN list. Ruby Arrays are SHAUN lists but their values
+  # have to be SHAUN values as well
+  def to_sn
+    map { |e| e.to_sn }
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: shaun
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kévin Le Bon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-12-30 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      This gem is an Ruby implementation of the SHAUN data-notation language.
+      It features an internal DSL that enables the user to manipulate datas directly in Ruby.
+email: kevin.le_bon@yahoo.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/shaun.rb
+homepage: 
+licenses:
+- BSD-2-Clause
+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.6.14
+signing_key: 
+specification_version: 4
+summary: A Ruby implementation of the SHAUN data-notation language
+test_files: []